One of the most important annotations in spring is @Configuration annotation which indicates that the class has @Bean definition methods. So Spring container can process the class and generate Spring Beans to be used in the application. This annotation is part of the spring core framework. So let’s understand @Configuration Annotation with an example project.
Implementation: Project
Suppose we have already a Java project and all the Spring JAR files are imported into that project. Now let’s create a simple class named College and inside the class, we have a simple method.
Prerequisite: Spring @ComponentScan Annotation with Example
A. File: College.java
Java
// Java Program to Illustrate College Classpackage ComponentAnnotation;// Classpublic class College { // Method public void test() { // Print statement System.out.println("Test College Method"); }} |
We can use @Component annotation for creating the bean for this class. So we can modify our College.java file something like this.
Java
// Java Program to Illustrate College Classpackage ComponentAnnotation;// Classpublic class College { // Method public void test() { // Print statement System.out.println("Test College Method"); }} |
But in this case, we have to write the following line inside the beans.xml file.
<context:component-scan base-package="ComponentAnnotation"/>
But we don’t want to use the complete beans.xml file in our project. So what we can do to replace the beans.xml file? In general, beans.xml is a configuration file. So what we can do is we can create a configuration class in Java and just make this class our Configuration class by just using the @Configuration Annotation. Yes, we can do that. So now let’s create another class named CollegeConfig.
B. File: CollegeConfig.java
Java
// Java Program to Illustrate College Classpackage ComponentAnnotation;// Classpublic class College { // Method public void test() { // Print statement System.out.println("Test College Method"); }} |
So now, we don’t want to use the @Component and @ComponentScan annotations to create the beans. Let’s discuss another way of doing the same task. So we are going to create the spring beans using the @Bean annotation. But how? Where to write these methods? As we have discussed at the beginning that “@Configuration annotation indicates that the class has @Bean definition methods”, so let’s explain this statement and create our beans inside the CollegeConfig.java file using the @Bean annotation. So we can write something like this inside our CollegeConfig.java file. Please refer to the comments for a better understanding.
@Bean
// Here the method name is the
// bean id/bean name
public College collegeBean(){
// Return the College object
return new College();
}
Yes, that’s it.
C. File: CollegeConfig.java
Java
// Java Program to Illustrate Configuration Classpackage BeanAnnotation;// Importing required classesimport org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;@Configurationpublic class CollegeConfig { // Using Bean annotation to create // College class Bean @Bean // Here the method name is the // bean id/bean name public College collegeBean() { // Return the College object return new College(); }} |
Similarly, if you have another class named Student and you want to create the bean for this Student class then you can create the bean using the @Bean annotation inside the configuration class just like that
@Bean
// Here the method name is the
// bean id/bean name
public Student studentBean(){
// Return the Student object
return new Student();
}
Now to check our application let’s create a main method inside our Main class. Below is the code for the Main.java file. Comments are added inside the code to understand the code in more detail.
D. File: Main.java
Java
// Java Program to Illustrate Application Classpackage ComponentAnnotation;// Importing required classesimport org.springframework.context.ApplicationContext;import org.springframework.context.annotation.AnnotationConfigApplicationContext;// Application classpublic class Main { // Main driver method public static void main(String[] args) { // Use AnnotationConfigApplicationContext // instead of ClassPathXmlApplicationContext // because we are not using XML Configuration ApplicationContext context = new AnnotationConfigApplicationContext( CollegeConfig.class); // Getting the bean College college = context.getBean("collegeBean", College.class); // Invoking the method // inside main() method college.test(); }} |
Output:
Test College Method
