Spring读源码系列之AOP--03---aop底层基础类学习

Spring读源码系列之AOP--03---aop底层基础类学习

• 引子
• Spring AOP常用类解释
• • AopInfrastructureBean---免被AOP代理的标记接口
  • ProxyConfig---AOP配置类
  • • ProxyProcessorSupport---代理创建器的通用实现
  • TargetClassAware---提供获取被代理类的接口
  • • Advised---代理类配置信息封装
    • AdvisedSupport---Advised接口的实现类
  • AdvisorChainFactory--获取方法关联的拦截器链
  • • DefaultAdvisorChainFactory---唯一的默认实现
  • AdvisorAdapter---advisor到methodinterceptor的适配器
  • AdvisorAdapterRegistry---管理AdvisorAdapter
  • • DefaultAdvisorAdapterRegistry---默认实现
  • AdvisorAdapterRegistrationManager---注册自定义适配器
  • GlobalAdvisorAdapterRegistry ---发布一个全局共享的 DefaultAdvisorAdapterRegistry 实例
  • TargetClassAware---保留被代理对象类型
  • • TargetSource--封装目标对象
  • AspectMetadat----切面的元数据类
  • • Spring AOP切面实例化模型
  • AspectInstanceFactory---切面工厂
  • • MetadataAwareAspectInstanceFactory---提供获取AspectMetadata的方法
    • • BeanFactoryAspectInstanceFactory---IOC中获取切面
      • • PrototypeAspectInstanceFactory----多例专用的工厂
• org.aspectj包下的几个类
• • AjTypeSystem：从@Aspect的Class到AjType的工具类
  • AjType---封装切面元数据信息
  • • AjTypeImpl

---

引子

就像IOC底层的实现依靠的是BeanWrapper,Convert,PropertyEditor这些基础设施类一样，AOP的实现底层也依赖了这样一批基础类，下面我们来看看。

---

Spring AOP常用类解释

---

AopInfrastructureBean—免被AOP代理的标记接口

AopInfrastructureBean是一个标记接口。若Bean实现了此接口，表明它是一个Spring AOP的基础类，那么这个类是不会被AOP给代理的，即使它能被切面切进去~~~

public interface AopInfrastructureBean {

}

---

ProxyConfig—AOP配置类

用于创建代理的配置的父类，以确保所有代理创建者具有一致的属性。 它有五个属性，解释如下：

public class ProxyConfig implements Serializable {

	// 标记是否直接对目标类进行代理，而不是通过接口产生代理
	private boolean proxyTargetClass = false;
	// 标记是否对代理进行优化。true：那么在生成代理对象之后，如果对代理配置进行了修改，已经创建的代理对象也不会获取修改之后的代理配置。
	// 如果exposeProxy设置为true，即使optimize为true也会被忽略。
	private boolean optimize = false;
	// 标记是否需要阻止通过该配置创建的代理对象转换为Advised类型，默认值为false，表示代理对象可以被转换为Advised类型
	//Advised接口其实就代表了被代理的对象（此接口是Spring AOP提供，它提供了方法可以对代理进行操作，比如移除一个切面之类的），它持有了代理对象的一些属性，通过它可以对生成的代理对象的一些属性进行人为干预
	// 默认情况，我们可以这么完 Advised target = (Advised) context.getBean("opaqueTest"); 从而就可以对该代理持有的一些属性进行干预勒   若此值为true，就不能这么玩了
	boolean opaque = false;
	//标记代理对象是否应该被aop框架通过AopContext以ThreadLocal的形式暴露出去。
	//当一个代理对象需要调用它【自己】的另外一个代理方法时，这个属性将非常有用。默认是是false，以避免不必要的拦截。
	//实践场景:如何让被代理的方法在代理对象被代理的方法中被调用时，依旧能被拦截
	boolean exposeProxy = false;
	//标记是否需要冻结代理对象，即在代理对象生成之后，是否允许对其进行修改，默认为false.
	// 当我们不希望调用方修改转换成Advised对象之后的代理对象时，就可以设置为true 给冻结上即可
	private boolean frozen = false;
	...
}

---

ProxyProcessorSupport—代理创建器的通用实现

简单的说它就是提供为代理创建器提供了一些公共方法实现：

具有代理处理器通用功能的基类，特别是 ClassLoader 管理和 evaluateProxyInterfaces 算法。

@SuppressWarnings("serial")
public class ProxyProcessorSupport extends ProxyConfig implements Ordered, BeanClassLoaderAware, AopInfrastructureBean {

	
	private int order = Ordered.LOWEST_PRECEDENCE;
    
    //代理类的类加载器
	@Nullable
	private ClassLoader proxyClassLoader = ClassUtils.getDefaultClassLoader();
    
    //代理类的类加载器是否被手动配置了---即用户是否手动指定了类加载器
	private boolean classLoaderConfigured = false;


	
	public void setOrder(int order) {
		this.order = order;
	}

	@Override
	public int getOrder() {
		return this.order;
	}

	
	public void setProxyClassLoader(@Nullable ClassLoader classLoader) {
		this.proxyClassLoader = classLoader;
		//如果不为空，说明手动设置生效,打个标记
		this.classLoaderConfigured = (classLoader != null);
	}
	
