Java 动态代理

2018-09-17

字数统计: 1.4k字 | 阅读时长≈ 5分

参考链接：

Java 实现动态代理主要涉及以下几个类：

java.lang.reflect.Proxy: 这是生成代理类的主类，通过 Proxy 类生成的代理类都继承了 Proxy 类，即 DynamicProxyClass extends Proxy。
java.lang.reflect.InvocationHandler: 这里称他为”调用处理器”，他是一个接口，我们动态生成的代理类需要完成的具体内容需要自己定义一个类，而这个类必须实现 InvocationHandler 接口。

Proxy 类

proxy的代理方法

1 2	//创建代理对象 static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

loader是类加载器对象（即哪个类加载器来加载这个代理类到 JVM 的方法区）

Interfaces是接口（表明你这个代理类需要实现哪些接口）

h参数是调用处理器类实例（指定代理类中具体要干什么）

newProxyInstance()这个代理类实现了我们指定的接口并且会把方法调用分发到指定的调用处理器

static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler handler)
{
    //1. 根据类加载器和接口创建代理类
    Class clazz = Proxy.getProxyClass(loader, interfaces); 
    //2. 获得代理类的带参数的构造函数
    Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class });
    //3. 创建代理对象，并制定调用处理器实例为参数传入
    Interface Proxy = (Interface)constructor.newInstance(new Object[] {handler});
}

Proxy.getProxyClass()方法

方法将给定类加载器和接口数组的代理类的方法返回java.lang.Class对象。代理类将由指定的类加载器定义，并将实现所有提供的接口。如果类加载器已经定义了接口相同置换的代理类，那么将返回现有的代理类; 否则，这些接口的代理类将被动态生成并由类加载器定义。

@CallerSensitive
public static Class<?> getProxyClass(ClassLoader loader,
                                     Class<?>... interfaces)
    throws IllegalArgumentException
{
    final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }

    return getProxyClass0(loader, intfs);
}

invocationHandler

从InvocationHandler这个名称我们就可以知道，实现了这个接口的中介类用做“调用处理器”。当我们调用代理类对象的方法时，这个“调用”会转送到invoke方法中，代理类对象作为proxy参数传入，参数method标识了我们具体调用的是代理类的哪个方法，args为这个方法的参数。这样一来，我们对代理类中的所有方法的调用都会变为对invoke的调用，这样我们可以在invoke方法中添加统一的处理逻辑(也可以根据method参数对不同的代理类方法做不同的处理)。

/**
 * 调用处理程序
 */
public interface InvocationHandler { 
    Object invoke(Object proxy, Method method, Object[] args); 
}

一个实现Java动态代理的demo

你要有委托方法的接口&&它的实现
实现一个自定义的代理类（这个类是实现InvovationHandler接口），下面的例子即为ProxyInvocationHandler，通过重写invoke方法来对原来的方法的前后添加自定义的内容
在Main中，Proxy.newProxyInstance()里面的classLoader和interfaces均可以填委托方法的接口类，最后的invocationHandler则填写我们自定义的ProxyInvocationHandler，生成的proxy对象就可以在实现委托类功能的同时，添加进代理类想新加入的方法。

demo

package com.titizz.simulation.toyspring.simple;


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

/**
 * @author lei.X
 * @date 2018/9/17
 */

public class Test {

    public static interface Foo {
        void test();
        void test2();
    }


    public static class  FooImpl implements Foo{

        @Override
        public void test() {
            System.out.println("test");
        }

        @Override
        public void test2() {
            System.out.println("test2");
        }
    }

    public static class MyInvocationHandler implements InvocationHandler {



        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("proxy method!");
            return null;
        }

    }

    /**
     * 自定义代理类
     */
    public static class ProxyInvocationHandler implements InvocationHandler{

        private Object object;
        private MethodInvocation beforeHandler;
        private MethodInvocation afterHandler;

        public ProxyInvocationHandler(Object object,MethodInvocation beforeHandler,MethodInvocation afterHandler){
            this.object = object;
            this.beforeHandler = beforeHandler;
            this.afterHandler = afterHandler;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            beforeHandler.invoke();
            Object result = method.invoke(object,args);
            afterHandler.invoke();
            return result;
        }
    }

    public static void main(String[] args) throws Exception {

        //设置saveGeneratedFiles值为true生成class字节码到文件
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");


        /**
         * 代理类只会实现MyInvocationHandler中的内容
         * 所以f.test()的结果为"proxy method"
         */
        Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(), new Class<?>[]{Foo.class}, new MyInvocationHandler());
        f.test();

        /**
         * 在委托类的前后添加了logTask和afterLog
         */
        MethodInvocation logTask = () -> System.out.println("log task start");
        MethodInvocation afterLog = () -> System.out.println("after start");

        FooImpl foo = new FooImpl();
        InvocationHandler invocationHandler = new ProxyInvocationHandler(foo,logTask,afterLog);
		 /**
         * 当调用代理类对象的方法时，这个调用会被转送到invoke方法中，代理类对象作为proxy，参数method标识了具体调用的方法，args为这个方法的参数
         * 所以下面代码的f2.test()会传入到invocationHandler的invoke中，f2位proxy，test()为method
         */
        Foo f2 = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(), new Class<?>[]{Foo.class}, invocationHandler);
        f2.test();

    }
}


#result:
#
#	log task start
#	test
#	after start

总结：

首先通过newProxyInstance方法获取代理类实例，而后我们便可以通过这个代理类实例调用代理类的方法，对代理类的方法的调用实际上都会调用中介类(调用处理器)的invoke方法，在invoke方法中我们调用委托类的相应方法，并且可以添加自己的处理逻辑。

本文作者： Noisy
本文链接： http://Metatronxl.github.io/2018/09/17/Java-动态代理/
版权声明： 本博客所有文章除特别声明外，均采用 Apache License 2.0 许可协议。转载请注明出处！