Spring IOC 注入方式详解附代码

引言

　　Spring框架作为优秀的开源框架之一，深受各大Java开发者的追捧，相信对于大家来说并不陌生，Spring之所以这么流行，少不了他的两大核心技术IOC和IOP。我们这里重点讲述Spring框架的IOC技术运用，如何运用好Spring的IOC技术。

　　在我们平常的java开发中，程序员在某个类中需要依赖其它类的方法，则通常是new一个依赖类再调用类实例的方法，这种开发存在的问题是new的类实例不好统一管理，spring提出了依赖注入的思想，即依赖类不由程序员实例化，而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是“控制反转”，通俗的理解是：平常我们new一个实例，这个实例的控制权是我们程序员，而控制反转是指new实例工作不由我们程序员来做而是交给spring容器来做。

　　在Spring容器中为一个bean配置依赖注入有三种方式：

　　 1）使用属性的setter方法注入；

　　 2）使用构造器注入；

　　 3）使用Filed注入（用于注解方式）

准备工作

　　在开始我们的学习之旅前，我们需要准备IOC必备的开发包。

　　资源下载链接：http://download.csdn.net/detail/yfyzy/8912543

一.使用属性的setter方法注入

　　首先要配置被注入的bean，在该bean对应的类中，应该有要注入的对象属性或者基本数据类型的属性，并且拥该属性或数据类型的set方法。

setter注入-示例：

 1 //我们首先定义一个UserDao的接口
 2 interface UserDao {
 3 
 4     public void say();
 5 }
 6 
 7 
 8 //定义一个类，并且实现我们的UserDao接口
 9 class UserDaoImpl implements UserDao {
10     
11     @Override
12     public void say() {
13         System.out.println("我是UserDaoImpl类，我是实现了UserDao接口，我是通过set方法创建的。");
14     }
15 }
16 
18 class UserService {
19 
20     //注意这里定义的userDao是接口的引用。当然也可以是 UserDaoImpl userDao 。
21     //我们提倡用前者，面向接口编程，来降低我们代码的耦合度！！！
22     private UserDao userDao;
23 
24     public void setUserDao(UserDao userDAO) {
25         this.userDao = userDAO;
26     }
27 
28     public void fun() {
29         
30         System.out.println("我要执行真正的逻辑操作了");
31         
32         //请注意，在整个过程中，我们并没有手动实例化过userDao对象，而是让Spring容器为我们实例化的
33         userDao.say();
34     }
35 }
36
38 public class SetTest {
39 
40     public static void main(String[] args) {
41         ApplicationContext context = new ClassPathXmlApplicationContext("set.xml");
42         
43         // 2、从容器中获取Bean
44         UserService userDao = context.getBean("userService", UserService.class);
45         
46         // 3、执行业务逻辑
47         userDao.fun();
48     }
49 }

set.xml配置

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
 4     xsi:schemaLocation="
 5         http://www.springframework.org/schema/beans        
 6         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 7         http://www.springframework.org/schema/context                
 8         http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 9 
10     <bean id="userService" class="UserService">
11           <!--依赖注入,配置当前类中相应的属性,该属性必须有对应的set方法-->
12         <property name="userDao" ref="userDao"></property>
13     </bean>
14     <bean id="userDao" class="UserDaoImpl"></bean>
15     
16 </beans>

不知道你对上述配置文件是否了解，我们就先简单的介绍一下，<bean>代表一个java对象，id="userService" class="UserService" ，则相当于我们平时写Java代码的UserService userService 。<property>则是为配置的对象设置属性。<property name="userDao" ref="userDao"></property> 在这个标签中 name 代表着 class="UserService" 这个类的属性，ref 则是指向已经当经定义好的bean对象。请特别留意代码中的那句注释“”，否则运行时会报错。特别注意了哦！！在这里我们的class引入的是类的路径：包名.类型，例如在在com包下有类 Test，则class = "com.Test" 。特别注意了哦。

工厂注入

　　有时候，我们希望产生对象是通过我们写工厂方法产生，并且又希望能通过Spring来产生对象，下面我们就来看看Spring如何通过工厂来注入。

静态工厂注入

　　静态工厂顾名思义，就是通过调用静态工厂的方法来获取自己需要的对象，为了让spring管理所有对象，我们不能直接通过"工程类.静态方法()"来获取对象，

