Spring IoC是如何进行依赖注入的

开发 前端
DI(Dependency Injection),Spring IoC 不是一种技术,而是一种思想,通过这种思想,能够指导我们设计出松耦合的程序代码。

一、依赖注入(DI)

DI(Dependency Injection),Spring IoC 不是一种技术,而是一种思想,通过这种思想,能够指导我们设计出松耦合的程序代码。而Spring IoC这个思想的作用体现在两个方面,一是如何将Bean装配到容器中去以及如何从容器中获取Bean,二是如何解决Bean之间的依赖关系,换句话说,就是如果由IoC容器来管理依赖关系,当一个Bean需要依赖另外一个Bean时,IoC容器如何实现这样的依赖关系。

解决Spring中Bean之间的依赖的实现方式,在Spring的概念中就被称之为依赖注入(Dependency Injection,DI)。普遍认为的Spring依赖注入的实现方式有三种:构造方法注入、setter方法注入、注解注入。但,就我而言,我认为应该划分为两种形式——基于XML注入和基于注解注入,然后再细分为下面的形式:

Spring IoC是如何进行依赖注入的

基于XML的注入方式是我们最先学习和使用的方式,也是最熟悉的方式,就简单的做个介绍,举个例子。

1. 通过构造方法注入

  1. public class UserServiceImpl implements UserService { 
  2.  
  3.     private UserDao userDao; 
  4.  
  5.     public UserServiceImpl(UserDao userDao) { 
  6.         this.userDao = userDao; 
  7.     } 
  8.  
  9.     /**继承自UserService的方法**/ 

首先定义一个服务层UserServiceImpl,然后在其内部增加对dao层的引用userDao。

接下来就是添加一个构造方法public UserServiceImpl(UserDao userDao)以待Spring通过这个方法为userDao注入实例。

  1. <!--注册userDao--> 
  2. <bean id="userDao" class="com.klasdq.sb.c1.di.dao.impl.UserDaoImpl"></bean> 
  3.  
  4. <!--注册userService 并注入userDao--> 
  5. <bean id="userService" class="com.klasdq.sb.c1.di.service.impl.UserServiceImpl"> 
  6.         <constructor-arg name="userDao" ref="userDao"></constructor-arg> 
  7. </bean> 

最后在Spring XML配置文件中注入相应的bean实例。

通过构造方法的注入,必须要注入类中具有对应的构造方法,若没有对应的构造方法,会出现报错。

2. 通过setter方法注入

修改UserServiceImpl.java为:

  1. public class UserServiceImpl implements UserService { 
  2.  
  3.     private UserDao userDao; 
  4.  
  5.     public void setUserDao(UserDao userDao) { 
  6.         this.userDao = userDao; 
  7.     } 
  8.  
  9.     /**继承自UserService的方法**/ 

再修改XML文件内容为:

  1. <!--注册userDao--> 
  2. <bean id="userDao" class="com.klasdq.sb.c1.di.dao.impl.UserDaoImpl"></bean> 
  3.  
  4. <!--注册userService 并注入userDao--> 
  5. <bean id="userService" class="com.klasdq.sb.c1.di.service.impl.UserServiceImpl"> 
  6.         <property name="userDao" ref="userDao"></property> 
  7. </bean> 

这两种方式的区别在于,一、UserServiceImpl.java可以不用添加构造方法,但是必须存在一个无参构造方法(如public UserServiceImpl(),示例里面没写,是因为java默认会提供一个无参构造方法)以供Spring 容器注册生成Bean(如userService)。二、XML文件中,采用构造方法注入时,需要使用这对标签;而在setter方法注入时,使用 标签。

在XML注入过程中,除了使用ref=""引用之外,还可以使用value=""设定具体的值,其效果和使用注解@Value差不多。

二、基于注解的依赖注入

三、Autowired

源码:

  1. @Target({ElementType.CONSTRUCTOR, 
  2.          ElementType.METHOD, 
  3.          ElementType.PARAMETER, 
  4.          ElementType.FIELD, 
  5.          ElementType.ANNOTATION_TYPE}) 
  6. @Retention(RetentionPolicy.RUNTIME) 
  7. @Documented 
  8. public @interface Autowired { 
  9.     boolean required() default true; 

@Autowired是基于注解的依赖注入的关键点,它的源码非常简单,只有一个参数request(),这个参数的作用是标识注入Bean是否一定要注入,也就是说,在Spring容器没有找到相应Bean时,如果其值为true,就会报出异常;如果其值为false,就不会出现异常,但在使用过程中,如果容器一直不对Bean进行注入,那么有可能出现空指针异常。

另外一点就是,源码当中的@Target所包含的参数正好就是基于注解的依赖注入的注入方式种类,@Target决定了@Autowired能够标注在哪些类型上面。

1. 通过构造方法注入:

  1. @Service("userService") 
  2. public class UserServiceImpl implements UserService { 
  3.  
  4.     private UserDao userDao; 
  5.  
  6.     @Autowired 
  7.     public UserServiceImpl(UserDao userDao) { 
  8.         this.userDao = userDao; 
  9.     } 
  10.     /**继承自UserService的方法**/ 

根据开发文档的说法,这种只有一个构造方法的情况,自Spring4.3以后,就不再需要添加@Autowired标注,也可以。但是,如果有多个构造方法时,是必须要对其中一个方法标注@Autowired,不然Spring会报出异常。

2. 通过setter方法注入

  1. @Service("userService") 
  2. public class UserServiceImpl implements UserService { 
  3.  
  4.     private UserDao userDao; 
  5.  
  6.     @Autowired 
  7.     public void setUserDao(UserDao userDao) { 
  8.         this.userDao = userDao; 
  9.     } 
  10.     /**继承自UserService的方法**/ 

3. 通过字段注入

  1. @Service("userService") 
  2. public class UserServiceImpl implements UserService { 
  3.  
  4.     @Autowired 
  5.     private UserDao userDao; 
  6.  
  7.     /**继承自UserService的方法**/ 

4. 通过方法入参注入

上面三种注入方式,都是比较熟悉的就不再多做阐述了。重点说一下参数注入,其实方法入参注入方式感觉上是和构造方法、setter方法注入形式差不多,相当于将构造方法、setter方法上的注解@Autowired放到入参的位置。说起来可能有些抽象,直接看例子:

  1. @Component 
  2. public class UserDaoImpl implements UserDao { 
  3.     //简单返回一个User,模拟数据库查找过程 
  4.     @Override 
  5.     public User getUser(Long id, String name){ 
  6.         User user = new User(); 
  7.         user.setId(id); 
  8.         user.setName(name); 
  9.         user.setAccount("12345678911"); 
  10.         user.setPassword("******"); 
  11.         user.setOtherInfo("this is a test account"); 
  12.         return user; 
  13.     } 
  1. //UserService类 
  2. @Service("userService") 
  3. public class UserServiceImpl implements UserService { 
  4.  
  5.     private UserDao userDao; 
  6.  
  7.    public UserServiceImpl(@Autowired UserDao userDao, 
  8.                           @Autowired User user) { 
  9.        System.out.println("UserServiceImpl: "+user); 
  10.        this.userDao = userDao; 
  11.    } 
  12.  
  13.     @Override 
  14.     public User getUser(Long id, String name){ 
  15.         return userDao.getUser(id,name); 
  16.     } 
  1. //简单的配置类 
  2. //作用就是为标有@Componet(@Service也算)注解的类 生成Bean 
  3. //同时 为@Autowired标识下的Bean(对象) 注入实例 
  4. @Configuration 
  5. @ComponentScan 
  6. public class DIConfig { 
  7.  
  8.     //用于Service类中入参user的注入 
  9.     @Bean 
  10.     public User getUser(){ 
  11.         User u = new User(); 
  12.         u.setName("user inject into service"); 
  13.         return u; 
  14.     } 
  1. //测试类 
  2. //注意:使用JUnit4测试时,如果需要使用@Autowired注入那么必须添加 
  3. //@RunWith    标注使用Spring方式启动(或者SpringBootRunner) 
  4. //@ContextConfiguration  扫描配置类 
  5. @RunWith(SpringRunner.class) 
  6. @ContextConfiguration(classes = DIConfig.class) 
  7. public class DITest { 
  8.  
  9.     //如果不添加测试类上两个注解,会注入失败 
  10.     @Autowired 
  11.     private UserService userService; 
  12.  
  13.     @Test 
  14.     public void testAutowired(){ System.out.println(userService.getUser(1L,"name")); 
  15.     } 

运行测试方法之后就得到以下结果:

public UserServiceImpl(@Autowired UserDao userDao,@Autowired User user)中的输出结果:

Spring IoC是如何进行依赖注入的

public void testAutowired()测试方法中的输出结果:

Spring IoC是如何进行依赖注入的

注意这里public UserServiceImpl(@Autowired UserDao userDao,@Autowired User user)的入参:

userDao是UserServiceImpl的字段,但user不是。也就是说,我们可以在构造方法中添加任意参数,只要是我们需要的,不一定要求该参数是类中属性字段。

此外还有需要注意的是,这里所说的方法,不是任意的方法,而是构造方法或setter方法,这种public void initService(@Autowired UserDao userDao)自定义的方法是无法完成注入的。

四、@Primary 和 @Qualifier

在上面的例子中,我们注入使用到的bean,都只是容器中只有一个Bean实例的情况。那么当容器当中出现多个同类型的Bean时,如何处理呢?

修改配置类代码如下:

  1. @Configuration 
  2. @ComponentScan 
  3. public class DIConfig { 
  4.  
  5.     @Bean 
  6.     public User getUser(){ 
  7.         User u = new User(); 
  8.         u.setName("this is user"); 
  9.         return u; 
  10.     } 
  11.  
  12.     @Bean 
  13.     public User getUser2(){ 
  14.         User u = new User(); 
  15.         u.setName("this is user2"); 
  16.         return u; 
  17.     } 

修改测试类:

  1. @RunWith(SpringRunner.class) 
  2. @ContextConfiguration(classes = DIConfig.class) 
  3. public class DITest { 
  4.  
  5.     @Autowired 
  6.     private User user; 
  7.  
  8.     @Test 
  9.     public void testAutowiredPriamry(){ 
  10.         System.out.println(user); 
  11.     } 

当不做其他处理时,结果为:

Spring IoC是如何进行依赖注入的

因为有两个User Bean(getUser , getUser2 ,@Bean未注明的情况下,默认方法名为Bean Name)的存在,所以Spring无法确定使用那个进行注入。

修改方式:

  • 在@Bean中设置name,如@Bean(name="user"),当名字能够匹配上private User user;时,也能完成注入。
  • 将private User user改写成getUser或getUser2任意一个,也能完成注入。道理和上面一样,Spring首先会按照type进行匹配,如果无法匹配,再按照名字匹配,都匹配不上时,自然抛出异常。

除此之外呢,Spring为我们提供了两个注解来消除依赖注入时的歧义问题。

  • @Primary
    1. @Target({ElementType.TYPE,    // 类、接口、枚举类型 
    2.          ElementType.METHOD})// 方法 
    3. @Retention(RetentionPolicy.RUNTIME) 
    4. @Documented 
    5. public @interface Primary { 

@Primary是一个设定相同类型Bean优先级的注解,也就是说,一旦在某个类型上添加@Priamry,当注入时,没有明确指定Bean时,就会注入被@Priamry标识的Bean。

  1. @Configuration 
  2. @ComponentScan 
  3. public class DIConfig { 
  4.  
  5.     @Primary 
  6.     @Bean 
  7.     public User getUser(){ 
  8.         User u = new User(); 
  9.         u.setName("this is user"); 
  10.         return u; 
  11.     } 
  12.  
  13.     @Bean 
  14.     public User getUser2(){ 
  15.         User u = new User(); 
  16.         u.setName("this is user2"); 
  17.         return u; 
  18.     } 

比如上面这样,在getUser()上添加相应注解,测试方法也能正常运行。

但是这种方法的问题就在于@Priamry可以用在很多类上,如果同一类型有多个Bean被标注了@Primary,那么@Priamry就失去了应有的效果。

  • @Qualifier

因此,Spring又提供了@Qualifier这个注解,直接标注在@Autowired注入的Bean上,为其明确指定注入某个Bean。

  1. @Target({ElementType.FIELD,  
  2.          ElementType.METHOD,  
  3.          ElementType.PARAMETER,  
  4.          ElementType.TYPE,  
  5.          ElementType.ANNOTATION_TYPE}) 
  6. @Retention(RetentionPolicy.RUNTIME) 
  7. @Inherited 
  8. @Documented 
  9. public @interface Qualifier { 
  10.     String value() default ""; 

@Qualifier可以出现任何@Autowired能够出现的地方,与之配套使用。比如下面这样:

  1. @RunWith(SpringRunner.class) 
  2. @ContextConfiguration(classes = DIConfig.class) 
  3. public class DITest {  
  4.  
  5.     //直接指定使用getUser2进行注入 
  6.     @Autowired 
  7.     @Qualifier("getUser2") 
  8.     private User user; 
  9.  
  10.     @Test 
  11.     public void testAutowiredPriamry(){ 
  12.         System.out.println(user); 
  13.     } 

这两种注解都可以消除歧义,推荐使用@Bean(name="xxx")和@Qualifier(value="xxx")组合使用的方式`。但是如果开发环境中没有歧义的存在,自然也就不需要使用这些了。

当然,上面只是对于@Autowired一些常用介绍,如果想要了解更多,可以查看Annotation-based Container Configuration。这个参考文档当中有着更加详细、丰富的介绍。

总结

总得来说,Spring是如何实现IoC的呢?首先,Spring提供了一个获取和管理Bean的IoC容器。然后,再提供了一套依赖注入的机制去帮助IoC容器更好地管理各个Bean之间的依赖关系,从而更好地实现IoC的思想。一个Bean不可能完全脱离其他Bean的依赖关系而独立存在,当一个Bean需要其他Bean的引入才能初始化时,就需要依赖注入这个机制。

举例来说,假如存在一个A类想要去调用B接口的方法或者说需要B接口的一个实例。

传统的程序流程是,使用一个C类实现B接口,然后A类创建一个C类的实例,从而调用其方法。

在Spring的依赖注入过程中就变成了,A类只需要在自己的内部添加一个注入接口(广义上的接口,不是interface这个接口),这个接口可以是构造方法,也可以是setter方法或者说其他形式;同时添加一个对B接口的引用(private B b;)。

当真正需要生成A类的实例时,Spring IoC容器根据A类提供的接口,为其注入相应的Bean,而这个Bean可以是C类(class C implements B{}),也可以D类(class D implements B{})等等;具体是谁,根据Bean的装配策略和IoC容器中的Bean来确定,不再由开发人员管理。

本文授权转载自公众号「良许Linux」。良许,世界500强外企Linux开发工程师,公众号里分享大量Linux干货,欢迎关注!

 

责任编辑:赵宁宁 来源: 今日头条
相关推荐

2011-05-31 10:00:21

Android Spring 依赖注入

2013-04-15 17:55:12

Windows认证安全认证

2013-04-16 10:33:58

Windows 安全认微软

2024-05-08 08:16:11

2023-10-17 00:01:34

Linux操作系统

2010-08-02 16:33:11

Flex Spring

2021-05-06 07:58:57

Spring BeanIOCAOP

2021-01-22 06:35:44

IoCxml驱动技术

2022-04-30 08:50:11

控制反转Spring依赖注入

2016-03-21 17:08:54

Java Spring注解区别

2014-09-19 10:46:36

LuaCC++

2020-12-29 08:34:08

spring循环依赖开发

2011-03-29 09:51:58

GuiceIOC

2017-08-16 16:00:05

PHPcontainer依赖注入

2009-09-08 15:22:20

Spring依赖注入

2020-04-06 14:50:43

MySQLSQL数据库

2021-03-15 10:23:44

IT支出技术投资CIO

2024-05-13 11:12:08

FO-DICOM开源应用开发

2020-07-14 14:59:00

控制反转依赖注入容器

2022-08-09 18:26:04

KubernetesLinux
点赞
收藏

51CTO技术栈公众号