java动态代理

package com.test.dynamicProxy;
/**
 * 真实对象和代理对象的共同接口
 * 
 * @author Administrator
 * 
 */
public interface SellInterface {
	
	void sell();
	
}

package com.test.dynamicProxy;
/**
 * 真实对象
 * 
 * @author Administrator
 * 
 */
public class SellFacotory implements SellInterface {
	@Override
	public void sell() {
		System.out.println("卖出什么东西........");
	}
}

package com.test.dynamicProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 * 
 * 代理对象
 * 
 * @author Administrator
 * 
 */
public class ProxyObject implements InvocationHandler {
	// 真实对象
	private Object obj;
	public ProxyObject(Object obj) {
		super();
		this.obj = obj;
	}
	/**
	 * 返回代理对象
	 * 
	 * @param obj
	 *            真实对象
	 * @return 代理对象
	 */
	public static Object proxy(Object obj) {
		Class cls = obj.getClass();
		return Proxy.newProxyInstance(cls.getClassLoader(),
				cls.getInterfaces(), new ProxyObject(obj));
	}
	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object,
	 * java.lang.reflect.Method, java.lang.Object[]) 在代理实例上处理方法调用并返回结果。
	 * 在与方法关联的代理实例上调用方法时，将在调用处理程序上调用此方法。
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object res = null;
		System.out.println("调用方法之前..............");
		// TODO 做一些事
		res = method.invoke(obj, args);
		System.out.println("调用方法之后..............");
		// TODO 做一些事
		return res;
	}
}

invoke(InvocationHandler接口中只有此方法)

Object invoke(Object proxy,

Method method,

Object[] args)

throws Throwable在代理实例上处理方法调用并返回结果。在与方法关联的代理实例上调用方法时，将在调用处理程序上调用此方法。

参数：

proxy - 在其上调用方法的代理实例

method - 对应于在代理实例上调用的接口方法的 Method 实例。Method 对象的声明类将是在其中声明方法的接口，该接口可以是代理类赖以继承方法的代理接口的超接口。

args - 包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null。基本类型的参数被包装在适当基本包装器类（如 java.lang.Integer 或 java.lang.Boolean）的实例中。

返回：

从代理实例的方法调用返回的值。如果接口方法的声明返回类型是基本类型，则此方法返回的值一定是相应基本包装对象类的实例；否则，它一定是可分配到声明返回类型的类型。如果此方法返回的值为 null 并且接口方法的返回类型是基本类型，则代理实例上的方法调用将抛出 NullPointerException。否则，如果此方法返回的值与上述接口方法的声明返回类型不兼容，则代理实例上的方法调用将抛出 ClassCastException。

抛出：

Throwable - 从代理实例上的方法调用抛出的异常。该异常的类型必须可以分配到在接口方法的 throws 子句中声明的任一异常类型或未经检查的异常类型 java.lang.RuntimeException 或 java.lang.Error。如果此方法抛出经过检查的异常，该异常不可分配到在接口方法的 throws 子句中声明的任一异常类型，代理实例的方法调用将抛出包含此方法曾抛出的异常的 UndeclaredThrowableException。

newProxyInstance

public static Object newProxyInstance(ClassLoader loader,

Class<?>[] interfaces,

InvocationHandler h)

throws IllegalArgumentException

返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。此方法相当于：

Proxy.getProxyClass(loader, interfaces).

getConstructor(new Class[] { InvocationHandler.class }).

newInstance(new Object[] { handler });

Proxy.newProxyInstance 抛出 IllegalArgumentException，原因与 Proxy.getProxyClass 相同。

参数：

loader - 定义代理类的类加载器

interfaces - 代理类要实现的接口列表

h - 指派方法调用的调用处理程序 (InvocationHandler)

返回：

一个带有代理类的指定调用处理程序的代理实例，它由指定的类加载器定义，并实现指定的接口

抛出：

IllegalArgumentException - 如果违反传递到 getProxyClass 的参数上的任何限制

NullPointerException - 如果 interfaces 数组参数或其任何元素为 null，或如果调用处理程序 h 为 null

package com.test.dynamicProxy;
//测试
public class Test {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		SellInterface si = (SellInterface) ProxyObject
				.proxy(new SellFacotory());
		si.sell();
	}
}