最全的 Spring 依赖注入方式，你都会了吗？

淩亂°似流年 2023-10-13 17:56 32阅读 0赞

Spring 正如其名字，给开发者带来了春天，Spring 是为解决企业级应用开发的复杂性而设计的一款框架，其设计理念就是：简化开发。

Spring 框架中最核心思想就是：

> 1.  IOC（控制反转）： 即转移创建对象的控制权，将创建对象的控制权从开发者转移到了 Spring 框架。
> 2.  AOP（切面编程）：将公共行为（如记录日志，权限校验等）封装到可重用模块中，而使原本的模块内只需关注自身的个性化行为。

本文，将主要介绍 Spring 中 IOC 的依赖注入

### 控制反转 IOC ###

就 IOC 本身而言，其并不是什么新技术，只是一种思想理念。IOC 的核心就是原先创建一个对象，我们需要自己直接通过 new 来创建，而 IOC 就相当于有人帮们创建好了对象，需要使用的时候直接去拿就行，IOC 主要有两种实现方式：

#### DL（Dependency Lookup）：依赖查找。 ####

这种就是说容器帮我们创建好了对象，我们需要使用的时候自己再主动去容器中查找，如：

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/application-context.xml");
    Object bean = applicationContext.getBean("object");

#### DI（Dependency Inject）：依赖注入。 ####

依赖注入相比较依赖查找又是一种优化，也就是我们不需要自己去查找，只需要告诉容器当前需要注入的对象，容器就会自动将创建好的对象进行注入（赋值）。微信搜索公众号：Java后端编程，回复：java 领取资料 。

### 依赖注入 DI ###

通过 xml 的注入方式我们不做讨论，在这里主要讨论基于注解的注入方式，基于注解的常规注入方式通常有三种：

> 基于属性注入  
> 基于 setter 方法注入  
> 基于构造器注入

### 三种常规注入方式 ###

接下来就让我们分别介绍一下三种常规的注入方式。

#### 属性注入 ####

通过属性注入的方式非常常用，这个应该是大家比较熟悉的一种方式：

@Service
    public class UserService {
        
        @Autowired
        private Wolf1Bean wolf1Bean;//通过属性注入
    }

#### setter 方法注入 ####

除了通过属性注入，通过 setter 方法也可以实现注入：

@Service
    public class UserService {
        
        private Wolf3Bean wolf3Bean;
        
        @Autowired  //通过setter方法实现注入
        public void setWolf3Bean(Wolf3Bean wolf3Bean) {
        
            this.wolf3Bean = wolf3Bean;
        }
    }

#### 构造器注入 ####

当两个类属于强关联时，我们也可以通过构造器的方式来实现注入：

@Service
    public class UserService {
        
      private Wolf2Bean wolf2Bean;
        
         @Autowired //通过构造器注入
        public UserService(Wolf2Bean wolf2Bean) {
        
            this.wolf2Bean = wolf2Bean;
        }
    }

### 接口注入 ###

在上面的三种常规注入方式中，假如我们想要注入一个接口，而当前接口又有多个实现类，那么这时候就会报错，因为 Spring 无法知道到底应该注入哪一个实现类。

比如我们上面的三个类全部实现同一个接口 IWolf，那么这时候直接使用常规的，不带任何注解元数据的注入方式来注入接口 IWolf。

@Autowired
    private IWolf iWolf;

此时启动服务就会报错：

![在这里插入图片描述][45c6a3ec00234435bd67d5e9334d5cc0.png]  
这个就是说本来应该注入一个类，但是 Spring 找到了三个，所以没法确认到底应该用哪一个。这个问题如何解决呢？

解决思路主要有以下 5 种：

#### 通过配置文件和 @ConditionalOnProperty 注解实现 ####

通过 `@ConditionalOnProperty` 注解可以结合配置文件来实现唯一注入。下面示例就是说如果配置文件中配置了 `lonely.wolf=test1`，那么就会将 Wolf1Bean 初始化到容器，此时因为其他实现类不满足条件，所以不会被初始化到 IOC 容器，所以就可以正常注入接口：

@Component
    @ConditionalOnProperty(name = "lonely.wolf",havingValue = "test1")
    public class Wolf1Bean implements IWolf{
        
    }

当然，这种配置方式，编译器可能还是会提示有多个 Bean，但是只要我们确保每个实现类的条件不一致，就可以正常使用。

#### 通过其他 `@Condition` 条件注解 ####

除了上面的配置文件条件，还可以通过其他类似的条件注解，如：

