乐趣区

关于springboot:深入学习-Spring-Web-开发-Bean-的注入

jiezi

上一篇文章，咱们聊了与 Bean 的申明相干的内容，本文，咱们重点聊聊与 Bean 注入相干的内容。

注入形式

Bean 注入的形式，次要蕴含三种，即：构造函数注入、setter 注入和属性注入。

构造函数注入

构造函数注入，示例代码如下。对于上面的代码，利用启动后，myBean 属性会被顺利注入：

@Component
public class InjectionComponent {

    private MyBean myBean;

    public InjectionComponent(MyBean myBean) {this.myBean = myBean;}

}

setter 注入

setter 注入的示例代码如下（必须给 setter 办法增加 @Autowired 注解）：

@Component
public class InjectionComponent2 {

    private MyBean myBean;

    @Autowired
    public void setMyBean(MyBean myBean) {this.myBean = myBean;}

}

属性注入

属性注入的示例代码如下：

@Component
public class InjectionComponent3 {

    @Autowired
    private MyBean myBean;

}

申明注解

@Autowired

从下面的代码例子，咱们能够晓得 @Autowired 是用来申明 Bean 的注入的。

@Autowired 的作用指标

@Autowired 是 JSR-330 javax.inject.Inject 的代替计划，能够作用在构造函数、办法、参数、字段和注解上。

作用在构造函数上
  • 如下面的例子 构造函数注入 ，应用该形式进行注入时，@Autowired 不是必须的。
  • 构造函数能够是公共的，也能够是公有的。
  • 构造函数中的参数，必须在 Spring IoC 容器中能够找到，否则利用启动时将抛出异样。
  • 如果存在多个构造函数，则必须存在一个无参构造函数，否则利用启动时将抛出异样。如果存在无参构造函数，则创立实例时，将应用该构造函数进行创立。
  • 当存在多个构造函数时，如果在其中一个构造函数上加上 @Autowired，则下面一条规定会被突破，即此时能够不存在无参构造函数，且创立实例时，应用的不是无参构造函数，而是加上了 @Autowired 的构造函数。
  • @Autowired 有一个 required 属性，默认为 true，示意构造函数中的全副参数都必须在 Spring IoC 容器中存在，否则利用启动时将抛出异样。
  • 默认状况下，不能有多个构造函数存在 @Autowired 注解，否则，利用启动时将抛出异样。
  • 如果多个构造函数都加上 @Autowired 注解，那么，这些注解的 required 属性必须全都设置为 false。这种状况下，示意这几个构造函数都是候选构造函数，创立实例时，将抉择可能满足的参数最多的一个构造函数来进行对象的创立。在这根底上，会优先选择公共的构造函数。例如：如果存在一个蕴含 2 个参数和一个蕴含 3 个参数的构造函数，且这两个构造函数都可能被满足，然而蕴含 2 个参数的构造函数是公共的，蕴含 3 个参数的构造函数是公有的，那么，此时抉择的将是蕴含 2 个参数的构造函数。
  • 如果下面一条规定中的所有候选构造函数，没有一个能够被满足，并且存在无参构造函数，则创立实例时会抉择无参构造函数。如果此时不存在无参构造函数，则利用启动时将抛出异样。

如上面的代码，因为不存在 Cache 类的实例，而 MyBean 类和 RestTemplate 类的实例是存在的，因而，利用启动时将应用构造函数 InjectionComponent4(MyBean, RestTemplate) 来初始化 InjectionComponent4 的实例。

@Component
public class InjectionComponent4 {

    private MyBean myBean;
    private RestTemplate restTemplate;
    private Cache cache;

    @Autowired(required = false)
    public InjectionComponent4(MyBean myBean) {this.myBean = myBean;}

    @Autowired(required = false)
    public InjectionComponent4(MyBean myBean, RestTemplate restTemplate) {
        this.myBean = myBean;
        this.restTemplate = restTemplate;
    }

    @Autowired(required = false)
    public InjectionComponent4(MyBean myBean, RestTemplate restTemplate, Cache cache) {
        this.myBean = myBean;
        this.restTemplate = restTemplate;
        this.cache = cache;
    }

}
作用在办法上

