jdk动态代理实现原理

动态代理的作用

   我们都知道,spring的面向切面编程默认由jdk动态代理和cglib动态代理实现，使用动态代理我们可以无侵入的实现切面编程，比如日志管理、权限管理、事务管理等。jdk动态代理是面向接口的，cglib是面向普通类。弄明白了这两种动态代理实现原理也就懂了spring的aop编程。

jdk动态代理说明

jdk动态代理是面向接口的，只能对接口生成代理类。我曾经以为这个接口必须有实现类，其实这是错误的。接口实现是否存在是根据业务需求而来的。

jdk动态代理实现方法

1、目标接口、目标接口实现类

2、自定义的InvocationHandler

public interface UserService {
	
	public void methodA();
	
}

public class UserServiceImpl implements UserService {

	public void methodA() {
		System.out.println("UserServiceImpl methodA()...");
	}
	
}

public class MyInvocationHandler implements InvocationHandler {
	
	public MyInvocationHandler() {
		super();
	}

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

	private Object obj;
	
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println("执行前....");
		Object value = method.invoke(obj, args);
		System.out.println("执行后");
		return value;
	}

import java.lang.reflect.Proxy;

import com.interceptor.MyInvocationHandler;
import com.jun.UserService;
import com.jun.impl.UserServiceImpl;

public class TestJDKDynamicProxy {

	public static void main(String[] args) {
	
		MyInvocationHandler h = new MyInvocationHandler(new UserServiceImpl());
		Class<?>[] interfaces ={UserService.class};
		UserService service = (UserService) Proxy.newProxyInstance(MyInvocationHandler.class.getClassLoader(), interfaces, h);
		service.methodA();
                System.out.println(service.getClass());
       }
}

输出结果

执行前....
UserServiceImpl methodA()...
执行后
class com.sun.proxy.$Proxy0

jdk动态代理原理

切面编程的效果出来了，在执行方法前和执行方法后，执行了逻辑操作，这里，我们可以做事务开启、关闭，日志的记录等。但背后的原理是什么？

通过对目标接口生成代理类，代理类会继承Proxy并实现目标接口，代理类的所有方法都会调用定制的invocationhandler的invoke方法,在定制InvocationHandler中调用目标类方法， 从而实现切面编程。

我们注意到打印出来的UserService类是com.sun.Proxy.$Proxy0,而不是UserService。通过追踪Proxy.newProxyInstance方法，我们发现有个getProxyClass0方法

Class<?> cl = getProxyClass0(loader, interfaces);

这个方法生成了代理类信息,进入方法发现，是这一行代码生成字节码

  byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                    proxyName, interfaces);

由于jdk是不开源的，所以我们需要下载openjdk查看源代码

 /**
     * Generate a proxy class given a name and a list of proxy interfaces.
     */
    public static byte[] generateProxyClass(final String name,
                                            Class[] interfaces)
    {
        ProxyGenerator gen = new ProxyGenerator(name, interfaces);
        final byte[] classFile = gen.generateClassFile();

        if (saveGeneratedFiles) {
            java.security.AccessController.doPrivileged(
            new java.security.PrivilegedAction<Void>() {
                public Void run() {
                    try {
                        FileOutputStream file =
                            new FileOutputStream(dotToSlash(name) + ".class");
                        file.write(classFile);
                        file.close();
                        return null;
                    } catch (IOException e) {
                        throw new InternalError(
                            "I/O exception saving generated file: " + e);
                    }
                }
            });
        }

        return classFile;
    }

我们发现saveGeneratedFiles控制是否把代理类保存到磁盘上

 private final static boolean saveGeneratedFiles =
        java.security.AccessController.doPrivileged(
            new GetBooleanAction(
                "sun.misc.ProxyGenerator.saveGeneratedFiles")).booleanValue();

现在已经确定是ProxyGenerator.generateProxyClass生成代理类，既然已经找到"真凶"，我们就生成代理类看看吧。

import sun.misc.ProxyGenerator;

public class TestJDKDynamicProxy {

	public static void main(String[] args) {
		
		
		System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true"); 
		Class<?>[] interfaces ={UserService.class};
		ProxyGenerator.generateProxyClass(
                "C:\\Users\\DELL\\Desktop\\$Proxy1", interfaces);
        }
}

注意，传入的属性值是字符串"true"，而不是布尔值true，传入布尔值true不会保存到磁盘

通过java反编译工具jad(java decomplier)反编译$Proxy1生成jad文件，打开后如下所示

import java.lang.reflect.*;

public final class C_3A__5C_Users_5C_DELL_5C_Desktop_5C_$Proxy1 extends Proxy
    implements UserService
{

	static 
    {
        try
        {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {
                Class.forName("java.lang.Object")
            });
            m4 = Class.forName("com.jun.UserService").getMethod("methodB", new Class[0]);
            m3 = Class.forName("com.jun.UserService").getMethod("methodA", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
        }
        catch(NoSuchMethodException nosuchmethodexception)
        {
            throw new NoSuchMethodError(nosuchmethodexception.getMessage());
        }
        catch(ClassNotFoundException classnotfoundexception)
        {
            throw new NoClassDefFoundError(classnotfoundexception.getMessage());
        }
    }
	
	 private static Method m3;
	 
    public C_3A__5C_Users_5C_DELL_5C_Desktop_5C_$Proxy1(InvocationHandler invocationhandler)
    {
        super(invocationhandler);
    }


    public final void methodA()
    {
        try
        {
            super.h.invoke(this, m3, null);
            return;
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }
}

我们可以看到代理类$Proxy1,实现了指定接口UserService并继承了Proxy，执行methodA时，会调用父类的invocationHandler，而这个InvocationHandler就是在创建代理类对象时，传入的MyInvocationHandler

 Class<?> cl = getProxyClass(loader, interfaces);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            Constructor cons = cl.getConstructor(constructorParams);
            return cons.newInstance(new Object[] { <strong><span style="font-size:18px;color:#ff0000;">h</span></strong> });

我们再回过头来回顾一下事情的经过，首先执行代理的methodA方法，然后调用MyInvocationHandler.invoke方法，首先进行方法前逻辑处理，然后执行UserServiceImpl的methodA方法，然后执行方法后逻辑处理。

注意：

1、目标接口不是必须有实现类的，比如Mybatis的mapper，mapper都是接口，但是没有实现类。Mybatis的InvocationHandler就是MapperProxy，在invoke方法中方法里执行sql。