@ConditionalOnBean：当存在某一个 Bean 时，初始化此类到容器。
    @ConditionalOnClass：当存在某一个类时，初始化此类的容器。
    @ConditionalOnMissingBean：当不存在某一个 Bean 时，初始化此类到容器。
    @ConditionalOnMissingClass：当不存在某一个类时，初始化此类到容器。
    …

类似这种实现方式也可以非常灵活的实现动态化配置。

不过上面介绍的这些方法似乎每次都只能固定注入一个实现类，那么如果我们就是想多个类同时注入，不同的场景可以动态切换而又不需要重启或者修改配置文件，又该如何实现呢？

#### 通过 @Resource 注解动态获取 ####

如果不想手动获取，我们也可以通过 @Resource 注解的形式动态指定 BeanName 来获取：

@Component
    public class InterfaceInject {
        
        @Resource(name = "wolf1Bean")
        private IWolf iWolf;
    }

如上所示则只会注入 BeanName 为 wolf1Bean 的实现类。

#### 通过集合注入 ####

除了指定 Bean 的方式注入，我们也可以通过集合的方式一次性注入接口的所有实现类：

@Component
    public class InterfaceInject {
        
        @Autowired
        List<IWolf> list;
    
        @Autowired
        private Map<String,IWolf> map;
    }

上面的两种形式都会将 IWolf 中所有的实现类注入集合中。如果使用的是 List 集合，那么我们可以取出来再通过 instanceof 关键字来判定类型；而通过 Map 集合注入的话，Spring 会将 Bean 的名称（默认类名首字母小写）作为 key 来存储，这样我们就可以在需要的时候动态获取自己想要的实现类。

#### @Primary 注解实现默认注入 ####

除了上面的几种方式，我们还可以在其中某一个实现类上加上 @Primary 注解来表示当有多个 Bean 满足条件时，优先注入当前带有 @Primary 注解的 Bean：

@Component
    @Primary
    public class Wolf1Bean implements IWolf{
        
    }

通过这种方式，Spring 就会默认注入 wolf1Bean，而同时我们仍然可以通过上下文手动获取其他实现类，因为其他实现类也存在容器中。

### 手动获取 Bean 的几种方式 ###

在 Spring 项目中，手动获取 Bean 需要通过 ApplicationContext 对象，这时候可以通过以下 5 种方式进行获取：

#### 直接注入 ####

最简单的一种方法就是通过直接注入的方式获取 ApplicationContext 对象，然后就可以通过 ApplicationContext 对象获取 Bean ：

@Component
    public class InterfaceInject {
        
        @Autowired
        private ApplicationContext applicationContext;//注入
    
        public Object getBean(){
        
            return applicationContext.getBean("wolf1Bean");//获取bean
        }
    }

#### 通过 ApplicationContextAware 接口获取 ####

通过实现 ApplicationContextAware 接口来获取 ApplicationContext 对象，从而获取 Bean。需要注意的是，实现 ApplicationContextAware 接口的类也需要加上注解，以便交给 Spring 统一管理（这种方式也是项目中使用比较多的一种方式）：

@Component
    public class SpringContextUtil implements ApplicationContextAware {
        
        private static ApplicationContext applicationContext = null;
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        
            this.applicationContext = applicationContext;
        }
    
        /**
         * 通过名称获取bean
         */
        public static <T>T getBeanByName(String beanName){
        
            return (T) applicationContext.getBean(beanName);
        }
    
        /**
         * 通过类型获取bean
         */
        public static <T>T getBeanByType(Class<T> clazz){
        
            return (T) applicationContext.getBean(clazz);
        }
    }

封装之后，我们就可以直接调用对应的方法获取 Bean 了：

Wolf2Bean wolf2Bean = SpringContextUtil.getBeanByName("wolf2Bean");
    Wolf3Bean wolf3Bean = SpringContextUtil.getBeanByType(Wolf3Bean.class);

#### 通过 ApplicationObjectSupport 和 WebApplicationObjectSupport 获取 ####

这两个对象中，`WebApplicationObjectSupport` 继承了 `ApplicationObjectSupport`，所以并无实质的区别。

同样的，下面这个工具类也需要增加注解，以便交由 Spring 进行统一管理：

@Component
    public class SpringUtil extends /*WebApplicationObjectSupport*/ ApplicationObjectSupport {
        
        private static ApplicationContext applicationContext = null;
    
        public static <T>T getBean(String beanName){
        
            return (T) applicationContext.getBean(beanName);
        }
    
        @PostConstruct
        public void init(){
        
            applicationContext = super.getApplicationContext();
        }
    }

有了工具类，在方法中就可以直接调用了：

