这是我参与8月更文挑战的第1天，活动详情查看：8月更文挑战

1、Bean实例化流程分析

// Bean实例化入口
// 【AbstractApplicationContext】# finishBeanFactoryInitialization 方法
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // 初始化上线文转换服务
   	// 省略部分代码...

    // 设置Bean工厂为冻结状态，说明不允许修改了，要开始创建Bean实例了
    beanFactory.freezeConfiguration();

    // 实例化单例Bean, 此处主要是初始化非抽象的、非延迟加载的、单例的Bean
    beanFactory.preInstantiateSingletons();
}

public Object getBean(String name) throws BeansException {
    // 获取Bean的实例
    return doGetBean(name, null, null, false);
}

// 【AbstractBeanFactory】# doGetBean() 方法
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
    // 去掉name中的&前缀：BeanFactoryUtils#transformedBeanName,对于获取MyFactoryBean本身的场景，
    // 就需要去掉&前缀，来获取真实的beanName, 否则获取到的是FactoryBean本身
    final String beanName = transformedBeanName(name);
    Object bean;

    // 尝试从单例缓存中获取bean实例
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) { 
        // 如果获取到单例bean，则走下面代码
        // 如果取出来的Bean实例是FactoryBean的Bean实例，则需要从FactoryBean实例中产生一个对象实例。
        // 需要调用FactoryBean.getObject来创建实例对象
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    } else {
        // 如果没有获取到单例bean，则走下面代码
        // 如果原型模式的Bean发生循环引用，则直接不处理，抛出异常
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
        // 父工厂处理，检查bean定义是否存在等功能暂时省略
        // 在 parentBeanFactory 中如果存在 beanName，则直接返回父容器里面的 bean
        try {
            // 获取要实例化的bean的BeanDefinition对象
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            // 检查该BeanDefinition对象对应的Bean是否是抽象的
            checkMergedBeanDefinition(mbd, beanName, args);

            // 初始化当前 bean 依赖的 bean
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException();
                    }
                    registerDependentBean(dep, beanName);
                    try {
                        // getBean() 会再递归调用 doGetBean()，以确保所依赖的 bean 全部初始化
                        getBean(dep);
                    }
                }
            }

            // Create bean instance.
            // 如果是单例的Bean，请下面的代码
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        // 创建单例Bean的主要方法
                        return createBean(beanName, mbd, args);
                    }
                });
                // 如果 bean 为 FactoryBean 的话，则调用 FactoryBean.getObject() 来创建 bean 实例
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            } else if (mbd.isPrototype()) {
                // 忽略此部分代码
            } else {
                // 忽略此部分代码
            }
        }
    }

	// 省略部分代码...
    return (T) bean;
}

// 核心方法 
// 【AbstractAutowireCapableBeanFactory】#createBean() 方法
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
    RootBeanDefinition mbdToUse = mbd;
    // 根据设置的 class 属性或 className 来解析 class
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }
    
    try {
        // 处理 lookup-method 和 replace-method 子标签
        mbdToUse.prepareMethodOverrides();
    }
    try {
        // 获取BeanPostProcessor代理对象
        // 给 BeanPostProcessors 机会返回一个代理来代替bean的实例
		// 即在初始化前，应用后置处理器，解析指定的bean是否存在初始化前的短路操作
        // 执行 InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation  -- bean 实例化前置处理
10      // 执行 InstantiationAwareBeanPostProcessor.postProcessAfterInitialization  -- bean 初始化后置处理
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        if (bean != null) {
            return bean;
        }
    }

    try {
        // 完成Bean实例的创建（实例化、填充属性、初始化）
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        return beanInstance;
    }
}

1.1 根据 bean 的 name 解析对应的 class

// 根据设置的class属性或者根据className来解析class：调用AbstractBeanFactory类
protected Class<?> resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class<?>... 
                                    												typesToMatch) {
    try {
        if (mbd.hasBeanClass()) {
            return mbd.getBeanClass();
        }
        if (System.getSecurityManager() != null) {
            return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () ->
                                                 doResolveBeanClass(mbd, typesToMatch), 
                                                 getAccessControlContext());
        }
        else {
            return doResolveBeanClass(mbd, typesToMatch);
        }
    }
}

private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch)
			throws ClassNotFoundException {
    // 省略部分代码....
    String className = mbd.getBeanClassName();
    if (className != null) {
        Object evaluated = evaluateBeanDefinitionString(className, mbd);
        if (!className.equals(evaluated)) {
            // A dynamically resolved expression, supported as of 4.2...
            if (evaluated instanceof Class) {
                return (Class<?>) evaluated;
            }
            else if (evaluated instanceof String) {
                return ClassUtils.forName((String) evaluated, classLoaderToUse);
            }
        }
        if (classLoaderToUse != beanClassLoader) {
            return ClassUtils.forName(className, classLoaderToUse);
        }
    }
    return mbd.resolveBeanClass(beanClassLoader);
}

