JDK动态代理

JDK动态代理主要用到了Proxy类和InvocationHandler接口，两者都在java.lang.reflect包下。

首先介绍一下Proxy类，这个类是所有动态代理类的父类，主要用到这个类的两个静态方法：

public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces)

      这个方法用于生成动态代理类所对应的Class对象。需要传入两个参数，第一个参数是被代理类对应的类加载器对象(Class对象的getClassLoader()方法可以得到类加载器对象)，第二个参数是被代理类实现的一系列接口对应的Class对象(组装成数组类型也不会错)。

      得到动态代理类对应的Class对象后，还要费一番周折才能得到动态代理类对象(好大一番周折，至今还没跑通)。为此，Proxy还提供了另外一个方法，封装了以上过程，直接生成一个动态代理对象。

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

      这个方法可直接生成一个动态代理类对象，方法需要传三个参数，第一个参数是被代理类对应的类加载器对象，第二个参数是被代理类实现的一系列接口对应的Class对象组成的数组一个数组，第三个参数是一个InvocationHandler对象(一个InvocationHandler实现类对象)。

InvocationHander接口就只有一个方法:

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

我们得自定义一个InvocationHander接口实现类，重写invoke()方法。上面newProxyInstance方法第三个参数传的就是自定义的InvocationHander接口实现类的一个实例。

以下是JDK动态代理使用代码示例：

//第一个接口
interface Subject {
	public void doSomething(String str);
}

// 第二个接口
interface Subject2 {
	public void doSomething(int a);
}

// 接口实现类
class RealSubject implements Subject, Subject2 {
	public void doSomething(String str) {
		System.out.println("Subject接口实现类RealSubject实现doSomething方法()");
	}

	public void doSomething(int a) {
		System.out.println("Subject2接口实现类RealSubject实现doSomething方法()");
	}
}

// InvocationHandler接口实现类
class IncovationHandlerImpl implements InvocationHandler {
	private Object proxied;

	// 构造器参数是一个类的实例
	public IncovationHandlerImpl(Object proxied) {
		this.proxied = proxied;
	}

	public IncovationHandlerImpl() {
	}

	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		before();
		method.invoke(proxied, args);
		after();
		return null;
	}

	private void before() {
		System.out.println("Before处理");
	}

	private void after() {
		System.out.println("After处理");
	}
}

public class JdkDynamicProxyTest {
	public static void main(String args[]) {
		Object obj = Proxy.newProxyInstance(RealSubject.class.getClassLoader(), RealSubject.class.getInterfaces(),
				new IncovationHandlerImpl(new RealSubject()));
		Class<?> clazz = obj.getClass();
		System.out.println(clazz.getName());
		// 打印出$Proxy0
		int modifier = clazz.getModifiers();
		System.out.println(Modifier.toString(modifier));
		// 打印出public final
		Class<?> superClazz = clazz.getSuperclass();
		System.out.println(superClazz.getName());
		// 打印出java.lang.reflect.Proxy
		Class[] interfaces = clazz.getInterfaces();
		System.out.println(Arrays.asList(interfaces));
		// 打印出[interface Subject, Subject2]

		Subject subject = (Subject) obj;
		subject.doSomething("kou");

		Subject2 subject2 = (Subject2) obj;
		subject2.doSomething(23);
	}
}

       上例中，有一个RealSubject类，实现了两个接口Subject和Subject2。声明了InvocationHander接口的一个实现类InvocationHanderImpl，这个实现类重写了invoke方法，在方法体中调用第二个参数method的invoke方法，method的invoke方法需要两个参数，第一个参数是被代理类的实例，第二个参数是参数列表，是invoke方法的第三个参数。这里被代理类的实例不建议直接new出来一个实例然后传进去，而是建议在创建InvocationHanderImpl实例时把被代理类实例传进来。如上例中，声明一个成员变量，并声明此成员变量对应的构造器，这样在创建InvocationHandlerImpl实例时用此带参构造器就可以把被代理类实例当做参数传进去，从而让method的invoke方法使用了。

        从上面的打印结果可知：动态代理类是public、finalt的；动态代理类的名字以"$Proxy"开头，父类是Java.lang.Proxy类；动态代理类实现了getProxyClass()或者newProxyInstance()方法中参数interfaces数组中的所有接口。

        编译上Proxy.newProxyInstance()的返回值类型是Object，但其实运行时类型是动态代理类的类型($Proxy开头的类)，又因为实现了代理类所实现的全部接口，所以可以强转为任意一个所实现的接口类型。这个时候调用该接口的方法，底层就会执行接口实现类对应的实现。

        这就是JDK动态代理了，JDK动态代理是建立在接口之上的，Proxy类的两个方法的第二个参数都是多个接口对应的Class对象组成的数组，而不是被代理类的Class对象。那么，如果被代理类没有实现任何接口，这就尴尬了，就不能用JDK动态代理了，这就要用到下一篇介绍的cglib动态代理了。