Java / Maven

Manually define a Bean - Spring Boot

This guide compares how to create a bean in a Spring Boot application with @Configuration vs. in a Micronaut application with @Factory.

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 will manually create a bean, a class managed by the bean context.

An Interface and an Implementation

With an interface such as:

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

public interface Greeter {
    String greet();
}

and an implementation such as:

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

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

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

There are several ways to do it. In this tutorial, we will manually instantiate the bean in both frameworks.

Spring @Configuration

Create a @Configuration class to declare Greeter bean through a @Bean-annotated method.

springboot/java/src/main/java/example/micronaut/GreeterFactory.java
package example.micronaut;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration // 
class GreeterFactory {

    @Bean
    Greeter helloGreeter() {
        return new HelloGreeter();
    }
}
1 @Configuration is a class-level annotation indicating that an object is a source of bean definitions.

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 @Factory

micronautframework/java/src/main/java/example/micronaut/GreeterFactory.java
package example.micronaut;

import io.micronaut.context.annotation.Factory;
import io.micronaut.context.annotation.Bean;

@Factory // 
class GreeterFactory {
    @Bean
    Greeter helloGreeter() {
        return new HelloGreeter();
    }
}
1 A factory is a class annotated with the @Factory annotation that provides one or more methods annotated with a bean scope annotation.

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 the @Configuration and @Factory APIs of both frameworks are almost identical.

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).