设计模式扫荡-行为型模式-责任链、命令、迭代器、备忘录、观察者、状态、策略、模板、访问者

小灰灰 2022-12-16 10:56 102阅读 0赞

# 设计模式扫荡-行为型模式-责任链、命令、迭代器、备忘录、观察者、状态、策略、模板、访问者 #

### 文章目录 ###

*  设计模式扫荡-行为型模式-责任链、命令、迭代器、备忘录、观察者、状态、策略、模板、访问者
 *   *  责任链模式（Chain of Responsibility Pattern）
     *  命令模式（Command Pattern）
     *  
     *  迭代器模式（Iterator Pattern）
     *  备忘录模式（Memento Pattern）
     *  观察者模式（Observer Pattern）
     *  状态模式(State Pattern)
     *  策略模式（Strategy Pattern）
     *  模板模式（Template Pattern）
     *  访问者模式（Visitor Pattern）

”行为型设计模式特别关注对象之间的通信。“

## 责任链模式（Chain of Responsibility Pattern） ##

责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链条。这种模式给予请求的类型，对请求的发送者和接收者进行解耦

职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。

责任链模式意图避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止

> 需求：
> 
> 前端应用的消息，在经过后台服务器到最终入库之间，需要进行一系列的处理、每个处理都是独立的且都有自己的责任！如何优雅的创建这个过程？
> 
> 可以借鉴平常开发中的过滤器/拦截器机制！

定义过滤器接口于消息对象：

//定义过滤器接口
    interface Filter {
        
        boolean doFilter(Msg m);
    }
    
    class Msg {
        
        //消息名称
        String name;
        //消息串
        String msg;
    
        // setter getter 略...
        // toString() 略
        
    }

每个责任都继承Filter接口并实现自己的职责：

//职责:防止前端输入html代码
    class HTMLFilter implements Filter {
        
        @Override
        public boolean doFilter(Msg m) {
        
            String r = m.getMsg();
            r = r.replace('<', '[');
            r = r.replace('>', ']');
            m.setMsg(r);
            return true;
        }
    }
    //职责: 敏感词筛选
    class SensitiveFilter implements Filter {
        
        @Override
        public boolean doFilter(Msg m) {
        
            String r = m.getMsg();
            r = r.replaceAll("996", "955");
            m.setMsg(r);
            return false;
        }
    }
    // ... 其他职责类
    }

创建过滤链条：

//创建过滤链条 并实现Filter接口
    class FilterChain implements Filter {
        
        //一对多聚合Filter
        private List<Filter> filters = new ArrayList<>(); 
    
    	//为职责链添加新的职责
        public FilterChain add(Filter f) {
        
            filters.add(f);
            return this;
        }
    
        //职责链发挥作用
        public boolean doFilter(Msg m) {
        
    		//任何一关过不去，整个过滤都会失败
            for(Filter f : filters) {
        
                if(!f.doFilter(m)) return false;
            }
    
            return true;
        }
    }

> 优点：  
> 1、降低耦合度。它将请求的发送者和接收者解耦。  
> 2、简化了对象。使得对象不需要知道链的结构。  
> 3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。  
> 4、增加新的请求处理类很方便。  
> 缺点：  
> 1、不能保证请求一定被接收。  
> 2、系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。  
> 3、可能不容易观察运行时的特征，有碍于除错。

## 命令模式（Command Pattern） ##

命令模式主要是对命令的封装，常见命令有如undo（撤回）、copy复制…

> 需求：对一个字符串，实现copy、delete、insert命令、且都支持撤回操作

