【源码】Spring AOP 8 TargetSource AdvisorAdapter AdvisorAdapterRegistry AdvisorChainFactory

前言

上一章节我们对 Advisor 做了解读，在进行 Advised 接口的解读前，还需要先了解几组类

TargetSource

public interface TargetSource extends TargetClassAware {

	// target class
	@Override
	@Nullable
	Class<?> getTargetClass();

	// 目标对象是否不可变
	boolean isStatic();

	@Nullable
	// 返回目标对象（包含 Joinpoint）
	Object getTarget() throws Exception;

	// 释放 getTarget 方法获取的 target object
	void releaseTarget(Object target) throws Exception;

}

TargetSource 是对代理目标对象的一层封装。如果 isStatic() 方法返回 true ，则每次调用 getTarget() 返回相同的对象

SingletonTargetSource

public class SingletonTargetSource implements TargetSource, Serializable {

	private final Object target;

	public SingletonTargetSource(Object target) {
		Assert.notNull(target, "Target object must not be null");
		this.target = target;
	}

	@Override
	public Class<?> getTargetClass() {
		return this.target.getClass();
	}

	@Override
	public Object getTarget() {
		return this.target;
	}

	@Override
	public void releaseTarget(Object target) {
	}

	@Override
	public boolean isStatic() {
		return true;
	}
	
	// 略

}

比较简单，初始化时即赋值单例，然后调用 getTarget() 时返回， isStatic() 为 true，Spring 创建代理时使用的就是此类类包装 target 对象，之后会讲到

AdvisorAdapter

// advice 和 MethodInterceptor 的适配器
public interface AdvisorAdapter {

	// 是否支持适配目标 advice
	boolean supportsAdvice(Advice advice);

	// 适配
	MethodInterceptor getInterceptor(Advisor advisor);

}

适配器设计模式 的应用，将 Advisor 适配成 MethodInterceptor

MethodBeforeAdviceAdapter

class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {
	
	// 支持适配 MethodBeforeAdvice
	@Override
	public boolean supportsAdvice(Advice advice) {
		return (advice instanceof MethodBeforeAdvice);
	}

	// advisor.getAdvice -> MethodInterceptor
	@Override
	public MethodInterceptor getInterceptor(Advisor advisor) {
		MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
		return new MethodBeforeAdviceInterceptor(advice);
	}
}

针对 MethodBeforeAdvice 的适配器，其余几个子类大同小异

AdvisorAdapterRegistry

public interface AdvisorAdapterRegistry {

	// advice -> advisor
	Advisor wrap(Object advice) throws UnknownAdviceTypeException;

	// 从给定的 advisor 上解析 MethodInterceptors
	MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException;

	// 注册适配器（实现类已经帮我们注册好了）
	void registerAdvisorAdapter(AdvisorAdapter adapter);

}

适配器注册接口，用于帮我们注册对应的 适配器

DefaultAdvisorAdapterRegistry

public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable {

	private final List<AdvisorAdapter> adapters = new ArrayList<>(3);

	// 实现类帮我们注册三个适配器
	public DefaultAdvisorAdapterRegistry() {
		registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
		registerAdvisorAdapter(new AfterReturningAdviceAdapter());
		registerAdvisorAdapter(new ThrowsAdviceAdapter());
	}

	@Override
	public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {
		if (adviceObject instanceof Advisor) {
			return (Advisor) adviceObject;
		}
		if (!(adviceObject instanceof Advice)) {
			throw new UnknownAdviceTypeException(adviceObject);
		}
		Advice advice = (Advice) adviceObject;
		if (advice instanceof MethodInterceptor) {
			// 我们提到过的最通用的 PointcutAdvisor，接受所有 Pointcut 和 Advice
			// 默认 private Pointcut pointcut = Pointcut.TRUE
			return new DefaultPointcutAdvisor(advice);
		}
		for (AdvisorAdapter adapter : this.adapters) {
			if (adapter.supportsAdvice(advice)) {
				return new DefaultPointcutAdvisor(advice);
			}
		}
		throw new UnknownAdviceTypeException(advice);
	}

	@Override
	public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
		List<MethodInterceptor> interceptors = new ArrayList<>(3);
		Advice advice = advisor.getAdvice();
		
		// 如果是 MethodInterceptor 直接加入
		if (advice instanceof MethodInterceptor) {
			interceptors.add((MethodInterceptor) advice);
		}
		
		// 如果不是则进行适配
		for (AdvisorAdapter adapter : this.adapters) {
			if (adapter.supportsAdvice(advice)) {
				interceptors.add(adapter.getInterceptor(advisor));
			}
		}
		if (interceptors.isEmpty()) {
			throw new UnknownAdviceTypeException(advisor.getAdvice());
		}
		return interceptors.toArray(new MethodInterceptor[0]);
	}

	@Override
	public void registerAdvisorAdapter(AdvisorAdapter adapter) {
		this.adapters.add(adapter);
	}

}

