标签：依赖 Spring 最全 class Bean 注解 public 注入

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

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

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

控制反转

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

DL（Dependency Lookup）：依赖查找。

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

DI（Dependency Inject）：依赖注入。

依赖注入相比较依赖查找又是一种优化，也就是我们不需要自己去查找，只需要告诉容器当前需要注入的对象，容器就会自动将创建好的对象进行注入（赋值）。

依赖注入 DI

基于注解的常规注入方式通常有三种：

基于属性注入
基于 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;

这个就是说本来应该注入一个类，但是 Spring 找到了三个，所以没法确认到底应该用哪一个。这个问题如何解决呢？

解决思路主要有以下：

通过 @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();
    }
}

通过 HttpServletRequest 获取

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

//直接通过方法中的HttpServletRequest对象
ApplicationContext applicationContext = WebApplicationContextUtils.getRequiredWebApplicationContext(request.getServletContext());
Wolf1Bean wolf1Bean = (Wolf1Bean)applicationContext.getBean("wolf1Bean");

@Autowired和@Resource 区别

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

@Autowired：通过类型（byType）去注入，可以用于构造器和参数注入。当我们注入接口时，其所有的实现类都属于同一个类型，所以就没办法知道选择哪一个实现类来注入。但是如果只根据type无法辨别注入对象时,就需要配合使用 @Qualifier 注解或者 @Primary 注解使用。
@Resource：默认通过名字（byName）注入，不能用于构造器和参数注入。如果通过名字（byName）找不到唯一的 Bean，则会通过类型（byType）去查找。如下可以通过指定 name 或者 type 来确定唯一的实现：

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

@Resource(name = "wolf2Bean",type = Wolf2Bean.class)
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 3.x：Spring 团队通常提倡 setter 注入，因为当属性特别多的时候，构造方法看起来会特别臃肿，特别是当属性是可选的时（属性可选意味着没必要通过构造方法注入）。Setter 方法注入还有一个好处就是可以使该类的属性可以在以后重新配置或重新注入。

Spring 4x：官方不推荐这种注入方式了，转而推荐构造器注入。通过构造方法注入的方式，能够保证注入的组件不可变，并且能够确保需要的依赖不为空。此外，构造方法注入的依赖总是能够在返回客户端（组件）代码的时候保证完全初始化的状态。在 Spring3.0 文档中，官方说如果构造方法注入的话，属性太多可能会让代码变得非常臃肿，那么在 4.0 文档中，官方对这个说法也做了一些订正：如果用构造方法注入的时候，参数过多以至于代码过于臃肿，那么此时你需要考虑这个类的设计是否合理，这个类是否参杂了太多的其他无关功能，这个类是否做到了单一职责。

为何不推荐属性注入？

属性注入其实有一个显而易见的缺点，那就是对于 IOC 容器以外的环境，除了使用反射来提供它需要的依赖之外，无法复用该实现类。因为该类没有提供该属性的 set 方法或者相应的构造方法来完成该属性的初始化。换言之，要是使用属性注入，那么你这个类就只能在 IOC 容器中使用，要是想自己 new 一下这个类的对象，那么相关的依赖无法完成注入。

日常开发应该还是属性注入较多，这个咱们不必纠结，代码该咋写还咋写，Spring 官方的态度了解一下即可，当然，如果项目允许，也不妨试试 Spring 推荐的代码规范。

标签：依赖,Spring,最全,class,Bean,注解,public,注入
From： https://www.cnblogs.com/xfeiyun/p/17937983

Spring最全的依赖注入方式