DEV Community: Salad Lam

Spring WebFlux example application: notice board

Salad Lam — Sat, 17 May 2025 17:16:01 +0000

Objective

I wrote this application to explain the mechanism of different components of the Spring framework.

Function

Display notice on stated time
Approval before display
Multi language UI

Main component used

Project Reactor 3.7.X
Spring Boot 3.4.X
Spring WebFlux 6.2.X with thymeleaf 3.1.X
Spring Security 6.4.X
Spring R2DBC 6.2.X
Dozer 7.0.X
netty 4.1.X

Database

By default, data is stored in an embedded H2 database. Schema and data is imported when the application starts and all data will be lost after application shutdown.

MySQL database is also supported. In order to switch to MySQL database, first to modify the following properties located in application.properties file.

spring.r2dbc.url=r2dbc:mysql://localhost:3306/database-name
spring.r2dbc.username=root
spring.r2dbc.password=password

Then deactivate 'db-h2' and activate 'db-mysql' Maven profiles when starting the application. And activate 'init-db' profiles also when starting the application at the first time.

Prerequisite

Java SE Development Kit 17 or above
Internet connection

Compile and run

Apache Maven wrapper is included, no additional package manager is necessary.

Compile (On Microsoft Windows)

mvnw package

Run (On Microsoft Windows)

mvnw spring-boot:run

Press Ctrl+C to stop.

Maven profiles

ID	Activated by default	Function
db-h2	Yes	Using embedded H2 database
db-mysql	No	Using MySQL database
init-db	Yes	Import schema and initial data into database

Account

Username	Password	Authorities
user1	user1	USER
user2	user2	USER
admin	admin	USER, ADMIN

Source code

You may download source code from here.

Micronaut dependency injection

Salad Lam — Mon, 07 Apr 2025 19:43:15 +0000

Following library is used

Java 17
Micronaut 4.7.6

Sample code

A REST service which returns the current time in JSON format.

ApplicationDateTimeService

package example.micronaut;

import java.time.LocalDateTime;

public interface ApplicationDateTimeService {
    LocalDateTime getCurrentLocalDateTime();
}

ApplicationDateTimeServiceImpl

package example.micronaut;

import jakarta.inject.Singleton;
import java.time.LocalDateTime;

@Singleton
public class ApplicationDateTimeServiceImpl implements ApplicationDateTimeService {
    @Override
    public LocalDateTime getCurrentLocalDateTime() {
        return LocalDateTime.now();
    }
}

IndexController

package example.micronaut;

import io.micronaut.http.HttpResponse;
import io.micronaut.http.MediaType;
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import io.micronaut.http.annotation.Produces;
import jakarta.inject.Inject;
import java.time.format.DateTimeFormatter;

@Controller
public class IndexController {
    private final ApplicationDateTimeService service;
    private final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm:ss");

    @Inject
    public IndexController(ApplicationDateTimeService service) {
        this.service = service;
    }

    @Produces(MediaType.APPLICATION_JSON)
    @Get
    public HttpResponse<Message> index() {
        return HttpResponse.ok(new Message(service.getCurrentLocalDateTime().format(formatter)));
    }
}

Message

package example.micronaut;

import io.micronaut.serde.annotation.Serdeable;

@Serdeable
public class Message {
    private final String message;