//命令执行所针对的对象
    public class Content {
        
        String msg = "hello everybody ";
    }
    
    //命令接口/抽象类 [以下统称接口]
    public abstract class Command {
        
        public abstract void doit(); //exec run
        public abstract void undo();
    }
    
    //复制命令，实现命令接口
    public class CopyCommand extends Command {
        
        //一比一聚合一个要操作的对象
        Content c; 
        public CopyCommand(Content c) {
        
            this.c = c;
        }
        @Override
        public void doit() {
        
            c.msg = c.msg + c.msg;
        }
        @Override
        public void undo() {
        
            c.msg = c.msg.substring(0, c.msg.length()/2);
        }
    }
    
    //删除命令，实现命令接口
    public class DeleteCommand extends Command {
        
        //一比一聚合一个要操作的对象
        Content c;
        //要删除的字段
        String deleted;
        public DeleteCommand(Content c) {
        
            this.c = c;
        }
        @Override
        public void doit() {
        
            //一次删除五个长度的字段 且所删除的字段要在对象内进行保留 方便undo
            deleted = c.msg.substring(0, 5);
            c.msg = c.msg.substring(5, c.msg.length());
        }
        @Override
        public void undo() {
        
            c.msg = deleted + c.msg;
        }
    }
    
    
    //插入命令，实现命令接口
    public class InsertCommand extends Command {
        
        //一比一聚合一个要操作的对象
        Content c;
        //头插内容
        String strToInsert = "http://www.baidu.com";
        public InsertCommand(Content c) {
        
            this.c = c;
        }
        @Override
        public void doit() {
        
            c.msg = c.msg + strToInsert;
        }
        @Override
        public void undo() {
        
            c.msg = c.msg.substring(0, c.msg.length()-strToInsert.length());
        }
    }

使用上也很简单，如下：

//针对的内容
    	    Content c = new Content();
    		// c = "hello everybody"
    		//插入
            Command insertCommand = new InsertCommand(c);
            insertCommand.doit();
    		//c = "www.baidu.comhello everybody "
            insertCommand.undo();
    		// c = "hello everybody"
    
            Command copyCommand = new CopyCommand(c);
            insertCommand.doit();
    	    // c = "hello everybodyhello everybody"
            insertCommand.undo();
    		// c = "hello everybody"
    
            Command deleteCommand = new DeleteCommand(c);
            deleteCommand.doit();
    		// c = "everybody"
            deleteCommand.undo();
    		// c = "hello everybody"
    
    	    // 实现多条命令连续执行与连续撤销
    		//为了实现按执行顺序的倒序撤销，应使用List
            List<Command> commands = new ArrayList<>();
            commands.add(new InsertCommand(c));
            commands.add(new CopyCommand(c));
            commands.add(new DeleteCommand(c));
    
            for(Command comm : commands) {
        
                comm.doit();
            }
            for(int i= commands.size()-1; i>=0; i--) {
        
                commands.get(i).undo();
            }

其UML表示为

![79770549fdc264c5cb8c98dcf5ec4c0f.png][]

> 优点： 1、降低了系统耦合度。 2、新的命令可以很容易添加到系统中去。  
> 缺点：使用命令模式可能会导致某些系统有过多的具体命令类。

##  ##

## 迭代器模式（Iterator Pattern） ##

迭代器模式（Iterator Pattern）是 Java 和 .Net 编程环境中非常常用的设计模式。

这种模式用于**顺序访问集合对象的元素**，不需要知道集合对象的底层表示。

> 现在你创建了一个容器，容器的内部结构只有你知道，调用者不知道。
> 
> 在调用者不知道的情况下，如何为调用者提供一种优雅的遍历方式？

![9dcf4d222d63701e876d16ad36fa2c36.png][]

由容器接口自己提供`collection.iterator()`遍历方法，具体容器类实现这个方法，即返回容器对应的Iterator（如图中ArrayIterator）

所有容器迭代器根据相关容器的内部结构实现`.hasNext()`和`.next()`方法

即判断是否有下一个元素和返回下一个元素】

调用者一把这么来遍历

//获得容器的迭代器
    Iterator it = 容器.iterator();
    //利用迭代器进行遍历
    while(it.hasNext()){
        
        容器元素类型 元素 = it.next();
        // ...
    }

以上是迭代器模式的基本原理

## 备忘录模式（Memento Pattern） ##

备忘录模式（Memento Pattern）保存一个对象的某个状态，以便在适当的时候恢复对象。

备忘录模式意图在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。

