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

时间  2020-08-06
标签 spring ioc 如何 进行 依赖 注入 栏目 Spring 繁體版
原文   原文链接

依赖注入（DI）

DI（Dependency Injection），Spring IoC 不是一种技术，而是一种思想，经过这种思想，可以指导咱们设计出松耦合的程序代码。而Spring IoC这个思想的做用体如今两个方面，一是如何将Bean装配到容器中去以及如何从容器中获取Bean，二是如何解决Bean之间的依赖关系，换句话说，就是若是由IoC容器来管理依赖关系，当一个Bean须要依赖另一个Bean时，IoC容器如何实现这样的依赖关系。html

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

DI实现.png

基于XML的注入方式是咱们最早学习和使用的方式，也是最熟悉的方式，就简单的作个介绍，举个例子。程序员

  • 经过构造方法注入
public class UserServiceImpl implements UserService {
    
    private UserDao userDao;
    
    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }
    
    /**继承自UserService的方法**/
}

首先定义一个服务层UserServiceImpl，而后在其内部增长对dao层的引用userDao。面试

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

<!--注册userDao-->
<bean id="userDao" class="com.klasdq.sb.c1.di.dao.impl.UserDaoImpl"></bean>

<!--注册userService 并注入userDao-->
<bean id="userService" class="com.klasdq.sb.c1.di.service.impl.UserServiceImpl">
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>

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

经过构造方法的注入，必需要注入类中具备对应的构造方法，若没有对应的构造方法，会出现报错。架构

  • 经过setter方法注入

修改UserServiceImpl.java为：ide

public class UserServiceImpl implements UserService {

    private UserDao userDao;
    
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    
    /**继承自UserService的方法**/
}

再修改XML文件内容为：学习

<!--注册userDao-->
<bean id="userDao" class="com.klasdq.sb.c1.di.dao.impl.UserDaoImpl"></bean>

<!--注册userService 并注入userDao-->
<bean id="userService" class="com.klasdq.sb.c1.di.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
</bean>

这两种方式的区别在于，1、UserServiceImpl.java能够不用添加构造方法，可是必须存在一个无参构造方法（如public UserServiceImpl()，示例里面没写，是由于java默认会提供一个无参构造方法）以供Spring 容器注册生成Bean（如userService）。2、XML文件中，采用构造方法注入时，须要使用<constructor-arg ></constructor-arg>这对标签；而在setter方法注入时，使用<property ></property>标签。测试

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

基于注解的依赖注入

@Autowired
  • 源码
@Target({ElementType.CONSTRUCTOR,
         ElementType.METHOD,
         ElementType.PARAMETER,
         ElementType.FIELD,
         ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
    boolean required() default true;
}

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

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

  • 经过构造方法注入
@Service("userService")
public class UserServiceImpl implements UserService {
    
    private UserDao userDao;
    
    @Autowired
    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }
    /**继承自UserService的方法**/
}

根据开发文档的说法，这种只有一个构造方法的状况，自Spring4.3之后，就再也不须要添加 @Autowired标注，也能够。可是，若是有多个构造方法时，是必需要对其中一个方法标注 @Autowired,否则Spring会报出异常。

  • 经过setter方法注入
@Service("userService")
public class UserServiceImpl implements UserService {

    private UserDao userDao;

    @Autowired
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    /**继承自UserService的方法**/
}
  • 经过字段注入
@Service("userService")
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;
    
    /**继承自UserService的方法**/
}
  • 经过方法入参注入

上面三种注入方式，都是比较熟悉的就再也不多作阐述了。重点说一下参数注入，其实方法入参注入方式感受上是和构造方法、setter方法注入形式差很少，至关于将构造方法、setter方法上的注解@Autowired放到入参的位置。提及来可能有些抽象，直接看例子：

