The new Certification Class of Learn Spring Security is out:

>> CHECK OUT THE COURSE

1. Overview

Spring 5 comes with support for functional bean registration in the application context.

Simply put, this can be done through overloaded versions of a new registerBean() method defined in the GenericApplicationContext class.

Let’s have a look at a few examples of this functionality in action.

2. Maven Dependencies

The quickest way to setup a Spring 5 project is to use Spring Boot by adding the spring-boot-starter-parent dependency to the pom.xml:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.0.M1</version>
    <relativePath />
</parent>

We also need the spring-boot-starter-web and spring-boot-starter-test for our example, to use a web application context in a JUnit test:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

Of course, Spring Boot is not necessary in order to use the new functional way to register a bean. We could also just add the spring-core dependency directly:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.0.0.RC2</version>
</dependency>

Since these versions are not yet found in the Maven Central repository, we also need to add the Spring Snapshot Repository to the pom.xml file:

<repositories>
    <repository>
        <id>spring-snapshot</id>
        <name>Spring Snapshot Repository</name>
        <url>https://repo.spring.io/snapshot</url>
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </repository>
</repositories>

3. Functional Bean Registration

The registerBean() API can receive two types of functional interfaces as parameters:

  • a Supplier argument used to create the object
  • a BeanDefinitionCustomizer vararg which can be used to provide one or more lambda expressions to customize the BeanDefinition; this interface has a single customize() method

First, let’s create a very simple class definition that we will use to create beans:

public class MyService {
    public int getRandomNumber() {
        return new Random().nextInt(10);
    }
}

Let’s also add a @SpringBootApplication class that we can use to run a JUnit test:

@SpringBootApplication
public class Spring5Application {
    public static void main(String[] args) {
        SpringApplication.run(Spring5Application.class, args);
    }
}

Next, we can setup our test class using the @SpringBootTest annotation to create a GenericWebApplicationContext instance:

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Spring5Application.class)
public class BeanRegistrationTest {
    @Autowired
    private GenericWebApplicationContext context;
   
    //...
}

We’re using the GenericWebApplicationContext type in our example, but any type of application context can be used in the same way to register a bean.

Let’s see how we can register a bean using a lambda expression for creating the instance:

context.registerBean(MyService.class, () -> new MyService());

Let’s verify that we can now retrieve the bean and use it:

MyService myService = (MyService) context.getBean("com.baeldung.functional.MyService"); 
 
assertTrue(myService.getRandomNumber() < 10);

We can see in this example that if the bean name isn’t explicitly defined, it will be determined from the lower-case name of the class. The same method above can also be used with an explicit bean name:

context.registerBean("mySecondService", MyService.class, () -> new MyService());

Next, let’s see how we can register a bean by adding a lambda expression to customize it:

context.registerBean("myCallbackService", MyService.class, 
  () -> new MyService(), bd -> bd.setAutowireCandidate(false));

This argument is a functional callback that we can use to set bean properties such as autowire-candidate flag or primary flag.

4. Conclusion

In this quick tutorial, we’ve seen how we can use the functional way of registering a bean.

The source code for the example can be found over on GitHub.

Go deeper into Spring Security with the course:

>> LEARN SPRING SECURITY