    public Message(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

Synthetic classes for dependency injection

After the project is compiled, following synthetic classes are generated. And they are extended from io.micronaut.context.AbstractInitializableBeanDefinitionAndReference.

Bean class	Synthetic class
ApplicationDateTimeServiceImpl	$ApplicationDateTimeServiceImpl$Definition
IndexController	$IndexController$Definition

These classes contain information of bean classes, as well as the code that instantiates those beans.

$ApplicationDateTimeServiceImpl$Definition

package example.micronaut;

import io.micronaut.context.AbstractInitializableBeanDefinition;
import io.micronaut.context.AbstractInitializableBeanDefinitionAndReference;
import io.micronaut.context.BeanContext;
import io.micronaut.context.BeanResolutionContext;
import io.micronaut.context.condition.Condition;
import io.micronaut.core.annotation.AnnotationMetadata;
import io.micronaut.core.annotation.Generated;
import io.micronaut.core.type.Argument;
import io.micronaut.inject.BeanDefinition;
import io.micronaut.inject.ExecutableMethodsDefinition;
import io.micronaut.inject.annotation.DefaultAnnotationMetadata;
import java.util.List;
import java.util.Map;
import java.util.Optional;

// $FF: synthetic class
@Generated(
    service = "io.micronaut.inject.BeanDefinitionReference"
)
public class $ApplicationDateTimeServiceImpl$Definition extends AbstractInitializableBeanDefinitionAndReference<ApplicationDateTimeServiceImpl> {
    public static final AnnotationMetadata $ANNOTATION_METADATA = new DefaultAnnotationMetadata(Map.of("jakarta.inject.Singleton", Map.of()), Map.of("jakarta.inject.Scope", Map.of()), Map.of("jakarta.inject.Scope", Map.of()), Map.of("jakarta.inject.Singleton", Map.of()), Map.of("jakarta.inject.Scope", List.of("jakarta.inject.Singleton")), false, false);
    private static final Throwable $FAILURE;
    private static final AbstractInitializableBeanDefinition.MethodOrFieldReference $CONSTRUCTOR;
    private static final AbstractInitializableBeanDefinition.PrecalculatedInfo $INFO;

    public ApplicationDateTimeServiceImpl instantiate(BeanResolutionContext var1, BeanContext var2) {
        ApplicationDateTimeServiceImpl var3 = new ApplicationDateTimeServiceImpl();
        var3 = (ApplicationDateTimeServiceImpl)this.inject(var1, var2, var3);
        return var3;
    }

    public Object inject(BeanResolutionContext var1, BeanContext var2, Object var3) {
        ApplicationDateTimeServiceImpl var4 = (ApplicationDateTimeServiceImpl)var3;
        return super.inject(var1, var2, var3);
    }

    static {
        try {
            $CONSTRUCTOR = new AbstractInitializableBeanDefinition.MethodReference(ApplicationDateTimeServiceImpl.class, "<init>", (Argument[])null, (AnnotationMetadata)null);
        } catch (Throwable var0) {
            $FAILURE = var0;
            $CONSTRUCTOR = null;
        }

        $INFO = new AbstractInitializableBeanDefinition.PrecalculatedInfo(Optional.of("jakarta.inject.Singleton"), false, false, true, false, false, false, false, false);
    }

    public $ApplicationDateTimeServiceImpl$Definition() {
        this(ApplicationDateTimeServiceImpl.class, $CONSTRUCTOR);
    }

    protected $ApplicationDateTimeServiceImpl$Definition(Class var1, AbstractInitializableBeanDefinition.MethodOrFieldReference var2) {
        super(var1, var2, $ANNOTATION_METADATA, (AbstractInitializableBeanDefinition.MethodReference[])null, (AbstractInitializableBeanDefinition.FieldReference[])null, (AbstractInitializableBeanDefinition.AnnotationReference[])null, (ExecutableMethodsDefinition)null, (Map)null, $INFO, new Condition[0], new Condition[0], $FAILURE);
    }

    public BeanDefinition load() {
        return new $ApplicationDateTimeServiceImpl$Definition();
    }

    public boolean isEnabled(BeanContext var1) {
        return true;
    }

    public boolean isEnabled(BeanContext var1, BeanResolutionContext var2) {
        return true;
    }
}

$IndexController$Definition

package example.micronaut;

import io.micronaut.context.AbstractInitializableBeanDefinition;
import io.micronaut.context.AbstractInitializableBeanDefinitionAndReference;
import io.micronaut.context.BeanContext;
import io.micronaut.context.BeanResolutionContext;
import io.micronaut.context.Qualifier;
import io.micronaut.context.condition.Condition;
import io.micronaut.core.annotation.AnnotationMetadata;
import io.micronaut.core.annotation.Generated;
import io.micronaut.core.type.Argument;
import io.micronaut.inject.BeanDefinition;
import io.micronaut.inject.annotation.DefaultAnnotationMetadata;
import java.util.List;
import java.util.Map;
import java.util.Optional;

// $FF: synthetic class
@Generated(
    service = "io.micronaut.inject.BeanDefinitionReference"
)
public class $IndexController$Definition extends AbstractInitializableBeanDefinitionAndReference<IndexController> {
    public static final AnnotationMetadata $ANNOTATION_METADATA = new DefaultAnnotationMetadata(Map.of("io.micronaut.http.annotation.Controller", Map.of(), "jakarta.inject.Singleton", Map.of()), Map.of("io.micronaut.context.annotation.Bean", Map.of(), "io.micronaut.context.annotation.DefaultScope", Map.of("value", $micronaut_load_class_value_0())), Map.of("io.micronaut.context.annotation.Bean", Map.of(), "io.micronaut.context.annotation.DefaultScope", Map.of("value", $micronaut_load_class_value_0())), Map.of("io.micronaut.http.annotation.Controller", Map.of(), "jakarta.inject.Singleton", Map.of()), Map.of("io.micronaut.context.annotation.Bean", List.of("io.micronaut.http.annotation.Controller"), "io.micronaut.context.annotation.DefaultScope", List.of("io.micronaut.http.annotation.Controller")), false, false);
    private static final Throwable $FAILURE;
    private static final AbstractInitializableBeanDefinition.MethodOrFieldReference $CONSTRUCTOR;
    private static final $IndexController$Definition$Exec $EXEC;
    private static final AbstractInitializableBeanDefinition.PrecalculatedInfo $INFO;

    public IndexController instantiate(BeanResolutionContext var1, BeanContext var2) {
        IndexController var3 = new IndexController((ApplicationDateTimeService)super.getBeanForConstructorArgument(var1, var2, 0, (Qualifier)null));
        var3 = (IndexController)this.inject(var1, var2, var3);
        return var3;
    }

    public Object inject(BeanResolutionContext var1, BeanContext var2, Object var3) {
        IndexController var4 = (IndexController)var3;
        return super.inject(var1, var2, var3);
    }

    static {
        try {
            $CONSTRUCTOR = new AbstractInitializableBeanDefinition.MethodReference(IndexController.class, "<init>", new Argument[]{Argument.of(ApplicationDateTimeService.class, "service")}, new DefaultAnnotationMetadata(Map.of("jakarta.inject.Inject", Map.of()), Map.of(), Map.of(), Map.of("jakarta.inject.Inject", Map.of()), Map.of(), false, false));
            $EXEC = new $IndexController$Definition$Exec();
        } catch (Throwable var0) {
            $FAILURE = var0;
            $CONSTRUCTOR = null;
            $EXEC = null;
        }

        $INFO = new AbstractInitializableBeanDefinition.PrecalculatedInfo(Optional.empty(), false, false, true, false, false, false, false, false);
        DefaultAnnotationMetadata.registerAnnotationDefaults($micronaut_load_class_value_1(), Map.of("consumes", new String[]{"application/json"}, "produces", new String[]{"application/json"}, "value", "/"));
        DefaultAnnotationMetadata.registerAnnotationDefaults($micronaut_load_class_value_2(), Map.of("single", false, "value", new String[]{"application/json"}));
        DefaultAnnotationMetadata.registerAnnotationDefaults($micronaut_load_class_value_3(), Map.of("consumes", new String[0], "headRoute", true, "processes", new String[0], "produces", new String[0], "single", false, "uri", "/", "uris", new String[]{"/"}, "value", "/"));
        DefaultAnnotationMetadata.registerAnnotationDefaults($micronaut_load_class_value_4(), Map.of("uris", new String[]{"/"}, "value", "/"));
        DefaultAnnotationMetadata.registerAnnotationType($micronaut_load_class_value_5());
    }

    public $IndexController$Definition() {
        this(IndexController.class, $CONSTRUCTOR);
    }

    protected $IndexController$Definition(Class var1, AbstractInitializableBeanDefinition.MethodOrFieldReference var2) {
        super(var1, var2, $ANNOTATION_METADATA, (AbstractInitializableBeanDefinition.MethodReference[])null, (AbstractInitializableBeanDefinition.FieldReference[])null, (AbstractInitializableBeanDefinition.AnnotationReference[])null, $EXEC, (Map)null, $INFO, new Condition[0], new Condition[0], $FAILURE);
    }

    public BeanDefinition load() {
        return new $IndexController$Definition();
    }

    public boolean isEnabled(BeanContext var1) {
        return true;
    }

    public boolean isEnabled(BeanContext var1, BeanResolutionContext var2) {
        return true;
    }
}

Following empty files are created.

META-INF/micronaut/io.micronaut.inject.BeanDefinitionReference/example.micronaut.$ApplicationDateTimeServiceImpl$Definition
META-INF/micronaut/io.micronaut.inject.BeanDefinitionReference/example.micronaut.$IndexController$Definition

Synthetic classes for avoid using Java Reflection API

Following synthetic class is generated also after compilation. And it is extended from io.micronaut.context.AbstractExecutableMethodsDefinition.

Bean class	Synthetic class
IndexController	$IndexController$Definition$Exec

Methods of a REST controller are normally called by the http server library by using Java Reflection API. Code in synthetic class performs the same function which Java Reflection API does.

$IndexController$Definition$Exec

package example.micronaut;

import example.micronaut..IndexController.Definition;
import io.micronaut.context.AbstractExecutableMethodsDefinition;
import io.micronaut.core.annotation.AnnotationMetadata;
import io.micronaut.core.annotation.Generated;
import io.micronaut.core.reflect.ReflectionUtils;
import io.micronaut.core.type.Argument;
import io.micronaut.http.HttpResponse;
import io.micronaut.inject.annotation.AnnotationMetadataHierarchy;
import io.micronaut.inject.annotation.DefaultAnnotationMetadata;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Map;

// $FF: synthetic class
@Generated
final class $IndexController$Definition$Exec extends AbstractExecutableMethodsDefinition {
    private static final AbstractExecutableMethodsDefinition.MethodReference[] $METHODS_REFERENCES = new AbstractExecutableMethodsDefinition.MethodReference[]{$metadata$index()};

    private static final AbstractExecutableMethodsDefinition.MethodReference $metadata$index() {
        return new AbstractExecutableMethodsDefinition.MethodReference(IndexController.class, new AnnotationMetadataHierarchy(new AnnotationMetadata[]{Definition.$ANNOTATION_METADATA, new DefaultAnnotationMetadata(Map.of("io.micronaut.http.annotation.Get", Map.of(), "io.micronaut.http.annotation.Produces", Map.of("value", new String[]{"application/json"})), Map.of("io.micronaut.context.annotation.Executable", Map.of(), "io.micronaut.core.annotation.EntryPoint", Map.of(), "io.micronaut.http.annotation.HttpMethodMapping", Map.of()), Map.of("io.micronaut.context.annotation.Executable", Map.of(), "io.micronaut.core.annotation.EntryPoint", Map.of(), "io.micronaut.http.annotation.HttpMethodMapping", Map.of()), Map.of("io.micronaut.http.annotation.Get", Map.of(), "io.micronaut.http.annotation.Produces", Map.of("value", new String[]{"application/json"})), Map.of("io.micronaut.context.annotation.Executable", List.of("io.micronaut.http.annotation.HttpMethodMapping"), "io.micronaut.core.annotation.EntryPoint", List.of("io.micronaut.http.annotation.HttpMethodMapping"), "io.micronaut.http.annotation.HttpMethodMapping", List.of("io.micronaut.http.annotation.Get")), false, false)}), "index", Argument.of(HttpResponse.class, "io.micronaut.http.HttpResponse", (AnnotationMetadata)null, new Argument[]{Argument.of(Message.class, "B")}), (Argument[])null, false, false);
    }

    public $IndexController$Definition$Exec() {
        super($METHODS_REFERENCES);
    }

    protected final Object dispatch(int var1, Object var2, Object[] var3) {
        switch (var1) {
            case 0 -> {
                return ((IndexController)var2).index();
            }
            default -> throw this.unknownDispatchAtIndexException(var1);
        }
    }

    protected final Method getTargetMethodByIndex(int var1) {
        switch (var1) {
            case 0 -> {
                return ReflectionUtils.getRequiredMethod(IndexController.class, "index", ReflectionUtils.EMPTY_CLASS_ARRAY);
            }
            default -> throw this.unknownDispatchAtIndexException(var1);
        }
    }
}

Synthetic classes for JSON serialization/deserialization

Following synthetic class is generated also after compilation. And it is extended from io.micronaut.inject.beans.AbstractInitializableBeanIntrospectionAndReference.

Class	Synthetic class
Message	$Message$Introspection

JSON serialization/deserialization libraries are also heavily relied on Java Reflection API. Code in synthetic class performs JSON serialization/deserialization.

$Message$Introspection

package example.micronaut;

import io.micronaut.core.annotation.AnnotationMetadata;
import io.micronaut.core.annotation.Generated;
import io.micronaut.core.reflect.ReflectionUtils;
import io.micronaut.core.type.Argument;
import io.micronaut.inject.annotation.DefaultAnnotationMetadata;
import io.micronaut.inject.beans.AbstractInitializableBeanIntrospection;
import io.micronaut.inject.beans.AbstractInitializableBeanIntrospectionAndReference;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Map;

// $FF: synthetic class
@Generated(
    service = "example.micronaut.$Message$Introspection"
)
public final class $Message$Introspection extends AbstractInitializableBeanIntrospectionAndReference {
    private static final Argument[] $CONSTRUCTOR_ARGUMENTS = new Argument[]{Argument.of(String.class, "message")};
    private static final AbstractInitializableBeanIntrospection.BeanPropertyRef[] $PROPERTIES_REFERENCES;
    public static final AnnotationMetadata $ANNOTATION_METADATA;

    static {
        AbstractInitializableBeanIntrospection.BeanPropertyRef[] var10000 = new AbstractInitializableBeanIntrospection.BeanPropertyRef[1];
        Argument var0 = Argument.of(String.class, "message");
        var10000[0] = new AbstractInitializableBeanIntrospection.BeanPropertyRef(var0, var0, (Argument)null, 0, -1, 1, true, true);
        $PROPERTIES_REFERENCES = var10000;
        DefaultAnnotationMetadata.registerAnnotationDefaults($micronaut_load_class_value_0(), Map.of("naming", $micronaut_load_class_value_1(), "validate", true));
        DefaultAnnotationMetadata.registerAnnotationType($micronaut_load_class_value_2());
        DefaultAnnotationMetadata.registerAnnotationDefaults($micronaut_load_class_value_3(), Map.of("as", $micronaut_load_class_value_4(), "naming", $micronaut_load_class_value_1(), "using", $micronaut_load_class_value_5(), "validate", true));
        DefaultAnnotationMetadata.registerAnnotationDefaults($micronaut_load_class_value_6(), Map.of("as", $micronaut_load_class_value_4(), "naming", $micronaut_load_class_value_1(), "using", $micronaut_load_class_value_7(), "validate", true));
        $ANNOTATION_METADATA = new DefaultAnnotationMetadata(Map.of("io.micronaut.serde.annotation.Serdeable", Map.of()), Map.of("io.micronaut.core.annotation.Internal", Map.of(), "io.micronaut.core.annotation.Introspected", Map.of(), "io.micronaut.serde.annotation.Serdeable$Deserializable", Map.of(), "io.micronaut.serde.annotation.Serdeable$Serializable", Map.of(), "io.micronaut.serde.config.annotation.SerdeConfig", Map.of()), Map.of("io.micronaut.core.annotation.Internal", Map.of(), "io.micronaut.core.annotation.Introspected", Map.of(), "io.micronaut.serde.annotation.Serdeable$Deserializable", Map.of(), "io.micronaut.serde.annotation.Serdeable$Serializable", Map.of(), "io.micronaut.serde.config.annotation.SerdeConfig", Map.of()), Map.of("io.micronaut.serde.annotation.Serdeable", Map.of()), Map.of("io.micronaut.core.annotation.Internal", List.of("io.micronaut.serde.config.annotation.SerdeConfig"), "io.micronaut.core.annotation.Introspected", List.of("io.micronaut.serde.annotation.Serdeable", "io.micronaut.serde.annotation.Serdeable$Serializable", "io.micronaut.serde.annotation.Serdeable$Deserializable"), "io.micronaut.serde.annotation.Serdeable$Deserializable", List.of("io.micronaut.serde.annotation.Serdeable"), "io.micronaut.serde.annotation.Serdeable$Serializable", List.of("io.micronaut.serde.annotation.Serdeable"), "io.micronaut.serde.config.annotation.SerdeConfig", List.of("io.micronaut.serde.annotation.Serdeable", "io.micronaut.serde.annotation.Serdeable$Serializable", "io.micronaut.serde.annotation.Serdeable$Deserializable")), false, false);
    }

    public $Message$Introspection() {
        super(Message.class, $ANNOTATION_METADATA, (AnnotationMetadata)null, $CONSTRUCTOR_ARGUMENTS, $PROPERTIES_REFERENCES, (AbstractInitializableBeanIntrospection.BeanMethodRef[])null);
    }

    protected final Object dispatchOne(int var1, Object var2, Object var3) {
        switch (var1) {
            case 0:
                return ((Message)var2).getMessage();
            case 1:
                Message var4 = (Message)var2;
                return new Message((String)var3);
            default:
                throw this.unknownDispatchAtIndexException(var1);
        }
    }

    protected final Method getTargetMethodByIndex(int var1) {
        switch (var1) {
            case 0 -> {
                return ReflectionUtils.getRequiredMethod(Message.class, "getMessage", ReflectionUtils.EMPTY_CLASS_ARRAY);
            }
            default -> throw this.unknownDispatchAtIndexException(var1);
        }
    }

    public final boolean hasConstructor() {
        return true;
    }

    public Object instantiateInternal(Object[] var1) {
        return new Message((String)var1[0]);
    }

    public final boolean isBuildable() {
        return true;
    }

    public final boolean hasBuilder() {
        return false;
    }
}

Following empty files are created.

META-INF/micronaut/io.micronaut.core.beans.BeanIntrospectionReference/example.micronaut.$Message$Introspection

Java compiler processor

In micronaut-inject-java-4.7.14.jar file, it contains following classes which implement javax.annotation.processing.Processor interface for generating synthetic classes.

io.micronaut.annotation.processing.BeanDefinitionInjectProcessor
io.micronaut.annotation.processing.ConfigurationMetadataProcessor
io.micronaut.annotation.processing.PackageConfigurationInjectProcessor
io.micronaut.annotation.processing.TypeElementVisitorProcessor
io.micronaut.annotation.processing.AggregatingTypeElementVisitorProcessor

And micronaut-http-validation-4.7.14.jar, micronaut-security-annotations-4.11.3.jar and micronaut-serde-processor-2.12.1.jar files contain classes for scanning annotations which are interesting.

Maven notes (1)

Salad Lam — Mon, 27 Jan 2025 19:05:51 +0000

Lifecycle

default, clean and site

Phase

When executes

mvn compile

Phase from validate to compile will be gone through.

Full list of phases is here.

Goal

In plugin goals are defined and are binded to phases. For example, the compile goal in maven-compiler-plugin is binded to compile phase.

The order of goal execution of plugins in the same phase is defined by entry order in the plugins section of the pom.xml file.

To list the plugin's goals is binded to the package phase.

mvn help:describe -Dcmd=package

To check goals and phases from plugin's source code

To configure frontend-maven-plugin plugin.

<plugin>
  <groupId>com.github.eirslett</groupId>
  <artifactId>frontend-maven-plugin</artifactId>
  <version>1.15.1</version>
  <executions>
    <execution>
      <id>install-node-and-npm</id>
      <goals>
        <goal>install-node-and-npm</goal>
      </goals>
    </execution>
    <execution>
      <id>npm install</id>
      <goals>
        <goal>npm</goal>
      </goals>
    </execution>
    ..
  </executions>
</plugin>

Following is the class of defining install-node-and-npm and npm goal. They are binded to generate-resources phase.

@Mojo(name="install-node-and-npm", defaultPhase = LifecyclePhase.GENERATE_RESOURCES, threadSafe = true)
public final class InstallNodeAndNpmMojo extends AbstractFrontendMojo {
  // ...
}

@Mojo(name="npm",  defaultPhase = LifecyclePhase.GENERATE_RESOURCES, threadSafe = true)
public final class NpmMojo extends AbstractFrontendMojo {
  // ...
}

Profile

add/override properties
add dependencies
add plugin dependencies
add pluginManagement dependencies

set default profile

<!-- (1) --->
<profiles>
  <profile>
    <activation>
      <property>
        <name>debug</name>
      </property>
    </activation>
    ...
  </profile>
</profiles>

<!-- (2) --->
<profile>
  <id>dev</id>
  <activation>
    <activeByDefault>true</activeByDefault>
  </activation>
  ...
</profile>

override enabled profile

assumes profile dev is enabled by default, and to enable profile production

mvn -P=-dev,production

Quarkus extension

Salad Lam — Mon, 27 Jan 2025 14:45:37 +0000

There is 2 files for a extension, for example Liquibase

quarkus-liquibase-3.17.7.jar
quarkus-liquibase-deployment-3.17.7.jar

File quarkus-liquibase is the runtime module and quarkus-liquibase-deployment is deployment module, and is used during the augmentation phase of the build.

Deployment module

contain classes (build step processor) of methods which annotated with @BuildStep (build step)

Runtime module

contain runtime and Recorder classes

Subclass of io.quarkus.builder.item.BuildItem

final and immutable class
created by @BuildStep, store information for other @BuildStep

io.quarkus.deployment.annotations.BuildStep annotation

produce BuildItems (e.g. io.quarkus.jdbc.h2.deployment.JDBCH2Processor#feature)
consume BuildItems and then produce BuildItems (e.g. io.quarkus.jdbc.h2.deployment.JDBCH2Processor#registerDriver)
consume BuildItems (e.g. io.quarkus.deployment.steps.ShutdownListenerBuildStep#setupShutdown)
accept BuildItem, List, BuildProducer, Config or Recorder as parameters
translation, create something
if @Record is annotated also, proxy recorder provided is also

Classes contain BuildSteps are listed in META-INF/quarkus-build-steps.list

Recorder example

Following is a sample code to demonstrate bytecode generation during the augmentation phase

Recorder, Processor and BuildItem class

@Recorder
public class MyMessageRecorder {

    private static final Logger LOGGER = LoggerFactory.getLogger(MyMessageRecorder.class);

    // will not be call in buildtime augmentation
    public void sayHello(String message) {
        LOGGER.info("Hello {}!", message);
    }

}

public class MyMessageProcessor {

    @BuildStep
    @Record(ExecutionTime.RUNTIME_INIT)
    @Consume(MyMessageBuildItem.class)
    public void printMessage(MyMessageRecorder recorder, MyMessageBuildItem myMessageBuildItem) {
        recorder.sayHello(myMessageBuildItem.getMessage());
    }

}

public final class MyMessageBuildItem extends SimpleBuildItem {

    private final String message;

    public MyMessageBuildItem(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

}

Test class

class TestExt {

    @Test
    void testBytecode() {
        ClassLoader originalCl = Thread.currentThread().getContextClassLoader();
        try {
            ClassLoader cl = QuarkusClassLoader.builder("CodeGenerator Config ClassLoader", originalCl, false).build();
            Thread.currentThread().setContextClassLoader(cl);
            BytecodeRecorderImpl bytecodeRecorder = new BytecodeRecorderImpl(
                    true,
                    "MyMessageProcessor",
                    "printMessage",
                    Integer.toString(Math.abs("printMessage".hashCode())),
                    true,
                    s -> {
                        throw new RuntimeException("Not implemented for testing");
                    });

            MyMessageBuildItem buildItem = new MyMessageBuildItem("world");
            MyMessageRecorder myMessageRecorder = bytecodeRecorder.getRecordingProxy(MyMessageRecorder.class);
            MyMessageProcessor processor = new MyMessageProcessor();
            processor.printMessage(myMessageRecorder, buildItem);

            GeneratedClassOutput generatedClassOutput = new GeneratedClassOutput();
            bytecodeRecorder.writeBytecode(generatedClassOutput);
            for (GeneratedClass c : generatedClassOutput.getOutput()) {
                try (FileOutputStream outputStream = new FileOutputStream("target/" + c.getName() + ".class")) {
                    outputStream.write(c.getData());
                }
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            Thread.currentThread().setContextClassLoader(originalCl);
        }
    }

}

Finally a bytecode class file is generated. Following is the class

package io.quarkus.deployment.steps;

import io.quarkus.runtime.StartupContext;
import io.quarkus.runtime.StartupTask;
import MyMessageRecorder;

// $FF: synthetic class
public class MyMessageProcessor$printMessage1094908058 implements StartupTask {
    public MyMessageProcessor$printMessage1094908058() {
    }

    public void deploy(StartupContext var1) {
        var1.setCurrentBuildStepName("MyMessageProcessor.printMessage");
        Object[] var2 = this.$quarkus$createArray();
        this.deploy_0(var1, var2);
    }

    public void deploy_0(StartupContext var1, Object[] var2) {
        (new MyMessageRecorder()).sayHello("world");
    }

    public Object[] $quarkus$createArray() {
        return new Object[0];
    }
}

Quarkus notes (2)

Salad Lam — Sun, 19 Jan 2025 14:37:32 +0000

About quarkus-app/quarkus/transformed-bytecode.jar file

Java reflection is not well supported on native executable code generation. But some libraries such as JPA are highly dependent on Java reflection. So some classes will be decompiled, added codes which were originally done by Java reflection, and then compiled and packed into transformed-bytecode.jar.

Following is the original code of a JPA entity.

@Entity
@Table(name = "users")
@UserDefinition
public class User {

    @Id
    @Username
    private String username;
    @Column(nullable = false)
    @Password
    private String password;
    @Column
    private Integer enabled;
    @ManyToMany
    @JoinTable(name = "user_authority", joinColumns = @JoinColumn(name = "username"), inverseJoinColumns = @JoinColumn(name = "authority_id"))
    private Set<Authority> authorities;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getEnabled() {
        return enabled;
    }

    public void setEnabled(Integer enabled) {
        this.enabled = enabled;
    }

    public Set<Authority> getAuthorities() {
        return authorities;
    }

    public void setAuthorities(Set<Authority> authorities) {
        this.authorities = authorities;
    }

    @Roles
    public String authorities() {
        return StringUtils.join(authorities, ",");
    }

}

Code is transformed as following.

@Entity
@Table(
    name = "users"
)
@UserDefinition
@EnhancementInfo(
    version = "6.6.4.Final"
)
public class User implements ManagedEntity, PersistentAttributeInterceptable, ExtendedSelfDirtinessTracker {
    @Id
    @Username
    String username;
    @Column(
        nullable = false
    )
    @Password
    String password;
    @Column
    Integer enabled;
    @ManyToMany
    @JoinTable(
        name = "user_authority",
        joinColumns = {@JoinColumn(
    name = "username"
)},
        inverseJoinColumns = {@JoinColumn(
    name = "authority_id"
)}
    )
    Set<Authority> authorities;
    @Transient
    private transient EntityEntry $$_hibernate_entityEntryHolder;
    @Transient
    private transient ManagedEntity $$_hibernate_previousManagedEntity;
    @Transient
    private transient ManagedEntity $$_hibernate_nextManagedEntity;
    @Transient
    private transient boolean $$_hibernate_useTracker;
    @Transient
    private transient PersistentAttributeInterceptor $$_hibernate_attributeInterceptor;
    @Transient
    private transient DirtyTracker $$_hibernate_tracker;
    @Transient
    private transient CollectionTracker $$_hibernate_collectionTracker;

    public User() {
    }

    public String getUsername() {
        return this.$$_hibernate_read_username();
    }

    public void setUsername(String username) {
        this.$$_hibernate_write_username(username);
    }

    public String getPassword() {
        return this.$$_hibernate_read_password();
    }

    public void setPassword(String password) {
        this.$$_hibernate_write_password(password);
    }

    public Integer getEnabled() {
        return this.$$_hibernate_read_enabled();
    }

    public void setEnabled(Integer enabled) {
        this.$$_hibernate_write_enabled(enabled);
    }

    public Set<Authority> getAuthorities() {
        return this.$$_hibernate_read_authorities();
    }

    public void setAuthorities(Set<Authority> authorities) {
        this.$$_hibernate_write_authorities(authorities);
    }

    @Roles
    public String authorities() {
        return StringUtils.join(this.$$_hibernate_read_authorities(), ",");
    }

    public Object $$_hibernate_getEntityInstance() {
        return this;
    }

    public EntityEntry $$_hibernate_getEntityEntry() {
        return this.$$_hibernate_entityEntryHolder;
    }

    public void $$_hibernate_setEntityEntry(EntityEntry var1) {
        this.$$_hibernate_entityEntryHolder = var1;
    }

    public ManagedEntity $$_hibernate_getPreviousManagedEntity() {
        return this.$$_hibernate_previousManagedEntity;
    }

    public void $$_hibernate_setPreviousManagedEntity(ManagedEntity var1) {
        this.$$_hibernate_previousManagedEntity = var1;
    }

    public ManagedEntity $$_hibernate_getNextManagedEntity() {
        return this.$$_hibernate_nextManagedEntity;
    }

    public void $$_hibernate_setNextManagedEntity(ManagedEntity var1) {
        this.$$_hibernate_nextManagedEntity = var1;
    }

    public boolean $$_hibernate_useTracker() {
        return this.$$_hibernate_useTracker;
    }

    public void $$_hibernate_setUseTracker(boolean var1) {
        this.$$_hibernate_useTracker = var1;
    }

    public PersistentAttributeInterceptor $$_hibernate_getInterceptor() {
        return this.$$_hibernate_attributeInterceptor;
    }

    public void $$_hibernate_setInterceptor(PersistentAttributeInterceptor var1) {
        this.$$_hibernate_attributeInterceptor = var1;
    }

    public void $$_hibernate_trackChange(String var1) {
        if (this.$$_hibernate_tracker == null) {
            this.$$_hibernate_tracker = new SimpleFieldTracker();
        }

        this.$$_hibernate_tracker.add(var1);
    }

    public String[] $$_hibernate_getDirtyAttributes() {
        Object var1 = null;
        String[] var2;
        if (this.$$_hibernate_collectionTracker == null) {
            var2 = this.$$_hibernate_tracker == null ? ArrayHelper.EMPTY_STRING_ARRAY : this.$$_hibernate_tracker.get();
        } else {
            if (this.$$_hibernate_tracker == null) {
                this.$$_hibernate_tracker = new SimpleFieldTracker();
            }

            this.$$_hibernate_getCollectionFieldDirtyNames(this.$$_hibernate_tracker);
            var2 = this.$$_hibernate_tracker.get();
        }

        return var2;
    }

    public boolean $$_hibernate_hasDirtyAttributes() {
        boolean var1 = false;
        var1 = this.$$_hibernate_tracker != null && !this.$$_hibernate_tracker.isEmpty() || this.$$_hibernate_areCollectionFieldsDirty();
        return var1;
    }

    public void $$_hibernate_clearDirtyAttributes() {
        if (this.$$_hibernate_tracker != null) {
            this.$$_hibernate_tracker.clear();
        }

        this.$$_hibernate_clearDirtyCollectionNames();
    }

    public void $$_hibernate_suspendDirtyTracking(boolean var1) {
        if (this.$$_hibernate_tracker == null) {
            this.$$_hibernate_tracker = new SimpleFieldTracker();
        }

        this.$$_hibernate_tracker.suspend(var1);
    }

    public CollectionTracker $$_hibernate_getCollectionTracker() {
        return this.$$_hibernate_collectionTracker;
    }

    public boolean $$_hibernate_areCollectionFieldsDirty() {
        boolean var1 = false;
        if (!var1 && this.$$_hibernate_collectionTracker != null) {
            int var2 = this.$$_hibernate_collectionTracker.getSize("authorities");
            if (this.authorities == null && var2 != -1) {
                var1 = true;
            } else if (this.authorities != null && (!(this.authorities instanceof PersistentCollection) || ((PersistentCollection)this.authorities).wasInitialized()) && var2 != this.authorities.size()) {
                var1 = true;
            }
        }

        return var1;
    }

    public void $$_hibernate_getCollectionFieldDirtyNames(DirtyTracker var1) {
        if (this.$$_hibernate_collectionTracker != null) {
            int var2 = this.$$_hibernate_collectionTracker.getSize("authorities");
            if (this.authorities == null && var2 != -1) {
                var1.add("authorities");
            } else if (this.authorities != null && (!(this.authorities instanceof PersistentCollection) || ((PersistentCollection)this.authorities).wasInitialized()) && var2 != this.authorities.size()) {
                var1.add("authorities");
            }
        }

    }

    public void $$_hibernate_clearDirtyCollectionNames() {
        if (this.$$_hibernate_collectionTracker == null) {
            this.$$_hibernate_collectionTracker = new SimpleCollectionTracker();
        }

        this.$$_hibernate_removeDirtyFields((LazyAttributeLoadingInterceptor)null);
    }

    public void $$_hibernate_removeDirtyFields(LazyAttributeLoadingInterceptor var1) {
        if (this.$$_hibernate_attributeInterceptor instanceof LazyAttributeLoadingInterceptor) {
            var1 = (LazyAttributeLoadingInterceptor)this.$$_hibernate_attributeInterceptor;
        }

        if (var1 == null || var1.isAttributeLoaded("authorities")) {
            if (this.authorities != null && (!(this.authorities instanceof PersistentCollection) || ((PersistentCollection)this.authorities).wasInitialized())) {
                this.$$_hibernate_collectionTracker.add("authorities", this.authorities.size());
            } else {
                this.$$_hibernate_collectionTracker.add("authorities", -1);
            }
        }

    }

    public String $$_hibernate_read_username() {
        if (this.$$_hibernate_getInterceptor() != null) {
            this.username = (String)this.$$_hibernate_getInterceptor().readObject(this, "username", this.username);
        }

        return this.username;
    }

    public void $$_hibernate_write_username(String var1) {
        if (this.$$_hibernate_getInterceptor() != null) {
            this.username = (String)this.$$_hibernate_getInterceptor().writeObject(this, "username", this.username, var1);
        } else {
            this.username = var1;
        }
    }

    public String $$_hibernate_read_password() {
        if (this.$$_hibernate_getInterceptor() != null) {
            this.password = (String)this.$$_hibernate_getInterceptor().readObject(this, "password", this.password);
        }

        return this.password;
    }

    public void $$_hibernate_write_password(String var1) {
        if (!InlineDirtyCheckerEqualsHelper.areEquals(this, "password", var1, this.password)) {
            this.$$_hibernate_trackChange("password");
        }

        if (this.$$_hibernate_getInterceptor() != null) {
            this.password = (String)this.$$_hibernate_getInterceptor().writeObject(this, "password", this.password, var1);
        } else {
            this.password = var1;
        }
    }

    public Integer $$_hibernate_read_enabled() {
        if (this.$$_hibernate_getInterceptor() != null) {
            this.enabled = (Integer)this.$$_hibernate_getInterceptor().readObject(this, "enabled", this.enabled);
        }

        return this.enabled;
    }

    public void $$_hibernate_write_enabled(Integer var1) {
        if (!InlineDirtyCheckerEqualsHelper.areEquals(this, "enabled", var1, this.enabled)) {
            this.$$_hibernate_trackChange("enabled");
        }

        if (this.$$_hibernate_getInterceptor() != null) {
            this.enabled = (Integer)this.$$_hibernate_getInterceptor().writeObject(this, "enabled", this.enabled, var1);
        } else {
            this.enabled = var1;
        }
    }

    public Set $$_hibernate_read_authorities() {
        if (this.$$_hibernate_getInterceptor() != null) {
            this.authorities = (Set)this.$$_hibernate_getInterceptor().readObject(this, "authorities", this.authorities);
        }

        return this.authorities;
    }

    public void $$_hibernate_write_authorities(Set var1) {
        if (this.$$_hibernate_getInterceptor() != null) {
            this.authorities = (Set)this.$$_hibernate_getInterceptor().writeObject(this, "authorities", this.authorities, var1);
        } else {
            this.authorities = var1;
        }
    }
}

About XXX$$accessor class

Some classes and their methods are defined in package-private, so they are inaccessible in many case. For example class io.quarkus.liquibase.deployment.LiquibaseProcessor.

class LiquibaseProcessor {

    @BuildStep
    FeatureBuildItem feature() {
        return new FeatureBuildItem(Feature.LIQUIBASE);
    }

    // ...
}

So a synthetic XXX$$accessor class is generated so that public method is provided for accessing instances of these classes.

@io.quarkus.Generated("Quarkus annotation processor")
public final class LiquibaseProcessor$$accessor {
    private LiquibaseProcessor$$accessor() {}
    public static Object construct() {
        return new LiquibaseProcessor();
    }
}

The class can be located by io.quarkus.deployment.AccessorFinder.

About quarkus/bootstrap/dev-app-model.dat and quarkus/bootstrap/test-app-model.dat files

Files are read/write by io.quarkus.bootstrap.BootstrapAppModelFactory#resolveAppModel.

Data is mainly serialized io.quarkus.bootstrap.model.DefaultApplicationModel instance, which contain jar files used in the application of development and test mode.

Quarkus notes (1)

Salad Lam — Sun, 19 Jan 2025 00:37:53 +0000

Background information

I suggest to read the following for grabbing basic idea on Quarkus startup process.

Program entry point of development mode

io.quarkus.runtime.Quarkus#run
Since synthetic class io.quarkus.runner.ApplicationImpl is not exists, so call io.quarkus.runtime.Quarkus#launchFromIDE

Program entry point of production mode

io.quarkus.bootstrap.runner.QuarkusEntryPoint#main
io.quarkus.bootstrap.runner.QuarkusEntryPoint#doRun
io.quarkus.runner.GeneratedMain#main. Synthetic class which generated by quarkus, the method has only one statement.
io.quarkus.runtime.Quarkus#run
io.quarkus.runner.ApplicationImpl#doStart (Synthetic class also)

About quarkus-app/quarkus/quarkus-application.dat file

It store jar files and classes used, so that the special designed ClassLoader (io.quarkus.bootstrap.runner.RunnerClassLoader) can use this information to locate class quickly. Entries of generated-bytecode.jar and transformed-bytecode.jar can also be found in this file.

File serialization method: io.quarkus.bootstrap.runner.SerializedApplication#write
File deserialization method: io.quarkus.bootstrap.runner.SerializedApplication#read

About synthetic class io.quarkus.runner.ApplicationImpl

This is from a sample program which used RESTEasy and contain a resource org.acme.GreetingResource only. This is generated by io.quarkus.deployment.steps.MainClassBuildStep.

// $FF: synthetic class
public class ApplicationImpl extends Application {
    static Logger LOG;
    public static StartupContext STARTUP_CONTEXT;
    private static final String __QUARKUS_ANALYTICS_QUARKUS_VERSION;

    public ApplicationImpl() {
        super(false);
    }

    static {
        DisabledInitialContextManager.register();
        System.setProperty("java.util.logging.manager", "org.jboss.logmanager.LogManager");
        System.setProperty("java.util.concurrent.ForkJoinPool.common.threadFactory", "io.quarkus.bootstrap.forkjoin.QuarkusForkJoinWorkerThreadFactory");
        System.setProperty("dev.resteasy.exception.mapper", "false");
        System.setProperty("logging.initial-configurator.min-level", "500");
        System.setProperty("io.netty.allocator.maxOrder", "3");
        System.setProperty("io.netty.machineId", "00:00:00:00:00:00:00:00");
        System.setProperty("io.quarkus.security.http.test-if-basic-auth-implicitly-required", "true");
        LaunchMode.set(LaunchMode.NORMAL);
        StepTiming.configureEnabled();
        ExecutionModeManager.staticInit();
        Timing.staticInitStarted(false);
        Config.ensureInitialized();
        LOG = Logger.getLogger("io.quarkus.application");
        __QUARKUS_ANALYTICS_QUARKUS_VERSION = "__quarkus_analytics__quarkus.version=3.17.7";
        StartupContext var0 = new StartupContext();
        STARTUP_CONTEXT = var0;

        try {
            StepTiming.configureStart();
            ((StartupTask)(new LoggingResourceProcessor.setupLoggingStaticInit2062061316())).deploy(var0);
            StepTiming.printStepTime(var0);
            ((StartupTask)(new MutinyProcessor.buildTimeInit521613965())).deploy(var0);
            StepTiming.printStepTime(var0);
            ((StartupTask)(new VertxProcessor.currentContextFactory166049300())).deploy(var0);
            StepTiming.printStepTime(var0);
            ((StartupTask)(new VertxCoreProcessor.ioThreadDetector1463825589())).deploy(var0);
            StepTiming.printStepTime(var0);
            ((StartupTask)(new NativeImageConfigBuildStep.build282698227())).deploy(var0);
            StepTiming.printStepTime(var0);
            ((StartupTask)(new BlockingOperationControlBuildStep.blockingOP558072755())).deploy(var0);
            StepTiming.printStepTime(var0);
            ((StartupTask)(new ResteasyStandaloneBuildStep.addDefaultAuthFailureHandler334719971())).deploy(var0);
            StepTiming.printStepTime(var0);
            ((StartupTask)(new SmallRyeContextPropagationProcessor.buildStatic677493008())).deploy(var0);
            StepTiming.printStepTime(var0);
            ((StartupTask)(new VirtualThreadsProcessor.setup282338138())).deploy(var0);
            StepTiming.printStepTime(var0);
            ((StartupTask)(new SyntheticBeansProcessor.initStatic1190120725())).deploy(var0);
            StepTiming.printStepTime(var0);
            ((StartupTask)(new ConfigBuildStep.validateStaticInitConfigProperty682828288())).deploy(var0);
            StepTiming.printStepTime(var0);
            ((StartupTask)(new ArcProcessor.initializeContainer1770303700())).deploy(var0);
            StepTiming.printStepTime(var0);
            ((StartupTask)(new ArcProcessor.notifyBeanContainerListeners1304312071())).deploy(var0);
            StepTiming.printStepTime(var0);
            ((StartupTask)(new ResteasyCommonProcessor.setupResteasyInjection131820800())).deploy(var0);
            StepTiming.printStepTime(var0);
            ((StartupTask)(new ResteasyStandaloneBuildStep.staticInit345281060())).deploy(var0);
            StepTiming.printStepTime(var0);
        } catch (Throwable var2) {
            ApplicationStateNotification.notifyStartupFailed(var2);
            var0.close();
            throw (Throwable)(new RuntimeException("Failed to start quarkus", var2));
        }
    }

    protected final void doStart(String[] var1) {
        System.setProperty("java.util.logging.manager", "org.jboss.logmanager.LogManager");
        System.setProperty("java.util.concurrent.ForkJoinPool.common.threadFactory", "io.quarkus.bootstrap.forkjoin.QuarkusForkJoinWorkerThreadFactory");
        System.setProperty("dev.resteasy.exception.mapper", "false");
        System.setProperty("logging.initial-configurator.min-level", "500");
        System.setProperty("io.netty.allocator.maxOrder", "3");
        System.setProperty("io.netty.machineId", "00:00:00:00:00:00:00:00");
        System.setProperty("io.quarkus.security.http.test-if-basic-auth-implicitly-required", "true");
        NativeImageRuntimePropertiesRecorder.doRuntime();
        ExecutionModeManager.runtimeInit();
        Timing.mainStarted();
        StartupContext var2 = STARTUP_CONTEXT;
        var2.setCommandLineArguments(var1);
        StepTiming.configureEnabled();

        try {
            StepTiming.configureStart();
            ((StartupTask)(new RuntimeConfigSetup())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new NettyProcessor.eagerlyInitClass1832577802())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new ConfigGenerationBuildStep.releaseConfigOnShutdown561040398())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new DeprecatedRuntimePropertiesBuildStep.reportDeprecatedProperties2011807353())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new VertxCoreProcessor.eventLoopCount1012482323())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new VertxHttpProcessor.cors1355075351())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new VertxCoreProcessor.createVertxThreadFactory1036986175())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new VertxCoreProcessor.createVertxContextHandlers780169010())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new ConfigGenerationBuildStep.checkForBuildTimeConfigChange1532146938())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new ThreadPoolSetup.createExecutor2117483448())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new MutinyProcessor.runtimeInit866247078())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new VertxCoreProcessor.build1754895780())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new SmallRyeContextPropagationProcessor.build1909893707())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new BannerProcessor.recordBanner921118789())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new ArcProcessor.setupExecutor1831044820())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new VertxHttpProcessor.bodyHandler1176441513())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new VertxHttpProcessor.preinitializeRouter1141331088())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new ConfigGenerationBuildStep.unknownConfigFiles604069353())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new LoggingResourceProcessor.setupLoggingRuntimeInit1041640541())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new VertxProcessor.build1689596782())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new CertificatesProcessor.initializeCertificate877524439())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new SyntheticBeansProcessor.initRuntime975230615())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new InitializationTaskProcessor.startApplicationInitializer180820092())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new ConfigBuildStep.validateRuntimeConfigProperty1282080724())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new ConfigBuildStep.registerConfigClasses1377682816())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new ResteasyStandaloneBuildStep.boot345593974())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new VertxHttpProcessor.initializeRouter938601780())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new VertxHttpProcessor.finalizeRouter992900573())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new LifecycleEventsBuildStep.startupEvent1144526294())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new ShutdownListenerBuildStep.setupShutdown1533204416())).deploy(var2);
            StepTiming.printStepTime(var2);
            ((StartupTask)(new VertxHttpProcessor.openSocket1753087980())).deploy(var2);
            StepTiming.printStepTime(var2);
            ExecutionModeManager.running();
            List var3 = ConfigUtils.getProfiles();
            Timing.printStartupTime("code-with-quarkus", "1.0.0-SNAPSHOT", "3.17.7", "cdi, resteasy, smallrye-context-propagation, vertx", var3, false, false);
            QuarkusConsole.start();
        } catch (PreventFurtherStepsException var8) {
            var2.close();
        } catch (Throwable var9) {
            QuarkusDelayedHandler var6 = InitialConfigurator.DELAYED_HANDLER;
            if (!var6.isActivated()) {
                Handler[] var4 = new Handler[1];
                ConsoleHandler var5 = new ConsoleHandler();
                var4[0] = (Handler)var5;
                var6.setHandlers(var4);
            }

            var2.close();
            throw (Throwable)(new RuntimeException("Failed to start quarkus", var9));
        }

    }

    protected final void doStop() {
        ExecutionModeManager.unset();
        STARTUP_CONTEXT.close();
    }

    public String getName() {
        return "code-with-quarkus";
    }
}

