动态代理

动态代理和代理模式有些相似，都是对某个类中的某些方法进行监听，代理模式在这里不多说，下面概括一下动态代理，以下概括完全是基于个人理解总结的：
动态代理：在不改变原有类实现的基础上，通过实现类的接口，对类实现的接口方法的调用进行监听，实现接口方法调用前后。0

动态代理实现方法:

1. 定义被代理类的接口方法
2. 创建被代理类并实现接口方法
3. 创建代理类
4. 添加代理

动态代理的实现

下面我们以对User对象的添加和查找进行代理为例。
User实体对象如下：

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

定义被代理类的接口方法

创建被代理类中代理方法的接口。

public interface IUserControl {
    
    public void addUser(User user);
    
    public User getUser(int index);
}

创建被代理类并实现接口方法

被代理的对象，一定要实现上面定义的接口

public class UserControl implements IUserControl {
    
    private User user;
    
    @Override
    public void addUser(User user) {
        this.user = user;
    }

    @Override
    public User getUser(int index) {
        return this.user;
    }
    
    public void delete() {}
}

在上面实体中，有两种方法的实现，一种是接口方法实现（必须有），一种是实体自己的方法（可有可无）。

创建代理类

代理类代码很少，也非常简单，先上代码，然后在说明：

public class UserProxy implements InvocationHandler {
    private UserControl control;
    private IProxyListener listener;

    public UserProxy(UserControl control, IProxyListener listener) {
        this.control = control;
        this.listener = listener;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object obj;
        listener.methoBefor();
        obj = method.invoke(control,args);
        listener.methodAfter();
        return obj;
    }
}

代码虽然不是很多，但是这里很关键，不了解的人看了一定会有很多疑问，下面介绍一下这部分代码。
InvocationHandler 接口
每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。

看到这里怎么又出来个invoke 方法，下面我们在看看invoke 方法。

invoke 方法

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable

我们看到这个方法一共接受三个参数，那么这三个参数分别代表什么：

proxy:　　指代我们所代理的那个真实对象
method:　　指代的是我们所要调用真实对象的某个方法的Method对象
args:　　指代的是调用真实对象某个方法时接受的参数

看到这里知道上面代码中为什么obj = method.invoke(control,args);这样写了吧，其实不难理解invoke 方法是通过InvocationHandler接口进行调用的。

添加代理

public class ProxyMain {
    public static void main(String[] args) {
        UserControl control = new UserControl();
        UserProxy proxy = new UserProxy(control, new IProxyListener() {
            @Override
            public void methoBefor() {
                System.out.println("method beford");
            }

            @Override
            public void methodAfter() {
                System.out.println("method after");
            }
        });

        IUserControl iUserControl = (IUserControl) Proxy.newProxyInstance(proxy.getClass().getClassLoader(),control.getClass().getInterfaces(),proxy);
        iUserControl.addUser(new User("hello",23));
        User user = iUserControl.getUser(0);
        System.out.println("user:" + user.getName());
    }
}

上面代码依然不是很多，其实关键的一行代码是：

IUserControl iUserControl = (IUserControl) Proxy.newProxyInstance(
        proxy.getClass().getClassLoader(),control.getClass().getInterfaces(),proxy);

看到这突然出来了一个Proxy类，Proxy这个类的作用就是用来动态创建一个代理对象的类的，Proxy 类有好几个方法，我们常用的就是newProxyInstance方法，通过这个方法名也能知道这个方法是干什么的，这个方法作用是创建一个代理实例的。这个方法有三个参数，下面说明一下：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

loader: 一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
interfaces: 被代理对象实现的接口数组
h:　一个InvocationHandler对象，实现InvocationHandler接口的代理对象

以上就是动态代理的实现过程，很简单吧！！！

如果上述有错误请指出，共同学习，共同进步。