设计模式下篇-行为型

行为型主要解决类或对象之间交互的经典结构。行为型的设计模式有观察者模式，模板模式，策略模式，职责链模式，状态模式，迭代器模式，访问者模式，备忘录模式，命令模式，解释器模式和中介模式。

接下来以3个W和1个H来学习下这十一种设计模式

十一种模式介绍

观察者模式-Observer

什么是观察者模式

在对象之间定义一个一对多的依赖，当一个对象（被观察者）状态改变的时候，所有依赖的对象（观察者）都会自动收到通知。

为什么使用观察者模式

降低被观察者和观察者的耦合性，提高易用性。

如何使用观察者模式

被观察者，该被观察者有一组注册的观察者，当被观察者改变时，通知每一个观察者

// 观察者
public interface Observer {
    
    void update(Observable o, Object arg);
}

// 被观察者的封装类
public class Observable {
    private boolean changed = false;
    private Vector<Observer> obs;
    
    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }
    
    // something
    
    public void notifyObservers(Object arg) {
        
        Object[] arrLocal;

        synchronized (this) {
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

    // something
    
    protected synchronized void setChanged() {
        changed = true;
    }

}

// 被观察者
public class MyObservable extends Observable {

    public synchronized void setChanged() {
        super.setChanged();
    }
}

// 调用类
public class Main {

    public static void main(String[] args) {
        // java.util.Observable
        MyObservable observable = new MyObservable();
        observable.addObserver(new java.util.Observer() {
            @Override
            public void update(Observable o, Object arg) {
                System.out.println("A"+arg.toString());
                o.deleteObserver(this);
            }
        });

        observable.addObserver(new java.util.Observer() {
            @Override
            public void update(Observable o, Object arg) {
                System.out.println("B"+arg.toString());
            }
        });

        observable.setChanged();
        observable.notifyObservers("message1");
        observable.setChanged();
        observable.notifyObservers("message2");

    }
}

// 打印如下：
Bmessage1
Amessage1
Bmessage2

额外学习

在jdk9，Observable被废弃，使用java.beans包下的PropertyChangeEvent和PropertyChangeListener来代替Observer和Observable的功能。

使用观察者模式实现简单的EventBus，git仓库：https://github.com/CNXMBuyu/design-pattern-study.git

• 改进方案-消息队列

设计模式核心是对程序进行解耦，在观察者模式中被观察者需要添加观察者，且当发起通知时要遍历所有的观察者。为了使解耦的更加彻底，就出现了消息队列。

模板模式-Template

什么是模板模式

将算法整体架构定义好，让子类在不改变算法整体结构的情况下，重新定义算法中的某些步骤。

为什么使用模板模式

代码复用

如何使用模板模式

定义算法整体架构（抽象类），将需要子类来实现的方法定义为抽象方法。

public abstract class Player {

    public void initPlayer() {
        // 保存玩家信息
        savePlayer();
        // 初始化玩家数据，因为每款游戏都不同，所以需要有子类具体实现
        initData();
    }

    protected void savePlayer() {
        System.out.println("已保存玩家信息");
    }

    /**
     * 初始化玩家数据
     */
    protected abstract void initData();

}

public class GamePlayer extends Player {

    @Override
    protected void initData() {
        System.out.println("初始化游戏玩家");
    }
}

相似功能：回调

A类事先注册某个函数F到B类，A类在调用B类的P函数的时候，B类反过来调用A类注册给它的F函数。

public class Player {

    public void initPlayer(PlayerCallback playerCallback){
        // 保存玩家信息
        savePlayer();
        // 初始化玩家数据，因为每款游戏都不同，所以需要有子类具体实现
        playerCallback.initData();
    }

    protected void savePlayer(){
        System.out.println("已保存玩家信息");
    }
}

public interface PlayerCallback {

    /**
     * 初始化玩家数据
     */
    void initData();
}

// 调用类
public class Main {

    public static void main(String[] args) {
        Player player = new Player();
        player.initPlayer(new PlayerCallback() {
            @Override
            public void initData() {
                System.out.println("初始化游戏玩家数据");
            }
        });
    }
}

回调函数的经典案例：spring的JdbcTemplate

模板模板是使用继承来实现，而回调函数是使用组合来实现。

策略模式-Strategy

什么是策略模式

策略模式就是定义一族算法类，将每个算法分别封装起来，让它们可以互相替换。

为什么使用策略模式

解耦策略的定义、创建、使用这三部分

如何使用策略模式

分为定义、创建、使用三个步骤。

// 以下为策略的定义

// 策略接口
public interface Cache {

    void addCache(String key, String content);

    String getCache(String key);
}


// 策略的实现者
public class MemoryCache implements Cache {

    private ConcurrentMap<String, String> cache = new ConcurrentHashMap<>();

    @Override
    public void addCache(String key, String content) {
        cache.put(key, content);
        System.out.println("memory add cache; key:" + key + ", content:" + content);
    }

    @Override
    public String getCache(String key) {
        System.out.println("memory get key:" + key + ", content:" + cache.get(key));
        return cache.get(key);
    }
}

// 策略的实现者
public class RedisCache implements Cache {

    @Override
    public void addCache(String key, String content) {
        System.out.println("redis add cache; key:" + key + ", content:" + content);
    }

    @Override
    public String getCache(String key) {
        String content = "redis get key:" + key;
        System.out.println(content);
        return content;
    }
}

// 策略的创建
public class CacheFactory {

    public Cache getCache(String type){
        String redisType = "redis";
        if(redisType.equals(type)){
            return RedisCacheSingleton.INSTANCE;
        } else {
            return MemoryCacheSingleton.INSTANCE;
        }
    }

    /**
     * 使用内部类的单例
     */
    private static class RedisCacheSingleton{
        private static RedisCache INSTANCE = new RedisCache();
    }

    /**
     * 使用内部类的单例
     */
    private static class MemoryCacheSingleton{
        private static MemoryCache INSTANCE = new MemoryCache();
    }
}

// 策略的使用
public class Main {

    public static void main(String[] args) {
        Cache redisCache = new CacheFactory().getCache("redis");
        redisCache.addCache("a", "a content");
        redisCache.getCache("a");

        Cache memoryCache = new CacheFactory().getCache("memory");
        memoryCache.addCache("a", "a content");
        memoryCache.getCache("a");
    }
}

职责链模式-Chain

什么是职责链模式

职责链模式是将请求的发送和接收解耦，让多个接收对象都有机会处理这个请求。将这些接收对象串成一条链，并沿着这条链传递这个请求，直到链上的某个接收对象能够处理它为止。

为什么使用职责链模式

将请求的发送和接收解耦。

如何使用职责链模式

public abstract class AbstractScript{

    /**
     * 执行初始化
     */
    public abstract void doInit();
}

public class ScriptA extends  AbstractScript {

    @Override
    public void doInit() {
        System.out.println(this.getClass().getName());
    }
}

public class ScriptB extends  AbstractScript {

    @Override
    public void doInit() {
        System.out.println(this.getClass().getName());
    }
}


// 这里对职责器模式进行了一个小的修改，职责器模式定义“直到链上的某个接收对象能够处理它为止”，而我们处理它之后依然没有停止，知道执行结束
public class ScriptChain {

    public void init(List<AbstractScript> initScriptList) {
        // 排序
        Collections.sort(initScriptList);
        // 遍历执行所有脚本
        for (AbstractScript script : initScriptList) {
            if (script.filter(predicate -> {
                return true;
            })) {
                script.doInit();
            }
        }
    }
}

状态模式-State

什么是状态模式

状态机又叫有限状态机，由3个部分组成：状态、事件、动作。其中，事件也称为转移条件。事件触发状态的转移及动作的执行。

为什么使用状态模式

当状态条状触发的动作比较复杂时，使用状态模式，可以提高代码的可维护性。

如何使用状态模式

订单有5个状态，分别为待付款，已关闭，已付款，已退款，已完成。事件有同意和拒绝。示例代码简单没有动作。

public class Order {

    private OrderStateEnum status =  OrderStateEnum.unpaid;

    public OrderStateEnum getStatus() {
        return status;
    }

    public void setStatus(OrderStateEnum status) {
        this.status = status;
    }
}

public enum OrderStateEnum {

    unpaid, closed, paid, refund, finish
}


// 状态接口
public interface OrderState {

    default void agree(OrderStateMachine orderStateMachine){
        // nothing
    }

    default void reject(OrderStateMachine orderStateMachine){
        // nothing
    }
}

// 待付款的状态改变
public class UnpaidOrderState implements OrderState {

    @Override
    public void agree(OrderStateMachine orderStateMachine) {
        // 处理已付款的相关事项
        // .....
        // 状态调整
        orderStateMachine.setState(new PaidOrderState());
    }

    @Override
    public void reject(OrderStateMachine orderStateMachine) {
        orderStateMachine.setState(new ClosedOrderState());
    }
}

// 已付款的状态改变
public class PaidOrderState implements OrderState {

    @Override
    public void agree(OrderStateMachine orderStateMachine) {
        orderStateMachine.setState(new FinishOrderState());
    }

    @Override
    public void reject(OrderStateMachine orderStateMachine) {
            orderStateMachine.setState(new RefundedOrderState());
    }
}

// 已退款-最终状态，没有任何操作
public class RefundedOrderState implements OrderState {}

// 已关闭-最终状态，没有任何操作
public class ClosedOrderState implements OrderState {}

// 已完成-最终状态，没有任何操作
public class FinishOrderState implements OrderState {}

// 状态机
public class OrderStateMachine {

    private OrderState state;

    private static Map<OrderStateEnum, OrderState> orderStateMap = new HashMap<>(10);

    static{
        orderStateMap.put(OrderStateEnum.unpaid, new UnpaidOrderState());
        orderStateMap.put(OrderStateEnum.closed, new ClosedOrderState());
        orderStateMap.put(OrderStateEnum.paid, new UnpaidOrderState());
        orderStateMap.put(OrderStateEnum.refund, new RefundedOrderState());
        orderStateMap.put(OrderStateEnum.finish, new FinishOrderState());
    }

    public OrderStateMachine(Order order){
        state = orderStateMap.get(order.getStatus());
    }

    public void agree(){
        state.agree(this);
    }

    public void reject(){
        state.reject(this);
    }

    public OrderState getState() {
        return state;
    }

    public void setState(OrderState state) {
        this.state = state;
    }
}

// 调用代码
public class Main {

    public static void main(String[] args) {
        Order order = new Order();
        OrderStateMachine orderStateMachine = new OrderStateMachine(order);
        orderStateMachine.agree();
        System.out.println(orderStateMachine.getState().toString());
        orderStateMachine.agree();
        System.out.println(orderStateMachine.getState().toString());
    }
}

// 打印日志如下：
cn.hgy.state.PaidOrderState@136432db
cn.hgy.state.FinishOrderState@7382f612

迭代器模式-Iterator

什么是迭代器模式

迭代器模式将集合对象的遍历操作从集合类中拆分出来，放到迭代器类中，让两者的职责更加单一。

为什么使用迭代器模式

• 迭代器模式封装集合内部的复杂数据结构，开发者不需要了解如何遍历，直接使用容器提供的迭代器即可；
• 迭代器模式将集合对象的遍历操作从集合类中拆分出来，放到迭代器类中，让两者的职责更加单一；
• 迭代器模式让添加新的遍历算法更加容易，更符合开闭原则。除此之外，因为迭代器都实现自相同的接口，在开发中，基于接口而非实现编程，替换迭代器也变得更加容易。

如何使用迭代器模式

定义迭代器接口和具体的实现。

public interface Iterator<E> {
    
    boolean hasNext();
    
    E next();
}

访问者模式-Visitor

什么是访问者模式

访问者模式允许一个或者多个操作应用到一组对象上。

为什么使用访问者模式

解耦操作和对象本身，保持类职责单一、满足开闭原则以及应对代码的复杂性。

如何使用访问者模式

public abstract class AbstractFile {

    public abstract void read(IRead read);
}

public class Doc extends AbstractFile {
    @Override
    public void read(IRead read) {
        read.read(this);
    }
}

public class Pdf extends  AbstractFile {
    @Override
    public void read(IRead read) {
        read.read(this);
    }
}

public interface IRead {

    void read(Doc doc);

    void read(Pdf pdf);
}

public class ReadImpl implements IRead {
    @Override
    public void read(Doc doc) {
        System.out.println("doc");
    }

    @Override
    public void read(Pdf pdf) {
        System.out.println("pdf");
    }
}

public class Main {

    public static void main(String[] args) {
        List<AbstractFile> fileList = new ArrayList<>();
        fileList.add(new Doc());
        fileList.add(new Pdf());
        IRead read = new ReadImpl();
        fileList.forEach(abstractFile -> {
            // 编译会失败，所以改用abstractFile.read(read);
            // read.read(abstractFile);
            abstractFile.read(read);
        });
    }
}

备忘录模式-Memento

什么是备忘录模式

备忘录模式也叫快照模式，具体来说，就是在不违背封装原则的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便之后恢复对象为先前的状态。

命令模式-Command

什么是命令模式

命令模式将请求封装为一个对象，这样可以使用不同的请求参数化其他对象，并且能够支持请求的排队执行、记录日志、撤销等附加功能。

为什么使用命令模式

解耦行为请求者与行为实现者。

在大部分编程语言中，函数是没法作为参数传递给其他函数的，也没法赋值给变量。借助命令模式，我们将函数封装成对象，这样就可以实现把函数像对象一样使用。

如何使用命令模式

public interface Command {
    
    void execute();
}

// 灯
public class Light {

    public void on() {
        System.out.println("灯亮了");
    }
    
    public void off() {
        System.out.println("灯暗了");
    }
}

// 开灯的命令
public class LightOnCommand implements Command {

    private Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.on();
    }
}

