JDK动态代理干了什么事情？为什么我的事务会不起效？spring的事务到底应该怎么使用？原理是什么？

JDK动态代理剖析：
//接口
public interface HelloInterface extends Serializable {
public String hello(String name);
public String bye(String name);
}
//实现类
public class HelloInterfaceImpl implements HelloInterface {
@Override
public String hello(String name) {
return "你好" + name;
}
@Override
public String bye(String name) {
hello(name);
return "Bye " + name;
}
}
//方法拦截
public class HelloInterceptor implements InvocationHandler {
private HelloInterface helloInterface;
public HelloInterceptor(HelloInterface helloInterface) {
this.helloInterface = helloInterface;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("拦截到方法：" + method.getName() + "，参数：" + args[0]);
return method.invoke(helloInterface, args);
}
}
//产生代理并测试
HelloInterface helloInterface = new HelloInterfaceImpl();
HelloInterceptor helloInterceptor = new HelloInterceptor(helloInterface);
HelloInterface helloInterfaceProxy = (HelloInterface) Proxy.newProxyInstance(
helloInterface.getClass().getClassLoader(),
helloInterface.getClass().getInterfaces(),
helloInterceptor);
helloInterfaceProxy.bye("张三");
输出结果：
拦截到方法：bye，参数：张三
注意：调用了方法bye，bye又调用了hello，但只拦截到了bye方法，没有拦截到bye又调用的hello方法
解释这个原因前先看看这个产生的代理对象：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import prox.HelloInterface;
public final class $Proxy0 extends Proxy
implements HelloInterface
{
private static Method m3;
private static Method m1;
private static Method m4;
private static Method m0;
private static Method m2;
public $Proxy0(InvocationHandler paramInvocationHandler)
throws
{
super(paramInvocationHandler);
}
public final String bye(String paramString)
throws
{
try
{
return (String)this.h.invoke(this, m3, new Object[] { paramString });
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
public final boolean equals(Object paramObject)
throws
{
try
{
return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
public final String hello(String paramString)
throws
{
try
{
return (String)this.h.invoke(this, m4, new Object[] { paramString });
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
public final int hashCode()
throws
{
try
{
return ((Integer)this.h.invoke(this, m0, null)).intValue();
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
public final String toString()
throws
{
try
{
return (String)this.h.invoke(this, m2, null);
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
static
{
try
{
m3 = Class.forName("prox.HelloInterface").getMethod("bye", new Class[] { Class.forName("java.lang.String") });
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
m4 = Class.forName("prox.HelloInterface").getMethod("hello", new Class[] { Class.forName("java.lang.String") });
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
return;
}
catch (NoSuchMethodException localNoSuchMethodException)
{
throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
}
catch (ClassNotFoundException localClassNotFoundException)
{
}
throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
}
}
该类是代理对象反编译后的源码，该类是JDK动态产生的，可以看到该类实现了HelloInterface，并通过如下代码得到了HelloInterface所有方法的反射
m3 = Class.forName("prox.HelloInterface").getMethod("bye", new Class[] { Class.forName("java.lang.String") });
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
m4 = Class.forName("prox.HelloInterface").getMethod("hello", new Class[] { Class.forName("java.lang.String") });
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
再看bye方法：
public final String bye(String paramString)
throws
{
try
{
return (String)this.h.invoke(this, m3, new Object[] { paramString });
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
调用改方法实际上是调用HelloInterceptor（即：this.h，这个是在父类Proxy中通过protected InvocationHandler h;定义的）的invoke方法，
参数this即是代理对象本身，m3是bye方法的反射，new Object[] { paramString }为传入的参数，因此当调用helloInterface.bye("张三");时，
其实是执行HelloInterceptor的invoke方法，而在该方法：
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("拦截到方法：" + method.getName() + "，参数：" + args[0]);
return method.invoke(helloInterface, args);
}
先输出，后用反射直接调用刚刚创建的实例 HelloInterface helloInterface = new HelloInterfaceImpl();的bye方法，很明显该实例是原始类，未做任何改变，
只不过调用的方式由显示调用变成了反射间接调用，不再与HelloInterceptor有关，其执行的不过是其内部的代码，所以bye方法再去调用hello方法并没有被拦截到，
同理，如果还有其它类似的方法被bye调用也不会被拦截到。
现在来回答事务的问题就简单了
spring中，JDK代理是由这个类产生的
final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable

它实现了InvocationHandler接口，当调用代理对象时会调用JdkDynamicAopProxy 的invoke方法，如果配置了事务，invoke方法会调用TransactionInterceptor来实现真正的事务处理，
现在就很明白了，如果我们有一个类BusinessService，它有两个方法methodA，methodB，如果methodA没有设置事务，methodB设置了事务，那么methodA调用了methodB，
methodB的事务也不会起效，因为虽然BusinessService被代理了，但当调用BusinessService的代理对象的methodA方法时会调用JdkDynamicAopProxy的invoke方法，

JdkDynamicAopProxy 发现mthodA没有事务就会略过TransactionInterceptor，进而调用原始的BusinessService的methodA方法，原始的BusinessService与JdkDynamicAopProxy 无关，
也就不会调用TransactionInterceptor了，所以不会起效；反之，如果先调用BusinessService的代理对象的 methodB，接着调用JdkDynamicAopProxy的invoke方法，

JdkDynamicAopProxy 发现mthodB有事务就会调用TransactionInterceptor进行事务处理，完毕后调用原始的BusinessService的methodB方法，如果methodB再掉其它方法，
这些方法都会有事务（因为事务对象（说白了就是jdbc的connnection）是存放在ThreadLocal中的，后续的方法如果设置了事务，调用时会判断事务是否在当前线程中存在，如果存在则直接使用，否则新开一个线程并存入TheadLocal中）
所以要保证事务有效可以有以下方法：
1.保证入口方法设置了事务
2.将事务方法封装到其他类中，在要使用的地方注入即可（这样保证了事务方法和调用方法属于不同的类，不同的代理）
3.要保证所有操作在一个事务中，请一定要在同一线程中执行