Spring管理Bean-IOC-05

3.基于注解配置bean

3.3自动装配

基本说明：

基于注解配置bean          ，也可以实现自动装配 
  
 
  
 
  
 
  
 
  
 ，使用的注解是：@AutoWired或者@Resource

@AutoWired 的规则说明

（1）在IOC容器中查找待装配的组件的类型










，如果有唯一的bean装配（按类型） 
  
  
  
  
 ，则使用该bean装配

（2）如果待装配的类型对应的bean在IOC容器中有多个 
  
  
  
  
  ，则使用待装配的属性的属性名作为id值进行查找

 


 


 


 


 

，找到就装配 
 
 
 
 
，找不到就抛异常

@Resource 的规则说明

（1）@Resource 有两个属性比较重要 
   
   
   
   
   ，分别是name和type

Spring将@Resource注解的name属性解析为bean的名字
 

 

 

 

 
，而type属性则解析为bean的类型          。所以如果使用name属性
 

 

 

 

 

，则使用byName的自动注入策略          ，而使用type属性时则使用byType的自动注入策略

（2）如果@Resource没有指定name或者type 

 
 

 
 

 
 

 
 

 
 ，则先使用ByName注入策略










，如果匹配不上               ，再使用byType策略 
 
 
 
 
 
 
 
 
 
 ，如果都不成功就会报错

不管是@AutoWired 还是 @Resource















，都保证属性名是规范的写法就可以注入 
  
 
  
 
  
 
  
 
  
 。

除了有特殊要求          ，一般推荐使用@Resource

3.3.1应用实例1-@AutoWired

应用实例需求：

以Action          、Service 
  
 
  
 
  
 
  
 
  
 、Dao几个组件来进行演示 这里演示UserAction和UserService的两级自动组装

UserService：

package com.li.component; import org.springframework.stereotype.Service; /** * @author 李 * @version 1.0 * @Service 标识该类是一个Service类/对象 */ @Service public class UserService { public void hi(){ System.out.println("UserService hi()..."); } }

UserAction：

package com.li.component; import org.springframework.stereotype.Controller; /** * @author 李 * @version 1.0 * @Controller 标识该类是一个控制器Controller 
  
 
  
 
  
 
  
 
  
 ，通常该类是一个Servlet */ @Controller public class UserAction { private UserService userService; public void sayOk() { System.out.println("UserAction 的 sayOk()"); userService.hi(); } }

beans05.xml指定要扫描的包：

<context:component-scan base-package="com.li.component"/>

测试类：

//通过注解来配置Bean @Test public void setProByAutowired() { ApplicationContext ioc = new ClassPathXmlApplicationContext("beans05.xml"); UserAction userAction = ioc.getBean("userAction", UserAction.class); System.out.println("userAction=" + userAction); userAction.sayOk(); }

如下










，当运行到userAction.sayOk();时抛出空指针异常：

这是因为userAction中的属性userService指向null 
  
  
  
  
 ，即没有正确的装配UserService对象










。

添加@Autowired注解：

在IOC容器中查找待装配的组件的类型 
  
  
  
  
  ，如果有唯一的bean装配(按照类型组装)

 


 


 


 


 

，则使用该bean装配

@Controller public class UserAction { //在IOC容器中查找待装配的组件的类型 
 
 
 
 
，如果有唯一的bean装配(按类型) 
   
   
   
   
   ，则使用该bean装配 @Autowired private UserService userService; public void sayOk() { System.out.println("UserAction 的 sayOk()"); userService.hi(); } }

运行结果如下
 

 

 

 

 
，成功调用了userService.hi()方法
 

 

 

 

 

，说明userService对象已经成功装配：

现在我们在beans05.xml容器中再配置两个UserService对象

spring允许同时使用xml配置文件和注解的方式配置bean

<context:component-scan base-package="com.li.component"/> <!--配置两个UserService对象--> <bean class="com.li.component.UserService" id="userService200"/> <bean class="com.li.component.UserService" id="userService300"/>

此时在ioc容器中就有三个UserService对象：

（1）对于自动扫描进去的UserService对象          ，它的id为它的类名（首字母小写） 
  
  
  
  
 。

（2）在xml文件中配置的两个UserService对象 

 
 

 
 

 
 

 
 

 
 ，它们的id为上面设置的id（userService200










、userService300）

现在我们重新运行测试方法：

//通过注解来配置Bean @Test public void setProByAutowired() { ApplicationContext ioc = new ClassPathXmlApplicationContext("beans05.xml"); UserAction userAction = ioc.getBean("userAction", UserAction.class); System.out.println("userAction=" + userAction); userAction.sayOk(); }

问题一：运行会不会报错？

问题二：@AutoWired注解的属性进行自动装配的时候










，装配的是哪一个UserService对象？

@Autowired private UserService userService;

答案一：没有报错