1.2 处理 lookup-metod 和 replace-method 子标签

// 验证以及准备覆盖的方法即Override方法
public void prepareMethodOverrides() throws BeanDefinitionValidationException {
    if (hasMethodOverrides()) {
        Set<MethodOverride> overrides = getMethodOverrides().getOverrides();
        synchronized (overrides) {
            for (MethodOverride mo : overrides) {
                prepareMethodOverride(mo);
            }
        }
    }
}

protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
    // 获取对应类的方法的个数
    int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
    if (count == 0) {
        throw new BeanDefinitionValidationException(
            "Invalid method override: no method with name '" + mo.getMethodName() +
            "' on class [" + getBeanClassName() + "]");
    }
    else if (count == 1) {
        // 标记 MethodOverride 未被覆盖，避免了后面参数类型检查的开销
        mo.setOverloaded(false);
    }
}

// 总结: 
// lookup-method 和 replace-method 子标签会被解析放到 BeanDefinition 对象的 methodOverrides 属性中，表示需要覆
// 盖的方法；所以在创建bean之前需要解析这两个标签，但是只是预处理.
// 在处理 prepareMethodOverride(MethodOverride mo) 方法为什么只处理方法个数为 1 的情况呢？如果一个类中有多个重载的方法，
// 在调用或增强的时候，还需要进行参数类型的解析才能确定调用的是哪个方法，Spring 把部分功能放在这里提前进行预处理，如果方法只有一
// 个，没有重载的方法，在后面调用的时候，直接找到该方法调用，不用再去解析参数来确定方法了，这样就可以避免的一些参数类型检查的开销

1.3 处理初始化前的后置处理

// 获取BeanPostProcessor代理对象
// 提醒：AbstractAutoProxyCreator AOP代理创建的判定就是在这里，此抽象类实现了
// SmartInstantiationAwareBeanPostProcessor，前者继承了 InstantiationAwareBeanPostProcessor
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
// 不为空，直接短路返回
if (bean != null) {
    return bean;
}
// 如果postProcessBeforeInstantiation()返回值为空，则进入上层调用者createBean()方法，
// 继续调用doCreateBean()方法，完成对象实例化(创建对象)，以及对象初始化.

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        // 首先，判断是否存在InstantiationAwareBeanPostProcessor接口的处理器
        // 如存在，则调用的是InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation()实例化
        // 前置处理方法，也就是在Bean对象没有生成之前执行（实例化过程中）。
        // （注意：这里所说的是Bean未生成指的是Bean没有走spring定义创建Bean的流程，也就是doCreateBean()方法。）
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            Class<?> targetType = determineTargetType(beanName, mbd);
            if (targetType != null) {
                bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                if (bean != null) {
                    // 如果postProcessBeforeInstantiation()返回的对象不为空, 意味着Bean对象已经存在，
                    // 表明对象已经初始化完成, 然后调用postProcessAfterInitialization()初始化后置处理器，
                    // 完成对Bean对象的操作.
                    bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }
        mbd.beforeInstantiationResolved = (bean != null);
    }
    return bean;
}

1.4 真正的创建 bean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, 
                              final @Nullable Object[] args) throws BeanCreationException {
    // 最终返回的 bean 的包装类
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        // 如果是单例，则检查工厂缓存中以前是否创建过
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    // bean初始化第一步：默认调用无参构造实例化Bean
    // 创建bean，工厂方法创建，构造方法创建，默认构造方法创建等
    // 构造参数依赖注入，就是发生在这一步
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    // 实例化后的Bean对象
    final Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }

    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            }
            mbd.postProcessed = true;
        }
    }

    // 解决循环依赖的关键步骤
    // 检查循环依赖：是否是单例 && 是否允许循环依赖 && 当前bean是否正在创建中
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                                      isSingletonCurrentlyInCreation(beanName));
    // 如果需要提前暴露单例Bean，则将该Bean放入三级缓存中
    if (earlySingletonExposure) {
        // 将刚创建的bean放入三级缓存中singleFactories(key是beanName，value是FactoryBean)
        // 为了避免后期的循环依赖，在bean初始化完成前，将创建bean的工厂添加到缓存中，
        // 如果其他的bean依赖该bean，直接从缓存中获取对应的工厂创建集合，解决循环依赖，注意是只有单例情况才能这么做
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        // bean初始化第二步：填充属性（DI依赖注入发生在此步骤）
        populateBean(beanName, mbd, instanceWrapper);
        // bean初始化第三步：调用初始化方法，完成bean的初始化操作（AOP发生在此步骤）
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
	// 只有在检测到循环依赖时才不会为空
    if (earlySingletonExposure) {
        Object earlySingletonReference = getSingleton(beanName, false);
        // 存在循环依赖
        if (earlySingletonReference != null) {
            // 如果 exposedObject 在初始化方法中没有被改变，即没有被增强
            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);
                    }
                }
                // 因为bean创建后，所依赖的bean一定是已经创建完毕的，actualDependentBeans 
                // 不为空则表示所依赖的bean还没有创建完，即存在循环依赖
                if (!actualDependentBeans.isEmpty()) {
					throw new BeanCurrentlyInCreationException("");
				}
            }
        }
    }

    // 根据 score 注册 bean 
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }

    return exposedObject;
}

