java动态代理

[size=medium][color=red]定义接口类：[/color][/size]

public interface CommonInterface {
	public void add();
	public void update();
	public String get(String str);
}

[size=medium][color=red]
被代理对象（实现上面定义的接口）[/color][/size]

public class Target implements CommonInterface {
	public void add(){
		System.out.println("target add method");
		System.out.println("");
	}

	@Override
	public void update() {
		System.out.println("target update method");
		System.out.println("");
	}

	@Override
	public String get(String str) {
		return str;
	}
}

[size=medium][color=red]静态代理实现[/color][/size]

public class StaticProxy implements CommonInterface{
	private CommonInterface target;
	public StaticProxy(CommonInterface target){
		this.target = target;
	}
	@Override
	public void add() {
		log();
		target.add();
	}

	@Override
	public void update() {
		log();
		target.update();
	}

	@Override
	public String get(String str) {
		log();
		return target.get(str);
	}

	public void log(){
		System.out.println("proxy log");
	}

}

[size=medium][color=red]动态代理处理类[/color][/size]

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

public class MyHandler implements InvocationHandler {
	private CommonInterface target;
	public MyHandler(CommonInterface target){
			this.target = target;
	}
	/*
	 * invoke方法是InvocationHandler接口中的方法，第一个参数是被代理对象，
	 * 第二个参数是当前调用的方法，第三个参数是当前被调用方法的参数
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		log();
		System.out.println("调用的方法："+method.getName());
		if(args == null){
			System.out.println("无参方法");
		}else{
			System.out.println("传递的参数：");
			for(int i=0;i<args.length;i++){
				System.out.println("param"+i+":"+args[i]);
			}
		}
		Object obj =  method.invoke(target, args);
		return obj;
	}

	public void log(){
		System.out.println("dynamic proxy log");
	}

}

[color=red][size=medium]客户端分别通过静态和动态实现代理[/size][/color]

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

public class Client {
	public static void main(String[] args) {

		CommonInterface target = new Target();
		//静态代理
		CommonInterface staticProxy = new StaticProxy(target);
		staticProxy.add();
		staticProxy.update();
		System.out.println(staticProxy.get("staticProxy"));
		//动态代理	
		InvocationHandler handler = new MyHandler(target);
		/*
		 * 创建代理类，代理类会实现目标对象的接口，因此，如果想调用目标对象的某个方法，可以直接调用代理类的相应接口方法，
		 * 所以目标对象实现某个接口是必须的。当上溯造型代理类到接口，调用接口中的相应方法，代理类会调用目标对象的Handler的invoke方法，
		 * 通过反射把调用的相应的方法和参数传递到Handler中，handler的invoke方法调用
		 */
		CommonInterface dynaProxy = (CommonInterface) Proxy.
								newProxyInstance(target.getClass().getClassLoader(), //第一个参数目标对象的类加载器的class文件
				                                  target.getClass().getInterfaces(),//第二个参数目标对象实现的接口的class文件
				                                   handler);//第三参数实现InvocationHandler接口的目标对象的Handler
		dynaProxy.add();
		dynaProxy.update();
		System.out.println(dynaProxy.get("dynaProxy"));//打印返回结果
	}
}

输出结果：
proxy log
target add method

proxy log
target update method

proxy log
staticProxy
dynamic proxy log
调用的方法：add
无参方法
target add method

dynamic proxy log
调用的方法：update
无参方法
target update method

dynamic proxy log
调用的方法：get
传递的参数：
param0:dynaProxy
dynaProxy