使用注解来构造IoC容器

用注解来向Spring容器注册Bean。需要在applicationContext.xml中注册<context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>。

如：在base-package指明一个包

1 
     

表明cn.gacl.java包及其子包中，如果某个类的头上带有特定的注解【@Component/@Repository/@Service/@Controller】，就会将这个对象作为Bean注册进Spring容器。也可以在<context:component-scan base-package=” ”/>中指定多个包，如：

1 
     

多个包逗号隔开。

1、@Component

@Component

2、@Controller

@Controller对应表现层的Bean，也就是Action，例如：

1 @Controller2 @Scope("prototype")3 public class UserAction extends BaseAction
     
      {4 ……5 }
     

使用@Controller注解标识UserAction之后，就表示要把UserAction交给Spring容器管理，在Spring容器中会存在一个名字为"userAction"的action，这个名字是根据UserAction类名来取的。注意：如果@Controller不指定其value【@Controller】，则默认的bean名字为这个类的类名首字母小写，如果指定value【@Controller(value="UserAction")】或者【@Controller("UserAction")】，则使用value作为bean的名字。

这里的UserAction还使用了@Scope注解，@Scope("prototype")表示将Action的范围声明为原型，可以利用容器的scope="prototype"来保证每一个请求有一个单独的Action来处理，避免struts中Action的线程安全问题。spring 默认scope 是单例模式(scope="singleton")，这样只会创建一个Action对象，每次访问都是同一Action对象，数据不安全，struts2 是要求每次次访问都对应不同的Action，scope="prototype" 可以保证当有请求的时候都创建一个Action对象

3、@ Service

@Service对应的是业务层Bean，例如：

1 @Service("userService")2 public class UserServiceImpl implements UserService {3 ………4 }

@Service("userService")注解是告诉Spring，当Spring要创建UserServiceImpl的的实例时，bean的名字必须叫做"userService"，这样当Action需要使用UserServiceImpl的的实例时,就可以由Spring创建好的"userService"，然后注入给Action：在Action只需要声明一个名字叫“userService”的变量来接收由Spring注入的"userService"即可，具体代码如下：

1 // 注入userService2 @Resource(name = "userService")3 private UserService userService;

注意：在Action声明的“userService”变量的类型必须是“UserServiceImpl”或者是其父类“UserService”，否则由于类型不一致而无法注入，由于Action中的声明的“userService”变量使用了@Resource注解去标注，并且指明了其name = "userService"，这就等于告诉Spring，说我Action要实例化一个“userService”，你Spring快点帮我实例化好，然后给我，当Spring看到userService变量上的@Resource的注解时，根据其指明的name属性可以知道，Action中需要用到一个UserServiceImpl的实例，此时Spring就会把自己创建好的名字叫做"userService"的UserServiceImpl的实例注入给Action中的“userService”变量，帮助Action完成userService的实例化，这样在Action中就不用通过“UserService userService = new UserServiceImpl();”这种最原始的方式去实例化userService了。如果没有Spring，那么当Action需要使用UserServiceImpl时，必须通过“UserService userService = new UserServiceImpl();”主动去创建实例对象，但使用了Spring之后，Action要使用UserServiceImpl时，就不用主动去创建UserServiceImpl的实例了，创建UserServiceImpl实例已经交给Spring来做了，Spring把创建好的UserServiceImpl实例给Action，Action拿到就可以直接用了。Action由原来的主动创建UserServiceImpl实例后就可以马上使用，变成了被动等待由Spring创建好UserServiceImpl实例之后再注入给Action，Action才能够使用。这说明Action对“UserServiceImpl”类的“控制权”已经被“反转”了，原来主动权在自己手上，自己要使用“UserServiceImpl”类的实例，自己主动去new一个出来马上就可以使用了，但现在自己不能主动去new“UserServiceImpl”类的实例，new“UserServiceImpl”类的实例的权力已经被Spring拿走了，只有Spring才能够new“UserServiceImpl”类的实例，而Action只能等Spring创建好“UserServiceImpl”类的实例后，再“恳求”Spring把创建好的“UserServiceImpl”类的实例给他，这样他才能够使用“UserServiceImpl”，这就是Spring核心思想“控制反转”，也叫“依赖注入”，“依赖注入”也很好理解，Action需要使用UserServiceImpl干活，那么就是对UserServiceImpl产生了依赖，Spring把Acion需要依赖的UserServiceImpl注入(也就是“给”)给Action，这就是所谓的“依赖注入”。对Action而言，Action依赖什么东西，就请求Spring注入给他，对Spring而言，Action需要什么，Spring就主动注入给他。

4、@ Repository

@Repository对应数据访问层Bean ，例如：

1 @Repository(value="userDao")2 public class UserDaoImpl extends BaseDaoImpl
     
       {3 ………4 }
     

