Spring AOP中自我调用的问题

现象描述：假设有一个service，其中有A B 两个方法，A B都被aop托管，且A中调用了B方法，这时请求方法A的时候只会触发A的aop逻辑而不会触发B的aop逻辑。

package aop;

public interface UserService {
    void A();
    void B();
} 

package aop;

public class UserServiceImpl implements UserService {

    @Override
    public void A() {
        System.out.println("UserService 逻辑执行A方法。。。。");
        this.B();
    }

    @Override
    public void B() {
        System.out.println("UserService 逻辑执行B方法。。。。");

    }

}

package aop;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
*代理类真正执行的是InvocationHandler的invoke方法
*/
public class MyInvocationHandler implements InvocationHandler {

    private Object target;

    public MyInvocationHandler(Object obj) {
        this.target = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Befroe invoke .............");
        Object r = method.invoke(target, args);
        System.out.println("After invoke ...............");
        return r;
    }

}

package aop;

import sun.misc.ProxyGenerator;

import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Proxy;

public class AopTest {

    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        UserService service = (UserService) Proxy.
                newProxyInstance(Thread.currentThread().getContextClassLoader(),
                        userService.getClass().getInterfaces(),
                        new MyInvocationHandler(userService));
        service.A();
        //这里将动态代理生成的类文件写入磁盘，方便反编译
        byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy11",
                UserServiceImpl.class.getInterfaces());

        FileOutputStream out = null;

        try {
            out = new FileOutputStream("F:\\UserServiceProxy.class");
            out.write(classFile);
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != out)
                    out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

生成的F:\\UserServiceProxy.class文件：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

import aop.UserService;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy11 extends Proxy implements UserService {
    private static Method m1;
    private static Method m4;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $Proxy11(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void A() throws  {
        try {
            super.h.invoke(this, m4, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void B() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m4 = Class.forName("aop.UserService").getMethod("A");
            m3 = Class.forName("aop.UserService").getMethod("B");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

从反编译的结果我们可以知道，jdk动态代理是以反射为基础的，被代理类必须是接口的实现类。jdk首先通过IO流生成相应的class文件，class类实现被代理类接口，继承Proxy父类，然后在返回对象代理对象的实例。

动态代理生成的类就是这个了，调用业务方法A()/B()这两个方法super.h.invoke(this, m3, (Object[])null);、super.h.invoke(this, m4, (Object[])null);的时候,实际上变成了这个h.invoke，而这个h是所有Proxy类里面含有的 protected InvocationHandler h;（源码可见），在用Proxy创建代理实例的时候已经传入过了。

 

代理对象持有了被代理类的Method对象，通过调用InvocationHandler，this.h.invoke(this, m3, null);和this.h.invoke(this, m4, null);执行被代理对象的逻辑。因此，以jdk动态代理为基础的aop实现，A方法调用B方法，只有A方法的aop逻辑会执行是合乎逻辑的，因为我们执行代理对象A方法的时候，其实是执行了原生被代理对象userServiceImpl的Method，此Method内部调用了B，因此不会被aop托管。spring事物注解 是基于aop对象实现管控的,所以这里事物没有生效

通过以上可以证明:如果在B方法上加上@Transaction注解 B方法发生异常 数据并没有回滚的原因

spring的事物管理通过AOP代理来实现， 根据aop的思想，不可能在具体类的方法上直接处理事物，而是通过代理类来处理，代理类在调用具体类的方法来实现，根据上面的情景methodA通过this调用methodB，那么此时相当于调用methodB时是没有经过代理类的调用，因此spring无法对事物的传播行为做处理。