答案二： 在@AutoWired注解中               ，如果待装配的类型对应的bean在IOC容器中有多个 
 
 
 
 
 
 
 
 
 
 ，则使用待装配属性的名称作为id值进行查找















，找到就装配          ，找不到就抛异常 
  
  
  
  
  。因此装配的是ioc容器中id与待装配属性的属性名一致的对象

 


 


 


 


 

。

3.3.2应用实例2-@Resource

使用UserAction和UserService说明 
  
 
  
 
  
 
  
 
  
 ，我们在UserAction类的属性userService400添加@Resource注解










，并给@Resource注解添加name属性值=“userService 
  
  
  
  
  ”

package com.li.component; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import javax.annotation.Resource; /** * @author 李 * @version 1.0 * @Controller 标识该类是一个控制器Controller 
  
  
  
  
 ，通常该类是一个Servlet */ @Controller public class UserAction { @Resource(name = "userService") private UserService userService400; public void sayOk() { System.out.println("UserAction 的 sayOk()"); userService400.hi(); } }

同时 
  
  
  
  
  ，我们在配置文件beans05.xml文件中又配置了两个UserService对象：

<context:component-scan base-package="com.li.component"/> <!--配置两个UserService对象--> <bean class="com.li.component.UserService" id="userService200"/> <bean class="com.li.component.UserService" id="userService300"/>

也就是说

 


 


 


 


 

，在beans05.xml文件对应的ioc容器中 
 
 
 
 
，此时一共有三个UserService对象：

（1）@Resource注解中配置的名为userService的对象

（2）在xml文件中配置的两个UserService对象 
   
   
   
   
   ，它们的id为上面设置的id（userService200 
  
  
  
  
 、userService300）

那么在UserAction类的userService400属性中
 

 

 

 

 
，spring给此属性自动装配的是三个中的哪一个对象呢？

答：id名为“userService
  
  
  
  
  
”的对象 
 
 
 
 
。因为Spring将@Resource注解的name属性解析为bean的名字 
   
   
   
   
   。 至于UserAction类的属性是什么名字无所谓
 

 

 

 

 
。

Spring将@Resource注解的type属性则解析为bean的类型
 

 

 

 

 

。

现在我们将UserAction类中的注解改为type=UserService.class
 

 

 

 

 

，表示按照UserService.class的类型来进行装配

@Resource(type = UserService.class) private UserService userService400;

这意味着在ioc容器中          ，只能有一个UserService类型的对象          。如果配置了多个 

 
 

 
 

 
 

 
 

 
 ，就会报错：

问题：如果我们在@Resource注解的属性下什么都不写










，会如何装配对象？

@Resource private UserService userService400;

分析如下：现在ioc容器中               ，还是有三个UserService对象：

（1）@Resource注解中配置的对象（当没有指定name时 
 
 
 
 
 
 
 
 
 
 ，该对象对应的id就是“userService
 


 


 


 


 

”）

（2）xml文件中配置的两个UserService对象















，它们的id为上面设置的id（userService200 
  
  
  
  
  、userService300）

如果@Resource没有指定name或者type          ，则先使用ByName注入策略 
  
 
  
 
  
 
  
 
  
 ，如果匹配不上










，再使用byType策略 
  
  
  
  
 ，如果都不成功就会报错 

 
 

 
 

 
 

 
 

 
 。

这里首先使用ByName策略 
  
  
  
  
  ，即匹配userService400

 


 


 


 


 

，匹配不上后又使用byType策略 
 
 
 
 
，显然这里有三个对象 
   
   
   
   
   ，不符合类型匹配










。也就是说两种策略都匹配失败
 

 

 

 

 
，因此结果是：运行出错               。

3.3.3注意事项和细节

如待装配的类型对应的bean在IOC容器中有多个
 

 

 

 

 

，则使用待装配的属性的属性名作为id值再进行查找          ，找到就装配 

 
 

 
 

 
 

 
 

 
 ，找不到就抛异常 [ByName策略]

可以使用@Autowired和@Qualifier两个注解配合










，可以指定装配对象的id值（注意这个id的对象要在ioc容器中存在）

@Autowired @Qualifier(value = "userService200") private UserService userService;

3.4泛型依赖注入

基本说明：

为了更好地管理有继承和相互依赖关系的bean的自动装配               ，spring还提供基于泛型依赖的注入机制 泛型依赖注入：子类之间的依赖关系由其父类泛型以及父类之间的依赖关系来确定 
 
 
 
 
 
 
 
 
 
 ，父类的泛型必须为同一类型 
 
 
 
 
 
 
 
 
 
 。通俗一点来说：两个子类之间的依赖关系不需要在子类中去声明















，而是在父类中进行了声明          ，而依赖的纽带就是 泛型类型 
  
 
  
 
  
 
  
 
  
 ，必须是相同的父类泛型类型才具有依赖关系















。 在继承关系复杂的情况下