1.4.1 创建 bean 实例

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
    // 获取 bean 对应的 class 
	Class<?> beanClass = resolveBeanClass(mbd, beanName);
    // 如果工厂方法不为空，则使用工厂方法创建
	if (mbd.getFactoryMethodName() != null)  {
		return instantiateUsingFactoryMethod(beanName, mbd, args);
	}
	boolean resolved = false;
	boolean autowireNecessary = false;
	if (args == null) {
		synchronized (mbd.constructorArgumentLock) {
            // 一个类有多个构造方法，带有不同的参数，所以调用前，需要根据参数解析出需要调用的构造方法，
            // 这里使用了缓存，如果以前解析过构造方法，则在这里直接使用即可。
			if (mbd.resolvedConstructorOrFactoryMethod != null) {
				resolved = true;
				autowireNecessary = mbd.constructorArgumentsResolved;
			}
		}
	}
	if (resolved) {
		if (autowireNecessary) {
            // 构造方法自动注入
			return autowireConstructor(beanName, mbd, null, null);
		}
		else {
            // 默认构造方法自动注入
			return instantiateBean(beanName, mbd);
		}
	}
	// 解析构造方法
	Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
	if (ctors != null ||
			mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
			mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
        // 构造方法自动注入
		return autowireConstructor(beanName, mbd, ctors, args);
	}
    // 默认构造方法自动注入
	return instantiateBean(beanName, mbd);
}

1.4.1.1 工厂方法创建

// 获取 bean 对应的 class 
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// 如果工厂方法不为空，则使用工厂方法创建
if (mbd.getFactoryMethodName() != null)  {
    return instantiateUsingFactoryMethod(beanName, mbd, args);
}

1.4.1.2 带参数的构造方法创建

public BeanWrapper autowireConstructor(final String beanName, final RootBeanDefinition mbd,
											Constructor<?>[] chosenCtors, final Object[] explicitArgs) {

	BeanWrapperImpl bw = new BeanWrapperImpl();
	this.beanFactory.initBeanWrapper(bw);

	Constructor<?> constructorToUse = null;
	ArgumentsHolder argsHolderToUse = null;
	Object[] argsToUse = null;
    // explicitArgs 参数通过 getBean() 方法传入，Object getBean(String name, Object... args)
	if (explicitArgs != null) {
        // 如果 getBean 方法传入了参数，则直接使用
		argsToUse = explicitArgs;
	}
	else {
        // 如果 getBean 方法没有传入参数，则从配置文件进行解析
		Object[] argsToResolve = null;
        // 从缓存中获取
		synchronized (mbd.constructorArgumentLock) {
			constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
			if (constructorToUse != null && mbd.constructorArgumentsResolved) {
				argsToUse = mbd.resolvedConstructorArguments;
				if (argsToUse == null) {
					argsToResolve = mbd.preparedConstructorArguments;
				}
			}
		}
		if (argsToResolve != null) {
            // 配置的构造方法参数
			argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
		}
	}
    // 该构造没有被缓存，则需要进行解析
	if (constructorToUse == null) {
		boolean autowiring = (chosenCtors != null || mbd.getResolvedAutowireMode() == 
                              							RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
		ConstructorArgumentValues resolvedValues = null;
        // 参数个数
		int minNrOfArgs;
		if (explicitArgs != null) {
			minNrOfArgs = explicitArgs.length;
		}
		else {
            // 获取配置文件中配置的构造方法参数
			ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
			resolvedValues = new ConstructorArgumentValues();
            // 获取参数个数
		    minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
		}
		Constructor<?>[] candidates = chosenCtors;
		if (candidates == null) {
			Class<?> beanClass = mbd.getBeanClass();
			candidates = (mbd.isNonPublicAccessAllowed() ? beanClass.getDeclaredConstructors() : 
                          	beanClass.getConstructors());
		}
        // 排序构造方法，按照参数个数进行排序
		AutowireUtils.sortConstructors(candidates);
		int minTypeDiffWeight = Integer.MAX_VALUE;
		Set<Constructor<?>> ambiguousConstructors = null;
		for (Constructor<?> candidate : candidates) {
			Class<?>[] paramTypes = candidate.getParameterTypes();
			if (constructorToUse != null && argsToUse.length > paramTypes.length) {
				// 如果已经找到满足条件的构造方法，则终止
				break;
			}
			if (paramTypes.length < minNrOfArgs) {
				continue;
			}
			ArgumentsHolder argsHolder;
			if (resolvedValues != null) {
                // 构造方法参数的名字
				String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, paramTypes.length);
			    if (paramNames == null) {
                    // 如果参数名字为空，则获取参数名称探索器
					ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
					if (pnd != null) {
                        // 使用探索器获取对应构造方法的参数名称
					   paramNames = pnd.getParameterNames(candidate);
					}
                    // 根据参数名称和类型创建参数持有者
				argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, 
                                         paramNames,getUserDeclaredConstructor(candidate), autowiring);
			}
			else {
				// 构造方法没有参数
				argsHolder = new ArgumentsHolder(explicitArgs);
			}
            // 检查是否有不确定性构造方法的存在，如参数为父子关系
			int typeDiffWeight = (mbd.isLenientConstructorResolution() 
                                  	? argsHolder.getTypeDifferenceWeight(paramTypes) 
                                  	: argsHolder.getAssignabilityWeight(paramTypes));
			if (typeDiffWeight < minTypeDiffWeight) {
				constructorToUse = candidate;
				argsHolderToUse = argsHolder;
				argsToUse = argsHolder.arguments;
				minTypeDiffWeight = typeDiffWeight;
				ambiguousConstructors = null;
			}
			else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
				if (ambiguousConstructors == null) {
					ambiguousConstructors = new LinkedHashSet<Constructor<?>>();
					ambiguousConstructors.add(constructorToUse);
				}
				ambiguousConstructors.add(candidate);
			}
		}

		if (constructorToUse == null) {
			throw new BeanCreationException("...")
		}
        // 将解析的构造方法加入缓存
		if (explicitArgs == null) {
			argsHolderToUse.storeCache(mbd, constructorToUse);
		}
	}
    // 实例化
	Object beanInstance;
	if (System.getSecurityManager() != null) {
		final Constructor<?> ctorToUse = constructorToUse;
		final Object[] argumentsToUse = argsToUse;
		beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
			public Object run() {
				return beanFactory.getInstantiationStrategy().instantiate(
						mbd, beanName, beanFactory, ctorToUse, argumentsToUse);
			}
		}, beanFactory.getAccessControlContext());
	}
	else {
		beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(
				mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
	}
	bw.setBeanInstance(beanInstance);
	return bw;
}

