AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor#postProcessPropertyValues实现注解给属性赋值：
从上面看到了，Bean已经解析拿到了注解的一些元信息，因此此处就调用一些处理器的postProcessPropertyValues方法，来给赋值了：
//AutowiredAnnotationBeanPostProcessor:这里就是解析该Bean的Autowired信息,然后给inject进去 @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; } //CommonAnnotationBeanPostProcessor:逻辑和上面一毛一样，它处理的JSR-250的注解，比如@Resource @Override public PropertyValues postProcessPropertyValues( PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException { InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs); try { metadata.inject(bean, beanName, pvs); } catch (Throwable ex) { throw new BeanCreationException(beanName, "Injection of resource dependencies failed", ex); } return pvs; } //RequiredAnnotationBeanPostProcessor：它就是去校验，标注了@Required注解的，必须是是存在这个Bean的 @Override public PropertyValues postProcessPropertyValues( PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException { if (!this.validatedBeanNames.contains(beanName)) { if (!shouldSkip(this.beanFactory, beanName)) { List<String> invalidProperties = new ArrayList<>(); for (PropertyDescriptor pd : pds) { if (isRequiredProperty(pd) && !pvs.contains(pd.getName())) { invalidProperties.add(pd.getName()); } } if (!invalidProperties.isEmpty()) { throw new BeanInitializationException(buildExceptionMessage(invalidProperties, beanName)); } } this.validatedBeanNames.add(beanName); } return pvs; }
InjectionMetadata#inject处理依赖注入：
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); } // 主要的方法，还是在InjectedElement#inject里 element.inject(target, beanName, pvs); } } }
InjectedElement实现如下：
这里我们就以最常用的AutowiredFieldElement为例讲解（它是一个普通内部类，为private的）：
@Override protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable { // 拿到这个字段名 Field field = (Field) this.member; Object value; // 大多数情况下，这里都是false 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"); // 转换器，没有手动注册，默认都是SimpleTypeConverter=============== TypeConverter typeConverter = beanFactory.getTypeConverter(); try { // 把当前bean所依赖的这个Bean解析出来（从Spring容器里面拿，或者别的地方获取吧~~~） value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter); } catch (BeansException ex) { throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex); } synchronized (this) { if (!this.cached) { // 如果已经拿到了这个Bean实例， if (value != null || this.required) { this.cachedFieldValue = desc; // 把该Bean的依赖关系再注册一次 registerDependentBeans(beanName, autowiredBeanNames); // 因为是按照类型注入，所以肯定只能指导一个这个的依赖Bean，否则上面解析就已经报错了 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; } } } // 给该对象的该字段赋值。注意这里makeAccessible设置为true了，所以即使你的字段是private的也木有关系哦~~~ if (value != null) { ReflectionUtils.makeAccessible(field); field.set(bean, value); } } }
initializeBean进行Bean的初始化工作
上面步骤已经完成了Bean的属性的赋值工作，接下里就进行Bean的一些初始化工作，其中包括：
1：Bean后置处理器初始化
2：Bean的一些初始化方法的执行init-method等等
3：Bean的实现的声明周期相关接口的属性注入
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) { // 第一步：先执行所有的AwareMethods，具体如下代码，比较简单 if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { invokeAwareMethods(beanName, bean); return null; }, getAccessControlContext()); } else { invokeAwareMethods(beanName, bean); } Object wrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) { // 执行所有的BeanPostProcessor#postProcessBeforeInitialization 初始化之前的处理器方法 // 规则：只要谁反悔了null，后面的就都不要执行了 // 这里面实现postProcessBeforeInitialization 的处理器就很多了，有很多对Aware进行了扩展的，具体如下面的具体介绍吧================= wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); } try { //这里就开始执行afterPropertiesSet（实现了InitializingBean接口）方法和initMethod // 备注：这里initMethod方法的名称不能是afterPropertiesSet，并且这个类不是 InitializingBean类型才会调用，需要特别注意。 //(然后该方法只有方法名，所以肯定是反射调用，效率稍微低那么一丢丢) // 由此可以见，实现这个接口的初始化方法，是在标注形如@PostConstruct之后执行的 invokeInitMethods(beanName, wrappedBean, mbd); } catch (Throwable ex) { throw new BeanCreationException( (mbd != null ? mbd.getResourceDescription() : null), beanName, "Invocation of init method failed", ex); } if (mbd == null || !mbd.isSynthetic()) { // 整个Bean都初始化完成了，就执行后置处理器的这个方法 // 如果谁反悔了null，后面的处理器都不会再执行了 wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } return wrappedBean; }