Most of the classes exist are synthetic classes and stored in io/quarkus/deployment/steps directory in quarkus-app/quarkus/generated-bytecode.jar file. For example io.quarkus.deployment.steps.VirtualThreadsProcessor.setup282338138 class

// $FF: synthetic class
public class VirtualThreadsProcessor$setup282338138 implements StartupTask {
    public VirtualThreadsProcessor$setup282338138() {
    }

    public void deploy(StartupContext var1) {
        var1.setCurrentBuildStepName("VirtualThreadsProcessor.setup");
        Object[] var2 = this.$quarkus$createArray();
        this.deploy_0(var1, var2);
    }

    public void deploy_0(StartupContext var1, Object[] var2) {
        VirtualThreadsRecorder var3 = new VirtualThreadsRecorder();
        VirtualThreadsConfig var4 = Config.VirtualThreadsConfig;
        Object var5 = var1.getValue("io.quarkus.runtime.ShutdownContext");
        LaunchMode var6 = LaunchMode.valueOf("NORMAL");
        var3.setupVirtualThreads(var4, (ShutdownContext)var5, var6);
        Supplier var7 = var3.getCurrentSupplier();
        var1.putValue("proxykey49", var7);
    }

    public Object[] $quarkus$createArray() {
        return new Object[0];
    }
}

