spring-aop-ProxyFactory 源码分析

spring 提供的编程式aop实现,即通过 ProxyFactory类完成的。

另外AnnotationAwareAspectJAutoProxyCreator BeanNameAutoProxyCreator DefaultAdvisorAutoProxyCreator 等自动aop代理创建器都是通过在其父类AbstractAutoProxyCreator中通过ProxyFactory 来实现aop逻辑的植入。所以理解ProxyFactory 的使用对理解spring aop 至关重要。

分析ProxyFactory 可以从两条线来分析:

1、代理对象的创建

2、method的调用以及拦截器(Advice)的织入。

使用方式:

[b]业务逻辑[/b]


public class LoginServiceImpl implements LoginService {
public boolean login(User user) {
System.out.println(user);
if (user == null) {
return false;
} else if (user.getUsername() == "xinchun.wang" && user.getPassword() == "123456") {
return true;
}
return false;
}
}

[b]addvice增强[/b]


public class AfterAdvice1 implements AfterReturningAdvice{

public void afterReturning(Object returnValue, Method method,
Object[] args, Object target) throws Throwable {
System.out.println("AfterAdvice1.afterReturning() execute ");
}
}
//
public class AfterAdvice2 implements AfterReturningAdvice{

public void afterReturning(Object returnValue, Method method,
Object[] args, Object target) throws Throwable {
System.out.println("AfterAdvice2.afterReturning() execute ");

}
}

public class BeforeAdvice1 implements MethodBeforeAdvice{
public void before(Method method, Object[] args, Object target)
throws Throwable {
System.out.println("BeforeAdvice1.before() execute ");
}
}

public class BeforeAdvice2 implements MethodBeforeAdvice{

public void before(Method method, Object[] args, Object target)
throws Throwable {
System.out.println("BeforeAdvice2.before() execute ");
}

}

[b]测试用例:[/b]


@Test
public void proxyLoginTest() {
ProxyFactory factory = new ProxyFactory();
factory.addAdvice(new BeforeAdvice1());
factory.addAdvice(new BeforeAdvice2());
factory.addAdvice(new AfterAdvice1());
factory.addAdvice(new AfterAdvice2());
LoginService target = new LoginServiceImpl();
factory.setTarget(target);
factory.setProxyTargetClass(false);
factory.setInterfaces(new Class[]{LoginService.class});

LoginService service = (LoginService)factory.getProxy();
System.out.println(service.login(new User("xinchun.wang","123456")));
}

输出:

BeforeAdvice1.before() execute

BeforeAdvice2.before() execute

User [username=admin, password=123456, open=false]

AfterAdvice2.afterReturning() execute

AfterAdvice1.afterReturning() execute

true

[b]数据结构:[/b]

ProxyConfig: 代理的基础配置属性

AdvisedSupport:提供基础的Advice的包装,Advisor 列表的维护,TargetSource 对象的维护,以及Interceptor 数据结构的解析和封装。

ProxyCreatorSupport:代理工厂的基类,主要负责代理对象的生成。

ProxyFactory:最常用的代理工厂应用,包含一些静态工厂方法,以及代理对象生成的方法。


public class ProxyFactory extends ProxyCreatorSupport {
//指定待实现接口和拦截器
public ProxyFactory(Class proxyInterface, Interceptor interceptor) {
addInterface(proxyInterface); //JDK代理需要接口
addAdvice(interceptor);//添加增强逻辑
}
}

//通过指定一个目标对象,构造ProxyFactory,可以继续通过addAdvice(interceptor);添加拦截器
public ProxyFactory(Object target) {
Assert.notNull(target, "Target object must not be null");
setInterfaces(ClassUtils.getAllInterfaces(target));
setTarget(target);
}

//生成代理对象,createAopProxy 在ProxyCreatorSupport 中实现
public Object getProxy() {
return createAopProxy().getProxy();
}

}

代理创建分析线

ProxyCreatorSupport 提供的createAopProxy() 提供了aopProxy的生成


/** 代理工厂的基类,提供了对 AopProxyFactory 的包装*/
public class ProxyCreatorSupport extends AdvisedSupport {
//代理工厂,默认实现 DefaultAopProxyFactory 提供了 JdkDynamicAopProxy 和 Cglib2AopProxy 的生成
private AopProxyFactory aopProxyFactory;
//aop配置的监听器
private List<AdvisedSupportListener> listeners = new LinkedList<AdvisedSupportListener>();

/** Set to true when the first AOP proxy has been created */
private boolean active = false;

/**
* 默认实现,指定DefaultAopProxyFactory 为默认aop代理生成工厂
*/
public ProxyCreatorSupport() {
this.aopProxyFactory = new DefaultAopProxyFactory();
}

/**
* 同上自定义一个AopProxyFactory,来实现aop代理对象的生成
*/
public ProxyCreatorSupport(AopProxyFactory aopProxyFactory) {
Assert.notNull(aopProxyFactory, "AopProxyFactory must not be null");
this.aopProxyFactory = aopProxyFactory;
}
/**
*留给子类调用的代理生成,此次是aop代理生成的入口
*/
protected final synchronized AopProxy createAopProxy() {
if (!this.active) { //第一次激活的时候,调用相关的监听器
activate();
}
return getAopProxyFactory().createAopProxy(this); //通过aop代理工厂 生成AopProxy
}

}

