Java Spring 依赖注入
Spring 框架中最核心思想就是:

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

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

控制反转 IOC

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

DL(Dependency Lookup):依赖查找。

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

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

DI(Dependency Inject):依赖注入。

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

依赖注入 DI

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

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

    三种常规注入方式

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

    属性注入

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

    1. @Service
    2. public class UserService {
    3. @Autowired
    4. private Wolf1Bean wolf1Bean;//通过属性注入
    5. }

    setter 方法注入

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

    1. @Service
    2. public class UserService {
    3. private Wolf3Bean wolf3Bean;
    4. @Autowired //通过setter方法实现注入
    5. public void setWolf3Bean(Wolf3Bean wolf3Bean) {
    6. this.wolf3Bean = wolf3Bean;
    7. }
    8. }

    构造器注入

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

    1. @Service
    2. public class UserService {
    3. private Wolf2Bean wolf2Bean;
    4. @Autowired //通过构造器注入
    5. public UserService(Wolf2Bean wolf2Bean) {
    6. this.wolf2Bean = wolf2Bean;
    7. }
    8. }

    接口注入

    在上面的三种常规注入方式中,假如想要注入一个接口,而当前接口又有多个实现类,那么这时候就会报错,因为 Spring 无法知道到底应该注入哪一个实现类。
    比如上面的三个类全部实现同一个接口 IWolf,那么这时候直接使用常规的,不带任何注解元数据的注入方式来注入接口 IWolf。

    1. @Autowired
    2. private IWolf iWolf;

    此时启动服务就会报错:
    最全的 Spring 依赖注入方式 - 图1
    这个就是说本来应该注入一个类,但是 Spring 找到了三个,所以没法确认到底应该用哪一个。这个问题如何解决呢?
    解决思路主要有以下 5 种:

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

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

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

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

    通过其他 @Condition 条件注解

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

  • @ConditionalOnBean:当存在某一个 Bean 时,初始化此类到容器。

  • @ConditionalOnClass:当存在某一个类时,初始化此类的容器。
  • @ConditionalOnMissingBean:当不存在某一个 Bean 时,初始化此类到容器。
  • @ConditionalOnMissingClass:当不存在某一个类时,初始化此类到容器。

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

通过 @Resource 注解动态获取

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

  1. @Component
  2. public class InterfaceInject {
  3. @Resource(name = "wolf1Bean")
  4. private IWolf iWolf;
  5. }

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

通过集合注入

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

  1. @Component
  2. public class InterfaceInject {
  3. @Autowired
  4. List<IWolf> list;
  5. @Autowired
  6. private Map<String,IWolf> map;
  7. }

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

@Primary 注解实现默认注入

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

  1. @Component
  2. @Primary
  3. public class Wolf1Bean implements IWolf{
  4. }

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

手动获取 Bean 的几种方式

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

直接注入

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

  1. @Component
  2. public class InterfaceInject {
  3. @Autowired
  4. private ApplicationContext applicationContext;//注入
  5. public Object getBean(){
  6. return applicationContext.getBean("wolf1Bean");//获取bean
  7. }
  8. }

通过 ApplicationContextAware 接口获取

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

  1. @Component
  2. public class SpringContextUtil implements ApplicationContextAware {
  3. private static ApplicationContext applicationContext = null;
  4. @Override
  5. public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  6. this.applicationContext = applicationContext;
  7. }
  8. /**
  9. * 通过名称获取bean
  10. */
  11. public static <T>T getBeanByName(String beanName){
  12. return (T) applicationContext.getBean(beanName);
  13. }
  14. /**
  15. * 通过类型获取bean
  16. */
  17. public static <T>T getBeanByType(Class<T> clazz){
  18. return (T) applicationContext.getBean(clazz);
  19. }
  20. }

封装之后,就可以直接调用对应的方法获取 Bean 了:

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

通过 ApplicationObjectSupportWebApplicationObjectSupport 获取