> 示例：使用三个类演示对象状态的存储与恢复
> 
> 备忘录模式使用三个类 *Memento*、*Originator* 和 *CareTaker*。
> 
> Memento 包含了要被恢复的对象的状态。即要保存的状态的封装
> 
> Originator 创建并在 Memento 对象中存储状态。即含有状态属性的对象的封装。
> 
> Caretaker 对象负责从 Memento 中恢复对象的状态。即恢复状态功能的封装

//备忘录
    public class Memento {
        
       private String state;
       public Memento(String state){
        
          this.state = state;
       }
       public String getState(){
        
          return state;
       }  
    }
    //针对的对象
    public class Originator {
        
       private String state;
       public void setState(String state){
        
          this.state = state;
       }
       public String getState(){
        
          return state;
       }
       //状态保存
       public Memento saveStateToMemento(){
        
          return new Memento(state);
       }
       //状态恢复 以状态封装类作为参数
       public void getStateFromMemento(Memento Memento){
        
          state = Memento.getState();
       }
    }
    
    //恢复状态
    public class CareTaker {
        
        //一系列状态
       private List<Memento> mementoList = new ArrayList<Memento>();
       //增加状态 
       public void add(Memento state){
        
          mementoList.add(state);
       }
       //根据序号返回状态
       public Memento get(int index){
        
          return mementoList.get(index);
       }
    }

> 在这种设计模式下，调用者可随时记录Originator对象某一时刻的对象

Originator originator = new Originator();
          CareTaker careTaker = new CareTaker();
          originator.setState("State #1");
          originator.setState("State #2");
    	  //保存状态2
          careTaker.add(originator.saveStateToMemento());
          originator.setState("State #3");
    	  //保存状态3
          careTaker.add(originator.saveStateToMemento());
          originator.setState("State #4");
     	  //获取state当前状态
          System.out.println("Current State: " + originator.getState());    
    	  //恢复备忘录中第一个保存的状态
          originator.getStateFromMemento(careTaker.get(0));
          System.out.println("First saved State: " + originator.getState());
    	  //恢复备忘录保存的第二个状态
          originator.getStateFromMemento(careTaker.get(1));
          System.out.println("Second saved State: " + originator.getState());

>     Current State: State #4
>     First saved State: State #2
>     Second saved State: State #3

使用UML表示为

![40bdcb59fe9bc051e345d15983d19f69.png][]

> 优点： 1、给用户提供了一种可以恢复状态的机制，可以使用户能够比较方便地回到某个历史的状态。 2、实现了信息的封装，使得用户不需要关心状态的保存细节。  
> 缺点：消耗资源。如果类的成员变量过多，势必会占用比较大的资源，而且每一次保存都会消耗一定的内存。

## 观察者模式（Observer Pattern） ##

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。

比如，当一个对象被修改时，则会自动通知依赖它的对象。

观察者模式主要解决一个对象状态改变给其他对象通知的问题，**而且要考虑到易用和低耦合，保证高度的协作**。

创建被观察的对象：

//被观察对象
    public class Subject {
        
       // 被观察对象的观察者们 
       private List<Observer> observers = new ArrayList<Observer>();
        //被观察对象的状态
       private int state;
     
       public int getState() {
        
          return state;
       }
    
       public void setState(int state) {
        
          this.state = state;
           //一旦状态改变，立即通知所有观察者们，观察者们会根据状态各自做出反应
          notifyAllObservers();
       }
     
        //可为被观察状态添加观察者
       public void attach(Observer observer){
        
          observers.add(observer);      
       }
     
        //通知所有观察者，所有观察者做出自己的反应
       public void notifyAllObservers(){
        
          for (Observer observer : observers) {
        
             observer.update();
          }
       }  
    }

创建观察者们：

