动态代理是什么？

本文内容如有错误、不足之处，欢迎技术爱好者们一同探讨，在本文下面讨论区留言，感谢。

文章目录

简介
原理

核心组件
例子

结论
参考资料

简介

oracle 官方关于动态代理的描述：

A dynamic proxy class is a class that implements a list of interfaces specified at runtime such that a method invocation through one of the interfaces on an instance of the class will be encoded and dispatched to another object through a uniform interface. Thus, a dynamic proxy class can be used to create a type-safe proxy object for a list of interfaces without requiring pre-generation of the proxy class, such as with compile-time tools. Method invocations on an instance of a dynamic proxy class are dispatched to a single method in the instance’s invocation handler, and they are encoded with a java.lang.reflect.Method object identifying the method that was invoked and an array of type Object containing the arguments.

动态代理类是实现在运行时指定的接口列表的类，这样，通过该类实例上的接口之一进行的方法调用将被编码，并通过统一接口分配给另一个对象。因此，动态代理类可用于为接口列表创建类型安全的代理对象，而无需使用诸如编译时工具之类的代理类预先生成。动态代理类的实例上的方法调用被分派到该实例的调用处理程序中的单个方法，并且它们使用java.lang.reflect.Method 对象进行编码，该对象标识了所调用的方法，并且包含 Object 类型的数组。

代理模式是为了提供额外或不同的操作，而插入的用来替代”实际”对象的对象，这些操作涉及到与”实际”对象的通信，因此代理通常充当中间人角色。Java的动态代理比代理的思想更前进了一步，它可以动态地创建并代理并动态地处理对所代理方法的调用。在动态代理上所做的所有调用都会被重定向到单一的调用处理器上，它的工作是揭示调用的类型并确定相应的策略。

原理

核心原理是：代理模式和反射

核心组件

InvocationHandler：每一个动态代理类都必须要实现 InvocationHandler 这个接口，并且每个代理类的实例都关联到了一个 handler，当开发人员通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由 InvocationHandler 这个接口的 invoke 方法来进行调用。
Proxy：java.lang.reflect.Proxy 类，用来动态创建一个代理对象的类，主要使用 newProxyInstance 方法。

例子

JdkProxyDemo.java

package proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class JdkProxyDemo {
    interface If {
        void originalMethod(String s);
    }
    static class Original implements If {
        public void originalMethod(String s) {
            System.out.println(s);
        }
    }
    static class Handler implements InvocationHandler {
        private final If original;
        public Handler(If original) {
            this.original = original;
        }
        public Object invoke(Object proxy, Method method, Object[] args)
                throws IllegalAccessException, IllegalArgumentException,
                InvocationTargetException {
            System.out.println("BEFORE");
            method.invoke(original, args);
            System.out.println("AFTER");
            return null;
        }
    }
    public static void main(String[] args){
        Original original = new Original();
        Handler handler = new Handler(original);
        If f = (If) Proxy.newProxyInstance(If.class.getClassLoader(),
                new Class[] { If.class },
                handler);
        f.originalMethod("Hallo");
    }
}