	@Nullable
	protected ClassLoader getProxyClassLoader() {
		return this.proxyClassLoader;
	}
//因为继承了BeanClassLoaderAware,因此默认的代理类加载器就是beanFactory用来加载所有bean的beanClassLoader
	@Override
	public void setBeanClassLoader(ClassLoader classLoader) {
	//手动配置的优先级更高，无法覆盖
		if (!this.classLoaderConfigured) {
			this.proxyClassLoader = classLoader;
		}
	}


	
	protected void evaluateProxyInterfaces(Class beanClass, ProxyFactory proxyFactory) {
	//拿到目标类上的所有接口
		Class[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, getProxyClassLoader());
		//是否存在合理的接口---可以决定是否采用jdk动态代理，如果为false则走cglib动态代理
		boolean hasReasonableProxyInterface = false;
		for (Class ifc : targetInterfaces) {
			if (
              //pass内部的回调接口
              !isConfigurationCallbackInterface(ifc) && 
               //pass内部语言接口
               !isInternalLanguageInterface(ifc) &&
					//当前接口内是否存在方法
					ifc.getMethods().length > 0) {
				hasReasonableProxyInterface = true;
				break;
			}
		}
		//如果存在合理的接口
		if (hasReasonableProxyInterface) {
			// Must allow for introductions; can't just set interfaces to the target's interfaces only.
			// 这里Spring的Doc特别强调了：不能值只把合理的接口设置进去，而是都得加入进去
			for (Class ifc : targetInterfaces) {
				proxyFactory.addInterface(ifc);
			}
		}
		else {
		// 这个很明显设置true，表示使用CGLIB得方式去创建代理了~~~~
		//proxyFactory继承了proxyConfig,这里调用的是proxyConfig的setProxyTargetClass方法
			proxyFactory.setProxyTargetClass(true);
		}
	}

	
	protected boolean isConfigurationCallbackInterface(Class ifc) {
		return (InitializingBean.class == ifc || DisposableBean.class == ifc || Closeable.class == ifc ||
				AutoCloseable.class == ifc || ObjectUtils.containsElement(ifc.getInterfaces(), Aware.class));
	}

	
	protected boolean isInternalLanguageInterface(Class ifc) {
		return (ifc.getName().equals("groovy.lang.GroovyObject") ||
				ifc.getName().endsWith(".cglib.proxy.Factory") ||
				ifc.getName().endsWith(".bytebuddy.MockAccess"));
	}

}

---

TargetClassAware—提供获取被代理类的接口

public interface TargetClassAware {

	@Nullable
	Class getTargetClass();

}

---

Advised—代理类配置信息封装

Spring官方英文注释:

• Interface to be implemented by classes that hold the configuration of a factory of AOP proxies. This configuration includes the Interceptors and other advice, Advisors, and the proxied interfaces.
• Any AOP proxy obtained from Spring can be cast to this interface to allow manipulation of its AOP advice.

简单解释:

该接口用于保存一个代理的相关配置。比如保存了这个代理相关的拦截器、通知、增强器等等。

所有的代理对象都实现了该接口（我们就能够通过一个代理对象获取这个代理对象怎么被代理出来的相关信息）

不管是JDKproxy，还是cglib proxy，代理出来的对象都实现了org.springframework.aop.framework.Advised接口；

---

public interface Advised extends TargetClassAware {

	
	boolean isFrozen();

	
	boolean isProxyTargetClass();

	
	Class[] getProxiedInterfaces();

	
	boolean isInterfaceProxied(Class intf);

	
	void setTargetSource(TargetSource targetSource);

	
	TargetSource getTargetSource();

	
	void setExposeProxy(boolean exposeProxy);

	
	boolean isExposeProxy();

	
	void setPreFiltered(boolean preFiltered);

	
	boolean isPreFiltered();


//操作当前代理对象advisors的相关方法
	Advisor[] getAdvisors();
	default int getAdvisorCount() {
		return getAdvisors().length;
	}
	void addAdvisor(Advisor advisor) throws AopConfigException;
	void addAdvisor(int pos, Advisor advisor) throws AopConfigException;
	boolean removeAdvisor(Advisor advisor);
	void removeAdvisor(int index) throws AopConfigException;
	int indexOf(Advisor advisor);
	boolean replaceAdvisor(Advisor a, Advisor b) throws AopConfigException;

//操作当前代理对象advice的相关方法
	void addAdvice(Advice advice) throws AopConfigException;
	void addAdvice(int pos, Advice advice) throws AopConfigException;
	boolean removeAdvice(Advice advice);
	int indexOf(Advice advice);



	String toProxyConfigString();
}

---

AdvisedSupport—Advised接口的实现类

它最重要的一个方法是：提供getInterceptorsAndDynamicInterceptionAdvice方法用来获取对应代理方法对应有效的拦截器链

AdvisedSupport本身不会提供创建代理的任何方法，专注于生成拦截器链。委托给ProxyCreatorSupport去创建代理对象

public class AdvisedSupport extends ProxyConfig implements Advised {
	private static final long serialVersionUID = 2651364800145442165L;

	
	public static final TargetSource EMPTY_TARGET_SOURCE = EmptyTargetSource.INSTANCE;


	
	TargetSource targetSource = EMPTY_TARGET_SOURCE;

	
	private boolean preFiltered = false;

	
	AdvisorChainFactory advisorChainFactory = new DefaultAdvisorChainFactory();

	
	private transient Map> methodCache;

	
	private List> interfaces = new ArrayList<>();

	
	private List advisors = new ArrayList<>();



	
	public List