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();
    }
}