当 @Autowired 作用在某个办法时，该办法能够有任意的名称和任意数量的参数，setter 办法只是其中的一种非凡模式，该办法也能够是公有的：

@Component
public class InjectionComponent5 {

    private MyBean myBean;

    @Autowired
    private void myBean(MyBean myBean) {this.myBean = myBean;}

}
作用在参数上

尽管 Spring 框架 5.0 之后反对在构造函数和办法的参数上加上 @Autowired 注解，然而 Spring 框架中的大部分代码都不反对该形式的注入，目前只有 Spring Test 局部反对。如上面的代码，在理论运行的时候，myBean 是注入不了的：

@Component
public class InjectionComponent6 {

    private MyBean myBean;

    public void init(@Autowired MyBean myBean) {this.myBean = myBean;}

}
作用在字段上

示例见前文的 属性注入 。

Collection 和 Map 的注入

应用 @Autowire 还能够注入 Collection 和 Map 类型的变量。

Collection 的注入

如上面的代码，OrderBean 和 OrderBean2 的实例都会被注入到 InjectionComponent7 的 orderBeans 中，能够通过实现 Ordered 接口为类的实例提供排序功能，order 小的排在后面。

@Component
public class OrderBean extends BaseOrderBean implements Ordered {

    @Override
    public int getOrder() {return 1;}

}
@Component
public class OrderBean2 extends BaseOrderBean implements Ordered {

    @Override
    public int getOrder() {return 2;}

}
@Component
public class InjectionComponent7 {

    @Autowired
    private List<BaseOrderBean> orderBeans;

}

也能够通过 @Order 实现排序：

public class OrderBean3 {

    private String field;

    public void setField(String field) {this.field = field;}

}
@Configuration
public class BeanConfig {

    @Bean
    @Order(1)
    public OrderBean3 orderBean3() {OrderBean3 orderBean = new OrderBean3();
        orderBean.setField("order 1");
        return orderBean;
    }

    @Bean
    @Order(2)
    public OrderBean3 orderBean4() {OrderBean3 orderBean = new OrderBean3();
        orderBean.setField("order 2");
        return orderBean;
    }

}
@Component
public class InjectionComponent8 {

    @Autowired
    private List<OrderBean3> orderBeans;

}
Map 的注入

上面的代码中，全副 BaseOrderBean 的实例都会注入到 orderBeanMap 中，Bean 的名字将作为 Map 的键，Bean 的实例将作为 Map 的值。

@Component
public class InjectionComponent9 {

    @Autowired
    private Map<String, BaseOrderBean> orderBeanMap;

}

@Primary

@Autowired 依据 Bean 的类型找到它，并将它注入到变量中，如果一个类型有两个 Bean，那么注入的时候将不晓得要注入的是哪一个。如果用 @Primary 对 Bean 进行了标注，那么注入的时候就会抉择该 Bean 进行注入。

public class MyBean3 {

    private String field;

    public MyBean3(String field) {this.field = field;}

}
@Configuration
public class BeanConfig2 {

    @Primary
    @Bean
    public MyBean3 primaryTestBean1() {return new MyBean3("primaryTestBean1");
    }

    @Bean
    public MyBean3 primaryTestBean2() {return new MyBean3("primaryTestBean2");
    }

}
@Component
public class InjectionComponent10 {

    @Autowired
    private MyBean3 myBean;

}

@Qualifier

一个类型有多个 Bean 的时候，也能够通过 @Qualifier 进行标注，以让变量注入的时候依据 Bean 的名字找到 Bean。

@Configuration
public class BeanConfig3 {

    @Bean
    public MyBean3 qualifierTestBean1() {return new MyBean3("qualifierTestBean1");
    }

    @Bean
    public MyBean3 qualifierTestBean2() {return new MyBean3("qualifierTestBean2");
    }

}
@Component
public class InjectionComponent11 {@Qualifier("qualifierTestBean1")
    @Autowired
    private MyBean3 myBean;

}