@Repository(value="userDao")注解是告诉Spring，让Spring创建一个名字叫“userDao”的UserDaoImpl实例。

当Service需要使用Spring创建的名字叫“userDao”的UserDaoImpl实例时，就可以使用@Resource(name = "userDao")注解告诉Spring，Spring把创建好的userDao注入给Service即可。

1 // 注入userDao，从数据库中根据用户Id取出指定用户时需要用到2 @Resource(name = "userDao")3 private BaseDao
     
       userDao;
     

注解实现Bean配置主要用来进行如依赖注入、生命周期回调方法定义等，不能消除XML文件中的Bean元数据定义，且基于XML配置中的依赖注入的数据将覆盖基于注解配置中的依赖注入的数据。

• 方式一:bean

• 方式二: 命名空间<context:annotation-config />

<context:annotationconfig /> 将隐式地向Spring 容器注册AutowiredAnnotationBeanPostProcessor 、CommonAnnotationBeanPostProcessor 、 PersistenceAnnotationBeanPostProcessor 以及RequiredAnnotationBeanPostProcessor 这4 个BeanPostProcessor 。

• 方式三: 命名空间<context:component-scan />

如果要使注解工作，则必须配置component-scan ，实际上不需要再配置annotation-config。

• Spring 支持以下4 种类型的过滤方式：

     • 注解 org.example.SomeAnnotation 将所有使用SomeAnnotation 注解的类过滤出来

     • 类名指定 org.example.SomeClass 过滤指定的类

     • 正则表达式 com.kedacom.spring.annotation.web..* 通过正则表达式过滤一些类

     • AspectJ 表达式 org.example..*Service+ 通过AspectJ 表达式过滤一些类

Spring3的基于注解实现Bean依赖注入支持如下三种注解：

• Spring自带依赖注入注解： Spring自带的一套依赖注入注解；
• JSR-250注解：Java平台的公共注解，是Java EE 5规范之一，在JDK6中默认包含这些注解，从Spring2.5开始支持。
• JSR-330注解：Java 依赖注入标准，Java EE 6规范之一，可能在加入到未来JDK版本，从Spring3开始支持；
• JPA注解：用于注入持久化上下文和尸体管理器。

@Required

         • 例如 

@Qualifier 和@AutoWired联合使用，自动装配的策略就变成byName

  使用@Autowired 时，如果找到多个同一类型的bean，则会抛异常，此时可以使用 @Qualifier("beanName")，明确指定bean的名称进行注入，此时与 @Resource指定name属性作用相同。

1. <bean id="mysqlDataSourceBean" class="org.springframework.jdbc.datasource.DriverManagerDataSource">   
2.      <qualifier value="mysqlDataSource"/>   
3. </bean>  

1.     @Autowired  
2.     @Qualifier(value = "mysqlDataSource2") //指定Bean限定标识符   
3.     //@Qualifier(value = "mysqlDataSourceBean")   
4.     //是错误的注入，不会发生回退容错，因为你指定了<qualifier>   
5.     public void initDataSource(DataSource dataSource) {   
6.         this.dataSource = dataSource;   
7.     }   

1. /** 表示注入Mysql相关 */  
2. @Target({ElementType.TYPE, ElementType.FIELD, ElementType.PARAMETER})   
3. @Retention(RetentionPolicy.RUNTIME)   
4. @Qualifier  
5. public @interface Mysql {   
6. }  

1. /** 表示注入Oracle相关 */  
2. @Target({ElementType.TYPE, ElementType.FIELD, ElementType.PARAMETER})   
3. @Retention(RetentionPolicy.RUNTIME)   
4. @Qualifier  
5. public @interface Oracle {   
6. }  

1. @Autowired  
2.     public void initDataSource(@Mysql DataSource mysqlDataSource, @Oracle DataSource oracleDataSource) {   
3.         this.mysqlDataSource = mysqlDataSource;   
4.         this.oracleDataSource = oracleDataSource;   
5.     }   

1. <bean id="mysqlDataSourceBean" class="org.springframework.jdbc.datasource.DriverManagerDataSource">   
2.      <qualifier value="mysqlDataSource"/>   
3.      <qualifier type="cn.javass.spring.chapter12.qualifier.Mysql"/>   
4. </bean>   
5. <bean id="oracleDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">   
6.       <qualifier type="cn.javass.spring.chapter12.qualifier.Oracle"/>   
7. </bean>
    

1.  Assert.assertEquals(ctx.getBean("mysqlDataSourceBean"), testBean33.getMysqlDataSoruce());  
2.  Assert.assertEquals(ctx.getBean("oracleDataSource"), testBean33.getOracleDataSoruce());  

1. package cn.javass.spring.chapter12.qualifier;   
2. public enum DataBase {   
3.     ORACLE, MYSQL;   
4. }  

