The document discusses the evolution of annotation support in Spring frameworks over different versions. It summarizes key annotations introduced in Spring 2.0, 2.5, 3.0 and beyond. It also explains how annotations like @Autowired, @Qualifier, @Component, @Repository, @Service and @Controller work and provides examples of their usage. The document additionally covers concepts like stereotype annotations, configuration classes, @Bean and JSR-250 annotations like @Inject, @Named and @Resource.

1. Spring AnnotationSupport :-
Spring2.0 has a verylittle supportto annotation,whenitcomestospring2.5 , it has extendedit's
frameworktosupportvariousaspectsof springdevelopmentusingannotations.Inspring3.0 it
startedsupportingjavaconfigprojectannotationsaswell.
In Spring2.0 it has added@Repositoryand@Requiredannotations.
In Spring2.5 it has addedfewmore annotations@Autowired,@Qualifierand@Scope.
alongwithabove annotation'sinspring2.5 sterotype annotations@Component,@Controller,
@Service .
In Spring3.0 fewmore annotationshasbeenaddedlike
@Lazy,@Bean,@Configuration,@DependsOn,@Valueetc..
In additiontospringbasedmetadataannotationsupport,ithasstartedadoptionJSR-250javaconfig
projectannotationslike @PostConstruct,@PreDestory,@Resource ,@Injectand@Namedetc...
@Requiredannotation :- In spring1.x onwordswe have dependency
check.fora beanif youwant to detectunresolveddependenciesof abean,youcanuse dependency
check.In Spring2.0 ithas introduced anannotation@Required .byusingthisannotationyoucan
make , a particularpropertyhas beensetwithvalue (OR) not.inspring2.5 @Requiredannotation
and dependency -checkcompletlyremoved.
@Autowired:- annotationtoautowire bean onthe settermethod,constructor(OR) afiled.
Example :-
EmployeeService.java
publicclassEmployeeService{
@Autowired
private EmployeeDAO empDao;
}
EmployeeDAO.java
publicclassEmployeeDAO{
@Autowired
private DataSource dataSource;
}

2. The @Autowired Annotationishighlyflexible andpowerful,andbetterthan<autowire>attribute in
bean configurationfile.
Aboutthe @Autowiredannotationtogive anintimationtospringIOCcontainerwe canuse
<context:annotation-config/> inspringfile.
Note :
By default,the @Autowiredwill performthe dependencycheckingtomake sure the propertyhas
beenwiredproperly.WhenSpringcontainer can'tfinda matchingbeanto wire,itwill throw an
Exception.if youwanttodisable the dependencycheckingfeature thenwe canuse the "required"
attribute of @Autowiredannotation.if the requiredattributevalue isfalsethenthe dependency-
checking is disabled.elsedependency -checkingisenabled.the defaultvalue of requiredattrbute is
true.
Example :-
publicclassEmployeeService{
@Autowired(required=false)
private EmployeeDAOempDao;
}
@Qualifier:-
for example,Inbeanconfigurationfile for EmployeeDAO bean two configuration'sare there.
<beans>
<beanid="empDao1"class="com.nareshit.dao.EmployeeDAO"/>
<beanid="empDao2"class="com.nareshit.dao.EmployeeDAO"/>
</beans>
In EmployeeService class
publicEmployeeService{
@Autowired
private EmployeeDAO employeeDao;
}
here employeeDao1(OR) employeeDao2whichbeanisrequiredto injectdon’tknow by the
containersoContainerWill rise AnException.ToSolve thisproblemand toinjecta particularbean
i,e employeeDao1(OR) employeeDao2 we can use @Qualifierannotation

3. The @Qualifierannotationisused to control whichbeanshouldbe autowire onafield.
Example:-
publicclassEmployeeService{
@Autowired
@Qualifier("emDao1")
private EmployeeDAOempDao;
}
DAO.java
package com.nareshit;
publicclass DAO{
publicvoid daoMethod(){
System.out.println("DAOMethod");
}
}
Service.java
package com.nareshit;
import org.springframework.beans.factory.annotation.Autowired;
publicclass Service {
@Autowired
private DAOdao;
publicvoid serviceMethod() {
System.out.println("serviceMethod");
dao.daoMethod();
}
}

4. myBeans.xml
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:annotation-config/>
<beanid="dao"class="com.nareshit.DAO"/>
<beanid="service" class="com.nareshit.Service" />
</beans>
Test.java
package com.nareshit.client;
importorg.springframework.context.ApplicationContext;
importorg.springframework.context.support.ClassPathXmlApplicationContext;
importcom.nareshit.Service;
publicclassTest{
publicstaticvoidmain(String[] args){
ApplicationContextcontext=
newClassPathXmlApplicationContext("com/nareshit/xml/myBeans.xml");
Service service=(Service)context.getBean("service");
service.serviceMethod();
}
}
Stereotype Annotations:
In Spring there are 4 Stereotype Annotations
1)@Component: Indicatesanauto scan component.
2) @Service – IndicatesaService component in the businesslayer/serviceLayer.
3) @Repository – IndicatesDAOcomponent inthe persistence layer.
4) @Controller– Indicatesacontroller componentinthe Controllerlayer.
Example 1 :-
@Component
public classEmployeeService{
}
Example 2 :-