The class is created by io.quarkus.virtual.threads.VirtualThreadsProcessor

public class VirtualThreadsProcessor {

    @BuildStep
    @Record(ExecutionTime.STATIC_INIT)
    public void setup(VirtualThreadsConfig config, VirtualThreadsRecorder recorder,
            ShutdownContextBuildItem shutdownContextBuildItem,
            LaunchModeBuildItem launchModeBuildItem,
            BuildProducer<AdditionalBeanBuildItem> beans,
            BuildProducer<SyntheticBeanBuildItem> producer) {
        beans.produce(new AdditionalBeanBuildItem(VirtualThreads.class));
        recorder.setupVirtualThreads(config, shutdownContextBuildItem, launchModeBuildItem.getLaunchMode());
        producer.produce(
                SyntheticBeanBuildItem.configure(ExecutorService.class)
                        .addType(Executor.class)
                        .addQualifier(AnnotationInstance.builder(VirtualThreads.class).build())
                        .scope(BuiltinScope.APPLICATION.getInfo())
                        .setRuntimeInit()
                        .supplier(recorder.getCurrentSupplier())
                        .done());
    }

}

If @Record(ExecutionTime.STATIC_INIT) is annotated, recorded step will be generated in ApplicationImpl's static section. If @Record(ExecutionTime.RUNTIME_INIT) is annotated, recorded step will be generated in ApplicationImpl doStart() method.

