@Override

public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

    return bean;

}

@Override

public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

    return bean;

}

@Service

public class AnimalServiceImpl implements IAnimalService {

    @Autowired

    private Dog dog;

    @Resource

    private Cat cat;

    @Inject

    private Pig pig;

    @Override

    public void printName() {

        System.out.println(dog.getName());

        System.out.println(cat.getName());

        System.out.println(pig.getName());

    }

}

@RunWith(SpringRunner.class)

@SpringBootTest(classes={Application.class})

public class AnimalTest {

    @Autowired

    private IAnimalService animalService;

    @Test

    public void test() {

        animalService.printName();

    }

}

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.

    }

}

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)

        throws BeanCreationException {

    // Instantiate the bean.

    BeanWrapper instanceWrapper = null;

    if (mbd.isSingleton()) {

        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);

    }

    if (instanceWrapper == null) {

        // 创建bean实例

        instanceWrapper = createBeanInstance(beanName, mbd, args);

    }

    final Object bean = instanceWrapper.getWrappedInstance();

    Class<?> beanType = instanceWrapper.getWrappedClass();

    if (beanType != NullBean.class) {

        mbd.resolvedTargetType = beanType;

    }

    // Allow post-processors to modify the merged bean definition.

    // 允许后置处理器来修改bean定义

    synchronized (mbd.postProcessingLock) {

        if (!mbd.postProcessed) {

            try {

                // 调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法

                // AutowiredAnnotationBeanPostProcessor实现了MergedBeanDefinitionPostProcessor，即MergedBeanDefinitionPostProcessor的MergedBeanDefinitionPostProcessor会被调用

                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

            }

            catch (Throwable ex) {

                throw new BeanCreationException(mbd.getResourceDescription(), beanName,

                        "Post-processing of merged bean definition failed", ex);

            }

            mbd.postProcessed = true;

        }

    }

    // Eagerly cache singletons to be able to resolve circular references 立即缓存单例以便能够解析循环引用

    // even when triggered by lifecycle interfaces like BeanFactoryAware.

    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&

            isSingletonCurrentlyInCreation(beanName));

    if (earlySingletonExposure) {

        if (logger.isDebugEnabled()) {

            logger.debug("Eagerly caching bean '" + beanName +

                    "' to allow for resolving potential circular references");

        }

        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

    }

    // Initialize the bean instance.

    Object exposedObject = bean;

    try {

        // 填充bean，包含依赖注入

        populateBean(beanName, mbd, instanceWrapper);

        // 初始化bean，BeanPostProcessor的两个方法在此中被调用

        exposedObject = initializeBean(beanName, exposedObject, mbd);

    }

    catch (Throwable ex) {

        if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {

            throw (BeanCreationException) ex;

        }

        else {

            throw new BeanCreationException(

                    mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);

        }

    }

    if (earlySingletonExposure) {

        Object earlySingletonReference = getSingleton(beanName, false);

        if (earlySingletonReference != null) {

            if (exposedObject == bean) {

                exposedObject = earlySingletonReference;

            }

            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {

                String[] dependentBeans = getDependentBeans(beanName);

                Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);

                for (String dependentBean : dependentBeans) {

                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {

                        actualDependentBeans.add(dependentBean);

                    }

                }

                if (!actualDependentBeans.isEmpty()) {

                    throw new BeanCurrentlyInCreationException(beanName,

                            "Bean with name '" + beanName + "' has been injected into other beans [" +

                            StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +

                            "] in its raw version as part of a circular reference, but has eventually been " +

                            "wrapped. This means that said other beans do not use the final version of the " +

                            "bean. This is often the result of over-eager type matching - consider using " +

                            "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");

                }

            }

        }

    }

    // Register bean as disposable.

    try {

        registerDisposableBeanIfNecessary(beanName, bean, mbd);

    }

    catch (BeanDefinitionValidationException ex) {

        throw new BeanCreationException(

                mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);

    }

    return exposedObject;

}