Why Replace the Spring Dependency Management Gradle Plugin?

The Spring Dependency Management Gradle Plugin simplifies dependency management by providing a BOM (Bill of Materials) file that declares dependency versions. However, it can sometimes result in transitive dependency conflicts or inadvertently using outdated versions. By leveraging a version catalog, you gain greater control and flexibility over your project dependencies.

Creating a Version Catalog

Start by creating a libs.versions.toml file in the gradle folder of your project. This file will serve as your version catalog, containing sections for versions, libraries, and plugins. Here’s how it might look:

[versions]
# libs
flyway = "10.8.1" # https://mvnrepository.com/artifact/org.flywaydb/flyway-core
# plugins
spring-boot = "3.2.3" # https://spring.io/projects/spring-boot
kotlin = "1.9.22" # https://kotlinlang.org/docs/releases.html#release-details
sonarqube = "4.3.1.3277" # https://plugins.gradle.org/plugin/org.sonarqube

[libraries]
org-flywaydb-core = { module = "org.flywaydb:flyway-core", version.ref = "flyway" }
org-flywaydb-database-postgresql = { module = "org.flywaydb:flyway-database-postgresql", version.ref = "flyway" }

[plugins]
org-springframework-boot = { id = "org.springframework.boot", version.ref = "spring-boot" }
kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
kotlin-spring = { id = "org.jetbrains.kotlin.plugin.spring", version.ref = "kotlin" }
kotlin-jpa = { id = "org.jetbrains.kotlin.plugin.jpa", version.ref = "kotlin" }
sonarqube = { id = "org.sonarqube", version.ref = "sonarqube" }

Integrating Version Catalog in Gradle

Now, let’s integrate the version catalog into your Gradle build using Kotlin DSL.

plugins {
    alias(libs.plugins.org.springframework.boot)
    alias(libs.plugins.kotlin.jvm)
    alias(libs.plugins.kotlin.spring)
    alias(libs.plugins.kotlin.jpa)

    alias(libs.plugins.sonarqube)
    jacoco
}

...

dependencies {
    implementation(platform(org.springframework.boot.gradle.plugin.SpringBootPlugin.BOM_COORDINATES))
    implementation("org.springframework.boot:spring-boot-starter-actuator")
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    implementation("org.springframework.boot:spring-boot-starter-web")

    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
    implementation("org.jetbrains.kotlin:kotlin-reflect")

    implementation(libs.org.sonarsource.sonar.ws)
    implementation(libs.swagger.annotations.v3)

    runtimeOnly("org.postgresql:postgresql")
    runtimeOnly(libs.org.flywaydb.core)
    runtimeOnly(libs.org.flywaydb.database.postgresql)

    testImplementation("org.springframework.boot:spring-boot-starter-test")
    testImplementation("org.springframework.boot:spring-boot-testcontainers")
    testImplementation("org.testcontainers:junit-jupiter")
    testImplementation("org.testcontainers:postgresql")
}

So all versions are either coming from the Spring Boot BOM that is imported first or from the libs.versions.toml file which is taken in account automatically.

Conclusion

Replacing the Spring Dependency Management Gradle Plugin with a version catalog provides a cleaner and more flexible approach to dependency management in your Spring projects. By centralizing your dependency versions in a separate file, you gain more control and avoid potential conflicts or outdated versions. Give it a try in your next Spring project and experience smoother dependency management firsthand. Happy coding!

First attempt was to use ehcache backing the jcache but this results in jaxb exceptions as usual. I already have redis in the system and thought about using it as second level cache. I found that redisson provides an implementation for this.

The following dependencies needed to be added to my gradle file:

implementation("org.hibernate.orm:hibernate-jcache")
// https://mvnrepository.com/artifact/org.redisson/redisson-hibernate-6
implementation("org.redisson:redisson-hibernate-6:3.20.0")

With this in place the application.yml was updated to use it (I only kept the relevant part in this post):

spring:
  jpa:
    ...
    properties:
      hibernate:
        ...
        cache:
          use_second_level_cache: true
          use_query_cache: true
          region:
            factory_class: org.redisson.hibernate.RedissonRegionFactory
          redisson:
            # not setting config path uses classpath /redisson.yaml
            # setting it requires a proper file path like shown below to use the same file
            # config: api/src/main/resources/redisson.yaml
      jakarta:
        persistence:
          sharedCache:
            mode: ENABLE_SELECTIVE

And by adding the following to the entities it already worked:

import jakarta.persistence.Cacheable

@Entity
...
@Cacheable
@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class ... { ... }

