axios在线源码

spring源码——aop源码解析

aop的实现原理：

aop的实现本质上就是通过在初始化bean对象的的时候，通过后置处理器对其进行一个动态代理，返回一个代理过后的wrappedBean。
具体过程：判断循环所有的BeanPostProcessor，然后我们aop什么时候被加进来的后置处理器？ @EnableAspectJAutoProxy中的@Import(AspectJAutoProxyRegistrar.class)AspectJAutoProxyRegistrar这个类实现了ImportBeanDefinitionRegistrar，这个类中加入了一个bean后置处理器AnnotationAwareAspectJAutoProxyCreator，这个后置处理器对我们的实体类进行一个代理一个aop的增强。

如果使用aop的话 会有一个类AbstractAutoProxyCreator继承SmartInstantiationAwareBeanPostProcessor后置处理器，其中getEarlyBeanReference()方法会 为了解决单例bean之间的循环依赖问题，提前将aop代理对象暴露出去。（initializeBean中执行后置处理器时再执行aop代理时，会直接从这里生产的缓存中获取，不需要再生成代理类了）

AbstractAutowireCapableBeanFactory：

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		//JDK的安全机制验证权限
		if (System.getSecurityManager() != null) {
			//实现PrivilegedAction接口的匿名内部类
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			//为Bean实例对象包装相关属性，如名称，类加载器，所属容器等信息
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		//对BeanPostProcessor后置处理器的postProcessBeforeInitialization
		//回调方法的调用，为Bean实例初始化前做一些处理
		if (mbd == null || !mbd.isSynthetic()) {
			//@@@第七次后置处理器 网上常说的后置处理器最原始的接口BeanPostProcessor中postProcessBeforeInitialization方法 在bean实例化后初始化前执行
			//@@@执行后置处理的before---PostConstruct
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		//调用Bean实例对象初始化的方法，这个初始化方法是在Spring Bean定义配置
		//文件中通过init-method属性指定的
		try {
			//@@@执行initializeBean 初始化（实现接口 InitializingBean重写方法 afterPropertiesSet() 和解析xml init-method）
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
		//对BeanPostProcessor后置处理器的postProcessAfterInitialization
		//回调方法的调用，为Bean实例初始化之后做一些处理
		if (mbd == null || !mbd.isSynthetic()) {
			//@@@第八次后置处理器 网上常说的后置处理器最原始的接口BeanPostProcessor中postProcessAfterInitialization方法 在bean初始后前执行
			//aop在这个后置处理器中即这个AnnotationAwareAspectJAutoProxyCreator处理器 通过这个改变bean 变成一个代理对象
			/**
			 * wrappedBean返回出去，判断循环所有的BeanPostProcessor，
			 * 然后我们aop什么时候被加进来的后置处理器？
			 * @EnableAspectJAutoProxy中的@Import(AspectJAutoProxyRegistrar.class)，AspectJAutoProxyRegistrar这个类实现了ImportBeanDefinitionRegistrar，这个类中加入了一个bean后置处理器AnnotationAwareAspectJAutoProxyCreator，这个后置处理器对我们的实体类进行一个代理一个aop的增强
			 */
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

	@Override
	//调用BeanPostProcessor后置处理器实例对象初始化之后的处理方法
	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
		//遍历容器为所创建的Bean添加的所有BeanPostProcessor后置处理器
		for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
			//调用Bean实例所有的后置处理中的初始化后处理方法，为Bean实例对象在
			//初始化之后做一些自定义的处理操作
			Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}

AbstractAutoProxyCreator：

@Override
	public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
		if (bean != null) {
		// 检查下该类是否已经暴露过了（可能已经创建了，⽐如A依赖B时，创建A时候，就会先去创建B。
 		// 当真正需要创建B时，就没必要再代理⼀次已经代理过的对象）,避免重复创建
			Object cacheKey = getCacheKey(bean.getClass(), beanName);
			if (!this.earlyProxyReferences.contains(cacheKey)) {
				return wrapIfNecessary(bean, beanName, cacheKey);
			}
		}
		return bean;
	}

	protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
		// targetSourcedBeans包含，说明前⾯创建过
		if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
			return bean;
		}
		if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
			return bean;
		}
		if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
			this.advisedBeans.put(cacheKey, Boolean.FALSE);
			return bean;
		}

		// Create proxy if we have advice.
		// 得到所有候选Advisor，对Advisors和bean的⽅法双层遍历匹配，最终得到⼀个List<Advisor>，即specificInterceptors
		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
		if (specificInterceptors != DO_NOT_PROXY) {
			this.advisedBeans.put(cacheKey, Boolean.TRUE);
			// 重点，创建代理对象
			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;
	}
	
	/**
	 * Create an AOP proxy for the given bean.
	 * 为指定 bean 创建代理对象
	 */
	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 proxyFactory = new ProxyFactory();
		proxyFactory.copyFrom(this);
		// 根据⼀些情况判断是否要设置proxyTargetClass=true
		if (!proxyFactory.isProxyTargetClass()) {
			if (shouldProxyTargetClass(beanClass, beanName)) {
				proxyFactory.setProxyTargetClass(true);
			}
			else {
				evaluateProxyInterfaces(beanClass, proxyFactory);
			}
		}
		// 把指定和通⽤拦截对象合并, 并都适配成Advisor
		Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
		proxyFactory.addAdvisors(advisors);
		proxyFactory.setTargetSource(targetSource);
		customizeProxyFactory(proxyFactory);
		// 设置参数
		proxyFactory.setFrozen(this.freezeProxy);
		if (advisorsPreFiltered()) {
			proxyFactory.setPreFiltered(true);
		}
		// 上⾯准备做完就开始创建代理
		return proxyFactory.getProxy(getProxyClassLoader());
	}

ProxyFactory：

public Object getProxy(@Nullable ClassLoader classLoader) {
		// ⽤ProxyFactory创建AopProxy, 然后⽤AopProxy创建Proxy, 所以这⾥重要的是看获取的AopProxy
 		// 对象是什么,
 		// 然后进去看怎么创建动态代理, 提供了两种：jdk proxy, cglib
		return createAopProxy().getProxy(classLoader);
	}

ProxyCreatorSupport：

protected final synchronized AopProxy createAopProxy() {
		if (!this.active) {
			activate();
		}
		//先获取创建AopProxy的⼯⼚, 再由此创建AopProxy
		return getAopProxyFactory().createAopProxy(this);
	}

DefaultAopProxyFactory ：

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

	@Override
	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.");
			}
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(config);
			}
			return new ObjenesisCglibAopProxy(config);
		}
		else {
			return new JdkDynamicAopProxy(config);
		}
	}

	/**
	 * Determine whether the supplied {@link AdvisedSupport} has only the
	 * {@link org.springframework.aop.SpringProxy} interface specified
	 * (or no proxy interfaces specified at all).
	 */
	private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
		Class<?>[] ifcs = config.getProxiedInterfaces();
		return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));
	}

}