代理创建分析线 DefaultAopProxyFactory 的 createAopProxy 方法

 

/** 默认的代理工厂实现
当 optimize =true或proxyTargetClass=ture 或 no proxy interfaces 指定,使用CGLIB 来生成代理,否则jdk代理
*/
public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

/** 检查CGLIB2 相关类是否存在 */
private static final boolean cglibAvailable =
ClassUtils.isPresent("net.sf.cglib.proxy.Enhancer", DefaultAopProxyFactory.class.getClassLoader());


public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
//optimize =true或proxyTargetClass=ture 或 no proxy interfaces 指定,使用CGLIB 来生成代理
//optimize 做优化,早期jdk的代理的生成相当慢,不过现在基本差异不大
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()) { //虽然符合以上要求,但是如果代理对象是借口,那么继续使用jdk
return new JdkDynamicAopProxy(config);
}
if (!cglibAvailable) {
throw new AopConfigException(
"Cannot proxy target class because CGLIB2 is not available. " +
"Add CGLIB to the class path or specify proxy interfaces.");
}
return CglibProxyFactory.createCglibProxy(config); // Cglib2 代理
}
else {
return new JdkDynamicAopProxy(config); //jdk 代理
}
}

/**
* 判断是否有接口
*/
private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
Class[] interfaces = config.getProxiedInterfaces();
return (interfaces.length == 0 || (interfaces.length == 1 && SpringProxy.class.equals(interfaces[0])));
}

/**
* 创建Cglib2AopProxy
*/
private static class CglibProxyFactory {
public static AopProxy createCglibProxy(AdvisedSupport advisedSupport) {
return new Cglib2AopProxy(advisedSupport);
}
}
}

代理创建分析线 举例 JdkDynamicAopProxy 的getProxy 方法


/**
* 基于JDK动态代理 的Aop代理实现
通过JDK代理的方法调用 只对接口中的方法做拦截
即使真实对象不是线程安全的,通过JdkDynamicAopProxy 产生的对象依然是线程安全的。
*/
final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {

private static final long serialVersionUID = 5531744639992436476L;

/** We use a static Log to avoid serialization issues */
private static Log logger = LogFactory.getLog(JdkDynamicAopProxy.class);

/** aop的配置信息(增强逻辑,真是对象,切点信息) */
private final AdvisedSupport advised;

/** 代理接口是否有equals方法
*/
private boolean equalsDefined;

/** 代理借口是否有hashCode方法
*/
private boolean hashCodeDefined;


public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {
Assert.notNull(config, "AdvisedSupport must not be null");
if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
throw new AopConfigException("No advisors and no TargetSource specified");
}
this.advised = config;
}

/** 获取代理*/
public Object getProxy() {
return getProxy(ClassUtils.getDefaultClassLoader());
}

/** 至此方法结束,通过jdk生成代理对象已经完成*/
public Object getProxy(ClassLoader classLoader) {
if (logger.isDebugEnabled()) {
logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
}
Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised); //找到所有借口
findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this); //生成代理
}

/**
* 检查是否定义了hashCode equals 方法
*/
private void findDefinedEqualsAndHashCodeMethods(Class[] proxiedInterfaces) {
for (Class proxiedInterface : proxiedInterfaces) {
Method[] methods = proxiedInterface.getDeclaredMethods();
for (Method method : methods) {
if (AopUtils.isEqualsMethod(method)) {
this.equalsDefined = true;
}
if (AopUtils.isHashCodeMethod(method)) {
this.hashCodeDefined = true;
}
if (this.equalsDefined && this.hashCodeDefined) {
return;
}
}
}
}