1.4.1.3 默认的构造方法创建

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
    try {
        Object beanInstance;
        final BeanFactory parent = this;
        if (System.getSecurityManager() != null) {
            beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
           						getInstantiationStrategy().instantiate(mbd, beanName, parent), 		
                                                      		getAccessControlContext());
        }
        else {
            beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
        }
        BeanWrapper bw = new BeanWrapperImpl(beanInstance);
        initBeanWrapper(bw);
        return bw;
    }
}

public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner,
		final Constructor<?> ctor, Object... args) {
    // 如果没有需要动态改变的方法，则直接使用反射进行实例化
	if (bd.getMethodOverrides().isEmpty()) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged(new PrivilegedAction<Object>() {
				@Override
				public Object run() {
					ReflectionUtils.makeAccessible(ctor);
					return null;
				}
			});
		}
        // 使用反射实例化
		return BeanUtils.instantiateClass(ctor, args);
	}
	else {
        // 如果需要覆盖或者动态替换的方法，则需要使用 CGLIB 来动态代理，在创建代理的时候，可以增强植入我们的代码
		return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);
	}
}

1.4.2 添加单例对象的工厂缓存

// 解决循环依赖的关键步骤
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                                  isSingletonCurrentlyInCreation(beanName));
// 如果需要提前暴露单例Bean，则将该Bean放入三级缓存中
if (earlySingletonExposure) {
    // 将刚创建的bean放入三级缓存中singletonFactories(key是beanName，value是FactoryBean)
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        // 如果一级缓存中没有改实例，则放入三级缓存中
        if (!this.singletonObjects.containsKey(beanName)) {
            // 放入三级缓存
            this.singletonFactories.put(beanName, singletonFactory);
            // 从二级缓存中移除
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

1.4.3 填充对象的各种属性

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
    if (bw == null) {
        if (mbd.hasPropertyValues()) {
            throw new BeanCreationException();
        }
        else {
            // Skip property population phase for null instance.
            return;
        }
    }
    
    // 给InstantiationAwareBeanPostProcessors 最后一次机会在属性注入前修改Bean的属性值
	boolean continueWithPropertyPopulation = true;
	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                // 具体通过调用postProcessAfterInstantiation方法，如果调用返回false,表示不必继续进行依赖注入，直接返回
				if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
					continueWithPropertyPopulation = false;
					break;
				}
			}
		}
	}
	if (!continueWithPropertyPopulation) {
		return;
	}
    // 获取bean标签的子标签property对应的属性信息集合，也就是待依赖注入的属性集合
	PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

    // 根据Bean配置的依赖注入方式完成注入，默认是0，即不走以下逻辑，所有的依赖注入都需要在xml文件中有显式的配置
    // 如果设置了相关的依赖装配方式，会遍历Bean中的属性，根据类型或名称来完成相应注入，无需额外配置
	if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
			mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
		MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
        // 名称注入
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
			autowireByName(beanName, mbd, bw, newPvs);
		}
        // 类型注入
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
			autowireByType(beanName, mbd, bw, newPvs);
		}
		pvs = newPvs;
	}
    // 容器是否注册了InstantiationAwareBeanPostProcessor后置处理器
	boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    // 需要依赖检查
	boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
	if (hasInstAwareBpps || needsDepCheck) {
		PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, 	
                                                                                 mbd.allowCaching);
		if (hasInstAwareBpps) {
		   for (BeanPostProcessor bp : getBeanPostProcessors()) {
			  if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                	// 对所有需要依赖检查的属性进行后置处理
					pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), 
                                                        	beanName);
					if (pvs == null) {
						return;
					}	
				}
			}
		}
		if (needsDepCheck) {
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}
	}
    // 将属性应用到 bean 中
	applyPropertyValues(beanName, mbd, bw, pvs);
}