@Component
public class UserDaoImpl implements UserDao {
    //简单返回一个User，模拟数据库查找过程
    @Override
    public User getUser(Long id, String name){
        User user = new User();
        user.setId(id);
        user.setName(name);
        user.setAccount("12345678911");
        user.setPassword("******");
        user.setOtherInfo("this is a test account");
        return user;
    }
}
//UserService类
@Service("userService")
public class UserServiceImpl implements UserService {

    private UserDao userDao;
   
   public UserServiceImpl(@Autowired UserDao userDao，
                          @Autowired User user) {
       System.out.println("UserServiceImpl: "+user);
       this.userDao = userDao;
   }
    
    @Override
    public User getUser(Long id, String name){
        return userDao.getUser(id,name);
    }
}
//简单的配置类
//做用就是为标有@Componet（@Service也算）注解的类 生成Bean
//同时 为@Autowired标识下的Bean（对象） 注入实例
@Configuration
@ComponentScan
public class DIConfig {
    
    //用于Service类中入参user的注入
    @Bean
    public User getUser(){
        User u = new User();
        u.setName("user inject into service");
        return u;
    }
}
//测试类
//注意：使用JUnit4测试时，若是须要使用@Autowired注入那么必须添加
//@RunWith    标注使用Spring方式启动（或者SpringBootRunner）
//@ContextConfiguration  扫描配置类
@RunWith(SpringRunner.class)
@ContextConfiguration(classes = DIConfig.class)
public class DITest {

    //若是不添加测试类上两个注解，会注入失败
    @Autowired
    private UserService userService;

    @Test
    public void testAutowired(){ System.out.println(userService.getUser(1L,"name"));
    }
}

运行测试方法以后就获得如下结果：

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

di-test1.png

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

di-test2.png

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

userDao是UserServiceImpl的字段，但user不是。也就是说，咱们能够在构造方法中添加任意参数，只要是咱们须要的，不必定要求该参数是类中属性字段。

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

@Primary 和 @Qualifier

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

修改配置类代码以下：

@Configuration
@ComponentScan
public class DIConfig {

    @Bean
    public User getUser(){
        User u = new User();
        u.setName("this is user");
        return u;
    }

    @Bean
    public User getUser2(){
        User u = new User();
        u.setName("this is user2");
        return u;
    }
}

修改测试类：

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = DIConfig.class)
public class DITest {
    
    @Autowired
    private User user;

    @Test
    public void testAutowiredPriamry(){
        System.out.println(user);
    }
}

当不作其余处理时，结果为：

di-test-priority.png

由于有两个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
@Target({ElementType.TYPE,    // 类、接口、枚举类型
         ElementType.METHOD})// 方法
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Primary {
}

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

@Configuration
@ComponentScan
public class DIConfig {

    @Primary
    @Bean
    public User getUser(){
        User u = new User();
        u.setName("this is user");
        return u;
    }

    @Bean
    public User getUser2(){
        User u = new User();
        u.setName("this is user2");
        return u;
    }
}

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

可是这种方法的问题就在于@Priamry能够用在不少类上，若是同一类型有多个Bean被标注了@Primary，那么@Priamry就失去了应有的效果。

  • @Qualifier

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

@Target({ElementType.FIELD, 
         ElementType.METHOD, 
         ElementType.PARAMETER, 
         ElementType.TYPE, 
         ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Qualifier {
    String value() default "";
}

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

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = DIConfig.class)
public class DITest { 

    //直接指定使用getUser2进行注入
    @Autowired
    @Qualifier("getUser2")
    private User user;

    @Test
    public void testAutowiredPriamry(){
        System.out.println(user);
    }
}

这两种注解均可以消除歧义，推荐使用@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学习路线图，因而我根据本身的经验，利用业余时间熬夜肝了一个月，整理了一份电子书。不管你是面试仍是自我提高，相信都会对你有帮助！

免费送给你们，只求你们金指给我点个赞！

电子书 | Linux开发学习路线图

也但愿有小伙伴能加入我，把这份电子书作得更完美！

有收获？但愿老铁们来个三连击，给更多的人看到这篇文章

推荐阅读：

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程