//所有观察者皆继承此抽象类
    public abstract class Observer {
        
        //聚合一个被观察对象
       protected Subject subject;
        //抽象方法  被观察对象状态变化时，观察者们的反应
       public abstract void update();
    }
    
    //负责对被观察者状态进行二进制表示的观察者
    public class BinaryObserver extends Observer{
        
       //使用此构造方法 为被观察对象绑定此观察者
       public BinaryObserver(Subject subject){
        
          this.subject = subject;
          //对被观察者添加此观察者
          this.subject.attach(this);
       }
       @Override
       public void update() {
        
          System.out.println( "Binary String: " 
          + Integer.toBinaryString( subject.getState() ) ); 
       }
    }
    // 负责对被观察者状态进行八进制表示的观察者
    public class OctalObserver extends Observer{
        
       public OctalObserver(Subject subject){
        
          this.subject = subject;
          this.subject.attach(this);
       }
     
       @Override
       public void update() {
        
         System.out.println( "Octal String: " 
         + Integer.toOctalString( subject.getState() ) ); 
       }
    }

主方法调用很方便：

Subject subject = new Subject();
    
    	 //为被观察对象传入观察者  
    	 //一次性使用 野指针 JVM GC回收
          new HexaObserver(subject);
          new OctalObserver(subject);
    
          System.out.println("First state change: 15");   
          subject.setState(15);
          System.out.println("Second state change: 10");  
          subject.setState(10);

> First state change: 15  
> Octal String: 17  
> Binary String: 1111  
> Second state change: 10  
> Octal String: 12  
> Binary String: 1010

UML表示为：

![7d898a9750266248528843631bf630b8.png][]

> 优点：  
> 1、观察者和被观察者是抽象耦合的。  
> 2、建立一套触发机制。  
> 缺点：  
> 1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会**花费很多时间**。  
> 2、如果在观察者和观察目标之间有**循环依赖**的话，观察目标会触发它们之间进行循环调用，可能导致**系统崩溃**。

## 状态模式(State Pattern) ##

在状态模式（State Pattern）中，类的行为是基于它的状态改变的

状态模式允许对象在内部状态发生改变时改变它的行为，对象看起来好像修改了它的类。

> 一个小妹妹有基本的笑、苦、说三种动作，这三种动作根据小妹妹的状态而不同，如何优雅的设计？

//状态抽象类
    //每种状态都去根据自己所代表的状态做出符合该状态的动作
    public abstract class MMState {
        
        abstract void smile();
        abstract void cry();
        abstract void say();
    }
    
    //MM类
    public class MM {
        
        String name;
        MMState state;
    
        //MM的动作由各状态类去实现
        public void smile() {
        
            state.smile();
        }
        public void cry() {
        
            state.cry();
        }
        public void say() {
        
            state.say();
        }
    }
    //开心态
    public class MMHappyState extends MMState {
        
        @Override
        void smile() {
        
            // “开心就应该开心得笑嘛”
            System.out.println("happy smile");
        }
        @Override
        void cry() {
        
    		//..
        }
        @Override
        void say() {
        
    		//..
        }
    }
    //悲伤态
    public class MMSadState extends MMState {
        
        @Override
        void smile() {
        
        }
        @Override
        void cry() {
        
        }
        @Override
        void say() {
        
        }
    }

UML表示为

![da592291975073214d11332867a98b5c.png][]

此处注意：在行为固定的情况下适合用State模式、否则增加一个行为需要在所有状态类中也保持同步，代价就有点大了

> 优点：  
> 1、封装了转换规则。  
> 2、枚举可能的状态，在枚举状态之前需要确定状态种类。  
> 3、将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态  
> 4、允许状态转换逻辑与状态对象合成一体，替代了某一个巨大的条件语句块。  
> 缺点：  
> 1、状态模式的使用必然会增加系统类和对象的个数。  
> 2、状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。  
> 3、状态模式对"开闭原则"的支持并不太好，对于可以切换状态的状态模式，增加新的状态类需要修改那些负责状态转换的源代码，否则无法切换到新增状态，而且修改某个状态类的行为也需修改对应类的源代码。

## 策略模式（Strategy Pattern） ##

一个类的行为或其算法可以在运行时更改。

策略模式意图定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。

> Java中的比较器就是其一典型应用
> 
> 在自定义排序的时候，我们创建一个类并实现Comparator接口中的compareTo()方法，即可自定义排序