1.4.3.1 名称注入

protected void autowireByName(
      String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
   // 获取非简单类型的属性名称数组
   // 根据bw的PropertyDescriptors，遍历出所有可写的（即set方法存在)，存在于BeanDefinition里的PropertyValues，
   // 且不是简单属性的属性名，简单属性的判定参照下面方法，主要涵盖基本类型及其包装类，Number, Date等
   String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
   for (String propertyName : propertyNames) {
      if (containsBean(propertyName)) {
         // 根据名称获取对应的Bean实例
         Object bean = getBean(propertyName);
         // 设置非简单类型属性
         pvs.add(propertyName, bean);
         registerDependentBean(propertyName, beanName);
      }
   }
}

// 简单类型判定
public static boolean isSimpleValueType(Class<?> clazz) {
	return ClassUtils.isPrimitiveOrWrapper(clazz) || clazz.isEnum() ||
			CharSequence.class.isAssignableFrom(clazz) ||
			Number.class.isAssignableFrom(clazz) ||
			Date.class.isAssignableFrom(clazz) ||
			clazz.equals(URI.class) || clazz.equals(URL.class) ||
			clazz.equals(Locale.class) || clazz.equals(Class.class);
}

1.4.3.2 类型注入

protected void autowireByType(
			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

    TypeConverter converter = getCustomTypeConverter();
    if (converter == null) {
        converter = bw;
    }

    Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
    String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
    for (String propertyName : propertyNames) {
        try {
            PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
            // Don't try autowiring by type for type Object: never makes sense,
            // even if it technically is a unsatisfied, non-simple property.
            if (Object.class != pd.getPropertyType()) {
                MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
                // Do not allow eager init for type matching in case of a prioritized post-processor.
                boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
                DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
                // 这里会根据传入desc里的入参类型，作为依赖装配的类型
				// 再根据这个类型在BeanFacoty中查找所有类或其父类相同的BeanName
				// 最后根据BeanName获取或初始化相应的类，然后将所有满足条件的BeanName填充到autowiredBeanNames中
                Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, 		
                                                             converter);
                if (autowiredArgument != null) {
                    pvs.add(propertyName, autowiredArgument);
                }
                for (String autowiredBeanName : autowiredBeanNames) {
                    registerDependentBean(autowiredBeanName, beanName);
                }
                autowiredBeanNames.clear();
            }
        }
    }
}

1.4.4 处理 init-method 方法

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
    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方法
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
        // 执行初始化方法（先调用InitializingBean的afterPropertiesSet，再调用init-method属性指定的初始化方法）
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    if (mbd == null || !mbd.isSynthetic()) {
        // 应用BeanPostProcessor的postProcessAfterInitialization方法(AOP代理对象生成)
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}

1.4.4.1 处理 bean 的前置处理器

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException {
	// 获取容器中所有的 BeanPostProcessor，执行其 postProcessBeforeInitialization 方法
    // （@PostConstruct注解指定的初始化方法，就是在这一步由 CommonAnnotationBeanPostProcessor 实现）
    // 实现ApplicationContextAware接口的bean将会调用ApplicationContextAwareProcessor的	
    // postProcessBeforeInitialization方法，最终实现接口的setApplicationContext赋值调用（然后在系统中就可以通过赋值的	// applicationContext对象getBean方法动态获取需要的bean对象了）
    Object result = existingBean;
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        Object current = beanProcessor.postProcessBeforeInitialization(result, beanName);
        if (current == null) {
            return result;
        }
        result = current;
    }
    return result;
}

