package pattern.chp07.proxy;
 
/**
 *  类描述：代理对象
 * 
 *  @author:  Jing
 *  @version  $Id: Exp$ 
 *
 *  History:  Dec 24, 2014 3:54:04 PM   Jing   Created.
 *           
 */
public class BuyerProxy  implements ITV{
	
	private Buyer buyer;
	public void buyTV() {
		
		System.out.println("Proxy buy ...");
		buyer.buyTV();
	}
 
}

/**
 * 类描述：借阅实现类
 * 
 * @author: Jing
 * @version $Id: Exp$
 * 
 * History: Dec 25, 2014 9:41:09 AM Jing Created.
 * 
 */
public class Borrow implements IBorrow {
 
	private Book book;
 
	public Book getBook() {
		return book;
	}
 
	public void setBook(Book book) {
		this.book = book;
	}
 
	public boolean borrow() {
		
		//保存数据
		//some code 
		
		return true;
	}
 
}

/**
 *  类描述：Email信件 
 * 
 *  @author:  Jing
 *  @version  $Id: Exp$ 
 *
 *  History:  Dec 25, 2014 11:05:15 AM   Jing   Created.
 *           
 */
public class EmailFrom implements IRegister {
 
	public void regist(String msg) {
		
		System.out.println("From Email");
	}
 
}

invoke
 
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。

/**
 * 类描述：动态代理实例
 * 
 * @author: Jing
 * @version $Id: Exp$
 * 
 * History: Dec 25, 2014 3:25:08 PM Jing Created.
 * 
 */
public class ProxyStudy {
	@SuppressWarnings("unchecked")
	public static void main(String[] args) throws Exception {
 
		Class<?> clazz = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
		System.out.println("动态代理产生的类名为： " + clazz.getName());
 
		// 获取动态代理产生的类的构造方法
		Constructor<?>[] cons = clazz.getConstructors();
		for (Constructor<?> con : cons) {
 
			System.out.println("构造方法： " + con.getName() + "----对应参数: "
					+ Arrays.asList(con.getParameterTypes()));
		}
 
		// 获取动态类的普通方法
		Method[] methods = clazz.getDeclaredMethods();
		for (Method method : methods) {
 
			System.out.println("方法：" + method.getName() + "----对应参数: "
					+ Arrays.asList(method.getParameterTypes()));
		}
 
		// 构造方法需要InvocationHandler对象
		Constructor<?> constructor = clazz.getConstructor(InvocationHandler.class);
		Collection<Object> proxyBuildCollection = (Collection<Object>) constructor
				.newInstance(new InvocationHandler() {
					ArrayList<Object> target = new ArrayList<Object>();
 
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {
						System.out.println("执行方法 ： " + method.getName() + "前,参数为："
								+ args.toString());
						Object result = method.invoke(target, args);
						System.out.println("执行方法 ： " + method.getName() + "后。");
						return result;
					}
				});
		
		proxyBuildCollection.add("asd");
		proxyBuildCollection.add("asd");
		proxyBuildCollection.add("asd");
	}
}