Java设计模式学习笔记（三）——行为型模式

2.2 行为型模式

2.2.1 责任链模式

定义：使得很多对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

应用场景：

• 有多个对象可以处理用户请求，希望程序在运行期间能够自行确定处理用户请求的那个对象；
• 希望用户不必明确接收者的情况下，向多个接收者的其中一个提交请求；
• 程序希望能够动态地指定能够处理用户请求的对象集合。

优点：

• 低耦合；
• 可以动态地增加删除处理者或重新指派处理者的职责；
• 可以动态改变处理者之间的先后顺序。

责任链模式实现

一般来说，一个纯粹的责任链模式需要将请求先传递给第一个对象处理，如果处理过了，那么请求处理到此结束，否则，继续向后传递。
责任链模式中，我们需要实现三个角色：抽象处理角色，具体处理角色，请求者。
我们可以假想一个场景，这是一个企业的自动化办公系统，其中的某个员工发出了一个请求，可以是请假或者其他，根据这个请求的细节来决定需要有哪些人、哪些部门来处理它。

//抽象的处理角色
public interface Handler {
    int handleRequest(int n);
    void setNextHandler(Handler next);
}

//具体处理角色1
public class Manager implements Handler {

    private Handler next;

    @Override
    public int handleRequest(int n) {
        if (n<0)
            return -n;
        else {
            if (next==null)
                throw new NullPointerException("next is null!");
            return next.handleRequest(n);
        }
    }

    @Override
    public void setNextHandler(Handler next) {
        this.next=next;
    }
}

//具体的请求者
public class TestUse {
    public static void main(String[] args){
        Handler h1,h2,h3;
        h1=new Manager();
        h2=new GroupLeader();
        h3=new DepartmentHeader();
        h1.setNextHandler(h2);
        h2.setNextHandler(h3);
        System.out.println(h1.handleRequest(-1));
        System.out.println(h1.handleRequest(3));
        System.out.println(h1.handleRequest(9999999));
    }
}

当然其实我们有更好的实践，在web项目中的FilterChain、InterceptorChain都是典型责任链模式的应用场景。另外，请求未必是处理一次就在整个链上终止传递，请求中可能会有许多的需求，如果有其他的需求，那么请求应该继续传递。

2.2.2命令模式

定义：将一个请求定义为一个对象，从而使用户可以用不同的请求对客户进行参数化。对请求排队或者记录请求日志，以及记录可撤销的操作。

应用场景：

• 程序需要在不同的时刻指定、排列、和执行请求；
• 程序需要执行撤销操作；
• 程序需要支持宏操作。

优点：

• 在命令模式中，请求者（Invoker）不直接与接受者（Receiver）进行交互，以及请求者不包含接受者的引用，因此彻底地解决了它们之间的耦合；
• 命令模式满足了“开闭原则”，如果增加新的具体命令或者该命令的接受者，不必修改调用者的代码，调用者就可以使用新的命令对象；如果增加新的调用者，那么也不必修改命令对象和接受者的代码，新增的调用者就可以使用已有的具体命令；
• 由于请求者的请求被封装在具体的命令之中，那么就可以将命令保存在持久化的媒介之中，在需要的时候，重新执行这个具体命令，因此，命令模式可以记录日志；
• 使用命令模式可以对请求者的请求进行排队，每一个请求都对应一个具体的命令，因此可以按顺序执行这些命令。

命令模式实现

命令模式实现的关键在于三个角色：Order（Command）——命令对象、Invoker——使用命令对象的入口以及Receiver——命令的真正执行者。
典型的应用场景中，Struts的ActionServlet 只有一个，它就相当于Invoker，而模型层的类会随着应用的不同而不同，就相当于具体的不同的Command。

1. 创建抽象的命令类

public interface Order {

    public void excute();
}

2.创建请求类

public class Stock {

    private String name="ABC";

    private int quantity=10;

    public void buy(){
        System.out.println("Stock [ Name: "+name+", "+
                "Quantity: " + quantity +" ] bought");
    }

    public void sell(){
        System.out.println("Stock [ Name: "+name+", Quantity: " + quantity +" ] sold");
    }
}

3.具体命令对象

//命令1
public class BuyStock implements Order {

    private Stock abcStock;

    public BuyStock(Stock abcStock) {
        this.abcStock = abcStock;
    }

    @Override
    public void execute() {
        abcStock.buy();
    }
}

//命令2
public class SellStock implements Order {

    private Stock abcStock;

    public SellStock(Stock abcStock) {
        this.abcStock = abcStock;
    }

    @Override
    public void execute() {
        abcStock.sell();
    }
}

4.创建命令调用类

//充当了Invoker的角色
public class Broker {
    private List<Order> orderList=new ArrayList<>();

    //接收命令
    public void takeOrder(Order order){
        orderList.add(order);
    }

    public void placeOrder(){
        for (Order order:orderList
             ) {
            order.execute();
        }
        orderList.clear();
    }
}