Spring Framework: Bean definition and creation

Salad Lam — Sat, 18 Jan 2025 14:06:32 +0000

Fields in org.springframework.beans.factory.config.BeanDefinition

Fields	Meaning
name	Name of bean
parentName
beanClassName	String of bean class
scope	singleton/prototype/request/session/refresh...
lazyInit	true if actual bean will be instantiated when being called
dependsOn	beans which is essential for this bean
autowireCandidate	to specify if this can be injected into other bean in autowire operation
primary	true is the first candidate in autowire operation
factoryBeanName	with factoryMethodName to specify class method to create a bean
factoryMethodName
initMethodName	initialization method after bean is instantiated
destroyMethodName	last method called before bean destroyed
role	ROLE_APPLICATION/ROLE_SUPPORT/ROLE_INFRASTRUCTURE which described in org.springframework.beans.factory.config.BeanDefinition

org.springframework.context.annotation.ComponentScan annotation

The base package of the class annotated with @ComponentScan will become the base package start to scanning. And the classes will following annotations will be picked up.

@Component

All annotated with @Component

@Configuration
@Repository
@Service
@Controller

Please note that org.springframework.boot.autoconfigure.SpringBootApplication is annotated with @ComponentScan annotation.

Function of org.springframework.context.annotation.Configuration annotation