5. @Component(“empService”)
public classEmployeeService{
}
@Component Annotationisindicatingtothe containerEmployeeService isclassisan auto scan
component.
About the Stereotype annotationtogive anintimationtothe containerwe canuse
<context:component-scanbase-package=”com.nareshit”/>inspringconfigurationfile.
DAO.java
package com.nareshit;
import org.springframework.stereotype.Component;
@Component
publicclass DAO{
publicvoid daoMethod(){
System.out.println("DAOMethod");
}
}
Service.java
package com.nareshit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component("service")
publicclass Service {
@Autowired
private DAOdao;
publicvoid serviceMethod() {
System.out.println("serviceMethod");
dao.daoMethod();
}
}

6. myBeans.xml
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:component-scanbase-package="com.nareshit">
</context:component-scan>
</beans>
Test.java
package com.nareshit.client;
importorg.springframework.context.ApplicationContext;
importorg.springframework.context.support.ClassPathXmlApplicationContext;
importcom.nareshit.Service;
publicclassTest{
publicstaticvoidmain(String[] args){
ApplicationContextcontext=
newClassPathXmlApplicationContext("com/nareshit/xml/myBeans.xml");
Service service=(Service)context.getBean("service");
service.serviceMethod();
}
}
The @Repository,@Service and@Controller are annotatedwith @Componentannotation
internally.the Three annotation'salso componentType annotations.
to increase the readability of the programwe can use @Service annotationinService Layer
@Repositoryannotation inDAO/Persistence Layerand @ContollerannotationinControllerLayer
Insteadof @Componenttype annotation.
Example :
EmployeeService.java
@Service
publicclassEmployeeService{
}
EmployeeDAO.java
@Repository
publicclassEmployeeDAO{

7. }
@Value Annotation
@Value Annotationisgivenspring3.0version.Itisusedto injectthe valuesonsimple type
dependencies
publicclass CustomerBean{
@Value(“1001”)
private intcustomerId;
@Value(“sathish”)
private StringcustomerName;
}
working with @Configurationand @Bean :-
Insteadof declaringaclass as springbeanina configurationfile,youcandeclare itina class.The
classin whichyouwantto provide the configurationaboutotherbeans,thatclassiscalled
configurationclassandyouneedtoannotate with@Configuration.
In thisclassyou needtoprovide the methodswhichare responsible forcreatingobject'sof your
beanclasses,these methodshastobe annotatedwith@Bean.
Example :-
Service.java
package com.nareshit;
publicclass Service {
private DAOdao;
publicvoid setDao(DAOdao) {
this.dao= dao;
}

8. publicvoid serviceMethod() {
System.out.println("serviceMethod");
dao.daoMethod();
}
}
DAO.java
package com.nareshit;
publicclass DAO{
publicvoid daoMethod(){
System.out.println("DAOMethod");
}
}
MyBeans.java
package com.nareshit.config;
importorg.springframework.beans.factory.annotation.Autowire;
importorg.springframework.context.annotation.Bean;
importorg.springframework.context.annotation.Configuration;
importcom.nareshit.DAO;
importcom.nareshit.Service;
@Configuration
publicclassMyBeans{
@Bean(name="service",autowire=Autowire.BY_TYPE)
publicService service(){
returnnewService();
}
@Bean(name="dao")
publicDAOdao(){
return newDAO();
}
}
Test.java
package com.nareshit.client;

9. import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.nareshit.Service;
publicclass Test{
publicstatic voidmain(String[]args){
ApplicationContextcontext=
new AnnotationConfigApplicationContext(com.nareshit.config.MyBeans.class);
Service service=(Service)context.getBean("service");
service.serviceMethod();
}
}
@Inject :-
@InjectisJ2ee specificannotation,usedforInjectiong/autowiringone classintoanother.
Thisis similarto@Autowiredspringannotation.Butthe difference between@Autowiredsupports
requiredattribute where @Injectdoesn'thas it.@Injectalsoinjectsabeanintoanotherbeanas
similarto@Autowired.itispresentinjavax.injectpackage.
Example :
EmployeeService.java
publicclassEmployeeService{
@Inject
private EmployeeDAOempDao;
}
EmployeeDAO.java
publicclass EmployeeDAO{

10. @Inject
private DataSource dataSource;
}
@Named it isa J2EE annotationandIt is similarto@Qualifier springAnnotation
@Resource isa J2EE annotationsimilarto@Injectbutitwill performthe injectionbyusingbyName
rules