而是依然通过Spring注入的形式获取。

静态工厂注入-示例：

 1 //我们首先定义一个UserDao的接口
 2 interface UserDao {
 3 
 4     public void say();
 5 }
 6 
 7 //定义一个类，并且实现我们的UserDao接口
 8 class UserDaoImpl implements UserDao {
 9     
10     @Override
11     public void say() {
12         System.out.println("我是UserDaoImpl类，我是实现了UserDao接口，我是通过工厂的静态方法产生的");
13     }
14 }
15 
16 //添加静态工厂
17 class DaoFactory {  
18     //静态工厂  
19     public static final UserDao getStaticFactoryDaoImpl(){  
20         return new UserDaoImpl();  
21     }  
22 }  
23 
24 class UserService {
25 
26     private UserDao userDao;
27 
28     public void setUserDao(UserDao userDao) {
29         this.userDao = userDao;
30     }
31 
32     public void fun() {
33         userDao.say();
34     }
35 }
36 
37 public class FactoryStaticsTest {
38 
39     public static void main(String[] args) {
40 
41         ApplicationContext context = new ClassPathXmlApplicationContext("factory.statics.xml");
42         
43         // 2、从容器中获取Bean
44         UserService userDao = context.getBean("userService", UserService.class);
45         
46         // 3、执行业务逻辑
47         userDao.fun();
48     }
49 
50 }

　factory.statics.xml配置

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
 4     xsi:schemaLocation="
 5         http://www.springframework.org/schema/beans        
 6         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 7         http://www.springframework.org/schema/context                
 8         http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 9 
10     <bean id="userService" class="factory.statics.UserService">
11           <!--依赖注入,配置当前类中相应的属性,该属性必须有对应的set方法-->
12         <property name="userDao" ref="userDao"></property>
13     </bean>
14     <bean id="userDao" class="factory.statics.DaoFactory" 
15     factory-method="getStaticFactoryDaoImpl"></bean>
16 </beans>

实例工厂的方法注入

　　实例工厂的意思是获取对象实例的方法不是静态的，所以你需要首先new工厂类，再调用普通的实例方法。（PS：先有工厂对象，在通过工厂的对象来产生我们的业务逻辑对象。）

实例工厂注入-示例：

 1 //我们首先定义一个UserDao的接口
 2 interface UserDao {
 3 
 4     public void say();
 5 }
 6 
 7 //定义一个类，并且实现我们的UserDao接口
 8 class UserDaoImpl implements UserDao {
 9     @Override
10     public void say() {
11         System.out.println("我是UserDaoImpl类，我是实现了UserDao接口，我是通过工厂的实例方法产生的");
12     }
13 }
14 
15 //添加工厂类
16 class DaoFactory {  
17     
18     //产生UserDao对象
19     public  UserDao getFactoryDaoImpl(){  
20         return new UserDaoImpl();  
21     }  
22 }  
23 
24 class UserService {
25 
26     private UserDao userDao;
27 
28     public void setUserDao(UserDao userDao) {
29         this.userDao = userDao;
30     }
31 
32     public void fun() {
33         userDao.say();
34     }
35 }
36 
37 public class FactoryObject {
38 
39     public static void main(String[] args) {
40         ApplicationContext context = new ClassPathXmlApplicationContext("factory.object.xml");
41         
42         // 2、从容器中获取Bean
43         UserService userDao = context.getBean("userService", UserService.class);
44         
45         // 3、执行业务逻辑
46         userDao.fun();
47     }
48 }

factory.object.xml 配置

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
 4     xsi:schemaLocation="
 5         http://www.springframework.org/schema/beans        
 6         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 7         http://www.springframework.org/schema/context                
 8         http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 9 
10     <bean id="userService" class="factory.object.UserService">
11           <!--依赖注入,配置当前类中相应的属性,该属性必须有对应的set方法-->
12         <property name="userDao" ref="userDao"></property>
13     </bean>
14     <bean id="daoFactory" class="factory.object.DaoFactory"></bean>
15     <bean id="userDao" factory-bean="daoFactory" 
16     factory-method="getFactoryDaoImpl"> </bean>
17 </beans>

二.使用构造器注入

　　使用构造器注入方式，不用为该类的属性属性设置setter方法，但是需要生成该类的相应的构造方法构造方法。

