Spring5的@Autowire原理分析
Autowire注解
从Autowire注解点进去看
注释的第一句话说是将构造函数、字段、setter方法或者配置方法通过由Spring依赖注入工具自动装入
在注释的最后 说这个注解是通过 BeanPostProcessor 这个接口进行的
最后的实现类是 AutowiredAnnotationBeanPostProcessor
AutowiredAnnotationBeanPostProcessor 类
public class AutowiredAnnotationBeanPostProcessor
extends InstantiationAwareBeanPostProcessorAdapter
implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware
- InstantiationAwareBeanPostProcessorAdapter能够设置Bean的属性值
- PriorityOrdered接口用于标识这个类的创建的优先级
- BeanFactoryAware接口用于获取Spring的BeanFactory
- MergedBeanDefinitionPostProcessor：合并Bean定义后置处理器(继承BeanPostProcessor）
构造函数
在创建的时候会把Autowired和Value设置到autowiredAnnotationTypes这个列表中，如果存在@Inject这个注解也同样会被塞进去
private final Set<Class<? extends Annotation>> autowiredAnnotationTypes = new LinkedHashSet<>();
public AutowiredAnnotationBeanPostProcessor() {
this.autowiredAnnotationTypes.add(Autowired.class);
this.autowiredAnnotationTypes.add(Value.class);
try {
this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
logger.info("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
}
catch (ClassNotFoundException ex) {
// JSR-330 API not available - simply skip.
}
}
运行过程
在容器执行的时候会调用refresh()方法，里面有个registerBeanPostProcessor方法，
会对AutowiredAnnotationBeanPostProcessor进行一个注册
之后会执行finishBeanFactoryInitialization(beanFactory)方法对非延迟初始化的单例bean进行初始化时，
会执行到AbstractAutowireCapableBeanFactory的createBean方法，并且调用doCreateBean方法创建Bean，
会调用MergedBeanDefinitionPostProcessor接口的postProcessMergedBeanDefinition方法
/**
* 这个方法是对注入属性的创建
*/
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof MergedBeanDefinitionPostProcessor) {
MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
}
}
}
// 在此之后会调用populateBean这个方法
// 在postProcessPropertyValues中才是最后把属性给写出去
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvs == null) {
return;
}
}
}
所以说，我们需要从postProcessMergedBeanDefinition这个方法开始看起
首先先定义了三个测试类：
@RestController
public class DemoController {
@Autowired
private DemoService demoService;
@RequestMapping("/")
String home() {
return demoService.getString();
}
}
@Service
public class DemoService {
public String getString() {
return "Hello World!";
}
}
@SpringBootApplication
public class SampleController {
public static void main(String[] args) throws Exception {
SpringApplication.run(SampleController.class, args);
}
}
在启动的时候，Spring会寻找每个Bean，并且调用postProcessMergedBeanDefinition为他们注入还有@Autowire的属性
[图片上传失败...(image-e85ff9-1530195131381)]
这里算是预处理部分，将注入列表给弄出来
/**
* 最终缓存列表的地方
*/
public void checkConfigMembers(RootBeanDefinition beanDefinition) {
Set<InjectedElement> checkedElements = new LinkedHashSet<>(this.injectedElements.size());
for (InjectedElement element : this.injectedElements) {
Member member = element.getMember();
if (!beanDefinition.isExternallyManagedConfigMember(member)) {
beanDefinition.registerExternallyManagedConfigMember(member);
checkedElements.add(element);
if (logger.isDebugEnabled()) {
logger.debug("Registered injected element on class [" + this.targetClass.getName() + "]: " + element);
}
}
}
this.checkedElements = checkedElements;
}
private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
// 接下来的操作会锁资源，所以先进行一遍查找，如果查询出来的没有被处理过才进行处理
InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
synchronized (this.injectionMetadataCache) {
metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
if (metadata != null) {
metadata.clear(pvs);
}
// 构造需要注入的元素
metadata = buildAutowiringMetadata(clazz);
// 将处理过的给缓存起来
this.injectionMetadataCache.put(cacheKey, metadata);
}
}
}
return metadata;
}
public static boolean needsRefresh(@Nullable InjectionMetadata metadata, Class<?> clazz) {
return (metadata == null || metadata.targetClass != clazz);
}
/**
* 构造需要注入的元素
*
*/
private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
LinkedList<InjectionMetadata.InjectedElement> elements = new LinkedList<>();
Class<?> targetClass = clazz;
do {
final LinkedList<InjectionMetadata.InjectedElement> currElements = new LinkedList<>();
// 循环这个类的所有属性
ReflectionUtils.doWithLocalFields(targetClass, field -> {
// 寻找含有在autowiredAnnotationTypes注解列表里面的属性
AnnotationAttributes ann = findAutowiredAnnotation(field);
// 如果不为空书面还有
if (ann != null) {
// 属性的修饰符不能是静态的
if (Modifier.isStatic(field.getModifiers())) {
if (logger.isWarnEnabled()) {
logger.warn("Autowired annotation is not supported on static fields: " + field);
}
return;
}
// 校验一下权限
boolean required = determineRequiredStatus(ann);
// 当前的属性表加入一个新的需要注入的属性
// 其实就是把DemoService放到这个列表中作为备用
currElements.add(new AutowiredFieldElement(field, required));
}
});
// 这段就是寻找还有包含自动注入的方法
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
return;
}
AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
if (Modifier.isStatic(method.getModifiers())) {
if (logger.isWarnEnabled()) {
logger.warn("Autowired annotation is not supported on static methods: " + method);
}
return;
}
if (method.getParameterCount() == 0) {
if (logger.isWarnEnabled()) {
logger.warn("Autowired annotation should only be used on methods with parameters: " +
method);
}
}
boolean required = determineRequiredStatus(ann);
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
currElements.add(new AutowiredMethodElement(method, required, pd));
}
});
elements.addAll(0, currElements);
// 类似递归去寻找他父类的注入信息
targetClass = targetClass.getSuperclass();
}
while (targetClass != null && targetClass != Object.class);
// 最后返回一个这个类需要注入的列表出去
return new InjectionMetadata(clazz, elements);
}
最后将属性注入到Bean中
@Override
public PropertyValues postProcessPropertyValues(
PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {
// 由于在上一步就已经进行了创建所以这不会再进行创建，直接把列表返回
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {
metadata.inject(bean, beanName, pvs);
}
catch (BeanCreationException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
}
return pvs;
}
public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
Collection<InjectedElement> checkedElements = this.checkedElements;
// 要注入的属性列表
Collection<InjectedElement> elementsToIterate =
(checkedElements != null ? checkedElements : this.injectedElements);
if (!elementsToIterate.isEmpty()) {
boolean debug = logger.isDebugEnabled();
// 依次注入各个属性
for (InjectedElement element : elementsToIterate) {
if (debug) {
logger.debug("Processing injected element of bean '" + beanName + "': " + element);
}
element.inject(target, beanName, pvs);
}
}
}
@Override
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
// 获取成员属性
Field field = (Field) this.member;
Object value;
if (this.cached) {
value = resolvedCachedArgument(beanName, this.cachedFieldValue);
}
else {
DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
desc.setContainingClass(bean.getClass());
Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
Assert.state(beanFactory != null, "No BeanFactory available");
TypeConverter typeConverter = beanFactory.getTypeConverter();
try {
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
}
synchronized (this) {
if (!this.cached) {
if (value != null || this.required) {
this.cachedFieldValue = desc;
registerDependentBeans(beanName, autowiredBeanNames);
if (autowiredBeanNames.size() == 1) {
String autowiredBeanName = autowiredBeanNames.iterator().next();
if (beanFactory.containsBean(autowiredBeanName) &&
beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
this.cachedFieldValue = new ShortcutDependencyDescriptor(
desc, autowiredBeanName, field.getType());
}
}
}
else {
this.cachedFieldValue = null;
}
this.cached = true;
}
}
}
// 上面都是执行各种构造，最终是使用反射将值塞到对应的Bean里面
if (value != null) {
ReflectionUtils.makeAccessible(field);
field.set(bean, value);
}
}
[图片上传失败...(image-d50582-1530195131381)]
END