/**
* 这里是代理对象调用,也是jdk代理 实现的核心逻辑
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
MethodInvocation invocation;
Object oldProxy = null;
boolean setProxyContext = false;

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

try {
if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) { //如果代理的是equlas 方法
return equals(args[0]);
}
if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) { //如果代理的是hashCode方法
// The target does not implement the hashCode() method itself.
return hashCode();
}
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) { // 是否允许把当前代理放到AopContext中,这样可以保存在ThreadLocal中,在代码里使用AopContext.currentProxy() 获取当前代理
// Make invocation available if necessary.
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}

// 获取目标对象以及Class类型
target = targetSource.getTarget();
if (target != null) {
targetClass = target.getClass();
}

// 根据Method 和 targetClass 获取对应的拦截器(Advice增强封装) 这里是获取拦截逻辑的地方。(MethodMatcher 和 ClassFilter 在此处做匹配)
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

// 如果没有配置,或者没有匹配到任何方法,那么直接调用当前实例的方法即可
if (chain.isEmpty()) {
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
}
else {
// ReflectiveMethodInvocation 类封装了 增强和实例方法的调用
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
//aop的增强的植入 精华全在于此
retVal = invocation.proceed();
}

// Massage return value if necessary.
if (retVal != null && retVal == target && method.getReturnType().isInstance(proxy) &&
!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
retVal = proxy;
}
return retVal;
}
finally {
if (target != null && !targetSource.isStatic()) {
targetSource.releaseTarget(target);
}
if (setProxyContext) {
AopContext.setCurrentProxy(oldProxy); //恢复currentProxy
}
}
}

}

代理方法调用分析线

JdkDynamicAopProxy 实现InvocationHandler,其方法 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable 会拦截所有通过代理调用的方法(如果对此不清楚,建议了解jdk的动态代理的实现)因此invoke就是调用的入口

基于以上分析,先看看拦截器对象的获取。 AdvisedSupport 的 getInterceptorsAndDynamicInterceptionAdvice 方法


public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, Class targetClass) {
MethodCacheKey cacheKey = new MethodCacheKey(method);
List<Object> cached = this.methodCache.get(cacheKey);
if (cached == null) {
cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
this, method, targetClass);
this.methodCache.put(cacheKey, cached);
}
return cached;
}

从上面代码可以看出,是做了缓存,如果缓存不存在,通过 AdvisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice 来获取。 注意 这里把拦截器的获取委托的同时,仅仅提供了缓存功能,其他功能都进行了委托。

代理方法调用分析线 -拦截器的获取


/** 此类的实现的唯一功能就是从Advised中,根据method 和 targetClass 实现拦截器的获取*/
public class DefaultAdvisorChainFactory implements AdvisorChainFactory, Serializable {

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

List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length);
//判断是否有引介增强
boolean hasIntroductions = hasMatchingIntroductions(config, targetClass);
//AdvisorAdapterRegistry 是对advice 的包装为MethodInterceptor 工具
AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
for (Advisor advisor : config.getAdvisors()) {
if (advisor instanceof PointcutAdvisor) { //如果是PointcutAdvisor,那么要对方法和类做匹配
// Add it conditionally.
PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(targetClass)) { //如果类匹配
// registry.getInterceptors(advisor) 这句话就是对Advice ->MethodInterceptor 包装
MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
if (MethodMatchers.matches(mm, method, targetClass, hasIntroductions)) { //如果方法也匹配
if (mm.isRuntime()) { //如果是运行时判断,会考虑参数等因素
for (MethodInterceptor interceptor : interceptors) {
interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
}
}
else { //不是运行时,直接添加
interceptorList.addAll(Arrays.asList(interceptors));
}
}
}
}
else if (advisor instanceof IntroductionAdvisor) { //引介增强
IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
if (config.isPreFiltered() || ia.getClassFilter().matches(targetClass)) { //引介增强只需匹配类,即可
Interceptor[] interceptors = registry.getInterceptors(advisor);
interceptorList.addAll(Arrays.asList(interceptors));
}
}
else { //如果不是PointcutAdvisor 也不是 IntroductionAdvisor,那么直接包装,默认是匹配的
Interceptor[] interceptors = registry.getInterceptors(advisor);
interceptorList.addAll(Arrays.asList(interceptors));
}
}
return interceptorList;
}

/**
* 判断targetClass 是否匹配Advised中的任意一个Advisor
*/
private static boolean hasMatchingIntroductions(Advised config, Class targetClass) {
for (int i = 0; i < config.getAdvisors().length; i++) {
Advisor advisor = config.getAdvisors()[i];
if (advisor instanceof IntroductionAdvisor) {
IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
if (ia.getClassFilter().matches(targetClass)) {
return true;
}
}
}
return false;
}

}

代理方法调用分析线 AdvisorAdapterRegistry 通过getInterceptors 对Advisor 包装,返回MethodInterceptor 的逻辑。

DefaultAdvisorAdapterRegistry 类这个接口的默认实现


