Java动态代理

    动态代理作为javaSE中相对比较高级的技术,它可以增强java类中的方法,和其他两种增强的方式相比较动态代理更灵活限制条件相对较少;它结合反射可以写出很多通用性很高的工具类.Spring的面向切面编程(AOP)的底层就有使用到jdk的动态代理.所以动态代理相对比较重要.
    动态代理的条件是被代理的类需要实现接口.在动态代理中有两个很重要的类(接口),Proxy(类),InvocationHandler(接口).我们来看一下java的API文档是怎样描述他们的.
Proxy
    
这个类中用得最多的方法就是newProxyInstance方法:

static Object  newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 
          返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。

这是个静态方法,返回一个动态代理对象,该方法有三个参数:
    loader 是一个类加载器对象(这里的类加载器对象只要是自己定义的类就可以)
    interfaces 代理类要实现的接口列表

    h    一个InvocationHandler实现类的对象,表示的是动态代理对象在调用方法时,会关联到哪一个InvocationHandler子类对象

InvocationHandler

    是代理实例的 调用处理程序 实现的接口。这个接口只有一个 invoke方法,每个代理实例都具有一个关联的调用处理程序。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法

这个方法也有三个参数:
    proxy     由上面的 newProxyInstance方法返回的动态代理对象
    method    代表的是 proxy正在调用的被代理对象的方法
    args    代表的是 proxy正在调用的被代理的方法的参数列表
简单的介绍先到这里,下面我们用实际的代码来演示一下:

首先定义一个接口:

/**
 * 定义一个接口
 * @author Administrator
 */

public interface Person {
	void speakName(String name);
}

再定义一个需要被代理的类实现该接口:

/**
 * 定义一个需要被代理的类
 * @author Administrator
 */

public class People implements Person {

	@Override
	public void speakName(String name) {
		System.out.println("我叫" + name);
	}

}

定义一个代理工厂类,用来生成代理对象:

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

import org.junit.Test;
/**
 * 写一个代理工厂类
 * @author Administrator
 */
public class ProxyFactory implements InvocationHandler{
	
	private Object obj;

	public ProxyFactory(Object obj) {
		this.obj = obj;
	}
	@Test
	public Object creatProxy() {
		//第一个参数:第三方类加载器
		ClassLoader loader = obj.getClass().getClassLoader();
		//第二个参数:被代理的类所实现的接口列表
		Class[] interfaces = obj.getClass().getInterfaces();
		//第三个参数:由于代理类(ProxyFactory)实现了InvocationHandler接口,所以此类的对象就可以了
		//代理对象在调用方法的时候关联的就是this对象,调用方法的时候,其实就是执行this的invoke方法
		/**
		 * 返回的proxyPeople就是代理对象
		 */
		return Proxy.newProxyInstance(loader, interfaces, this);
		
	}
	
	/**
	 * 此方法就是代理对象调用方法时实际执行的方法
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println(method);
		System.out.println(args);
		System.out.print("你好,");
		method.invoke(obj, args);
		return null;
	}

}

最后测试定义的代理工厂:

import org.junit.Test;

public class ProxyDemo {
	
	@Test
	public void test() {
		//定义People类的实例
		People people = new People();
		//定义代理工厂ProxyFactory类的实例(要有People类对象的引用)
		ProxyFactory proxyFactory = new ProxyFactory(people);
		//创建代理对象 proxyPeople
		Person proxyPeople = (Person) proxyFactory.creatProxy();
		//使用代理对象调用方法
		proxyPeople.speakName("张三");
	}
}

运行测试类控制台的效果是:

public abstract void ProxyDemo.Person.speakName(java.lang.String)
[Ljava.lang.Object;@45283ce2
你好,我叫张三

到此代码演示就结束了,下面进行简单的说明一下:
1.从控制台打印的数据我们可以看到,通过代理对象调用speakName方法,实际上是调用了代理工厂的invoke方法,
2.在代理工厂的invoke方法中,通过反射的方式调用了people对象的speakName方法;
3.invoke方法中的method参数实际上就是Person接口的speakName方法(实际调用的是子类People类中对应的方法);
4.invoke的args参数就是代理对象proxyPeople对象调用方法传递的参数;
5.代理工厂可以对方法进行增强.