代理模式（Proxy pattern）

代理模式（Proxy pattern）
核心作用：
通过代理，控制对对象的访问。
可以详细控制访问某个（某类）对象方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。（即：AOP的微观实现）
Aop（Aspect Oriented Programming面向切面编程）核心实现机制。
核心角色:
抽象角色：定义代理角色和真实角色的公共对外方法。
真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色的调用，关注真正的业务逻辑。
代理角色：实现抽象角色，定义真实角色代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。将统一的流程控制放到代理角色中处理。
应用场景：
     安全代理：屏蔽对真实角色的直接访问
     远程代理：通过代理类处理远程方法调用（RMI）
     延迟加载：先加载轻量级的代理对象，真正需要在加载真实对象。
分类：
     静态代理（静态定义代理类）
     动态代理（动态生成代理类）
         JDK自带的动态代理（要提供抽象角色（接口））
         Javassist字节码操作库实现
         CGLIB（不需要提供抽象角色（接口））
         ASM（底层使用指令，可维护性差）
 
静态代理
抽象角色                                                  真实角色

//核心方法接口 interface Car {    void make(); }

//实现核心方法的类 class Byd implements Car {    publicvoid make() {       System.out.println("Byd正在行驶....");    } }

 
代理角色                                                  代理角色

//记录日志类 class Log implements Car {      private Car car;      public Log() {}      public Log(Car car) {       this.car = car;    }    publicvoid make() {       System.out.println("日志记录开始.....");       car.make();       System.out.println("日志记录结束.....");    } }

//里程记算器类 class Computer implements Car {    private Car car;      public Computer() {}      public Computer(Car car) {       this.car = car;    }      publicvoid make() {       System.out.println("里程记算器开始记算....");       car.make();       System.out.println("里程记算器结束记算....");    } }

 

publicclass Main {    publicstaticvoid main(String[] args) {       Byd byd = new Byd();       Log log = new Log(byd);       Computer com = new Computer(log);       com.make();    } }

输出结果： 记算器开始记算.... 日志记录开始..... Byd正在行驶.... 日志记录结束..... 里程记算器结束记算....

 

publicclass Main {    publicstaticvoid main(String[] args) {       Byd byd = new Byd();       Computer com = new Computer(byd);       Log log = new Log(com);       log.make();    } }

输出结果： 日志记录开始..... 里程记算器开始记算.... Byd正在行驶.... 里程记算器结束记算.... 日志记录结束.....

 
JDK动态代理（需要提供一个抽象对象）
抽象对象

interface IpersonService {    publicvoid save(String name);    publicvoid update(String name, Integer personid);    public String getPersonName(Integer personid); }

 
真实对象

class PersonServieBean implements IpersonService {    private String user = null;    public PersonServieBean() {    }    public PersonServieBean(String user) {       this.user = user;    }    public String getUser() {       returnuser;    }    publicvoid save(String name) {       System.out.println("执行save()方法....");    }    publicvoid update(String name, Integer personid) {       System.out.println("执行update()方法....");    }    public String getPersonName(Integer personid) {       System.out.println("执行getPersonName()方法....");       return"xxx";    } }

 
代理对象

class JDKProxyFactory implements InvocationHandler {    private Object targetObject;    /*     * this.targetObject.getClass().getClassLoader():通过类加载器加载要被代理的类(真实角色)。     * this.targetObject.getClass().getInterfaces():(抽象角色) *this:回调方法     */    public Object createProxyInstance(Object targetObject) {       this.targetObject = targetObject;       return Proxy.newProxyInstance(this.targetObject.getClass()              .getClassLoader(),              this.targetObject.getClass().getInterfaces(), this);    }    /*     * 当客户端调用代理类中的方法时，调用操作会被this拦截到。然后执行invoke()方法     */    public Object invoke(Object proxy, Method method, Object[] args)           throws Throwable {       PersonServieBean bean = (PersonServieBean) this.targetObject;       Object result = null;       if (bean.getUser() != null) {           // 代理对象将客户端的调用委派给真实对象。           result = method.invoke(targetObject, args);       }       return result;    } }

 

publicstaticvoid main(String[] args) {       JDKProxyFactory jpf = new JDKProxyFactory();       IpersonService service = (IpersonService) jpf              .createProxyInstance(new PersonServieBean("xxx"));       service.save("888");    } 输出结果：执行save()方法....