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对象。请特别留意代码中的那句注释“<!--依赖注入,配置当前类中相应的属性,该属性必须有对应的set方法-->”,否则运行时会报错。特别注意了哦!! 在这里我们的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对象,如下:

   <bean id="userDao" class="annotation.manul.UserDaoImpl"></bean>
   <bean id="userService" class="annotation.manul.UserService"></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中提供了自动装配依赖对象的机制,但是在实际应用中并不推荐使用自动装配,因为自动装配会产生未知情况,开发人员无法预见最终的装配结果。自动装配是在配置文件中实现的,如下:

  <bean id="***" class="***" autowire="byType">

  只需要配置一个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~。

你可能感兴趣的:(spring ioc)