构造器注入-示例：

 1 //我们首先定义一个UserDao的接口
 2 interface UserDao {
 3 
 4     public void say();
 5 }
 6 
 7 //定义一个类，并且实现我们的UserDao接口
 8 class UserDaoImpl implements UserDao {
 9     @Override
10     public void say() {
11         System.out.println("我是UserDaoImpl类，我是实现了UserDao接口，我是通过构造方法创建的。");
12     }
13 }
14 
15 class UserService {
16 
17     private UserDao userDao;
18     
19     public UserService(UserDao userDao){
20         this.userDao = userDao;
21     }
22 
23     public void fun() {
24         userDao.say();
25     }
26 }
27 
28 
29 public class ConstructorTest {
30 
31     public static void main(String[] args) {
32         
33         ApplicationContext context = new ClassPathXmlApplicationContext("construct.xml");
34         
35         // 2、从容器中获取Bean
36         UserService userDao = context.getBean("userService", UserService.class);
37         
38         // 3、执行业务逻辑
39         userDao.fun();
40     }
41 
42 }

construct.xml 配置

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 4     xmlns:context="http://www.springframework.org/schema/context"
 5     xsi:schemaLocation="
 6         http://www.springframework.org/schema/beans        
 7         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 8         http://www.springframework.org/schema/context                
 9         http://www.springframework.org/schema/context/spring-context-3.0.xsd">
10 
11     <bean id="userService" class="constructor.UserService">
12         <!--创建构造器注入,如果主类有带参的构造方法则需添加此配置 -->
13         <constructor-arg index="0" ref="userDao"></constructor-arg>
14     </bean>
15     <bean name="userDao" class="constructor.UserDaoImpl"></bean>
16 </beans>

三.使用字段(Filed)注入（用注解方式）

　　在学习注解注入方式之前，我们首先了解从spring2.5增加的新特性，这些新特性包括：

　　注解驱动的依赖性注入（annotation- driven dependency injection），使用注解而非XML元数据来自动侦测classpath上的Spring组件，注解对生命周期方法的支持，一个新的web控制器模型将请求映射到加注解的方法上，在测试框架中支持Junit4，Spring XML命名空间的新增内容，等等。

在Spring中，注入依赖对象可以采用手工装配或自动装配，在实际应用开发中建议使用手工装配，因为自动装配会产生许多未知情况，开发人员无法预见最终的装配结果。

手工装配依赖对象又分为两种方式：

1）一种是在XML文件中，通过在bean节点下配置；如上面讲到的使用属性的setter方法注入依赖对象和使用构造器方法注入依赖对象都是这种方式。

2）另一种就是在java代码中使用注解的方式进行装配，在代码中加入@Resource或者@Autowired

怎样使用注解的方式来为某个bena注入依赖对象呢？

首先，我们需要在Spring容器的配置文件applicationContext.Xml文件中配置以下信息,该信心是一个Spring配置文件的模板：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 
 3 <beans
 4 
 5 xmlns="http://www.springframework.org/schema/beans"
 6 
 7 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 8 
 9 xmlns:context="http://www.springframework.org/schema/context"
10 
11 xmlns:p="http://www.springframework.org/schema/p"
12 
13 xsi:schemaLocation="http://www.springframework.org/schema/beans 
14 
15 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
16 
17 http://www.springframework.org/schema/context
18 
19 http://www.springframework.org/schema/context/spring-context-2.5.xsd
20 
21 ">
22 
23 </beans>

为了获得新的的特性首先要引入新的context的Schema命名空间，该命名空间对注释驱动、属性文件引入、加载期织入等功能提供了便捷的配置。我们知道注释本身是不会做任何事情的，它仅提供元数据信息。要使元数据信息真正起作用，必须让负责处理这些元数据的处理器工作起来。

注意：只有配置了红色部分的代码才可以引入注解的命名空间，否则报错。以上的配置隐式的注册了多个对注释进行解析的处理器：AutowiredAnnotationBeanPostProcessor、 CommonAnnotationBeanPostProcessor、PersistenceAnnotationBeanPostProcessor 等。

其次，在配置文件中打开<context:annotation-config>节点，告诉Spring容器可以用注解的方式注入依赖对象；其在配置文件中的代码如下：

<beans>

……

<context:annotation-config></context:annotation-config>

……

</beans>

第三，在配置文件中配置bean对象，如下：