这两个对象中,WebApplicationObjectSupport 继承了 ApplicationObjectSupport,所以并无实质的区别。
同样的,下面这个工具类也需要增加注解,以便交由 Spring 进行统一管理:

  1. @Component
  2. public class SpringUtil extends /*WebApplicationObjectSupport*/ ApplicationObjectSupport {
  3. private static ApplicationContext applicationContext = null;
  4. public static <T>T getBean(String beanName){
  5. return (T) applicationContext.getBean(beanName);
  6. }
  7. @PostConstruct
  8. public void init(){
  9. applicationContext = super.getApplicationContext();
  10. }
  11. }

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

  1. @RestController
  2. @RequestMapping("/hello")
  3. @Qualifier
  4. public class HelloController {
  5. @GetMapping("/bean3")
  6. public Object getBean3(){
  7. Wolf1Bean wolf1Bean = SpringUtil.getBean("wolf1Bean");
  8. return wolf1Bean.toString();
  9. }
  10. }

通过 HttpServletRequest 获取

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

  1. @RestController
  2. @RequestMapping("/hello")
  3. @Qualifier
  4. public class HelloController {
  5. @GetMapping("/bean1")
  6. public Object getBean1(HttpServletRequest request){
  7. //直接通过方法中的HttpServletRequest对象
  8. ApplicationContext applicationContext = WebApplicationContextUtils.getRequiredWebApplicationContext(request.getServletContext());
  9. Wolf1Bean wolf1Bean = (Wolf1Bean)applicationContext.getBean("wolf1Bean");
  10. return wolf1Bean.toString();
  11. }
  12. @GetMapping("/bean2")
  13. public Object getBean2(){
  14. HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();//手动获取request对象
  15. ApplicationContext applicationContext = WebApplicationContextUtils.getRequiredWebApplicationContext(request.getServletContext());
  16. Wolf2Bean wolf2Bean = (Wolf2Bean)applicationContext.getBean("wolf2Bean");
  17. return wolf2Bean.toString();
  18. }
  19. }

其他方式获取

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

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

注入一个 Bean 可以通过 @Autowrite,也可以通过 @Resource 注解来注入,这两个注解有什么区别呢?

  • @Autowrite:通过类型去注入,可以用于构造器和参数注入。当注入接口时,其所有的实现类都属于同一个类型,所以就没办法知道选择哪一个实现类来注入。
  • @Resource:默认通过名字注入,不能用于构造器和参数注入。如果通过名字找不到唯一的 Bean,则会通过类型去查找。如下可以通过指定 name 或者 type 来确定唯一的实现:
    1. @Resource(name = "wolf2Bean",type = Wolf2Bean.class)
    2. private IWolf iWolf;
    @Qualifier 注解是用来标识合格者,当 @Autowrite@Qualifier 一起使用时,就相当于是通过名字来确定唯一:
    1. @Qualifier("wolf1Bean")
    2. @Autowired
    3. private IWolf iWolf;
    那可能有人就会说,直接用 @Resource 就好了,何必用两个注解结合那么麻烦,这么一说似乎显得 @Qualifier 注解有点多余?

    @Qualifier 注解是多余的吗

    先看下面声明 Bean 的场景,这里通过一个方法来声明一个 Bean (MyElement),而且方法中的参数又有 Wolf1Bean 对象,那么这时候 Spring 会自动注入 Wolf1Bean:
    1. @Component
    2. public class InterfaceInject2 {
    3. @Bean
    4. public MyElement test(Wolf1Bean wolf1Bean){
    5. return new MyElement();
    6. }
    7. }
    然而如果说把上面的代码稍微改一下,把参数改成一个接口,而接口又有多个实现类,这时候就会报错了:
    1. @Component
    2. public class InterfaceInject2 {
    3. @Bean
    4. public MyElement test(IWolf iWolf){//此时因为IWolf接口有多个实现类,会报错
    5. return new MyElement();
    6. }
    7. }
    @Resource 注解又是不能用在参数中,所以这时候就需要使用 @Qualifier 注解来确认唯一实现了(比如在配置多数据源的时候就经常使用 @Qualifier 注解来实现):
    1. @Component
    2. public class InterfaceInject2 {
    3. @Bean
    4. public MyElement test(@Qualifier("wolf1Bean") IWolf iWolf){
    5. return new MyElement();
    6. }
    7. }