1.4.4.2 执行 init-method 方法

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
			throws Throwable {
    boolean isInitializingBean = (bean instanceof InitializingBean);
    // 如果是InitializingBean接口的实现类，则先初始化InitializingBean的实现类
    if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
        if (System.getSecurityManager() != null) {
            try {
                AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                    ((InitializingBean) bean).afterPropertiesSet();
                    return null;
                }, getAccessControlContext());
            }
        }
        else {
            // 调用InitializingBean接口的afterPropertiesSet方法
            ((InitializingBean) bean).afterPropertiesSet();
        }
    }

    // 然后再初始化<bean>标签对应的init-method属性中的方法
    if (mbd != null && bean.getClass() != NullBean.class) {
        String initMethodName = mbd.getInitMethodName();
        if (StringUtils.hasLength(initMethodName) &&
            !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
            !mbd.isExternallyManagedInitMethod(initMethodName)) {
            // 调用自定义的初始化方法
            invokeCustomInitMethod(beanName, bean, mbd);
        }
    }
}

1.4.4.3 处理 bean 的后置处理器

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {
	// 配置了事物或者AOP的实例在这里将会调用AbstractAutoProxyCreator类的postProcessAfterInitialization方法，
    // 最终完成代理对象的创建和缓存等（然后在系统中当需要访问此实例时则会获取到这个代理对象，通过代理对象来访问对象的实例函数）
    Object result = existingBean;
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
        if (current == null) {
            return result;
        }
        result = current;
    }
    return result;
}

1.5 Bean生命周期说明

1. 实例化 Instantiation
2. 属性赋值 Populate
3. 初始化 Initialization
4. 销毁 Destruction

实例化 -> 属性赋值 -> 初始化 -> 销毁

2、Spring AOP 原理分析

2.1 程序入口分析

// 首先回到上一篇解析BeanDefinition流程
// BeanDefinitionParserDelegate#parseCustomElement方法，找到具体的标签, 如<aop:config> <aop:autoproxy>等，获取到
// 对应的NameSpaceHandler: AopNameSpaceHandler
public class AopNamespaceHandler extends NamespaceHandlerSupport {
    // 此方法会在DefaultNamespaceHandlerResolver类的resolve方法中被调用
    @Override
    public void init() {
        // <aop:config></aop:config>对应的BeanDefinitionParser
        registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
        registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
        registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());

        // Only in 2.0 XSD: moved to context namespace as of 2.1
        registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    }
}
// 找到AspectJAutoProxyBeanDefinitionParser#parse
public BeanDefinition parse(Element element, ParserContext parserContext) {
    AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
    extendBeanDefinition(element, parserContext);
    return null;
}

// 进入到registerAspectJAnnonationAutoProxyCreatorIfNecessary方法
public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(
			ParserContext parserContext, Element sourceElement) {
    // 注册AutoProxyCreator，定义的name为internalAutoProxyCreator的beanDefinition
    BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
        parserContext.getRegistry(), parserContext.extractSource(sourceElement));
    // 对于 proxy-target-class（强制使用cglib） 以及 expose-proxy（是否需要暴露代理接口） 属性的处理
    useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
    // 注册组件并通知，便于监听器作进一步处理    
	// 其中 beanDefinition 的 className 为 AnnotationAwareAspectJAutoProxyCreator
    registerComponentIfNecessary(beanDefinition, parserContext);
}

// 对于AOP的实现上，基本上都是靠AnnotationAwareAspectJAutoProxyCreator去完成的，它可以根据@Point注解定义的切点来自动代理
// 相匹配的bean。但是为了配置简便，Spring 使用了自定义配置来帮我们自动注册 AnnotationAwareAspectJAutoProxyCreator。

// 继承关系：
// AnnotationAwareAspectJAutoProxyCreator继承类AbstractAutoProxyCreator，而AbstractAutoProxyCreator实现了
// BeanPostProcessor接口

public interface BeanPostProcessor {
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}

入口分析：
// 入口1：对象实例化之前：AbstractAutoProxyCreator.postProcessBeforeInstantiation
try {
    // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
    // 给BeanPostProcessors一个创建代理对象的机会，如果代理对象返回不为空则createBean就直接返回了，
    // 后面的目标对象就不再实例化了。
    Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    if (bean != null) {
        return bean;
    }
}
// resolveBeforeInstantiation 本质调用的是此处本质调用的
// AbstractAutoProxyCreator.applyBeanPostProcessorsBeforeInstantiation
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
    Object cacheKey = getCacheKey(beanClass, beanName);
    if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
        if (this.advisedBeans.containsKey(cacheKey)) {
            return null;
        }
        // 1. 有些对象是不可以被代理的，基类：Advices, Advisors and AopInfrastructureBeans; 
        // 带有aop注解类: @Aspect
        // 2. 子类可以复写该类,如果一些情况不需要被代理, shouldSkip返回true
        if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return null;
        }
    }

    // 获取targetSource, 如果存在则直接在对象初始化之前进行创建代理, 避免了目标对象不必要的实例化
    TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
    // 如果有自定义targetSource就要这里创建代理对象
    // 这样做的好处是被代理的对象可以动态改变，而不是只针对一个target对象
    // (可以对对象池中对象进行代理，可以每次创建代理都创建新对象)
    if (targetSource != null) {
        if (StringUtils.hasLength(beanName)) {
            this.targetSourcedBeans.add(beanName);
        }
        // 获取Advisors, 这个是交给子类实现的
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
        Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
        this.proxyTypes.put(cacheKey, proxy.getClass());
        // 返回代理的对象
        return proxy;
    }

    return null;
}