，泛型依赖注入就会有很大的优越性

应用实例

现有多个类 
  
  
  
  
 ，关系如下：

如上图 
  
  
  
  
  ，如果我们想要在BookService类中使用BookDao属性对象

 


 


 


 


 

，或者要在PhoneService类中使用PhoneDao对象 
 
 
 
 
，传统方法是将 PhoneDao /BookDao自动装配到 BookService/PhoneSerive 中          。

但是 
   
   
   
   
   ，当这种继承关系多起来时
 

 

 

 

 
，即要自动装配的属性多起来时
 

 

 

 

 

，这种配置方式就显得比较麻烦 
  
 
  
 
  
 
  
 
  
 。因此我们可以使用 spring 提供的泛型依赖注入










。

下面模拟图中的类：

Javabean-Phone：

package com.li.depeinjection; /** * @author 李 * @version 1.0 */ public class Phone { }

Javabean-Book：

package com.li.depeinjection; /** * @author 李 * @version 1.0 */ public class Book { }

自定义泛型类BaseDao：

package com.li.depeinjection; /** * @author 李 * @version 1.0 * 自定义泛型类 */ public abstract class BaseDao<T> { public abstract void save(); }

BookDao继承BaseDao          ，指定泛型Book 

 
 

 
 

 
 

 
 

 
 ，并添加@Repository注解

package com.li.depeinjection; import org.springframework.stereotype.Repository; /** * @author 李 * @version 1.0 */ @Repository public class BookDao extends BaseDao<Book> { @Override public void save() { System.out.println("BookDao save()"); } }

PhoneDao同样继承BaseDao










，指定泛型Phone               ，并添加@Repository注解

package com.li.depeinjection; import org.springframework.stereotype.Repository; /** * @author 李 * @version 1.0 */ @Repository public class PhoneDao extends BaseDao<Phone>{ @Override public void save() { System.out.println("PhoneDao save()"); } }

自定义泛型类BaseService：

package com.li.depeinjection; import org.springframework.beans.factory.annotation.Autowired; /** * @author 李 * @version 1.0 * 自定义泛型类 */ public class BaseService<T> { @Autowired private BaseDao<T> baseDao; public void save() { baseDao.save(); } }

BookService继承BaseService 
 
 
 
 
 
 
 
 
 
 ，指定泛型Book















，并添加@Service注解

package com.li.depeinjection; import org.springframework.stereotype.Service; /** * @author 李 * @version 1.0 */ @Service public class BookService extends BaseService<Book> { //并没有写属性 }

PhoneService也继承BaseService          ，指定泛型Phone 
  
 
  
 
  
 
  
 
  
 ，并添加注解@Service

package com.li.depeinjection; import org.springframework.stereotype.Service; /** * @author 李 * @version 1.0 */ @Service public class PhoneService extends BaseService<Phone>{ //并没有写属性 }

在配置文件beans06.xml中配置要扫描的包：

<context:component-scan base-package="com.li.depeinjection"/>

这意味着在com.li.depeinjection包下










，添加了四种注解的类将会被进行扫描 
  
  
  
  
 ，在这里就是PhoneService类

 


 


 


 


 

、BookService类 
 
 
 
 
、PhoneDao类 
   
   
   
   
   、BookDao类

@Controller /@Service/ @Repository/ @Component

现在我们来进行测试：

//通过泛型依赖来配置Bean @Test public void setProByDependencyInjection() { ApplicationContext ioc = new ClassPathXmlApplicationContext("beans06.xml"); System.out.println("ok"); }

在语句System.out.println("ok");旁打上断点 
  
  
  
  
  ，点击debug

 


 


 


 


 

，可以看到在ioc容器中已经有四个对象：

打开ioc-->beanFactory-->singletonObjects-->table属性 
 
 
 
 
，展开phoneService对象 
   
   
   
   
   ，可以看到该对象已经自动装载了PhoneDao类型的对象！！

这意味着我们通过泛型依赖注入
 

 

 

 

 
，可以自动装配需要的对象
 

 

 

 

 

，不必像之前一样一个个地为属性添加注解 
  
  
  
  
 。

现在我们获取phoneService对象          ，调用该对象的save()方法：

//通过泛型依赖来配置Bean @Test public void setProByDependencyInjection() { ApplicationContext ioc = new ClassPathXmlApplicationContext("beans06.xml"); PhoneService phoneService = ioc.getBean("phoneService", PhoneService.class); phoneService.save(); System.out.println("ok"); }

因为PhoneService类中没有实现save方法 

 
 

 
 

 
 

 
 

 
 ，因此在运行的时候会调用父类BaseService的save()方法










，而BaseService的save()方法中又调用了baseDao属性的save()方法.

我们在上图可以知道baseDao的实际对象是PhoneDao类型               ，根据动态绑定 
 
 
 
 
 
 
 
 
 
 ，最终调用了PhoneDao类中的save()方法：