Java动态代理（二）——jdk动态代理

一、什么是动态代理？
代理类在程序运行时创建的代理方式被成为动态代理。动态代理的代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。

Java动态代理有两种：jdk动态代理和Cglib动态代理

二、JDK动态代理
在java的动态代理机制中，有两个重要的类或接口，一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class)，这一个类和接口是实现动态代理所必须用到的东西。

1.InvocationHandler:
每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。我们来看看InvocationHandler这个接口唯一的一个方法 invoke 方法：

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

其接受三个参数，那么这三个参数分别代表什么呢？

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

2.Proxy：
Proxy这个类的作用就是用来动态创建一个代理对象的类，它提供了许多的方法，但是我们用的最多的就是 newProxyInstance 这个方法：

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

其接收三个参数，我们来看看这三个参数所代表的含义：

• loader:　　一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
• interfaces: 一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
• h:　　一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上。

3.用上一篇的Person例子来进一步运用
（1）定义一个IPerson接口

public interface IPerson {
public String getName();

public Integer getAge();
}

（2）定义一个真实的对象类来实现这个接口　

public class PersonImp implements IPerson {
private String name;
private Integer age;

public PersonImp() {
super();
}

public PersonImp(String name, Integer age) {
super();
this.name = name;
this.age = age;
}

@Override
public String getName() {
// TODO Auto-generated method stub
return name;
}

@Override
public Integer getAge() {
// TODO Auto-generated method stub
return age;
}
}

（3）定义一个动态代理类，实现InvocationHandler接口

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

public class MyInvocationHandler implements InvocationHandler {
private Object target;

public MyInvocationHandler() {
super();
}

public MyInvocationHandler(Object target) {
super();
this.target = target;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if ("getName".equals(method.getName())) {
System.out.println("**********before*********");
System.out.println("method:" + method);
Object res = method.invoke(target, args);
System.out.println("***********after*********");
return res;
} else {
Object res = method.invoke(target, args);
return res;
}
}
}

（4）测试一下

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

public class PersonProxyTest {
public static void main(String[] args) {
IPerson person = new PersonImp("jack", 20);//我们要代理的真实对象（被代理对象）
InvocationHandler handler = new MyInvocationHandler(person);//代理对象，代理哪个对象，就把哪个对象传进去

IPerson personProxy = (IPerson) Proxy.newProxyInstance(person.getClass().getClassLoader(),
person.getClass().getInterfaces(), handler);
System.out.println(personProxy.getClass().getName());
System.out.println(personProxy.getName());
System.out.println(personProxy.getAge());
}
}

（5）看一下输出结果：

我们看看 com.sun.proxy.$Proxy0 这个东西，这个东西是由 System.out.println(personProxy.getClass().getName()); 这条语句打印出来的，那么为什么我们返回的这个代理对象的类名是这样的呢？
原因是：通过 Proxy.newProxyInstance 创建的代理对象是在jvm运行时动态生成的一个对象，它并不是我们的InvocationHandler类型，也不是我们定义的那组接口的类型，而是在运行是动态生成的一个对象，并且命名方式都是这样的形式，以$开头，proxy为中，最后一个数字表示对象的标号。