注解注入-示例：

 1 interface UserDao {
 2 
 3     void say();
 4 }
 5 
 6 
 7 class UserDaoImpl implements UserDao {
 8     @Override
 9     public void say() {
10         System.out.println("I am created by manual annotation! + UserDaoImpl");
11     }
12 }21 
22 class UserService {
23 
24     @Resource(name="userDao")
25     private UserDao userDao = null;
26 
27     public UserDao getUserDao() {
28         return userDao;
29     }
30     
31     //在该属性的set方法上添加对应的方法，也能达到相同的效果。
32     /*@Resource(name="userDao")
33     public void setUserDa(UserDao userDao) {
34         this.userDao = userDao;
35     }*/
36 
37     public void fun() {
38         userDao.say();
39     }
40 }
41 
42 public class AnnotationManulTest {
43 
44     public static void main(String[] args) {
45 
46         ApplicationContext context = new ClassPathXmlApplicationContext(
47                 "applicationContext.xml");
48         
49         // 2、从容器中获取Bean
50         
51         UserService userDao = context.getBean("userService", UserService.class);
52         
53         // 3、执行业务逻辑
54         userDao.fun();
55     
56     }
57 
58 }

applicationContext.xml配置

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
 4     xsi:schemaLocation="
 5         http://www.springframework.org/schema/beans        
 6         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 7         http://www.springframework.org/schema/context                
 8         http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 9     <!-- 打开<context:annotation-config>节点，告诉Spring容器可以用注解的方式注入依赖对象 -->
10     <context:annotation-config></context:annotation-config>
11  
14      <bean id="userDao" class="annotation.manul.UserDaoImpl"></bean>
15      <bean id="userService" class="annotation.manul.UserService"></bean> 
16     
17 </beans>

　　其中，在Java代码中可以使用@Autowired或@Resource注解方式进行Spring的依赖注入。两者的区别是：

　　1）@Autowired默认按类型装配。

　　2）@Resource默认按名称装配，当找不到与名称匹配的bean时，才会按类型装配。

　　比如：我们用@Autowired为上面的代码UserDAO接口的实例对象进行注解，它会到Spring容器中去寻找与UserDAO对象相匹配的类型，如果找到该类型则将该类型注入到userdao字段中；

　　如果用@Resource进行依赖注入，它先会根据指定的name属性去Spring容器中寻找与该名称匹配的类型，例如：@Resource(name="userDao")，如果没有找到该名称，则会按照类型去寻找，找到之后，会对字段userDao进行注入。

通常我们使用@Resource。

　　使用注解注入依赖对象不用再在代码中写依赖对象的setter方法或者该类的构造方法，并且不用再配置文件中配置大量的依赖对象，使代码更加简洁，清晰，易于维护。我们可以直接对属性进行注入，也可以对setter方法，进行注入。以下两种方式都是对的：

　　1）@Resource(name="userDao")

　　　private UserDao userDao ；

2） @Resource(name="userDao")

　 public void setUserDa(UserDao userDao)

　　　　{ this.userDao = userDao; }

　　PS：在Spring IOC编程的实际开发中推荐使用注解的方式进行依赖注入。

依赖注入—自动装配

　　Spring中提供了自动装配依赖对象的机制，但是在实际应用中并不推荐使用自动装配，因为自动装配会产生未知情况，开发人员无法预见最终的装配结果。自动装配是在配置文件中实现的，如下：

　　只需要配置一个autowire属性即可完成自动装配，不用再配置文件中写<property>,但是在类中还是要生成依赖对象的setter方法。

　　Autowire的属性值有如下几个：

　　byType 按类型装配可以根据属性类型，在容器中寻找该类型匹配的bean，如有多个，则会抛出异常，如果没有找到，则属性值为null；　　

byName 按名称装配可以根据属性的名称在容器中查询与该属性名称相同的bean，如果没有找到，则属性值为null；

　 constructor 与byType方式相似，不同之处在与它应用于构造器参数，如果在容器中没有找到与构造器参数类型一致的bean，那么将抛出异常；

autodetect 通过bean类的自省机制(introspection)来决定是使用constructor还是byType的方式进行自动装配。如果发现默认的构造器，那么将使用byType的方式。

