java动态代理

1、动态代理

参考

1.1 动态代理使用的流程

1. 创建代理对象的接口

    /*Params:
           loader – the class loader to define the proxy class
           interfaces – the list of interfaces for the proxy class to implement
           h – the invocation handler to dispatch method invocations to 
   */
   public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
   

   loader： 类加载器，用来加载代理目标的

   interfaces： 指定你要代理（增强）的接口

   h：代理处理器，所有的代理增强都在这个处理器中的invoke中处理，比如直接修改原对象的方法，想在原方法前后添加一些逻辑。

   return ：返回的Object就是生成的代理对象

2. 创建代理对象传参loader和class都好说，那么InvocationHandler怎么获得呢？

public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

看源码可知，这是一个只包含invoke方法的接口类，使用第一步创建的代理对象，调用方法时会回调InvocationHandler中的invoke，，在invoke中我们可以修改原来的方法逻辑，比如在原方法前后打印一些东西。实际使用中我们需要自定义一个类来实现InvocationHandler，重写invoke

1.2 demo

//创建一个接口，使用代理的方式在add方法执行前后打印点东西
public interface Executor {
    int add(int x, int y);
}

//接口实现类
public class ExecutorImpl implements Executor {
    @Override
    public int add(int x, int y) {
        System.out.println("调用add方法");
        return x + y;
    }
}

//InvocationHandler实现类，在此对被代理的对象的方法进行增强
public class LogTimeInvocationHandler implements InvocationHandler {
    /**
     * 被代理的对象（源对象）
     */
    private Object source;

    public LogTimeInvocationHandler(Object source) {
        this.source = source;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        for (int i = 0; i < args.length; i++) {
            System.out.println("参数：" + args[i]);
        }
        System.out.println("我在原方法执行前打印。。。");
        Object result = method.invoke(source, args);
        System.out.println("我在原方法执行后打印。。。");
        return result;
    }
}

//主函数类，包含执行代理方法，以及打印代理方法
public class DynamicProxyTest {
    public static void main(String[] args) {
        //1. 创建一个代理对象，Proxy会自动返回一个代理类，此类是Excutor的子类
        Executor executor = (Executor) Proxy.newProxyInstance(Executor.class.getClassLoader(), new Class[]{Executor.class}, new LogTimeInvocationHandler(new ExecutorImpl()));
        //2. 把自动生成的代理对象打印到文件，方便查看分析
        Class<?> proxyClass = Proxy.getProxyClass(Executor.class.getClassLoader(), new Class[]{Executor.class});
        saveClass("$UserProxy", proxyClass.getInterfaces(), "/home/chenkun/Desktop/");
        //3. 使用代理对象调用
        int add = executor.add(1, 2);
    }

    /**
     * 生成代理类 class 并保持到文件中
     *
     * @param className  生成的代理类名称
     * @param interfaces 代理类需要实现的接口
     * @param pathdir    代理类保存的目录路径,以目录分隔符结尾
     */
    public static void saveClass(String className, Class<?>[] interfaces, String pathdir) {
        /**
         * 第一个参数是 代理类 名 。
         * 第二个参数是 代理类需要实现的接口
         */
        byte[] classFile = ProxyGenerator.generateProxyClass(className, interfaces);
        /**
         * 如果目录不存在就新建所有子目录
         */
        Path path1 = Paths.get(pathdir);
        if (!path1.toFile().exists()) {
            path1.toFile().mkdirs();
        }
        String path = pathdir + className + ".class";
        try (FileOutputStream fos = new FileOutputStream(path)) {
            fos.write(classFile);
            fos.flush();
            System.out.println("代理类class文件写入成功");
        } catch (Exception e) {
            System.out.println("写文件错误");
        }
    }

    /**
     * 设置保存Java动态代理生成的类文件。
     *
     * @throws Exception
     */
    public static void saveGeneratedJdkProxyFiles() throws Exception {
        Field field = System.class.getDeclaredField("props");
        field.setAccessible(true);
        Properties props = (Properties) field.get(null);
        props.put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
    }
}

动态生成的代理类

import com.chen.base.proxy.Executor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $ExecutorProxy0 extends Proxy implements Executor {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $ExecutorProxy0(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 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 add(int var1, int var2) throws  {
        try {
            return (Integer)super.h.invoke(this, m3, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }

    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"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.chen.base.proxy.Executor").getMethod("add", Integer.TYPE, Integer.TYPE);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

自动生成的代理类中有个add方法，此方法回调了InvocationHandler的invoke方法，因此可以对原方法进行增强

 public final int add(int var1, int var2) throws  {
        try {
            return (Integer)super.h.invoke(this, m3, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }

1.3 仓库地址

github地址