In this post, we’ll take a look at the annotations available in the Spring Framework.
Core Spring Boot Framework Annotations
@Required
This annotation is applied on bean setter methods. Consider a situation where you have to enforce a required property. The @Required annotation indicates that the affected bean must be populated at configuration time with the required property. Otherwise an exception of type BeanInitializationException is thrown.
@Configuration
This annotation is utilized on classes which characterize beans.@Configuration is an analog for XML configuration file – it is configuration using Java class. Java class annotated with @Configuration is a configuration by itself and will have methods to instantiate and configure the dependencies.
Here is an example:
@Configuration
public class DataConfig{
@Bean
public DataSource source(){
DataSource source = new OracleDataSource();
source.setURL();
source.setUser();
return source;
}
@Bean
public PlatformTransactionManager manager(){
PlatformTransactionManager manager = new BasicDataSourceTransactionManager();
manager.setDataSource(source());
return manager;
}
}
@Autowired
Here is an example:
@Configuration
public class DataConfig{
@Bean
public DataSource source(){
DataSource source = new OracleDataSource();
source.setURL();
source.setUser();
return source;
}
@Bean
public PlatformTransactionManager manager(){
PlatformTransactionManager manager = new BasicDataSourceTransactionManager();
manager.setDataSource(source());
return manager;
}
}
@Autowired
This annotation is applied on fields, setter
methods, and constructors. The @Autowired annotation injects object dependency implicitly.When you use @Autowired on fields and pass the values for the fields using the property
name, Spring will automatically assign the fields with the passed values.
When you use @Autowired on a constructor, constructor injection happens at the time of
object creation. It indicates the constructor to autowire when used as a bean.
One thing to note here is that only one constructor of any bean class can carry
the @Autowired annotation.
Here is an example:
@Component
public class Customer {
private Person
person;
@Autowired
public Customer
(Person person) {
this.person=person;
}
}
@ComponentScan
This
annotation is used with @Configuration annotation to allow Spring to know the packages to scan
for annotated components. @ComponentScan is also used to specify base packages using basePackageClasses or
basePackage attributes to scan. If specific packages are not
defined, scanning will occur from the package of the class that declares this
annotation.
@Qualifier
This annotation is used along with @Autowired annotation. When you need more control of the dependency injection process, @Qualifier can be used. @Qualifier can be specified on individual constructor arguments or method parameters. This annotation is utilized to keep away from confusion which happens when you make in excess of one bean of a similar sort and need to wire just a single of them with a property.
Consider an example where an interface Bean Interface is implemented by two beans BeanB1 and BeanB2.
@Component
public class BeanB1 implements BeanInterface
{
//
}
@Component
public class BeanB2 implements BeanInterface
{
//
}
Now if BeanA autowires this interface, Spring will not
know which one of the two implementations to inject. One solution to this
problem is the use of the @Qualifier annotation.
@Component
public class BeanA {
@Autowired
@Qualifier("beanB2")
private BeanInterface dependency;
...
}
With the @Qualifier annotation added, Spring will now know which
bean to autowire where beanB2 is the name of BeanB2.
@Bean
This annotation is used at the method level. @Bean annotation works with @Configuration to create Spring beans. As mentioned earlier, @Configuration will have methods to instantiate and configure dependencies. Such
methods will be annotated with @Bean. The method annotated with this annotation works as bean ID and it
creates and returns the actual bean.
ConversionConversion EmoticonEmoticon