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

由程序员创建或由特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.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.代理本身并没有实际操作