依赖注入-自动装备-示例：

 1 //我们首先定义一个UserDao的接口
 2 interface UserDao {
 3 
 4     void say();
 5 }
 6 
 7 //定义一个类，并且实现我们的UserDao接口
 8 class UserDaoImpl implements UserDao {
 9     
10     @Override
11     public void say() {
12         System.out.println("I am created by manual annotation! + UserDaoImpl");
13     }
14 }
15 
16 class UserService {
17 
18     private UserDao userDao = null;
19 
20     //这个步骤不能少，一定要设置对应的setter方法
21     public void setUserDao(UserDao userDao) {
22         this.userDao = userDao;
23     }
24     
25     public void fun() {
26         userDao.say();
27     }
28 }
29 
30 public class AnnotationManulTest {
31 
32     public static void main(String[] args) {
33 
34         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
35         
36         // 2、从容器中获取Bean
37         UserService userDao = context.getBean("userService", UserService.class);
38         
39         // 3、执行业务逻辑
40         userDao.fun();
41     
42     }
43 
44 }

applicationContext.xml 配置

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
 4     xsi:schemaLocation="
 5         http://www.springframework.org/schema/beans        
 6         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 7         http://www.springframework.org/schema/context                
 8         http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 9     <!-- 打开<context:annotation-config>节点，告诉Spring容器可以用注解的方式注入依赖对象 -->
10 
11     <context:annotation-config></context:annotation-config>
12 
13     <bean id="userDao" class="annotation.manul.UserDaoImpl"></bean>
14     <bean id="userService" class="annotation.manul.UserService" autowire="byName"></bean>
15 
16 </beans>

自动扫描注入（实现零配置）

　　spring2.5为我们引入了组件自动扫描机制，它可以在 classPath路径底下寻找标注了@Component、@Service、@Controller、@Repository注解的类，并把这些类纳入进spring容器中管理。它的作用和在xml文件中使用bean节点配置组件是一样的。

　　也就是要spring自动扫描机制只会查找指定类路径下包含@Component、@Service、@Controller、@Repository这四种注解的类。

　　要使用自动扫描机制，我们需要打开以下配置信息:

　　1、引入context命名空间需要在xml配置文件中配置以下信息：同上先引入context 命名空间，同时

　　2、在配置文件中添加context:component-scan标签

　　<context:component-scan base-package="*"/>

　　其中base-package为需要扫描的包(含子包)。

　　注意：

　　1、在使用组件扫描元素时，AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor 会隐式地被包括进来。也就是说，连个组件都会被自动检测并织入 - 所有这一切都不需要在XML中提供任何bean配置元数据。也就是说如果使用了context:component-scan标签，就可以不需要再引入 context:annotation-config标签

<context:component-scan />还允许定义过滤器将基包下的某些类纳入或排除。Spring支持以下4种类型的过滤方式：
过滤器类型表达式范例说明:
　　1)注解 org.example.SomeAnnotation 将所有使用SomeAnnotation注解的类过滤出来
　　2)类名指定 org.example.SomeClass 过滤指定的类
　　3)正则表达式 com\.kedacom\.spring\.annotation\.web\..* 通过正则表达式过滤一些类
　　4)AspectJ表达式 org.example..*Service+ 通过AspectJ表达式过滤一些类

以正则表达式为例，我列举一个应用实例：

<context:component-scan base-package="com.casheen.spring.annotation">  
　　<context:exclude-filter type="regex" expression="com\.casheen\.spring\.annotation\.web\..*" /> 
</context:component-scan>    
    
<context:component-scan base-package="com.casheen.spring.annotation">       
　　<context:exclude-filter type="regex" expression="com\.casheen\.spring\.annotation\.web\..*" />  
 </context:component-scan>

　　注意： <context:component-scan />配置项不但启用了对类包进行扫描以实施注释驱动Bean定义的功能，同时还启用了注释驱动自动注入的功能（即还隐式地在内部注册了 AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor），因此当使用<context:component-scan />后，就可以将<context:annotation-config />移除了。

　　需要被扫描的类添加相应的注解,注解的类型有以下几种:

　　@Service用于标注业务层组件、

　　@Controller用于标注控制层组件（如struts中的action）、

　　@Repository用于标注数据访问组件，即DAO组件。

　　而@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。这四种注解仅仅是角色不同，但实质都一样。

　　细节问题总结：