This annotation is for annotates class (configuration class) which provide methods of creating bean (will annotated with @bean)

Configuration classes behave like normal beans, and will be created at the beginning of bean creation of starting ApplicationContext.

proxyBeanMethods element: default is true, it is to avoid double bean instance creation when a method in the configuration class refers to another method of the class.

ConditionalOnXXX annotation

Following are commonly used annotations.

Annotation	Function
ConditionalOnBean	Defined bean can be found in BeanFactory
ConditionalOnClass	Defined class can be found in Classpath
ConditionalOnMissingBean	Defined bean cannot be found in BeanFactory
ConditionalOnMissingClass	Defined class cannot be found in Classpath
ConditionalOnProperty	To check particular value of a property
ConditionalOnResource	Defined resource can be found
ConditionalOnSingleCandidate	Only one bean can be found in BeanFactory

Control code of ConditionalOnXXX annotation

Below is the definition of ConditionalOnClass annotation

package org.springframework.boot.autoconfigure.condition;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.context.annotation.Conditional;

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnClassCondition.class)
public @interface ConditionalOnClass {
  Class<?>[] value() default {};
  String[] name() default {};
}

It is annotated with Conditional annotation, the class OnClassCondition is the actual implementation to define the behavior of ConditionalOnClass annotation.

Multiple annotation