org.springframework.context.ApplicationContextException: Unable to start web server; nested exception is org.springframework.boot.web.server.WebServerException: Unable to start embedded Tomcat
…
Caused by: java.lang.IllegalStateException: StandardEngine[Tomcat].StandardHost[localhost].TomcatEmbeddedContext[] failed to start

Digging a bit deeper I found the real reason:

java.lang.NoClassDefFoundError: javax/annotation/PostConstruct

This can be fixed by also including javax.annotation:javax.annotation-api as a dependency. The new jakarta based library only includes jakarta.annotation.* but not javax.annotation.*. But Spring Boot still requires the old namespace to work. I didn’t dig deeper why including the dependency broke the app though it was working before without both of the dependencies.

Another great sample for how convenient this rename is and further will be.

The 8000FF00-FF00-FFFF-FFFF-FFFFFFFFFFFF commands used with FF01 in the video also work with my a6400.

I also used the BlueSee software which is available via Apple App Store for free.

For getting it to work you first need to enable bluetooth and bluetooth remote. Further you need to pair the BlueSee software by going into pairing mode on the camera. The software will show pairing information which you just have to accept and from then on it worked.

With this it should be quite easy to build a custom remote based on a BLE capable chip like the suggested Adafruit nrf52840.

One step is to get rid of server information from header and default error pages.

Result

With my suggested changes in place the default error result pages will look like this:

➜  ~ curl -i http://127.0.0.1:5000 
HTTP/1.1 404 
Content-Type: text/html;charset=utf-8
Content-Length: 79
Date: Mon, 01 Aug 2022 11:56:16 GMT
Server: disclosed

<!doctype html><html lang="en"><title>error</title><body>Ups! 404</body></html>

Header

Open your application.yml or application.properties file and add the property server.server-header and set it to whatever you want to have in your header. In the sample above I simply used “disclosed”.

Body

The default body also tells the server software name and version. With tomcat this can be removed with the sample above by adding the following classes:

import org.apache.catalina.Container;
import org.apache.catalina.core.StandardHost;
import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class ErrorConfig {

    // https://docs.spring.io/spring-boot/docs/2.5.4/reference/htmlsingle/#howto-use-tomcat-legacycookieprocessor
    // https://github.com/spring-projects/spring-boot/issues/21257#issuecomment-745565376
    @Bean
    public WebServerFactoryCustomizer<TomcatServletWebServerFactory> errorReportValveCustomizer() {
        return (factory) -> {
            factory.addContextCustomizers(context -> {
                final Container parent = context.getParent();
                if (parent instanceof StandardHost) {
                    // above class FQCN
                    ((StandardHost) parent).setErrorReportValveClass(CustomErrorReportValve.class.getName());
                }
            });
        };
    }

}

import org.apache.catalina.connector.Request;
import org.apache.catalina.connector.Response;
import org.apache.catalina.valves.ErrorReportValve;
import org.apache.coyote.ActionCode;
import org.apache.tomcat.util.ExceptionUtils;
import org.springframework.http.MediaType;

import java.io.IOException;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.atomic.AtomicBoolean;

// Converting this to Kotlin results in this class not being used.
public class CustomErrorReportValve extends ErrorReportValve {

    @Override
    protected void report(final Request request, final Response response, final Throwable throwable) {
        // ref: ErrorReportValve implementation

        final int statusCode = response.getStatus();

        // Do nothing on a 1xx, 2xx and 3xx status
        // Do nothing if anything has been written already
        // Do nothing if the response hasn't been explicitly marked as in error
        //    and that error has not been reported.
        if (statusCode < 400 || response.getContentWritten() > 0 || !response.setErrorReported()) {
            return;
        }

        // If an error has occurred that prevents further I/O, don't waste time
        // producing an error report that will never be read
        final AtomicBoolean result = new AtomicBoolean(false);
        response.getCoyoteResponse().action(ActionCode.IS_IO_ALLOWED, result);
        if (!result.get()) {
            return;
        }

        try {
            try {
                response.setContentType(MediaType.TEXT_HTML_VALUE);
                response.setCharacterEncoding(StandardCharsets.UTF_8.name());
            } catch (final Throwable t) {
                ExceptionUtils.handleThrowable(t);
                if (container.getLogger().isDebugEnabled()) {
                    container.getLogger().debug("status.setContentType", t);
                }
            }
            final Writer writer = response.getReporter();
            if (writer != null) {
                // If writer is null, it's an indication that the response has
                // been hard committed already, which should never happen
                writer.write("<!doctype html><html lang=\"en\"><title>error</title><body>Ups! " + statusCode + "</body></html>");
                response.finishResponse();
            }
        } catch (IOException | IllegalStateException e) {
            // Ignore
        }
    }
}