JAVA的23种设计模式---代理模式（二）

概要：

该文章参考了《设计模式之禅》一书及一些前辈的博客文章

1.该文章阐述了代理模式的基础原理及示例代码；
2.该文章适合初学设计模式的技术人员研习；
3.该文章有许多不足之处，请各位大咖指正，喷子绕道；
4.该文章是《JAVA的23种设计模式—代理模式（一）》的续写，点此跳转到第一部分

正文：

4.代理模式的多接口实现示例代码：

package com.csdn;/** * 代理扩展方法接口 * @author Administrator * */public interface IProxy {    //代管店铺收取费用方法    public void pay();  }

package com.csdn;/** * 抽象开店 * @author Administrator * */public interface Shop {    //开门营业    public void openTheDoor();    //卖东西    public void sell();    //关门打烊    public void closeTheDoor();}

package com.csdn;/** * 具体的一家店 * @author Administrator * */public class Boss implements Shop {    //店主名字    private String name = "";    //构造器限制谁能创建对象，并同时传递店主名    public Boss(Shop shop,String _name)throws Exception {        if(shop == null){            throw new Exception("不能创建一个店铺");        }else{            this.name = _name;        }    }    //店门打开方法    @Override    public void openTheDoor() {        System.out.println(this.name+"的店门打开了..");    }    //营业、卖东西方法    @Override    public void sell() {        System.out.println(this.name+"的店开始出售东西..");    }    //关门打烊方法    @Override    public void closeTheDoor() {        System.out.println(this.name+"的店门关上了..");    }}

package com.csdn;/** * 代理开店服务 * @author Administrator * */public class BossProxy implements Shop,IProxy{    private Shop boss = null;    //通过构造函数来传递对谁的店进行代理    public BossProxy(String _boss){        try {            boss = new Boss(this, _boss);        } catch (Exception e) {            // TODO: handle exception        }    }    //代理打开店门方法    @Override    public void openTheDoor() {        this.boss.openTheDoor();    }    //代理营业、卖东西方法    @Override    public void sell() {        this.boss.sell();    }    //代理关门打烊方法    @Override    public void closeTheDoor() {        this.boss.closeTheDoor();        this.pay();    }    @Override    public void pay() {        System.out.println("代理收取代管费100元..");    }}

package com.csdn;/** * 模拟代理经营店铺 * @author Administrator * */public class Business {    public static void main(String[] args) {                //“小明”的店铺需要代理服务        Shop proxy = new BossProxy("小明");        //代理打开小明的店门        proxy.openTheDoor();        //代理帮小明卖东西        proxy.sell();        //代理关上小明的店门并向小明收取了管理费        proxy.closeTheDoor();           }}

输出：

小明的店门打开了..小明的店开始出售东西..小明的店门关上了..代理收取代管费100元..

注：
a：该示例与之前相比增加了IProxy接口，增加了pay方法以及其实现，并在closeTheDoor方法中调用了它的实现方法
b：代理的职责并不单一，可以组合其他的真实角色，也可以实现自己的职责，它可以为真实角色预处理消息、过滤消息、消息转发、事后处理消息等功能。

5.通用代理模式模板代码实现：

package com.csdn;/** * 抽象类，可以是抽象类也可以是接口，是一个最普通的业务类型定义，无特殊要求 * @author Administrator * */public interface Subject {      //定义一个方法      public void request();  } 

package com.csdn;/** * 具体类，也叫被委托的角色、被代理的角色，它才是最重要的，是业务逻辑的具体执行者。  * @author Administrator * */ public class RealSubject implements Subject {      @Override      public void request() {          //业务逻辑处理      }  } 

package com.csdn;/** * 代理类 * @author Administrator * */ public class Proxy implements Subject {      //要代理哪个实现类      private Subject subject = null;      //默认被代理者      public Proxy() {          this.subject = new Proxy();      }      //通过构造方法传递代理者      public Proxy(Object...objects) {      }      //实现接口中的方法      @Overrdie      public void request() {          this.before();          this.subject.request();          this.after();      }           //预处理      private void before() {          //do something      }           //善后处理      private void after() {          //do something      }  } 

5.虚拟代理模式代码实现：

package com.csdn;/** * 虚拟代理类 * @author Administrator * */ public class Proxy implements Subject {      //要代理哪个实现类      private Subject subject;       //实现接口中的方法      @Overrdie      public void request() {          if(subject == null){            subject = new RealSubject();        }        subject.request();    }        } 

注：在需要的时候才初始化主题对象，可以避免被代理对象较多而引起的初始化缓慢问题

6.动态代理模式代码实现示例代码：

package com.csdn;/** * 抽象开店 * @author Administrator * */public interface Shop {    //开门营业    public void openTheDoor();    //卖东西    public void sell();    //关门打烊    public void closeTheDoor();}

package com.csdn;/** * 具体的一家店 * @author Administrator * */public class Boss implements Shop {    //店主名字    private String name = "";    //带参构造器    public Boss(String _name) {        this.name = _name;    }    //店门打开方法    @Override    public void openTheDoor() {        System.out.println(this.name+"的店门打开了..");    }    //营业、卖东西方法    @Override    public void sell() {        System.out.println(this.name+"的店开始出售东西..");    }    //关门打烊方法    @Override    public void closeTheDoor() {        System.out.println(this.name+"的店门关上了..");    }}

package com.csdn;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;/** * 动态代理类 * @author Administrator * */public class DynamicAgent implements InvocationHandler{    //被代理者    Class clazz = null;    //被代理的实例    Object obj = null;    //要代理谁    public DynamicAgent(Object _obj){        this.obj = _obj;    }    //调用被代理的方法    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        Object result = method.invoke(this.obj, args);        //此处可以加入面向切面的功能，AOP（面向切面的编程）的提现处        //如在门被打开时的提醒功能        if(method.getName().equalsIgnoreCase("openTheDoor")){            System.out.println("(有人正在打开店门！)");        }               return result;    }}

package com.csdn;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Proxy;/** * 模拟动态代理经营店铺 * @author Administrator * */public class Business {    public static void main(String[] args) {        //初始化“小明”的店铺        Boss boss = new Boss("小明");        //“小明”的店铺需要动态代理服务        InvocationHandler handler = new DynamicAgent(boss);        //获得类的类加载器        ClassLoader cl = boss.getClass().getClassLoader();        //动态产生一个代理者        Shop proxy = (Shop)Proxy.newProxyInstance(cl,new Class[]{Shop.class}, handler);        //代理打开小明的店门        proxy.openTheDoor();        //代理帮小明卖东西        proxy.sell();        //代理关上小明的店门        proxy.closeTheDoor();    }}

输出：

小明的店门打开了..(有人正在打开店门！)小明的店开始出售东西..小明的店门关上了..

注：
a：invoke方法是InvocationHandler定义必须实现的，他完成对真实方法的调用，所有被代理的方法都由InvocationHandler接管实际的处理任务
b：对于日志、事物、权限等都可以在系统设计阶段不用去考虑，而在设计后通过AOP（面向切面的编程）的方式切过去

7.通用动态代理模式模板代码：

package com.csdn;/** * 抽象类 * @author Administrator * */public interface Subject {      //业务操作     public void doSomething(String str);  } 

package com.csdn;/** * 具体类 * @author Administrator * */ public class RealSubject implements Subject {      //业务操作    @Override      public void doSomething(String str){        System.out.println("do something----->" + str);    };   } 

package com.csdn;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;/** * 动态代理的Handler类 * @author Administrator * */public class MyInvocationHandler implements InvocationHandler {    //被代理的对象    private Object target = null;    //通过构造函数传递一个对象    public MyInvocationHandler(Object _obj){        this.target = _obj;    }    //代理方法    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        //执行被代理的方法        return method.invoke(this.target, args);    }}

package com.csdn;import java.lang.reflect.InvocationHandler;/** * 动态代理类 * @author Administrator * * @param <T> */public class DynamicProxy<T> {    public static <T> T newProxyInstance(ClassLoader loader,Class<?>[]interfaces,InvocationHandler h){        //寻找JoinPoint连接点，AOP框架使用元数据定义        if(true){            //执行一个前置通知            (new BeforeAdvice()).exec();        }        //执行目标并返回结果        return (T)Proxy.newProxyInstance(loader, interfaces, h);            }}

package com.csdn;/** * 通知接口 * @author Administrator * */public interface IAdvice {    //通知的方法    public void exec();}

package com.csdn;/** * 通知实现类 * @author Administrator * */public class BeforeAdvice implements IAdvice {    @Override    public void exec() {        System.out.println("前置通知");    }}

package com.csdn;import java.lang.reflect.InvocationHandler;/** * 动态代理场景类 * @author Administrator * */public class Client {    public static void main(String[] args) {        //定义一个主题        Subject subject = new RealSubject();        //定义一个Handler        InvocationHandler handler = new MyInvocationHandler(subject);        //定义主题的代理        Subject proxy = DynamicProxy.newProxyInstance(subject.getClass().getClassLoader(), subject.getClass().getInterfaces(), handler);        //代理的行为        proxy.doSomething("Finish");    }}

输出：

前置通知do something----->Finish

注：
a：在动态代理类中newProxyInstance方法有三个参数，其中c.getInterfaces查找该类的所有接口，然后实现接口的所有方法，由new MyInvocationHandler(subject)这个对象接管

扩展：

package com.csdn;import java.lang.reflect.InvocationHandler;/** * 具体业务的动态代理 * @author Administrator * */public class SubjectDynamicProxy extends DynamicProxy{    public static <T> T newProxyInstance(Subject subject){        //获得类加载器        ClassLoader loader = subject.getClass().getClassLoader();        //获得接口数据        Class<?>[] classes = subject.getClass().getInterfaces();        //获得Handler        InvocationHandler handler = new MyInvocationHandler(subject);        return newProxyInstance(loader, classes, handler);    }}

package com.csdn;/** * 动态代理场景类 * @author Administrator * */public class Client {    public static void main(String[] args) {        //定义一个主题        Subject subject = new RealSubject();        //定义主题的代理        Subject proxy = SubjectDynamicProxy.newProxyInstance(subject);        //代理的行为        proxy.doSomething("Finish");    }}

注：
a：动态代理的主要意图就是横切面编程，在不改变我们已有的代码结构的情况下增强或控制对象的行为