If more than one ConditionalOnXXX annotation are annotated on a configuration class. This will be instantiated only if all annotations hold (i.e. AND condition). On following example

@Configuration(proxyBeanMethods = false)
@ConditionalOnMissingBean(ReactiveWebServerFactory.class)
@ConditionalOnClass({ org.apache.catalina.startup.Tomcat.class })
static class EmbeddedTomcat {

  @Bean
  TomcatReactiveWebServerFactory tomcatReactiveWebServerFactory(
      ObjectProvider<TomcatConnectorCustomizer> connectorCustomizers,
      ObjectProvider<TomcatContextCustomizer> contextCustomizers,
      ObjectProvider<TomcatProtocolHandlerCustomizer<?>> protocolHandlerCustomizers) {
    //...
  }

}

This will be instantiated if org.apache.catalina.startup.Tomcat class is found and bean which provides org.springframework.boot.web.reactive.server.ReactiveWebServerFactory is not found in BeanFactory.

ConditionalOnProperty annotation

There is little special of ConditionalOnProperty annotation because . On following example

@AutoConfiguration
@ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
public class AopAutoConfiguration {
  //...
}

If property spring.aop.auto is not found, the condition holds. If the value of property spring.aop.auto is true, the condition holds also. Conditions don't hold if the value of property spring.aop.auto is other than true.

Auto-configuration class provided by Spring Boot

In the spring-boot-autoconfigure package, many auto-configuration classes exist in order to create essential beans with default properties when there are no such beans defined in the application.

About org.springframework.web.bind.annotation.ModelAttribute annotation of Spring Web MVC

Salad Lam — Sat, 18 Jan 2025 13:33:05 +0000

Controller

Following is a Controller to handle POST requests of HTTP form.

@Controller
@RequestMapping("/manage")
public class PrivateController {

    @PostMapping("/new")
    public String saveCreateMessage(@Valid @ModelAttribute("message") MessageMvcDto message, BindingResult errors, Model model) {
        if (errors.hasErrors()) {
            model.addAttribute("isEdit", false);
            model.addAttribute("postHandler", "new");
            return "private/message";
        }

        MessageDto dto = new MessageDto();
        dto.setPublishDate(message.getPublishDate());
        dto.setRemoveDate(message.getRemoveDate());
        dto.setDescription(message.getDescription());
        dto.setOwner(this.getLoginName());
        this.messageService.save(dto);
        return "redirect:/manage";
    }

    // ...
}

Before executing saveCreateMessage() method, the framework will bind values sent by POST to MessageMvcDto instance, perform validation and build BindingResult instance.

Then execute saveCreateMessage() and pass MessageMvcDto, BindingResult instance as parameter. Assume that validation failed and has an error, a template string is returned.

Since parameter message is annotated with @ModelAttribute("message"), the binded MessageMvcDto and BindingResult instance will write into Model as follows.

Key	Value
message	MessageMvcDto instance
org.springframework.validation.BindingResult.message	BindingResult instance

If annotated with @ModelAttribute (without name), will become the following.

Key	Value
messageMvcDto	MessageMvcDto instance
org.springframework.validation.BindingResult.messageMvcDto	BindingResult instance

Rendering

Values in the Model will become attributes of HttpServletRequest (but not in Session). WebEngineContext instance is built for Thymeleaf to lookup the value of expression.

Using the following template

