Spring 5 Functional Bean Registration

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.4.0</version>
</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.3.3</version>
</dependency>

3. Functional Bean Registration

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

  • Supplier argument used to create the object
  • 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 set up our test class using the @SpringBootTest annotation to create a GenericWebApplicationContext instance:

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Spring5Application.class)
public class BeanRegistrationIntegrationTest {
    @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.maixuanviet.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 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.

Related posts:

Java String to InputStream
Java 9 Stream API Improvements
Java Program to Implement the Checksum Method for Small String Messages and Detect
Java Program to Perform Cryptography Using Transposition Technique
Java – Write an InputStream to a File
JUnit5 Programmatic Extension Registration with @RegisterExtension
Java Program to Implement Sparse Array
Guide to PriorityBlockingQueue in Java
Java Program to Implement vector
Guide to Selenium with JUnit / TestNG
Java Program to Implement Gabow Algorithm
The Thread.join() Method in Java
Overview of Spring Boot Dev Tools
Java Program to Check if a Given Graph Contain Hamiltonian Cycle or Not
Adding a Newline Character to a String in Java
Introduction to Spliterator in Java
Quick Guide to Spring Bean Scopes
Java Program to Implement a Binary Search Algorithm for a Specific Search Sequence
Java Program to Solve Knapsack Problem Using Dynamic Programming
Java Program to Apply DFS to Perform the Topological Sorting of a Directed Acyclic Graph
Merging Streams in Java
Java Program to Generate Date Between Given Range
Apache Commons Collections OrderedMap
Java Program to Implement Expression Tree
Java Program to Implement Extended Euclid Algorithm
Instance Profile Credentials using Spring Cloud
Loại bỏ các phần tử trùng trong một ArrayList như thế nào?
Java Program to Implement Rope
Different Ways to Capture Java Heap Dumps
Java Program to Find the Median of two Sorted Arrays using Binary Search Approach
Get and Post Lists of Objects with RestTemplate
Java Program to Implement JobStateReasons API