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

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

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

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

二、责任链模式（例子）

创建测试接口：HelloWorld.java

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

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

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 }
View Code

 创建代理类：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