Java / Gradle

Mark a class as a bean - Spring Boot

This guide compares how to mark a class as a bean in a Spring Boot application with @Component vs. in a Micronaut application with @Singleton.

Sergio del Amo

On this guide

In this section

Sample Project

You can download a sample application with the code examples shown in this article.

Introduction

Both Spring and Micronaut frameworks are dependency injection engines. In this tutorial, we create a bean by "marking" a class as a bean.

An Interface

With an interface such as:

springboot/java/src/main/java/example/micronaut/Greeter.java

package example.micronaut;

public interface Greeter {
    String greet();
}

We want to be able to inject a bean of the type Greeter into our application.

Spring Boot @Component

In Spring, we can create an implementation and annotate it with @Component.

springboot/java/src/main/java/example/micronaut/HelloGreeter.java

package example.micronaut;
import org.springframework.stereotype.Component;

@Component // 
public class HelloGreeter implements Greeter {
    @Override
    public String greet() {
        return "Hello";
    }
}

1	The `@Component` annotation indicates that the annotated class is a component.

A class annotate with @Component is considered as a candidate for auto-detection when using annotation-based configuration and classpath scanning.

Spring Boot Test

The following test verifies that it is possible to inject a bean of type Greeter in a Spring Boot application.

springboot/java/src/test/java/example/micronaut/GreeterTest.java

package example.micronaut;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest // 
class GreeterTest {

    @Autowired // 
    Greeter greeter;

    @Test
    void helloGreeterIsInjectedAsBeanOfTypeGreeter() {
        assertNotNull(greeter);
        assertEquals("Hello", greeter.greet());
    }

}

1	The `@SpringBootTest` annotation tells Spring Boot to look for a main configuration class (one with `@SpringBootApplication`, for instance) and use that to start a Spring application context.
2	Inject a bean of type `Greeter` by using `@Autowired` on the field definition.

Micronaut @Singleton

In Micronaut framework, we can create an implementation and annotate it with @Singleton.

micronautframework/java/src/main/java/example/micronaut/HelloGreeter.java

package example.micronaut;

import jakarta.inject.Singleton;

@Singleton // 
public class HelloGreeter implements Greeter {
    @Override
    public String greet() {
        return "Hello";
    }
}

1	Use `jakarta.inject.Singleton` to designate a class as a singleton.

Micronaut Test

The following test verifies that it is possible to inject a bean of type Greeter in a Micronaut application.

micronautframework/java/src/test/java/example/micronaut/GreeterTest.java

package example.micronaut;

import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

@MicronautTest // 
class GreeterTest {

    @Inject // 
    Greeter greeter;

    @Test
    void helloGreeterIsInjectedAsBeanOfTypeGreeter() {
        assertNotNull(greeter);
        assertEquals("Hello", greeter.greet());
    }

}

1	Annotate the class with `@MicronautTest` so the Micronaut framework will initialize the application context and the embedded server. More info.
2	Injection for `Greeter`.

Conclusion

This guide illustrates that marking a class as a bean is similar in both frameworks. Micronaut Framework uses the standard jakarta.inject.Singleton annotation while Spring uses custom annotations.

Note	Micronaut Framework generates the necessary information to fulfill the injection points at compilation time.

Warning

Spring relies on classpath scanning to find classes annotated with @Component. In the Spring Boot application, HelloGreeter is detected because the application contains an Application with the @SpringBootApplication annotation. The @SpringBootApplication annotation applies the @ComponentScan annotation, which tells Spring to scan the package where the Application class is located and its sub-packages.

Next Steps

Read more Spring Boot to Micronaut guides.

Help with the Micronaut Framework

The Micronaut Foundation sponsored the creation of this Guide. A variety of consulting and support services are available.

License

Note	All guides are released with an Apache License 2.0 for the code and a Creative Commons Attribution 4.0 license for the writing and media (images).