JavaEE互联网轻量级框架整合开发（书籍）阅读笔记（5）：责任链模式、观察者模式...

末蓝、 2021-12-19 04:59 155阅读 0赞

**一、责任链模式、观察者模式**

**　　1、责任链模式：**当一个对象在一条链上被多个拦截器处理（烂机器也可以选择不拦截处理它）时，我们把这样的设计模式称为责任链模式，它用于一个对象在多个角色中传递的场景。

**2、观察者模式：**观察者模式又称为发布电话与模式，是对象的行为模式。观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监视着被观察者的状态，当被观察者的状态变化时，会通知观察者，并让其自动更新自己。

**二、责任链模式（例子）**

创建测试接口：HelloWorld.java

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 package com.xfwl.proxy.jdk;
    2 
    3 public interface HelloWorld {
    4     public void  sayHelloWorld();
    5 }

创建测试接口的实现子类：HelloWorldImpl.java

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1 package com.xfwl.proxy.jdk;
    2 
    3 public class HelloWorldImpl implements HelloWorld {
    4 
    5     public void sayHelloWorld() {
    6         System.out.println("Hello World!");
    7     }
    8 }

创建代理类：JdkProxyExample.java

1 package com.xfwl.proxy.jdk;
     2 
     3 import java.lang.reflect.InvocationHandler;
     4 import java.lang.reflect.Method;
     5 import java.lang.reflect.Proxy;
     6 /**
     7  * JDK的动态代理
     8  * @function  两个步骤：（1）建立代理对象和真实服务对象的关系。（2）实现代理逻辑。
     9  * @author 小风微凉
    10  * @time  2018-7-9 上午10:45:53
    11  */
    12 public class JdkProxyExample implements InvocationHandler {
    13     //真实对象
    14     private Object target=null;
    15     /**
    16      * 建立代理对象和真实对象之间的代理关系，并返回代理对象
    17      * @param target 真实对象
    18      * @return 代理对象
    19      */
    20     public Object bind(Object target){
    21         this.target=target;
    22         return Proxy.newProxyInstance(
    23                     target.getClass().getClassLoader(), //类加载器
    24                     target.getClass().getInterfaces(),    //动态代理所挂的接口
    25                     this                                //实现方法逻辑的代理类，必须实现InvocationHandler接口的invoke方法
    26                 );
    27     }
    28     /**
    29      * 代理方法逻辑
    30      * @param proxy 代理对象
    31      * @param method 当前调度方法
    32      * @param args 当前方法参数
    33      * @return 代理结果返回
    34      * @throws Throwable 异常
    35      */
    36     public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
    37         System.out.println("进入代理方法");
    38         System.out.println("在调度真实方法之前的服务");
    39         Object obj=method.invoke(this.target, args);//相当于调用sayHelloWorld方法
    40         System.out.println("在调度真实方法之后的服务");        
    41         return obj;
    42     }
    43 }

创建责任链拦截器-1

1 package com.xfwl.designmodels.responseChain;
     2 
     3 import java.lang.reflect.Method;
     4 
     5 import com.xfwl.interceptor.Interceptor;
     6 /**
     7  * 拦截逻辑1
     8  * @function  
     9  * @author 小风微凉
    10  * @time  2018-7-9 下午4:03:37
    11  */
    12 public class Interceptor1 implements Interceptor {
    13 
    14     @Override
    15     public boolean before(Object proxy, Object target, Method method,
    16             Object[] args) {
    17         System.out.println("【拦截器1】的before方法");
    18         return true;
    19     }
    20 
    21     @Override
    22     public void around(Object proxy, Object target, Method method, Object[] args) {
    23         // TODO Auto-generated method stub
    24 
    25     }
    26 
    27     @Override
    28     public void after(Object proxy, Object target, Method method, Object[] args) {
    29         System.out.println("【拦截器1】的after方法");
    30     }
    31 }

创建责任链拦截器-2

1 package com.xfwl.designmodels.responseChain;
     2 
     3 import java.lang.reflect.Method;
     4 
     5 import com.xfwl.interceptor.Interceptor;
     6 /**
     7  * 拦截逻辑2
     8  * @function  
     9  * @author 小风微凉
    10  * @time  2018-7-9 下午4:03:37
    11  */
    12 public class Interceptor2 implements Interceptor {
    13 
    14     @Override
    15     public boolean before(Object proxy, Object target, Method method,
    16             Object[] args) {
    17         System.out.println("【拦截器2】的before方法");
    18         return true;
    19     }
    20 
    21     @Override
    22     public void around(Object proxy, Object target, Method method, Object[] args) {
    23         // TODO Auto-generated method stub
    24 
    25     }
    26 
    27     @Override
    28     public void after(Object proxy, Object target, Method method, Object[] args) {
    29         System.out.println("【拦截器2】的after方法");
    30     }
    31 }

创建责任链拦截器-3

1 package com.xfwl.designmodels.responseChain;
     2 
     3 import java.lang.reflect.Method;
     4 
     5 import com.xfwl.interceptor.Interceptor;
     6 /**
     7  * 拦截逻辑3
     8  * @function  
     9  * @author 小风微凉
    10  * @time  2018-7-9 下午4:03:37
    11  */
    12 public class Interceptor3 implements Interceptor {
    13 
    14     @Override
    15     public boolean before(Object proxy, Object target, Method method,
    16             Object[] args) {
    17         System.out.println("【拦截器3】的before方法");
    18         return true;
    19     }
    20 
    21     @Override
    22     public void around(Object proxy, Object target, Method method, Object[] args) {
    23         // TODO Auto-generated method stub
    24 
    25     }
    26 
    27     @Override
    28     public void after(Object proxy, Object target, Method method, Object[] args) {
    29         System.out.println("【拦截器3】的after方法");
    30     }
    31 }