// 入口2： 对象实例化完成，初始化完成后，在AOP中，AbstractAutoProxyCreator实现了该接口，且实现了接口中的方法：
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    if (bean != null) {
        Object cacheKey = getCacheKey(bean.getClass(), beanName); 
        // 根据给定的bean和className构建cacheKey，形式为beanClassName_beanName
        if (!this.earlyProxyReferences.contains(cacheKey)) {
            // 判断是否需要代理
            return wrapIfNecessary(bean, beanName, cacheKey); 
        }
    }
    return bean;
}

// 由此可见，先完成加载XML的aop相关的BeanDefinition定义并注册到容器中，然后产生两种情况
// 1. 如果有自定义的TargetSource, 则在创建Bean实例对象之前进行代理创建，不再执行后续实例化流程
// 2. 如果没有自定义的TargetSource, 则创建了个默认的TargetSource（SingletonTargetSource）
// 也就是说在完成Bean实例已创建并且完成初始化之后，开始调用后置处理器方法，进行代理实例的创建流程。

2.2 代理创建入口

// 入口1: 对象实例化之前进行代理创建
protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
			@Nullable Object[] specificInterceptors, TargetSource targetSource) {

    if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
        AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory,
                                         beanName, beanClass);
    }

    // 创建代理工厂对象
    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.copyFrom(this);

    // 如果没有使用CGLib代理
    if (!proxyFactory.isProxyTargetClass()) {
        // 是否可能使用CGLib代理
        if (shouldProxyTargetClass(beanClass, beanName)) {
            proxyFactory.setProxyTargetClass(true);
        }
        else {
            // 查看beanClass对应的类是否含有InitializingBean.class/DisposableBean.class/Aware.class接口
            // 无则采用JDK动态代理，有则采用CGLib动态代理
            evaluateProxyInterfaces(beanClass, proxyFactory);
        }
    }
    // 获得所有关联的Advisor集合(该分支待补充)
    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    proxyFactory.addAdvisors(advisors);
    // 此处的targetSource一般为SingletonTargetSource
    proxyFactory.setTargetSource(targetSource);
    // 空的实现
    customizeProxyFactory(proxyFactory);
    proxyFactory.setFrozen(this.freezeProxy);
    // 是否设置预过滤模式，此处针对本文为true
    if (advisorsPreFiltered()) {
        proxyFactory.setPreFiltered(true);
    }
    // 获取使用JDK动态代理或者cglib动态代理产生的对象
    return proxyFactory.getProxy(getProxyClassLoader());
}

// 入口2: 对象实例化后，初始化完成后创建
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    }
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    }
    // Advice/Pointcut/Advisor/AopInfrastructureBean接口的beanClass不进行代理
    // 以及对beanName为aop内的切面名也不进行代理
    // 此处可查看子类复写的shouldSkip()方法
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

    // Create proxy if we have advice.
    // 查找对代理类相关的advisor对象集合，此处就与ponit-cut表达式有关了
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);

    // 对相应的advisor不为空才采取代理
    if (specificInterceptors != DO_NOT_PROXY) {
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        // 通过jdk动态代理或者cglib动态代理，产生代理对象
        Object proxy = createProxy(
            bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        // 放入代理类型缓存
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }
    // 放入通知缓存
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}

// 由此可见，最终第二个方法也会进入protected Object createProxy(...)方法，两者都完成了代理的创建流程

2.3 代理类型解读

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
        Class<?> targetClass = config.getTargetClass();
        if (targetClass == null) {
            throw new AopConfigException("TargetSource cannot determine target class: " +
                                         "Either an interface or a target is required for proxy creation.");
        }
        // 如果目标类是接口或者目标类是Proxy的子类，则使用JDK动态代理方式
        if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
            return new JdkDynamicAopProxy(config);
        }
        // 使用Cglib动态代理
        return new ObjenesisCglibAopProxy(config);
    }
    else {
        // 默认使用JDK动态代理
        return new JdkDynamicAopProxy(config);
    }
}

// JdkDynamicAopProxy
public Object getProxy(@Nullable ClassLoader classLoader) {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
    }
    Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
    findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

