Spring自动装配之方法、构造器位置的自动注入
1. 注解定义
@Autowired的定义信息如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
/**
* Declares whether the annotated dependency is required.
* <p>Defaults to {@code true}.
*/
boolean required() default true;
}
|
可以看出，@Autowired注解可以定义在构造器上，方法上，方法参数上，字段上，还有自定义注解上；
2. 注解使用
2.1 定义在造器上
|
1
2
3
4
|
@Autowired //定义在构造器方法上
public UserService(UserDao userDao) {
this.userDao = userDao;
}
|
或者
|
1
2
3
4
|
// 定义在构造器参数上
public UserService(@Autowired UserDao userDao) {
this.userDao = userDao;
}
|
特别注意，当一个类只有一个有参构造器，且该构造器不一定需要是public修饰的， 组件注入的时候不需要指定在构造器方法上或者构造器参数上指定@Autowired，只需要声明构造器即可；
2.2 定义在方法和参数上
定义在Set方法上
|
1
2
3
4
|
@Autowired //定义在set方法上
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
|
定义在配置Bean的方法上
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
package com.yibai.spring.annotation.main.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;
import com.yibai.spring.annotation.service.UserDao;
import com.yibai.spring.annotation.service.UserService;
//@ComponentScan("com.yibai.spring.annotation.service")
@Service
public class MainConfigForAutowired {
// Spring自动从IOC容器中找出UserDao作为方法参数传入，这里@Autowired可有可无
@Bean
public UserService userService(@Autowired UserDao userDao) {
UserService userService = new UserService();
userService.setUserDao(userDao);
return userService;
}
@Bean
public UserDao userDao() {
return new UserDao();
}
}
|
2.3 定义在字段上
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
package com.yibai.spring.annotation.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import lombok.Getter;
@Getter
@Service
public class UserService {
@Qualifier(value = "userDao")
@Autowired(required = true)
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
}
|
3. 注入位置推荐
一般推荐注入位置放在构造器上，因为不管字段还是方法的方式注入，都是先创建组件，再注入依赖的组件，如果在构造方法上就需要使用依赖的组件，那么只有在构造器上注入才是可以实现的，因为执行顺序的问题；
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
package com.yibai.spring.annotation.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import lombok.Getter;
@Getter
@Service
public class UserService {
@Qualifier(value = "userDao")
@Autowired(required = true)
private UserDao userDao;
public UserService() {
//@Autowired定义在字段或者set方式上，在构造器上无法获取到依赖的组件
System.out.println(userDao); // null
}
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
}
|
Spring 自动注入的几种方式
Spring 中实现自动装配的注解有以下几个：
-
@Autowired -
@Qualifier -
@Primary -
@Resource -
@Inject
一、@Autowired
Spring 中最常用的一个注解，当一个组件需要另一个组件作为属性的时候，我们可以通过两种方式对属性进行赋值，一种是通过构造方法，一种是通过 set 方法（类比），而这个注解使用的方法就是后者。
下面介绍该注解的特点：
首先是 按照类型 自动注入，适用于容器中只有一种该类型的组件；
如果存在多个相同类型的组件，则将属性名作为 id 查询容器中的组件并注入；
默认属性对应的组件在容器中必须是存在的，如果想无论存在与否都注入可以令属性 required = false；
可以在该注解的基础之上使用 @Qualifier("bookDao") 注解指定要注入组件的 id，这时属性名的 id 已失效；
如果不使用上述注解指定 id ，存在多个相同类型的组件时也可以使用 @Primary 注解设置 Bean 的优先级为最优。
|
1
2
3
|
@Autowired(required = false)
@Qualifier("bookDao2")
private BookDao bookDao;
|
上面注入的组件的 id 值为 bookDao2；
二、@Resource
与 @Autowired 不同，@Resource 注解是 按照属性名 自动注入，它属于 JSR250 规范；
该注解不支持 @Qualifier、@Primary 的使用，但是可以使用它的 name 属性指定要注入组件的 id 值。
|
1
2
|
@Resource(name = "bookDao3")
private BookDao bookDao;
|
上面注入的组件的 id 值为 bookDao3；
三、@Inject
要使用 @Inject 注解必须要先导包，它属于 JSR330 规范 ：
|
1
2
3
4
5
6
|
<!-- inject 注解 -->
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
<version>1</version>
</dependency>
|
导包之后就可以使用了，该注解的效果和 @Autowired 的效果一样，只不过没有任何属性，所以功能有些欠缺，但是可以和另外两个注解配合使用。
|
1
2
|
@Inject
private BookDao bookDao;
|
上面注入的组件的 id 值为 bookDao；
四、@Autowired 的使用方式
该注解主要是通过 BeanPostProcessor 的实现类 AutowiredAnnotationBeanPostProcessor 实现的。
该类及其父类重写了 postProcessBeforeInitialization 方法，在初始化 Bean 之前，先对属性进行赋值，从而实现自动注入。
1、Set 方法
该注解除了可以放在属性上面，还可以放在方法上面：
|
1
2
3
4
5
6
7
8
9
10
11
|
@Component
public class Boss {
private Car car;
public Car getCar() {
return car;
}
@Autowired
public void setCar(Car car) {
this.car = car;
}
}
|
可以放在 set 方法上面，他会自动的去 IOC 容器中找方法中的参数，这里的参数是 car ，所以他会去容器中找 car 这个类，然后创建一个对象完成赋值。
官方 3.X 建议使用该方式注入。
2、构造器
对于加在 IOC 容器中的组件，容器启动后会调用 无参构造器 创建对象进行初始化赋值操作。
我们也可以不使用默认的，我们提供一个有参构造器：
|
1
2
3
4
|
@Autowired
public Boss(Car car) {
this.car = car;
}
|
构造器要使用的组件，也都是从容器中获取。
所以也可以这么写：
|
1
2
3
|
public Boss(@Autowired Car car) {
this.car = car;
}
|
同时如果该类只有一个有参构造器，那么 @Autowired 注解 可以省略。
官方 4.X 开始建议使用该方式注入。
3、@Bean + 方法参数
我们可以不改变 Boss 这个类，即不在 Boss 中注入 Car，而是在将 Boss 放入容器的时候注入它需要的参数 Car。
|
1
2
3
4
|
@Bean
public Boss boss(@Autowired Car car) {
return new Boss();
}
|
这里的 @Autowired 可以省略，也是用的最多的一种方式。
五、使用 Spring 底层的组件
如果自己写的组件想要使用 Spring 底层的组件可以使用另一种方式 ：比如想要使用 Spring 的 ApplicationContext。
Spring 为我们提供了相关的接口，他们都是 xxxAware，比如 ApplicationContextAware。
每一个接口都对应一个方法，我们可以在方法中获取 Spring 底层的组件，然后给成员变量赋值以获取相关组件。
|
1
2
3
4
5
6
7
|
public class Red implements ApplicationContextAware {
private ApplicationContext context;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.context = applicationContext;
}
}
|
关于 Aware 的原理：
其实它还是使用了我们之前说过的 BeanPostProcessor ，每一个 Aware 都对应一个 AwareProcessor，这个 processor 正是BeanPostProcessor 的实现类，所以肯定会有一个 postProcessBeforeInitialization 方法，我们重点来看一下这个方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
@Override
@Nullable
public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
AccessControlContext acc = null;
if (System.getSecurityManager() != null && (bean instanceof ApplicationContextAware)) {
acc = this.applicationContext.getBeanFactory().getAccessControlContext();
}
if (acc != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareInterfaces(bean);
return null;
}, acc);
}
else {
invokeAwareInterfaces(bean);
}
return bean;
}
|
在 invokeAwareInterfaces(bean); 方法中主要是下面的逻辑：
|
1
2
3
|
if (bean instanceof ApplicationContextAware) {
((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
}
|
其实就是先判断是不是那几个 Aware 中的一个，如果是就赋值，我们能看到的就是在 初始化 的时候利用 后置处理器 完成赋值。
以上为个人经验，希望能给大家一个参考，也希望大家多多支持服务器之家。
原文链接：https://blog.csdn.net/luojinbai/article/details/86586512