// 关灯的命令
public class LightOffCommand implements Command {

    private Light light;

    public LightOffCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.off();
    }
}

// 使用类
public class Main {

    public static void main(String[] args) {
        Queue<Command> request = new LinkedList<>();
        Light light = new Light();
        request.add(new LightOnCommand(light));
        request.add(new LightOffCommand(light));

        request.forEach(command -> {
            command.execute();
        });
    }
}

解释器模式-Interpreter

什么是解释器模式

解释器模式为某个语言定义它的语法（或者叫文法）表示，并定义一个解释器用来处理这个语法。

中介模式-Mediator

什么是中介模式

中介模式定义了一个单独的对象，来封装一组对象之间的交互。将这组对象之间的交互委派给与中介对象交互，来避免对象之间的直接交互。

总结

观察者模式

观察者将自己注册到被观察者中，当被观察者发生改变时，将改变推送给每一个被观察中。

可以通过框架或者反射解决注册到被观察者中，或者使用消息队列解耦观察者和被观察者；可以通过异步执行观察者函数。

模板模式

定义一套流程，将其中部分功能放在子类实现。

模板模式需要继承实现，可以通过回调来实现类似功能，解决继承问题。

策略模式

定义一组功能相似的算法实现，可以互相替换。

职责链模式

职责链模式是将请求的发送和接收解耦，让多个接收对象都有机会处理这个请求。

状态模式

适用于状态并不多、状态转移也比较简单，但事件触发执行的动作包含的业务逻辑可能比较复杂的状态机。

迭代器模式

迭代器模式用来遍历集合对象。解耦容器代码和遍历代码。

访问者模式

访问者模式允许一个或者多个操作应用到一组对象上。

备忘录模式

备忘录模式也叫快照模式，具体来说，就是在不违背封装原则的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便之后恢复对象为先前的状态。

命令模式

命令模式将请求封装为一个对象，这样可以使用不同的请求参数化其他对象，并且能够支持请求的排队执行、记录日志、撤销等附加功能。

解释器模式

解释器模式为某个语言定义它的语法（或者叫文法）表示，并定义一个解释器用来处理这个语法

中介模式

中介模式定义了一个单独的对象，来封装一组对象之间的交互。将这组对象之间的交互委派给与中介对象交互，来避免对象之间的直接交互。