创建测试类：TestChain.java

1 package com.xfwl.designmodels.responseChain;
     2 
     3 import com.xfwl.interceptor.InterceptorJdkProxy;
     4 import com.xfwl.proxy.jdk.HelloWorld;
     5 import com.xfwl.proxy.jdk.HelloWorldImpl;
     6 
     7 /**
     8  * 测试责任链模式
     9  * @function  
    10  * @author 小风微凉
    11  * @time  2018-7-9 下午4:05:43
    12  */
    13 public class TestChain {
    14     /**
    15      * @param args
    16      */
    17     public static void main(String[] args) {
    18     
    19         //拿到代理对象1，并绑定真实对象
    20         HelloWorld proxy1=(HelloWorld) new InterceptorJdkProxy().bind(
    21                                                 new HelloWorldImpl(), 
    22                                                 "com.xfwl.designmodels.responseChain.Interceptor1"
    23                                                 );
    24         //拿到代理对象2，并绑定真实对象
    25         HelloWorld proxy2=(HelloWorld) new InterceptorJdkProxy().bind(
    26                                                 proxy1, 
    27                                                 "com.xfwl.designmodels.responseChain.Interceptor2"
    28                                                 );
    29         //拿到代理对象3，并绑定真实对象
    30         HelloWorld proxy3=(HelloWorld) new InterceptorJdkProxy().bind(
    31                                                 proxy2, 
    32                                                 "com.xfwl.designmodels.responseChain.Interceptor3"
    33                                                 );
    34         //执行代理逻辑
    35         proxy3.sayHelloWorld();
    36 
    37     }
    38 
    39 }

运行结果：

【拦截器3】的before方法
    【拦截器2】的before方法
    【拦截器1】的before方法
    Hello World!
    【拦截器1】的after方法
    【拦截器2】的after方法
    【拦截器3】的after方法

**三、观察者模式（例子）**

创建一个产品列表类：ProductionList.java

1 package com.xfwl.designmodels.observer;
     2 import java.util.ArrayList;
     3 import java.util.List;
     4 import java.util.Observable;
     5 import java.util.Observer;
     6 /**
     7  * 创建一个产品列表
     8  * @function  
     9  * @author 小风微凉
    10  * @time  2018-7-9 下午4:18:36
    11  */
    12 public class ProductionList extends Observable {
    13     //产品容器
    14     private List<String> productionList=null;
    15     //单例模式:懒汉式
    16     private static ProductionList instance;
    17     private ProductionList(){}
    18     /**
    19      * 取得唯一实例
    20      * @return 产品列表唯一实例
    21      */
    22     public static ProductionList getInstance(){
    23         if(instance==null){
    24             instance=new ProductionList();
    25             instance.productionList=new ArrayList<String>();
    26         }
    27         return instance;
    28     }
    29     /**
    30      * 增加观察则（电商接口）
    31      * @param observer 观察者
    32      */
    33     public void addProductionListObserver(Observer observer){
    34         this.addObserver(observer);
    35     }
    36     /**
    37      * 新增产品
    38      * @param newProudct 新产品
    39      */
    40     public void addProudct(String newProudct){
    41         this.productionList.add(newProudct);
    42         System.out.println("产品列表新增了产品："+newProudct);
    43         //告诉观察者，当前被观察者发生了变化
    44         this.setChanged();
    45         //通知观察者，开始相关操作
    46         this.notifyObservers(newProudct);        
    47     }
    48 }

创建一个京东电商推送接口类:JingDongObserver.java

1 package com.xfwl.designmodels.observer;
     2 
     3 import java.util.Observable;
     4 import java.util.Observer;
     5 /**
     6  * 京东电商接口
     7  * @function  
     8  * @author 小风微凉
     9  * @time  2018-7-9 下午4:29:03
    10  */
    11 public class JingDongObserver implements Observer {
    12 
    13     @Override
    14     public void update(Observable o, Object product) {
    15         String newProudct=(String)product;
    16         System.out.println("发送新产品【"+newProudct+"】同步到京东商城");
    17     }
    18 }

创建一个淘宝电商推送接口类：TaoBaoObserver.java

1 package com.xfwl.designmodels.observer;
     2 
     3 import java.util.Observable;
     4 import java.util.Observer;
     5 /**
     6  * 淘宝电商接口
     7  * @function  
     8  * @author 小风微凉
     9  * @time  2018-7-9 下午4:29:03
    10  */
    11 public class TaoBaoObserver implements Observer {
    12 
    13     @Override
    14     public void update(Observable o, Object product) {
    15         String newProudct=(String)product;
    16         System.out.println("发送新产品【"+newProudct+"】同步到淘宝商城");
    17     }
    18 }

创建一个测试类：TestObserver.java

1 package com.xfwl.designmodels.observer;
     2 /**
     3  * 观察者模式测试
     4  * @function  
     5  * @author 小风微凉
     6  * @time  2018-7-9 下午4:32:12
     7  */
     8 public class TestObserver {
     9     /**
    10      * @param args
    11      */
    12     public static void main(String[] args) {
    13         ProductionList observable=ProductionList.getInstance();
    14         TaoBaoObserver taobao=new TaoBaoObserver();
    15         JingDongObserver jingdong=new JingDongObserver();
    16         observable.addObserver(jingdong);
    17         observable.addObserver(taobao);
    18         observable.addProudct("德芙·巧克力");        
    19     }
    20 }

测试结果：

1 产品列表新增了产品：德芙·巧克力
    2 发送新产品【德芙·巧克力】同步到淘宝商城
    3 发送新产品【德芙·巧克力】同步到京东商城

转载于:https://www.cnblogs.com/newwind/p/9284693.html

[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20211218/62203265253b4b3ca58c32ff658aa12a.png