// CglibAopProxy
public Object getProxy(@Nullable ClassLoader classLoader) {
    try {
        Class<?> rootClass = this.advised.getTargetClass();
        // 省略部分代码....
        // Configure CGLIB Enhancer...
        Enhancer enhancer = createEnhancer();
        if (classLoader != null) {
            enhancer.setClassLoader(classLoader);
            if (classLoader instanceof SmartClassLoader &&
                ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
                enhancer.setUseCache(false);
            }
        }
        enhancer.setSuperclass(proxySuperClass);
        enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
        enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
        enhancer.setStrategy(new ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));

        Callback[] callbacks = getCallbacks(rootClass);
        Class<?>[] types = new Class<?>[callbacks.length];
        for (int x = 0; x < types.length; x++) {
            types[x] = callbacks[x].getClass();
        }
        // fixedInterceptorMap only populated at this point, after getCallbacks call above
        enhancer.setCallbackFilter(new ProxyCallbackFilter(
            this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, 
            this.fixedInterceptorOffset));
        enhancer.setCallbackTypes(types);

        // Generate the proxy class and create a proxy instance.
        return createProxyClassAndInstance(enhancer, callbacks);
    }
}

protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
    enhancer.setInterceptDuringConstruction(false);
    enhancer.setCallbacks(callbacks);
    return (this.constructorArgs != null && this.constructorArgTypes != null ?
            enhancer.create(this.constructorArgTypes, this.constructorArgs) :
            enhancer.create());
}


// 总结：
// 1、proxy-target-class没有配置或者proxy-target-class=“false”，返回JdkDynamicAopProxy
// 2、proxy-target-class="true"或者对象没有实现任何接口或者只实现了SpringProxy接口，返回CglibAopProxy

2.4 jdk动态代理调用实现

// 最后生成了代理对象，生成代理之后就要调用方法了，由于JdkDynamicAopProxy本身实现了InvocationHandler接口，因此具体代理前后
// 处理的逻辑在JdkDynamicAopProxy类的invoke方法中
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    MethodInvocation invocation;
    Object oldProxy = null;
    boolean setProxyContext = false;

    TargetSource targetSource = this.advised.targetSource;
    Object target = null;

    try {
        // 判断如果被代理的目标对象要执行的方法是equal则执行JdkDynamicAopProxy（即代理对象的equal）方法，
        // 然后就返回了，也就说spring不对equal方法进行AOP拦截
        if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
            // The target does not implement the equals(Object) method itself.
            return equals(args[0]);
        }
        // 如果被代理的目标对象要执行的方法是hashcode则执行JdkDynamicAopProxy（即代理对象的hashcode）方法，
        // 随即也返回，同理，spring也不对hashcode进行AOP拦截
        else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
            // The target does not implement the hashCode() method itself.
            return hashCode();
        }
        else if (method.getDeclaringClass() == DecoratingProxy.class) {
            // There is only getDecoratedClass() declared -> dispatch to proxy config.
            return AopProxyUtils.ultimateTargetClass(this.advised);
        }
        // 如果被代理的目标对象实现了Advised接口，直接用反射执行目标对象的方法。不做增强处理。
        else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                 method.getDeclaringClass().isAssignableFrom(Advised.class)) {
            // Service invocations on ProxyConfig with the proxy config...
            return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
        }

        Object retVal;

        // 需要提前暴露
        if (this.advised.exposeProxy) {
            oldProxy = AopContext.setCurrentProxy(proxy);
            setProxyContext = true;
        }

        // 得到目标对象
        target = targetSource.getTarget();
        Class<?> targetClass = (target != null ? target.getClass() : null);
		
        // 得到该方法的拦截链
        // 从方法拦截链缓存methodCache中看有不有该方法的拦截链，有就直接返回，没有则调用		
        // this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(this, method, targetClass)
        // 得到方法拦截链，放入缓存中，并且返回，以下为此方法执行逻辑
        // 1.遍历Advisor
		// 2.如果是Advisor是PointcutAdvisor类型：得到该Advisor的Pointcut，判断要执行的目标对象的方法是否被这个Advisor增		// 强。如果运行时需要做一些检测，则往返回列表中加入InterceptorAndDynamicMethodMatcher封装后的拦截器。否则直接加入
        // 拦截器到返回列表
		// 3.如果Advisor是IntroducationAdvisor类型的，用该Advisor的classFilter判断目标对象的类是否被这个Advisor增强，
        // 是则得到拦截器，加入到返回列表
        // 4.如果 Advisor既不是PointcutAdvisor类型也不是IntroducationAdvisor类型，则不用匹配，直接生成拦截器，加入到返
        // 回列表
        List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

        // 检查是否我们有一些通知。如果我们没有，我们可以直接对目标类进行反射调用，避免创建MethodInvocation类
        // 调用目标类的方法
        if (chain.isEmpty()) {
            Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
            // 通过反射调用目标对象的方法
            retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
        }
        else {
            // 我们需要创建一个方法调用
            invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
            // 通过拦截器链进入连接点
            retVal = invocation.proceed();
        }

        // 处理方法返回值
        Class<?> returnType = method.getReturnType();
        if (retVal != null && retVal == target &&
            returnType != Object.class && returnType.isInstance(proxy) &&
            !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
            retVal = proxy;
        }
        else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
            throw new AopInvocationException(
                "Null return value from advice does not match primitive return type for: " + method);
        }
        return retVal;
    }
}