• AdvisorAdapterRegistry 的唯一实现类，默认注册了三个适配器
• wrap(Object adviceObject) 方法将 Advice 包装成 DefaultPointcutAdvisor
• getInterceptors(Advisor advisor) 方法委托给对应的适配器实现

demo

	@Test
    public void test() {
        AdvisorAdapterRegistry registry = new DefaultAdvisorAdapterRegistry();
        MethodBeforeAdvice advice = new MethodBeforeAdvice() {
            @Override
            public void before(Method method, Object[] args, Object target) throws Throwable {
                System.out.println("before");
            }
        };

        // wrap advice to DefaultPointcutAdvisor
        Advisor wrap = registry.wrap(advice);

        // adapt advice to MethodInterceptor
        MethodInterceptor[] interceptors = registry.getInterceptors(new DefaultPointcutAdvisor(
                new MethodBeforeAdviceInterceptor(advice)
        ));
    }

AdvisorChainFactory

public interface AdvisorChainFactory {

	List<Object> getInterceptorsAndDynamicInterceptionAdvice(Advised config, Method method, @Nullable Class<?> targetClass);

}

基于 Advised 提供的 Advisors，获取指定（类）方法上的 Interceptors chain

DefaultAdvisorChainFactory

public class DefaultAdvisorChainFactory implements AdvisorChainFactory, Serializable {

	@Override
	public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
			Advised config, Method method, @Nullable Class<?> targetClass) {

		// DefaultAdvisorAdapterRegistry
		AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();

		// Advised.getAdvisors()
		Advisor[] advisors = config.getAdvisors();
		List<Object> interceptorList = new ArrayList<>(advisors.length);
		Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());

		Boolean hasIntroductions = null;
		for (Advisor advisor : advisors) {
			// 如果是 PointcutAdvisor
			if (advisor instanceof PointcutAdvisor) {
				PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;

				// 已提前检查 || 类匹配
				if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {

					// 获取 MethodMatcher
					MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
					boolean match;

					// AspectJExpressionPointcut 就是一个 IntroductionAwareMethodMatcher
					// 实现了 IntroductionAwareMethodMatcher 的 Pointcut matches 方法有所不同
					if (mm instanceof IntroductionAwareMethodMatcher) {
						if (hasIntroductions == null) {
							hasIntroductions = hasMatchingIntroductions(advisors, actualClass);
						}

						// 判断是否匹配，因为
						match = ((IntroductionAwareMethodMatcher) mm).matches(method, actualClass, hasIntroductions);
					}
					else {
						match = mm.matches(method, actualClass);
					}
					if (match) {
						/**
						 * 如果类和方法都匹配上了，则通过 DefaultAdvisorAdapterRegistry
						 * advisor -> advice ---对应的适配器--> MethodInterceptors
						 */
						MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
						if (mm.isRuntime()) {
							// 如果是 Runtime 方法，则再存一份 InterceptorAndDynamicMethodMatcher
							for (MethodInterceptor interceptor : interceptors) {
								interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
							}
						}
						else {
							interceptorList.addAll(Arrays.asList(interceptors));
						}
					}
				}
			}
			// ...
			else {
				// 其他类型
				Interceptor[] interceptors = registry.getInterceptors(advisor);
				interceptorList.addAll(Arrays.asList(interceptors));
			}
		}

		return interceptorList;
	}

	// ...

}

唯一实现类，主要实现了 getInterceptorsAndDynamicInterceptionAdvice 方法

• 从 Advised 获取 Advisors
• 根据 Advisor 的不同类型对目标方法进行匹配，对于匹配上的方法，则通过 DefaultAdvisorAdapterRegistry 将 Advisor 上的 Advice 转换为 Interceptor

类图

TargetSource

AdvisorAdapter

AdvisorAdapterRegistry

AdvisorChainFactory

序列图

AdvisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice

总结

这一章节我们解读了 TargetSource AdvisorAdapter AdvisorAdapterRegistry 几个接口，为我们解读 Advised 接口做好铺垫

上一篇：【源码】Spring AOP 7 AspectJAdvisorFactory
下一篇：【源码】Spring AOP 9 Advised