1. Introduction
Spring Boot simplifies the process of working with Spring Framework by removing much of the boilerplate code and providing out-of-the-box configurations. One of the key features of Spring Boot is its ability to support Java-based configuration, which allows developers to configure their applications programmatically with annotations. This approach is not only cleaner but also type-safe and easy to refactor.
We configure Java-based configuration using @Configuration and @Bean annotations in Spring-based applications. In this blog post, we will discuss how to create a simple Spring Boot application with Java-based configuration and how to invoke methods at startup to demonstrate the concepts.
2. Implementation Steps
1. Initialize a new Spring Boot project with the necessary dependencies.
2. Create a configuration class annotated with @Configuration that defines bean methods.
3. Implement a service class with the logic you wish to execute at startup.
4. Develop the main Spring Boot application class with @SpringBootApplication.
5. Utilize the CommandLineRunner interface to invoke methods after the application context is loaded.
3. Implementation Example
// Step 1: Configuration class to define beans
@Configuration
public class AppConfig {
// Step 2: Define a bean to return a service instance
@Bean
public MyService myService() {
return new MyServiceImpl();
}
}
// Step 3: Service class implementation
public interface MyService {
void performAction();
}
@Service
public class MyServiceImpl implements MyService {
@Override
public void performAction() {
// Implementation of the action
System.out.println("Action performed!");
}
}
// Step 4: Main application class
@SpringBootApplication
public class MySpringBootApplication implements CommandLineRunner {
// Step 5: Inject the service class via constructor
private final MyService myService;
public MySpringBootApplication(MyService myService) {
this.myService = myService;
}
public static void main(String[] args) {
SpringApplication.run(MySpringBootApplication.class, args);
}
@Override
public void run(String... args) {
// Step 6: Call the service method to perform the action
myService.performAction();
}
}
Output:
Upon starting the Spring Boot application, you should see "Action performed!" printed to the console, indicating that the service method has been successfully invoked.
Explanation:
1. @Configuration: Classes annotated with this are considered as configuration classes by Spring.
2. @Bean: Methods annotated with this will return objects that should be registered as beans in the Spring application context.
3. MyService: Interface for the service layer; defines performAction method.
4. MyServiceImpl: Implementation of MyService interface; contains the business logic.
5. @SpringBootApplication: Entry point for the Spring Boot application; also a configuration annotation.
6. CommandLineRunner: An interface used to indicate that a bean should run when it is contained within a SpringApplication.
7. @Override: Method overriding, in this case, run method from CommandLineRunner interface.
8. System.out.println: Used to print the output to the console.
9. SpringApplication.run(): Launches the application.
10. Constructor Injection: MyService is injected into MySpringBootApplication through constructor injection, a recommended approach for dependency injection in Spring.