代理设计模式之(静态代理+Java自身提供的动态代理机制)

参考：http://blog.youkuaiyun.com/hivon/article/details/576691

静态代理和动态代理的概念：

由程序员创建或由特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。动态代理类：在程序运行时，运用反射机制动态创建而成。

1.代理模式使用的原因：当类违反单一职责原则时，就要去考虑是否采用代理模式实现。

public class ViewAction {
 	/*
 	 * 设计缺陷：
 	 * 		一个类中有两个功能1.验证激活 2.执行具体操作
 	 * 违反：单一职责原则
 	 * 因此：引入代理机制
 	 * 
 	 */
 	public void doAction(User user){
 		//假如用户被激活，则做view操作
 		if(user.isActive()){
 			System.out.println("do the viewAction!");
 		}
 	}
 }

2.引入代理模式(静态代理)：解决类违反单一职责原则，使类专注于自己的核心操作

public class AddAction {
 	public void doAction(User user) {
 		//添加操作
 		System.out.println("add..");
 	}
 }

public class ProxyAddAction extends AddAction {
 	AddAction action = new AddAction();
 	@Override
 	public void doAction(User user) {
 		if (user.isActive()) {
 			// 代理执行
 			action.doAction(user);
 		}
 	}
 }

3.代理模式的优化(静态代理)：虽然每一个动作都不相同，但是我们仍可以抽象出一个动作接口。利于系统的扩展。

public interface IAction {
 	public void doAction(User user);
 }

public class AddAction implements IAction {
 	@Override
 	public void doAction(User user) {
 		//添加操作
 		System.out.println("add..");
 	}
 }

public class ProxyAction implements IAction {
 	private IAction action;
 	public ProxyAction(IAction action) {
 		this.action = action;
 	}
 	@Override
 	public void doAction(User user) {
 		if (user.isActive()) {
 			// 代理执行，本质上还是有实现类进行执行
 			action.doAction(user);
 		}
 	}
 }

4.动态代理引入的原因：

	不仔细深入会觉得与3区别不大，但是确实代理类的编写上灵活很多，因为很多时候系统并非能抽象出统一的接口类，即使能抽象出来也是不符合面向对象的。这时候就可能需要编写不同的代理类。而使用Java API提供的反射机制：正是这种反射机制的使用使得我们调用核心功能更加灵活，而不用依赖于某一个具体的接口，而是依赖于Object对象。

ps：IAction和AddAction的编写与3种一致，不再重复

public class ProxyAction implements InvocationHandler {
 	private Object action;
 	public ProxyAction(Object action) {
 		this.action = action;
 	}
 	/*
 	 * 得到代理类的实例
 	 */
 	public static Object getInstance(Object action) {
 		return Proxy.newProxyInstance(action.getClass().getClassLoader(),
 				action.getClass().getInterfaces(), new ProxyAction(action));
 	}
 	@Override
 	public Object invoke(Object proxy, Method method, Object[] args)
 			throws Throwable {
 		Object result=null;
 		try {
 			// 在委派之前作动作，如权限判断等
 			System.out.println("before method " + method.getName());
 			//验证是否被激活
 			if (((User) args[0]).isActive()) {
 				// 进行委派
 				result = method.invoke(action, args);
 			}
 		} catch (InvocationTargetException e) {
 			throw e.getTargetException();
 		} catch (Exception e) {
 			throw new RuntimeException("unexpected invocation exception: "
 					+ e.getMessage());
 		} finally {
 			// 在委派之后做动作
 			System.out.println("after method " + method.getName());
 		}
 		return result;
 	}
 }

5.动态代理的优化：

	模板方法模式来对这个代理类进行优化 ：BaseProxy类

ps：IAction和AddAction的编写与3种一致，不再重复

public abstract class BaseProxy implements InvocationHandler {
 	private Object obj;
 	protected BaseProxy(Object obj) {
 		this.obj = obj;
 	}
 	public static Object getInstance(Object obj, InvocationHandler instance) {
 		return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
 				.getClass().getInterfaces(), instance);
 	}
 	@Override
 	public Object invoke(Object proxy, Method m, Object[] args)
 			throws Throwable {
 		Object result=null;
 		try {
 			this.doBegin();// 代理执行前操作
 			System.out.println("before method " + m.getName());
 			//验证是否被激活
 			if (((User) args[0]).isActive()) {
 				// 进行委派
 				result = m.invoke(obj, args);
 			}
 		} catch (InvocationTargetException e) {
 			throw e.getTargetException();
 		} catch (Exception e) {
 			throw new RuntimeException("unexpected invocation exception: "
 					+ e.getMessage());
 		} finally {
 			System.out.println("after method " + m.getName());
 			this.doAfter();// 代理执行后操作
 		}
 		return result;
 	}
 	public abstract void doBegin();
 	public abstract void doAfter();
 }

public class ProxyImpl extends BaseProxy {
 	protected ProxyImpl(Object obj) {
 		super(obj);
 	}
 	public static Object getInstance(Object foo) {
 		return getInstance(foo, new ProxyImpl(foo));
 	}
 	@Override
 	public void doBegin() {
 		System.out.println("do the job before..");
 		
 	}
 	@Override
 	public void doAfter() {
 		System.out.println("do the job after..");
 	}
 	@Override
 	public Object invoke(Object proxy, Method m, Object[] args)
 			throws Throwable {
 		return super.invoke(proxy, m, args);
 	}
 }

总结：

1.何时代理？

2.代理本身并没有实际操作