1. @Target({ElementType.TYPE, ElementType.FIELD, ElementType.PARAMETER})   
2. @Retention(RetentionPolicy.RUNTIME)   
3. @Qualifier  
4. public @interface DataSourceType {   
5.     String ip();      //指定ip,用于多数据源情况   
6.     DataBase database();//指定数据库类型   
7. }  

1. @Autowired  
2.     public void initDataSource(   
3.             @DataSourceType(ip="localhost", database=DataBase.MYSQL)   
4.             DataSource mysqlDataSource,   
5.             @DataSourceType(ip="localhost", database=DataBase.ORACLE)   
6.             DataSource oracleDataSource) {   
7.         this.mysqlDataSource = mysqlDataSource;   
8.         this.oracleDataSource = oracleDataSource;   
9.     }   

1. <bean id="mysqlDataSourceBean" class="org.springframework.jdbc.datasource.DriverManagerDataSource">   
2.     <qualifier value="mysqlDataSource"/>   
3.     <qualifier type="cn.javass.spring.chapter12.qualifier.Mysql"/>   
4.     <qualifier type="cn.javass.spring.chapter12.qualifier.DataSourceType">   
5.         <attribute key="ip" value="localhost"/>   
6.         <attribute key="database" value="MYSQL"/>   
7.     </qualifier>   
8. </bean>   
9. <bean id="oracleDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">   
10.     <qualifier type="cn.javass.spring.chapter12.qualifier.Oracle"/>   
11.     <qualifier type="cn.javass.spring.chapter12.qualifier.DataSourceType">   
12.         <attribute key="ip" value="localhost"/>   
13.         <attribute key="database" value="ORACLE"/>   
14.     </qualifier>   
15. </bean>  

1. Assert.assertEquals(ctx.getBean("mysqlDataSourceBean"), testBean34.getMysqlDataSource());   
2. Assert.assertEquals(ctx.getBean("oracleDataSource"), testBean34.getOracleDataSoruce());   

1. @Target({ElementType.TYPE, ElementType.FIELD, ElementType.PARAMETER})   
2. @Retention(RetentionPolicy.RUNTIME)   
3. public @interface CustomQualifier {   
4.     String value();   
5. }  

1. @Autowired  
2.     public TestBean35(@CustomQualifier("oracleDataSource") DataSource dataSource) {   
3.         this.dataSoruce = dataSource;   
4.     } 

1. <bean id="customAutowireConfigurer" class="org.springframework.beans.factory.annotation.CustomAutowireConfigurer">   
2.     <property name="customQualifierTypes">   
3.         <set>   
4.             <value>cn.javass.spring.chapter12.qualifier.CustomQualifier</value>   
5.         </set>   
6.    </property>   
7. </bean>  

用于注入SpEL表达式，可以放置在字段方法或参数上

1. @Value(value = "#{message}")   
2. private String message;  

1. @Autowired  
2. public void initMessage(@Value(value = "#{message}#{message}") String message) {   
3.     this.message = message;   
4. }  

1. @Autowired  
2. private TestBean43(@Value(value = "#{message}#{message}") String message) {   
3.     this.message = message;   
4. }  

@Lazy

定义Bean将延迟初始化

1. @Component("component")   
2. @Lazy(true)   
3. public class TestCompoment {   
4. ……   
5. } 

1. @Component("component")   
2. @DependsOn({
   "managedBean"})   
3. public class TestCompoment {   
4. ……   
5. }  

1. @Component("component")   
2. @Scope("singleton")   
3. public class TestCompoment {   
4. ……   
5. } 

1. @Component("component")   
2. @Primary  
3. public class TestCompoment {   
4. ……   
5. } 

• name：指定Bean的名字，可有多个，第一个作为Id，其他作为别名；
• autowire：自动装配，默认no表示不自动装配该Bean，另外还有Autowire.BY_NAME表示根据名字自动装配，Autowire.BY_TYPE表示根据类型自动装配；
• initMethod和destroyMethod：指定Bean的初始化和销毁方法。

@Import

类似于基于XML配置中的<import/>，基于Java的配置方式提供了@Import来组合模块化的配置类

自动装配，默认根据类型装配，如果指定name属性将根据名字装配，可以使用如下方式来指定

• @Resource注解应该只用于setter方法注入，不能提供如@Autowired多参数方法注入；
• @Resource在没有指定name属性的情况下首先将根据setter方法对于的字段名查找资源，如果找不到再根据类型查找；
• @Resource首先将从JNDI环境中查找资源，如果没找到默认再到Spring容器中查找，因此如果JNDI环境中有和Spring容器同名的资源时需要注意。

JSR-330注解

@Inject：等价于默认的@Autowired，只是没有required属性；

@Named：指定Bean名字，对应于Spring自带@Qualifier中的缺省的根据Bean名字注入情况；

@Qualifier：只对应于Spring自带@Qualifier中的扩展@Qualifier限定描述符注解，即只能扩展使用，没有value属性。