@Qualifier 还有另一个用法，就是在申明 Bean 和注入 Bean 的中央都应用该注解进行标注，那么注入的时候就会主动定位到对应的 Bean。

@Configuration
public class BeanConfig4 {

    @Qualifier
    @Bean
    public MyBean3 qualifierTestBean3() {return new MyBean3("qualifierTestBean3");
    }

    @Bean
    public MyBean3 qualifierTestBean4() {return new MyBean3("qualifierTestBean4");
    }

}
@Component
public class InjectionComponent12 {

    @Qualifier
    @Autowired
    private MyBean3 myBean;

}

@Resource

@Resource 也是用来申明 Bean 注入的注解。

  • 对于 @Resource，默认状况下，优先应用名字查找待注入的 Bean；如果找不到，则应用类型查找待注入的 Bean。
  • @Resource 能够正文在办法和字段上。
  • 正文在办法上时，Bean 类型为办法参数的类型，Bean 名字优先应用办法的名字（如果是 setter 办法，会去掉“set”，并将首字母小写），如果通过办法名字找不到 Bean，则再应用参数的名字。
  • 正文在字段上时，Bean 类型为字段类型，Bean 名字为字段名字。

代码示例如下：

public class ResourceBean {

    private String field;

    public ResourceBean(String field) {this.field = field;}

}
@Configuration
public class BeanConfig5 {

    @Bean
    public ResourceBean resourceBean1() {return new ResourceBean("resourceBean1");
    }

    @Bean
    public ResourceBean resourceBean2() {return new ResourceBean("resourceBean2");
    }

}
@Component
public class InjectionComponent13 {

    @Resource
    private ResourceBean resourceBean1;

    private ResourceBean resourceBean2;

    @Resource
    public void setResourceBean2(ResourceBean resourceBean) {this.resourceBean2 = resourceBean;}

}

@Resource 有一个 name 属性，能够间接指定 Bean 的名字：

@Component
public class InjectionComponent14 {@Resource(name = "resourceBean1")
    private ResourceBean myBean1;

    private ResourceBean myBean2;

    @Resource(name = "resourceBean2")
    public void setMyBean2(ResourceBean resourceBean) {this.myBean2 = resourceBean;}

}

另外，@Resource 也能够配合 @Primary 或 @Qualifier 一起应用。

@Inject

要应用 @Inject，须要先引入 jar 包：

<dependency>
    <groupId>javax.inject</groupId>
    <artifactId>javax.inject</artifactId>
    <version>1</version>
</dependency>

@Inject 能够正文在构造函数、办法和字段上，@Inject 能够通过类型注入：

@Component
public class InjectionComponent15 {

    @Inject
    private MyBean myBean1;

    private MyBean myBean2;

    @Inject
    public void setMyBean(MyBean myBean) {this.myBean2 = myBean;}

    private MyBean myBean3;

    @Inject
    public InjectionComponent15(MyBean myBean) {this.myBean3 = myBean;}

}

@Inject 也能够通过名字注入：

@Component
public class InjectionComponent16 {

    @Inject
    private ResourceBean resourceBean1;

    private ResourceBean resourceBean2;

    @Inject
    public void setResourceBean(ResourceBean resourceBean2) {this.resourceBean2 = resourceBean2;}

    private ResourceBean resourceBean3;

    @Inject
    public InjectionComponent16(ResourceBean resourceBean2) {this.resourceBean3 = resourceBean2;}

}

同样地，@Inject 也能够配合 @Primary 或 @Qualifier 一起应用。

小结

@Autowired、@Resource、@Inject 有什么异同点？显然，它们都能够用来申明 Bean 的注入。它们的不同点次要集中在：1. 能够标注的中央有所差别，2. 领有的属性不同，3. 注入的形式略有差别。而它们最大的不同，笔者认为是，@Autowired 是 Spring 自定义的注解（@Primary、@Qualifier 也是 Spring 自定义的注解），@Resource 是 Jakarta 定义的注解，而 @Inject 则是在 JSR-330 中定义的注解，即它们的作用十分相似，最大的区别在于制定者的不同。

退出移动版