## 模板模式（Template Pattern） ##

一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。

> 最直白的例子：

abstract class F{
        
        //定义一个模板方法
        //即不管op1和op2是什么操作，只要按照先1后2的顺序执行即可
        public void m(){
        
            op1();
            op2();
        }
        
       //由子类去实现 
       abstract void op1();
       abstract void op1();
    }

## 访问者模式（Visitor Pattern） ##

主要将数据结构与数据操作分离，在**结构不变**的情况下动态改变内部元素动作

> 需求：假设电脑商城卖一台电脑配件

public class Computer {
        
    	//固定卖三种配件
        ComputerPart cpu = new CPU();
        ComputerPart memory = new Memory();
        ComputerPart board = new Board();
    	//接待顾客，根据顾客的类型不同采取不同的折扣
        public void acccept(Visitor v) {
        
            this.cpu.accept(v);
            this.memory.accept(v);
            this.board.accept(v);
        }
    }
    
    abstract class ComputerPart {
        
        
        abstract void accept(Visitor v);
        //根据visitor来访者的不同，执行自己的折扣逻辑
        abstract double getPrice();
    }
    
    class CPU extends ComputerPart {
        
    
        @Override
        void accept(Visitor v) {
        
            v.visitCpu(this);
        }
        //原价
        @Override
        double getPrice() {
        
            return 500;
        }
    }
    
    class Memory extends ComputerPart {
        
    
        @Override
        void accept(Visitor v) {
        
            v.visitMemory(this);
        }
        @Override
        //原价
        double getPrice() {
        
            return 300;
        }
    }
    
    class Board extends ComputerPart {
        
        @Override
        void accept(Visitor v) {
        
            v.visitBoard(this);
        }
        //原价
        @Override
        double getPrice() {
        
            return 200;
        }
    }
    
    //访问者接口，各自实现不同配件的折扣策略
    interface Visitor {
        
        void visitCpu(CPU cpu);
        void visitMemory(Memory memory);
        void visitBoard(Board board);
    }
    
    //个人用户
    class PersonelVisitor implements Visitor {
        
        double totalPrice = 0.0;
        @Override
        public void visitCpu(CPU cpu) {
        
            totalPrice += cpu.getPrice()*0.9;
        }
        @Override
        public void visitMemory(Memory memory) {
        
            totalPrice += memory.getPrice()*0.85;
        }
        @Override
        public void visitBoard(Board board) {
        
            totalPrice += board.getPrice()*0.95;
        }
    }
    
    //企业用户
    class CorpVisitor implements Visitor {
        
        double totalPrice = 0.0;
        @Override
        public void visitCpu(CPU cpu) {
        
            totalPrice += cpu.getPrice()*0.6;
        }
        @Override
        public void visitMemory(Memory memory) {
        
            totalPrice += memory.getPrice()*0.75;
        }
        @Override
        public void visitBoard(Board board) {
        
            totalPrice += board.getPrice()*0.75;
        }
    }

Main

//个人用户
            PersonelVisitor p = new PersonelVisitor();
            //电脑接客
            new Computer().acccept(p);
            System.out.println(p.totalPrice);

UML表示为

![4ac8770d92ad9826d841d59cdb19a994.png][]

[79770549fdc264c5cb8c98dcf5ec4c0f.png]: /images/20221123/4357572d88824d00b30d0b179ffd0e31.png
[9dcf4d222d63701e876d16ad36fa2c36.png]: /images/20221123/2768268cdcf040dca41730fa7dbeeaf0.png
[40bdcb59fe9bc051e345d15983d19f69.png]: /images/20221123/12285519f94b47c3a57ad9d0a6ced509.png
[7d898a9750266248528843631bf630b8.png]: /images/20221123/f356196eaa5d4a2dbeae6bbef310bfcf.png
[da592291975073214d11332867a98b5c.png]: /images/20221123/c29aabf010de4f0b986f01efc85fd82a.png
[4ac8770d92ad9826d841d59cdb19a994.png]: /images/20221123/8daff4fd022c4bb5bedac30d51068379.png