<!-- ... -->
  <form th:action="@{/manage/__${postHandler}__}" method="post" th:object="${message}" th:classappend="${#fields.hasErrors()}?error" class="ui form">
    <fieldset>
      <legend th:text="#{message}"></legend>
      <div th:if="${#fields.hasErrors()}" th:classappend="${#fields.hasErrors()}?error" class="ui message">
        <ul class="list">
          <li th:each="error:${#fields.allErrors()}" th:text="${error}"></li>
        </ul>
      </div>
      <div class="field">
        <label th:text="#{message.publishDate}"></label>
        <div class="two fields">
          <div th:classappend="${#fields.hasErrors('publishDateDate')}?error" class="field">
            <input id="edPublishDateDate" type="date" th:field="*{publishDateDate}" />
          </div>
          <div th:classappend="${#fields.hasErrors('publishDateTime')}?error" class="field">
            <input id="edPublishDateTime" type="time" th:field="*{publishDateTime}" />
          </div>
        </div>
      </div>
      <!-- ... -->
      <button id="edSave" class="ui mini primary button">[[#{save}]] <i class="send icon"></i></button>
      <button id="edCancel" type="button" class="ui mini button" onclick="document.location='../manage'; return false;">[[#{cancel}]] <i class="window close icon"></i></button>
    </fieldset>
  </form>
<!-- ... -->

#fields expression can be used within form tag with th:object only.

When processing form tag, attribute th:object will save into HttpServletRequest attribute springBoundObjectExpression (i.e. "${message}").

When processing #fields expression, first lookup HttpServletRequest attribute springBoundObjectExpression, then prepend the result with org.springframework.validation.BindingResult. (i.e. org.springframework.validation.BindingResult.message) and lookup HttpServletRequest attribute again. Afterward a BindingResult instance is found (BindingResult is the child interface of Errors) and a related method is called.

The reason why nothing happened on using #fields expression is not to set name on @ModelAttribute annotation.

Query beans by using Spring Expression Language (SpEL)

Salad Lam — Sat, 18 Jan 2025 13:29:08 +0000

There is a getBeanExpressionResolver() method in ConfigurableBeanFactory interface. Following is the actual implementation.

public class StandardBeanExpressionResolver implements BeanExpressionResolver {

    @Override
    @Nullable
    public Object evaluate(@Nullable String value, BeanExpressionContext beanExpressionContext) throws BeansException {
        if (!StringUtils.hasLength(value)) {
            return value;
        }
        try {
            Expression expr = this.expressionCache.get(value);
            if (expr == null) {
                expr = this.expressionParser.parseExpression(value, this.beanExpressionParserContext);
                this.expressionCache.put(value, expr);
            }
            StandardEvaluationContext sec = this.evaluationCache.get(beanExpressionContext);
            if (sec == null) {
                sec = new StandardEvaluationContext(beanExpressionContext);
                sec.addPropertyAccessor(new BeanExpressionContextAccessor());
                sec.addPropertyAccessor(new BeanFactoryAccessor());
                sec.addPropertyAccessor(new MapAccessor());
                sec.addPropertyAccessor(new EnvironmentAccessor());
                sec.setBeanResolver(new BeanFactoryResolver(beanExpressionContext.getBeanFactory()));
                sec.setTypeLocator(new StandardTypeLocator(beanExpressionContext.getBeanFactory().getBeanClassLoader()));
                sec.setTypeConverter(new StandardTypeConverter(() -> {
                    ConversionService cs = beanExpressionContext.getBeanFactory().getConversionService();
                    return (cs != null ? cs : DefaultConversionService.getSharedInstance());
                }));
                customizeEvaluationContext(sec);
                this.evaluationCache.put(beanExpressionContext, sec);
            }
            return expr.getValue(sec);
        }
        catch (Throwable ex) {
            throw new BeanExpressionException("Expression parsing failed", ex);
        }
    }

    // ...
}

org.springframework.expression.PropertyAccessor interface

To get/set value/instance by class's method/property on a particular type of object.

org.springframework.expression.BeanResolver interface

For lookup the actual bean when following symbol exists in expression

"&" get the FactoryBean itself instead of actual bean
"@" bean reference

org.springframework.expression.TypeLocator interface

For lookup the actual class instance when package information is omitted in expression. For example the expression "T(String)", the actual class "java.lang.String" will be returned.

org.springframework.expression.TypeConverter interface

For converting an instance of a type to other, such as java.time.ZonedDateTime to java.util.Calendar.

Example

Following is a bean class

@Service("applicationDateTimeService")
public class ApplicationDateTimeService {

    @Override
    public LocalDateTime getCurrentLocalDateTime() {
        return LocalDateTime.now();
    }

}

Access the bean

ConfigurableBeanFactory beanfactory;
// code of inject ConfigurableBeanFactory
String result = (String) beanfactory.getBeanExpressionResolver().evaluate("#{applicationDateTimeService.currentLocalDateTime.toString()}", new BeanExpressionContext(beanfactory, null));
// 2025-01-16T18:36:07.012526300

In this example, "#{applicationDateTimeService}" and "#{@applicationDateTimeService}" refer to the same bean because the root object is BeanFactory instance.

Create parent-child ApplicationContext in Spring Framework test

Salad Lam — Sat, 18 Jan 2025 13:26:07 +0000

Setup

Bean class

package test;

public class ParentClass {
    @Override
    public String toString() {
        return "ParentClass " + super.toString() + " {}";
    }
}

public class ChildClass {
    private ParentClass parent;

    public void setParent(ParentClass parent) {
        this.parent = parent;
    }

    @Override
    public String toString() {
        return "ChildClass " + super.toString() + " {" +
                "parent=" + parent +
                '}';
    }
}

parent.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="beanParent" class="test.ParentClass">
    </bean>
</beans>

child.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="beanChild" class="test.ChildClass">
        <property name="parent" ref="beanParent"/>
    </bean>
</beans>

Test class

package test;

import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.ContextHierarchy;
import org.springframework.test.context.junit.jupiter.SpringExtension;

import static org.assertj.core.api.Assertions.assertThat;

@ExtendWith(SpringExtension.class)
@ContextHierarchy({
        @ContextConfiguration(name = "parent", locations = {"classpath:/parent.xml"}),
        @ContextConfiguration(name = "child", locations = {"classpath:/child.xml"}),
})
@TestMethodOrder(MethodOrderer.MethodName.class)
// re-create child ApplicationContext after each test method
@DirtiesContext(
        classMode = DirtiesContext.ClassMode.AFTER_EACH_TEST_METHOD,
        hierarchyMode = DirtiesContext.HierarchyMode.CURRENT_LEVEL
)
class ContextHierarchyTest {

    private static final Logger LOGGER = LoggerFactory.getLogger(ContextHierarchyTest.class);

    private ApplicationContext applicationContext;

    @Autowired
    public void setApplicationContext(ApplicationContext applicationContext) {
        LOGGER.info("ApplicationContext injected");
        this.applicationContext = applicationContext;
    }

    @Test
    void test1() {
        ApplicationContext parentApplicationContext = applicationContext.getParent();
        assertThat(parentApplicationContext).isNotNull();

        assertThat(parentApplicationContext.getBean("beanParent")).isEqualTo(applicationContext.getBean("beanParent"));
        String parentBean = applicationContext.getBean("beanParent").toString();
        String childBean = applicationContext.getBean("beanChild").toString();
        LOGGER.info("parent={}, child={}", parentBean, childBean);
    }

    @Test
    void test2() {
        LOGGER.info("parent={}, child={}", applicationContext.getBean("beanParent"), applicationContext.getBean("beanChild"));
    }

}

Screen output

ApplicationContext injected
parent=ParentClass test.ParentClass@314ed053 {}, child=ChildClass test.ChildClass@35088e87 {parent=ParentClass test.ParentClass@314ed053 {}}
ApplicationContext injected
parent=ParentClass test.ParentClass@314ed053 {}, child=ChildClass test.ChildClass@7a231dfd {parent=ParentClass test.ParentClass@314ed053 {}}

when a bean cannot be found in child ApplicationContext, will query its parent ApplicationContext
child ApplicationContext will be re-create after each test method, beans in child ApplicationContext will be re-create also. But parent ApplicationContext not be re-created

Inside Spring Boot test framework

Salad Lam — Sat, 18 Jan 2025 13:24:32 +0000

Following is a basic description of Spring test framework for helping to read source code.

org.springframework.test.context.TestExecutionListener interface

Allows to add actions during different phases of testing. Following is some useful classes.

Class	Function
MockitoTestExecutionListener	setup Mockito mock class
TransactionalTestExecutionListener	handle database transaction
ServletTestExecutionListener	build necessary Servlet instances when testing Servlet component
DirtiesContextBeforeModesTestExecutionListener and DirtiesContextTestExecutionListener	force to recreate ApplicationContext on different phase of testing
WithSecurityContextTestExecutionListener	setup SecurityContextHolder
DependencyInjectionTestExecutionListener	inject beans into test instance

org.springframework.test.context.TestContextManager class

Contains test class information and it runs methods of TestExecutionListener.

org.springframework.test.context.junit.jupiter.SpringExtension class

Bridge class between JUnit 5 and Spring test framework.

org.springframework.test.context.ContextCustomizer interface

Provides a way to alter ApplicationContext. Following is some useful classes.

DynamicPropertiesContextCustomizer
MockitoContextCustomizer
SpringBootTestWebEnvironment
ImportsContextCustomizer
ExcludeFilterContextCustomizer
TypeExcludeFiltersContextCustomizer
SpringBootTestArgs
DisableAutoConfigurationContextCustomizer
PropertyMappingContextCustomizer

org.springframework.boot.autoconfigure.ImportAutoConfiguration annotation

Spring Boot annotation that to include specific Spring Boot AutoConfiguration class. There are two ways to use it.

@ImportAutoConfiguration(AutoConfigureDatabase.class)

This means that to import AutoConfigureDatabase class.

// ...
@ImportAutoConfiguration
public @interface AutoConfigureTestDatabase {
  // ...

This means that to import entries of AutoConfigureTestDatabase in /META-INF/spring.factories file.

This annotation is used without @EnableAutoConfiguration or with @OverrideAutoConfiguration(enabled = false) when @EnableAutoConfiguration is already annotated in application.

org.springframework.boot.test.autoconfigure.json.JsonTest annotation

Instead of loading a full set of AutoConfiguration classes, a set of AutoConfiguration related to Json testing is imported. Beans defined in your application will be filtered. Following are also imported.

anything in class annotated with @SpringBootConfiguration
@TestConfiguration classes
ContextCustomizer classes
TypeExcludeFilter and TestTypeExcludeFilter classes

Other test annotation

@SpringBootTest
@DataCassandraTest
@DataJdbcTest
@DataLdapTest
@DataMongoTest
@DataNeo4jTest
@DataR2dbcTest
@DataRedisTest
@JdbcTest
@JooqTest
@JsonTest
@DataJpaTest
@RestClientTest
@WebFluxTest
@WebMvcTest
@WebServiceClientTest
@WebServiceServerTest

Spring Boot: About @SpringBootApplication

Salad Lam — Tue, 07 Jan 2025 22:12:49 +0000

Following is the definition. For following discussion assumes that the class com.example.app.TestApplication annotated with @SpringBootApplication.

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
  // ...
}

@EnableAutoConfiguration annotation

@EnableAutoConfiguration means to lookup org.springframework.boot.autoconfigure.EnableAutoConfiguration entry from \META-INF\spring.factories file of all jar files. Following is one of the entries.

# spring-boot-autoconfigure-2.6.11.jar!\META-INF\spring.factories
# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
# ...

Specified AutoConfiguration classes coming from different files will be merged, imported to ApplicationContext and processed after finishing processing @Configuration classes. Spoken behaviour is controlled by org.springframework.boot.autoconfigure.AutoConfigurationImportSelector.

@AutoConfigurationPackage annotation

@AutoConfigurationPackage is annotated in @EnableAutoConfiguration. This is for saving the path of base package (in this example com.example.app) and allow other configuration class (such as Spring Data) to scan annotation which is not handled by @ComponentScan. (In case of Spring Data, @Repository. Although it is annotated with @Component, but @Repository is annotated in interface that will not be processed by @ComponentScan.)

@SpringBootConfiguration annotation

Same behaviour as @Configuration, in addition that any properties defined will be merged into test class and will not be affected by the existence of @AutoConfigureXXX annotation.

@ComponentScan annotation

Scan component from base package (in this example com.example.app) and all childs. Exclude AutoConfiguration class found by @EnableAutoConfiguration (controlled by org.springframework.boot.autoconfigure.AutoConfigurationExcludeFilter) and child filter of TypeExcludeFilter (controlled by org.springframework.boot.context.TypeExcludeFilter).