@RestController
    @RequestMapping("/hello")
    @Qualifier
    public class HelloController {
        
        @GetMapping("/bean3")
        public Object getBean3(){
        
            Wolf1Bean wolf1Bean = SpringUtil.getBean("wolf1Bean");
            return wolf1Bean.toString();
        }
    }

#### 通过 HttpServletRequest 获取 ####

通过 `HttpServletRequest` 对象，再结合 Spring 自身提供的工具类 `WebApplicationContextUtils` 也可以获取到 `ApplicationContext` 对象，而 `HttpServletRequest` 对象可以主动获取（如下 getBean2 方法），也可以被动获取（如下 getBean1 方法）：

@RestController
    @RequestMapping("/hello")
    @Qualifier
    public class HelloController {
        
    
        @GetMapping("/bean1")
        public Object getBean1(HttpServletRequest request){
        
            //直接通过方法中的HttpServletRequest对象
            ApplicationContext applicationContext = WebApplicationContextUtils.getRequiredWebApplicationContext(request.getServletContext());
            Wolf1Bean wolf1Bean = (Wolf1Bean)applicationContext.getBean("wolf1Bean");
    
            return wolf1Bean.toString();
        }
    
        @GetMapping("/bean2")
        public Object getBean2(){
        
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();//手动获取request对象
            ApplicationContext applicationContext = WebApplicationContextUtils.getRequiredWebApplicationContext(request.getServletContext());
    
            Wolf2Bean wolf2Bean = (Wolf2Bean)applicationContext.getBean("wolf2Bean");
            return wolf2Bean.toString();
        }
    }

#### 其他方式获取 ####

当然，除了上面提到的方法，我们也可以使用最开始提到的 DL 中代码示例去手动 new 一个 ApplicationContext 对象，但是这样就意味着重新初始化了一次，所以是不建议这么去做，但是在写单元测试的时候这种方式是比较适合的。

#### 谈谈 `@Autowrite` 和 `@Resource` 以及 `@Qualifier` 注解的区别 ####

上面我们看到了，注入一个 Bean 可以通过 @Autowrite，也可以通过 @Resource 注解来注入，这两个注解有什么区别呢？

> @Autowrite：通过类型去注入，可以用于构造器和参数注入。当我们注入接口时，其所有的实现类都属于同一个类型，所以就没办法知道选择哪一个实现类来注入。  
> @Resource：默认通过名字注入，不能用于构造器和参数注入。如果通过名字找不到唯一的 Bean，则会通过类型去查找。如下可以通过指定  
> name 或者 type 来确定唯一的实现：

@Resource(name = "wolf2Bean",type = Wolf2Bean.class)
    private IWolf iWolf;

而 @Qualifier 注解是用来标识合格者，当 @Autowrite 和 @Qualifier 一起使用时，就相当于是通过名字来确定唯一：

@Qualifier("wolf1Bean")
    @Autowired
    private IWolf iWolf;

那可能有人就会说，我直接用 @Resource 就好了，何必用两个注解结合那么麻烦，这么一说似乎显得 @Qualifier 注解有点多余？

#### @Qualifier 注解是多余的吗 ####

我们先看下面声明 Bean 的场景，这里通过一个方法来声明一个 Bean (MyElement)，而且方法中的参数又有 Wolf1Bean 对象，那么这时候 Spring 会帮我们自动注入 Wolf1Bean：

@Component
    public class InterfaceInject2 {
        
        @Bean
        public MyElement test(Wolf1Bean wolf1Bean){
        
            return new MyElement();
        }
    }

然而如果说我们把上面的代码稍微改一下，把参数改成一个接口，而接口又有多个实现类，这时候就会报错了：

@Component
    public class InterfaceInject2 {
        
        @Bean
        public MyElement test(IWolf iWolf){
        //此时因为IWolf接口有多个实现类，会报错
            return new MyElement();
        }
    }

而 @Resource 注解又是不能用在参数中，所以这时候就需要使用 @Qualifier 注解来确认唯一实现了（比如在配置多数据源的时候就经常使用 @Qualifier 注解来实现）：

@Component
    public class InterfaceInject2 {
        
        @Bean
        public MyElement test(@Qualifier("wolf1Bean") IWolf iWolf){
        
            return new MyElement();
        }
    }

### 总结 ###

本文主要讲述了如何在 Spring 中使用灵活的方式来实现各种场景的注入方式，并且着重介绍了当一个接口有多个实现类时应该如何注入的问题，最后也介绍了常用几个注入注解的区别，通过本文，相信大家对如何使用 Spring 中的依赖注入会更加的熟悉。

[45c6a3ec00234435bd67d5e9334d5cc0.png]: https://img-blog.csdnimg.cn/45c6a3ec00234435bd67d5e9334d5cc0.png