public class CommandPatternDemo {
    public static void main(String[] args){
        Stock abcStock=new Stock();

        Order buStock=new BuyStock(abcStock);
        Order sellStock=new SellStock(abcStock);

        Broker broker=new Broker();
        broker.takeOrder(buStock);
        broker.takeOrder(sellStock);

        broker.placeOrder();
    }
}

2.2.3 解释器模式（Interpreter pattern）

定义：解释器模式提供了评估语言的语法和表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。

应用场景：

• 当一个简单的语言需要解释执行，并且可以将该语言的每一个规则表示为一个类时，就可以使用解释器模式。

优点：

• 将每一个规则表示为一个类，方便于实现简单的语言；
• 由于使用类表示语法的规则，可以较容易地表示和扩展语言的行为；
• 增加了新的解释表达式的方式。

缺点：

• 应用场景较少；
• 复杂语法维护困难；
• 解释器模式会引发类膨胀；
• 解释器模式采用递归调用方法。

实现

其中有四个角色：抽象表达式、终结符表达式、非终结符表达式、上下文，上下文中会包含一些解释器之外的全局信息。

1. 定义一个抽象的表达式

public interface Expression {
    public boolean interpret(String context);
}

2.实现一个终结符表达式

public class TerminalExpression implements Expression {

    private String data;

    public TerminalExpression(String data) {
        this.data = data;
    }

    @Override
    public boolean interpret(String context) {
        if (context.contains(data))
            return true;
        return false;
    }
}

3.非终结符表达式，可以有一个或几个

2.2.4观察者模式

也称为发布订阅模式，隔了好长时间又回来写设计模式，主要是觉得这个观察者模式是很常见的，常见的东西应该加以记忆，不常见的学了也未必有什么卵用，而且记忆是个重复的过程，不用会忘记。

定义：在对象之间定义了一对多的依赖关系，这样当一个对象的状态发生变化，那么依赖它的对象就会收到通知，并自动更新。

应用场景：

• 一个抽象模型有两方面，其中一方面依赖于另一个方面，将这些方面封装在独立的对象当中，使它们可以各自独立改变和复用；
• 一个对象的改变将导致其它一个或多个对象的改变，但我们并不知道具体有多少个变量会发生改变；
• 一个对象必须通知其它对象而不知道这些对象是谁；
• 需要在系统中创建一个触发链，A对象的行为影响B对象，接着影响B/C等等，使用观察者模式可以创建一套链式的触发机制。

优点：

• 观察者和被观察者之间是抽象耦合的；
• 建立一套触发机制。

缺点：

• 如果一个被观察者有很多的直接的和间接的观察者的话，将所有观察者都通知到会花费相当多的时间；
• 如果观察者与被观察者之间存在循环依赖的话，观察目标就有可能触发它们之间的循环调用，就可能导致系统崩溃；
• 观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅知道观察目标发生了变化。

实现

观察者模式中存在四个角色：

• 抽象被观察者：一个抽象的主题，它把对所有观察者对象的引用保存在一个集合中，每个主题都可以有任意数量的观察者。被观察者提供添加和删除观察者的方法，被观察者通常是抽象类或者接口。

/***
 * 抽象被观察者接口
 * 声明了添加、删除、通知观察者方法
 *
 */
public interface Observerable {
    
    public void registerObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyObserver();
}

• 抽象观察者：为所有的具体观察者提供更新状态的方法。

/***
 * 抽象观察者
 * 定义了一个update()方法，当被观察者调用notifyObservers()方法时，观察者的update()方法会被回调。
 * @author jstao
 *
 */
public interface Observer {
    public void update(String message);
}

• 具体观察者：观察者的具体实现，以便随主题内部状态的改变更新自身状态。

import java.util.ArrayList;
import java.util.List;

/**
 * 被观察者，也就是具体的服务
 * 实现了Observerable接口，对Observerable接口的三个方法进行了具体实现
 *
 */
public class ConcreteService implements Observerable {
    
    //注意到这个List集合的泛型参数为Observer接口，设计原则：面向接口编程而不是面向实现编程
    private List<Observer> list;
    private String message;
    
    public ConcreteService () {
        list = new ArrayList<Observer>();
    }
    
    @Override
    public void registerObserver(Observer o) {
        
        list.add(o);
    }
    
    @Override
    public void removeObserver(Observer o) {
        if(!list.isEmpty())
            list.remove(o);
    }

    //遍历
    @Override
    public void notifyObserver() {
        for(int i = 0; i < list.size(); i++) {
            Observer oserver = list.get(i);
            oserver.update(message);
        }
    }
    
    public void setInfomation(String s) {
        this.message = s;
        System.out.println("服务更新消息： " + s);
        //消息更新，通知所有观察者
        notifyObserver();
    }

}

• 具体被观察者：主题的具体实现，当主题的内部状态发生改变时，向所有注册过的观察者发送更新通知。

/**
 * 观察者
 * 实现了update方法
 *
 */
public class User implements Observer {

    private String name;
    private String message;
    
    public User(String name) {
        this.name = name;
    }
    
    @Override
    public void update(String message) {
        this.message = message;
        read();
    }
    
    public void read() {
        System.out.println(name + " 收到推送消息： " + message);
    }
    
}