/** 对advice 的包装为MethodInterceptor 功能*/
public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable {
private final List<AdvisorAdapter> adapters = new ArrayList<AdvisorAdapter>(3);
/**
* 构造方法中默认注册最常用的三个Advice的适配器
*/
public DefaultAdvisorAdapterRegistry() {
registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
registerAdvisorAdapter(new AfterReturningAdviceAdapter());
registerAdvisorAdapter(new ThrowsAdviceAdapter());
}

//把advice 包装成Advisor
public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {
if (adviceObject instanceof Advisor) {
return (Advisor) adviceObject;
}
if (!(adviceObject instanceof Advice)) { //如果不是advice ,直接抛出异常
throw new UnknownAdviceTypeException(adviceObject);
}
Advice advice = (Advice) adviceObject;
if (advice instanceof MethodInterceptor) { //如果环绕拦截器,那么通过DefaultPointcutAdvisor包装
return new DefaultPointcutAdvisor(advice);
}
for (AdvisorAdapter adapter : this.adapters) { //通过构造方法中的适配器来判断是否支持
// Check that it is supported.
if (adapter.supportsAdvice(advice)) {
return new DefaultPointcutAdvisor(advice);
}
}
throw new UnknownAdviceTypeException(advice);
}

//把advisor 包装为MethodInterceptor 列表,因为advisor 的Advice可能实现了MethodBeforeAdvice 同时也实现了 AfterReturningAdvice
public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
List<MethodInterceptor> interceptors = new ArrayList<MethodInterceptor>(3);
Advice advice = advisor.getAdvice();
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[interceptors.size()]);
}

public void registerAdvisorAdapter(AdvisorAdapter adapter) { //预留了扩展适配器的方法
this.adapters.add(adapter);
}
}

代理方法调用分析线 ReflectiveMethodInvocation.proceed() 方法的调用,这里拦截增强逻辑植入的地方。


public Object proceed() throws Throwable {
// 我们从第一个currentInterceptorIndex = -1开始,如果currentInterceptorIndex 那么拦截器已经调用完,这时候调用真实的业务方法
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}

//从第一个拦截器开始调用
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
// 如果是动态匹配
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
//动态匹配时,会考虑到参数,如果匹配就调用
if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
return dm.interceptor.invoke(this);
}
else {
//如果动态匹配失败,那么继续进行下一个拦截器调用
return proceed();
}
}
else {
// 如果是静态的,那么已经在构造ReflectiveMethodInvocation时,过滤了,都是匹配的拦截器,那么直接调用
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}

//实现思路很简单,就是method 在 target上进行反射调用
protected Object invokeJoinpoint() throws Throwable {
return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);
}

至此,调用分析已经完毕,但是似乎没有看到增强具体的逻辑,其实不然,这些拦截器是对advice封装,让我们看下这些对advice’的拦截器适配的实现。 这些逻辑的封装是在AdvisorAdapter 中的各个实现。


class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {
public boolean supportsAdvice(Advice advice) {
return (advice instanceof MethodBeforeAdvice);
}
public MethodInterceptor getInterceptor(Advisor advisor) {
MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
return new MethodBeforeAdviceInterceptor(advice); //如果是MethodBeforeAdvice,那么使用MethodBeforeAdviceInterceptor 进行适配
}

}

public class MethodBeforeAdviceInterceptor implements MethodInterceptor, Serializable {
private MethodBeforeAdvice advice;
public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
Assert.notNull(advice, "Advice must not be null");
this.advice = advice;
}

public Object invoke(MethodInvocation mi) throws Throwable {
this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() ); //前置增强的调用,然后继续向下调用
return mi.proceed();
}

}

class AfterReturningAdviceAdapter implements AdvisorAdapter, Serializable {
public boolean supportsAdvice(Advice advice) {
return (advice instanceof AfterReturningAdvice);
}
public MethodInterceptor getInterceptor(Advisor advisor) {
AfterReturningAdvice advice = (AfterReturningAdvice) advisor.getAdvice();
return new AfterReturningAdviceInterceptor(advice);
}

}

public class AfterReturningAdviceInterceptor implements MethodInterceptor, AfterAdvice, Serializable {
private final AfterReturningAdvice advice;
public AfterReturningAdviceInterceptor(AfterReturningAdvice advice) {
Assert.notNull(advice, "Advice must not be null");
this.advice = advice;
}
public Object invoke(MethodInvocation mi) throws Throwable {
Object retVal = mi.proceed();//先让其他方法调用完,然后才调用自己的后置增强
this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
return retVal;
}
}

至此分析完毕,一个简单的spring aop实现ProxyFactory 大致轮廓就是如此!

另外:如果你能清楚的理解下面的输出顺序,并且在随意更改advice添加顺序的情况下,你都能清楚预测出输出顺序,ok,你明白了AfterReturningAdviceInterceptor和MethodBeforeAdviceInterceptor 的invoke方法执行流程啦~

BeforeAdvice1.before() execute

BeforeAdvice2.before() execute

User [username=admin, password=123456, open=false]

AfterAdvice2.afterReturning() execute

AfterAdvice1.afterReturning() execute

    原文作者:Spring Boot
    原文地址: https://blog.csdn.net/iteye_5504/article/details/82582436
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