　　1.当我们进行测试时，用ApplicationContext对象的getBean()方法寻找组件。在之前的配置文件中我们会用<bean>标签的id属性去定义，在使用自动扫描注解后怎样获得组建的id呢？

　　在这种情况下，Spring会将被标注注解的类名，然后再将该类名的第一个字母变为小写，放到getBean()方法中。如：UserBizImpl类的组件Id就会是userBizImpl，获取时为context.getBean("userBizImpl");

　　2.那么，我们在使用注解时可以自定义组件的Id吗？

　　当然可以。我们需要在为相应的类添加注解时，在注解之后添加自定义的类名，例如：

　　@Service("userBiz")

　　public class UserBizImpl implements UserBiz {

　　……

　　}

　　当我们在获取该组件时，为context.getBean("userBiz);

　　3.在配置文件中我们可以对组件(bean)的作用域范围进行设置，它的默认值是单例模式，那么在添加注解的情况下，我们怎样设置组件的作用域范围呢?

　　我们可以直接在为类添加注解的同时，运用另一个注解@Scope("prototype")来设置，如下

　　@Service("userBiz")@Scope("prototype")

　　public class UserBizImpl implements UserBiz {

　　……

　　}

　　4.在使用注解时，为组件设置初始化和销毁方法：

　　在添加注解的相应的类中，如果想初始化或销毁某个方法，我们可以直接在方法上添加注解，如下：

　　@PostConstruct

　　public void addItem() {

　　System.out.println("初始化方法");

　　}

　　@PreDestroy

　　public void testItem() {

　　System.out.println("释放资源");

　　}

　　5.在使用Spring自动扫描组件后，怎样进行依赖注入？

　　运用注解@Resource和@Autowired，并为依赖对象设置名称，例如：

　　@Resource(name="userDao")

　　private UserDAO userDao = null;

　　首先它会根据名称去找Spring自动扫描的并加入到Spring容器的组件(bean),如果有相同的名称，则进行依赖注入，如果没有相同的名称。则会根据类型　　区寻找组件。

　　理解以上的内容后，你就可以很轻松的实现spirng零配置了 O(∩_∩)O。

自动扫描注入-示例：

 1 //我们首先定义一个UserDao的接口
 2 interface UserDao {
 3 
 4     void say();
 5 }
 6 
 7 //定义一个类，并且实现我们的UserDao接口
 8 @Repository("userDao")     //@Repository用于标注数据访问组件，即DAO组件.注解仅仅是角色不同，但实质都一样。
 9 class UserDaoImpl implements UserDao {
10     
11     @Override
12     public void say() {
13         System.out.println("I am created by manual annotation! + UserDaoImpl");
14     }
15 }
16 
17 @Service("userService")
18 class UserService {
19 
20     private UserDao userDao = null;
21 
22     //这个步骤不能少，一定要设置对应的setter方法
23     @Resource
24     public void setUserDao(UserDao userDao) {
25         this.userDao = userDao;
26     }
27     
28     public void fun() {
29         userDao.say();
30     }
31 }
32 
33 public class AnnotationManulTest {
34 
35     public static void main(String[] args) {
36 
37         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
38         
39         // 2、从容器中获取Bean
40         UserService userDao = context.getBean("userService", UserService.class);
41         
42         // 3、执行业务逻辑
43         userDao.fun();
44     }
45 }

applicationContext.xm配置

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 4     xmlns:context="http://www.springframework.org/schema/context"
 5     xsi:schemaLocation="
 6         http://www.springframework.org/schema/beans        
 7         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 8         http://www.springframework.org/schema/context                
 9         http://www.springframework.org/schema/context/spring-context-3.0.xsd">
10 
11    <context:component-scan base-package="annotation.manul"></context:component-scan> 
12 
13     <!--运用自动扫描注入，就不需要下面的配置了，这个已经包含进去了-->
14     <!-- 打开<context:annotation-config>节点，告诉Spring容器可以用注解的方式注入依赖对象 -->
15 
16 </beans>

------------------------------------------------------------------------------------------------

　　以上就是关于spring注入的介绍，怎么样，比较简单吧，~O(∩_∩)O~。

posted @ 2015-07-18 17:49 风走了，雨停了阅读(628) 评论(0) 编辑收藏举报

刷新页面返回顶部

Spring IOC 注入方式详解 附代码

依赖注入—自动装配

公告

Spring IOC 注入方式详解附代码