动态代理和代理模式有些相似，都是对某个类中的某些方法进行监听，代理模式在这里不多说，下面概括一下动态代理，以下概括完全是基于个人理解总结的：
动态代理：在不改变原有类实现的基础上，通过实现类的接口，对类实现的接口方法的调用进行监听，实现接口方法调用前后。0
动态代理实现方法:
- 定义被代理类的接口方法
- 创建被代理类并实现接口方法
- 创建代理类
- 添加代理
动态代理的实现
下面我们以对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接口的代理对象
以上就是动态代理的实现过程，很简单吧！！！
如果上述有错误请指出，共同学习，共同进步。
