01设计模式(D3_设计模式类型 - D3_行为型模式)

news2025/1/20 1:42:07

目录

一、模版方法模式

1. 基本介绍

2. 应用案例一:豆浆制作问题

需求

代码实现

模板方法模式的钩子方法

3. View的draw(Android)

Android中View的draw方法就是使用了模板方法模式

模板方法模式在 Spring 框架应用的源码分析

知识小结

二、命令模式

1. 基本介绍

2. 应用案例一:智能生活问题

需求

代码实现

3. 常见应用

Thread

Android 中的 Handler

4. 知识小结

三、访问者模式

1. 基本介绍

2. 应用案例一:歌手测评问题

需求

传统方式的问题分析

代码实现

双分派

3. 知识小结

四、迭代器模式

1. 基本介绍

2. 应用案例一:学校院系结构问题

需求

3. 代码实现

4. JDK源码(ArrayList)

5. 知识小结

五、观察者模式

1. 基本介绍

2. 应用案例一:天气预报问题

需求

传统方案

传统方式代码实现

传统方式问题分析

观测者模式实现

3. JDK源码(Observable)

4. 知识小结

六、中介者模式

1. 基本介绍

2. 应用案例一:智能家庭管理问题

需求

传统方式解决

传统的方式的问题分析

代码实现

3. 知识小结

七、备忘录模式

1. 基本介绍

2. 基本原理

3. 代码实现

4. 应用案例一:游戏角色状态恢复问题

需求提出

代码实现

5. 知识小结

八、解释器模式

1. 基本介绍

2. 基本原理

3. 应用案例一:四则运算问题

需求

传统方案解决四则运算问题分析

代码实现

4. 知识小结

九、状态模式

1. 基本介绍

2. 基本原理

3. 应用案例一:APP 抽奖活动问题

需求提出

代码实现

4. 源码剖析(借贷平台 )

需求提出

代码实现

5. 知识小结

十、策略模式

1. 基本介绍

2. 应用案例一:鸭子飞行

需求分析

代码实现

3. 应用案例二:旅游出行

简介

结构

三案例实现

4. 应用案例三:综合案例

简介

目前已实现的代码

代码改造(工厂+策略)

举一反三

5. JDK源码(Arrays)

6. 知识小结

十一、职责链模式

1. 基本介绍

2. 应用案例一:学校OA系统采购审批

需求分析

代码实现

3. 应用案例二:订单处理

基本介绍

基本结构

案例实现

优缺点

举一反三

4. Andorid 应用

5. 知识小结


一、模版方法模式

1. 基本介绍

  1. 模板方法模式(Template Method Pattern),又叫模板模式(Template Pattern),在一个抽象类公开定义了执行它的方法的模板。它的子类可以按需要重写方法实现,但调用将以抽象类中定义的方式进行。
  2. 简单说,模板方法模式定义一个操作中的算法的骨架,而将一些步骤延迟到子类中,使得子类可以不改变一个算法的结构,就可以重定义该算法的某些特定步骤
  3. 这种类型的设计模式属于行为型模式。

对原理类图的说明-即(模板方法模式的角色及职责)

  1. AbstractClass 抽象类, 类中实现了模板方法(template),定义了算法的骨架,具体子类需要去实现 其它的抽象方法 operationr2,3,4
  2. ConcreteClass 实现抽象方法 operationr2,3,4, 以完成算法中特点子类的步骤

2. 应用案例一:豆浆制作问题

需求

编写制作豆浆的程序,说明如下:

  1. 制作豆浆的流程 选材--->添加配料--->浸泡--->放到豆浆机打碎
  2. 通过添加不同的配料,可以制作出不同口味的豆浆
  3. 选材、浸泡和放到豆浆机打碎这几个步骤对于制作每种口味的豆浆都是一样的
  4. 请使用 模板方法模式完成

代码实现

  1. 应用实例要求 编写制作豆浆的程序,说明如下: 制作豆浆的流程 选材--->添加配料--->浸泡--->放到豆浆机打碎通过添加不同的配料,可以制作出不同口味的豆浆 选材、浸泡和放到豆浆机打碎这几个步骤对于制作每种口味的豆浆都是一样的(红豆、花生豆浆。。。)
  2. 思路分析和图解(类图)
public abstract class SoyaMilk {
    //模板方法 make
    final void make(){
        select();
        addCondiments();
        soak();
        beat();
    }

    //选材
    void select(){
        System.out.println("第一步,选择好的新鲜黄豆");
    }

    //添加不同配料,子类具体实现
    abstract void addCondiments();

    //浸泡
     void soak(){
        System.out.println("第三步,黄豆和配料开始浸泡,需要3个小时");
    }

    //打豆浆
    void beat(){
        System.out.println("第四步,黄豆和配料放到豆浆机去打碎");
    }

}

红豆豆浆和花生豆浆,某些具体细节不同

public class RedBeanSoyaMilk extends SoyaMilk {
    @Override
    void addCondiments() {
        System.out.println("第二步,加入上等红豆");
    }
}

public class PeanutSoyaMilk extends SoyaMilk {
    @Override
    void addCondiments() {
        System.out.println("第二步,加入上好的花生");
    }
}

客户端调用

public class Client {
    public static void main(String[] args) {
        System.out.println("--------制作红豆豆浆--------");
        SoyaMilk soyaMilk = new RedBeanSoyaMilk();
        soyaMilk.make();
        System.out.println("--------制作红豆豆浆--------");
        SoyaMilk peanutSoyaMilk = new PeanutSoyaMilk();
        peanutSoyaMilk.make();
    }
}

模板方法模式的钩子方法

  1. 在模板方法模式的父类中,我们可以定义一个方法,它默认不做任何事,子类可以视情况要不要覆盖它,该方法称为“钩子”。
  2. 还是用上面做豆浆的例子来讲解,比如,我们还希望制作纯豆浆,不添加任何的配料,请使用钩子方法对前面的模板方法进行改造

改造抽象类

public abstract class SoyaMilk {
    //模板方法 make
    final void make(){
        select();
        if (customerWantCondiments()) {
            addCondiments();
        }
        soak();
        beat();
    }
    
    ...
    
    //钩子方法,决定是否需要添加配料
    boolean customerWantCondiments() {
        return true;
    }
}

纯豆浆

public class PureSoyaMilk extends SoyaMilk {
    @Override
    void addCondiments() {

    }

    //重写钩子方法
    @Override
    boolean customerWantCondiments() {
        return false;
    }
}

客户端调用

main(...){
    System.out.println("--------制作纯豆浆--------");
    SoyaMilk pureSoyaMilk = new PureSoyaMilk();
    pureSoyaMilk.make();
    
    //输出
    --------制作纯豆浆--------
    第一步,选择好的新鲜黄豆
    第三步,黄豆和配料开始浸泡,需要3个小时
    第四步,黄豆和配料放到豆浆机去打碎
}

3. View的draw(Android)

Android中View的draw方法就是使用了模板方法模式

public class View{
    //钩子方法,空实现
    protected void onDraw(Canvas canvas) {
    }
    //钩子方法,空实现
    protected void dispatchDraw(Canvas canvas) {
    }
    //绘制方法,定义绘制流程
    public void draw(Canvas canvas) {
       //其他代码略

        /*
         *  绘制流程如下:
         *
         *      1. 绘制view背景
         *      2. 如果有需要,就保存图层
         *      3. 绘制view内容
         *      4. 绘制子View
         *      5. 如果有必要,绘制渐变框和恢复图层
         *      6. 绘制装饰(滑动条等)
         */

        if (!dirtyOpaque) {
            drawBackground(canvas);//步骤1. 绘制view背景
        }

        // 如果可能的话跳过第2步和第5步(常见情况)
        final int viewFlags = mViewFlags;
        boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0;
        boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0;
        if (!verticalEdges && !horizontalEdges) {
            if (!dirtyOpaque) onDraw(canvas);//步骤3. 绘制view内容

            dispatchDraw(canvas);//步骤4. 绘制子View

            // 覆盖一部分内容,绘制前景
            if (mOverlay != null && !mOverlay.isEmpty()) {
                mOverlay.getOverlayView().dispatchDraw(canvas);
            }

            onDrawForeground(canvas); //步骤6. 绘制装饰(滑动条等)

            return;
        }
}

说明:

  • View的draw()方法中定义了一整套的绘制流程,这个流程是固定的,所有的Android中的View都是按照这个流程来绘制的。其中drawBackground()这个方法在View类中是实现了具体过程的,而onDraw()方法和dispatchDraw()方法在View中都是空实现,即都是钩子方法。不同的子类通过重写这些空实现来实现自身不同的绘制效果。
  • 具体的View,像TextView这些单一的View,就会重写onDraw()方法,由于TextView没有子View,所以dispatchDraw()还是空实现;而ViewGroup类含有子View,需要遍历子View并绘制,因此需要重写onDraw()和dispatchDraw()。
  • 所以,我们自定义View时必须且只需重写onDraw();自定义ViewGroup时则需要重写onDraw()和dispatchDraw()。

模板方法模式在 Spring 框架应用的源码分析

知识小结

  1. 基本思想是:算法只存在于一个地方,也就是在父类中,容易修改。需要修改算法时,只要修改父类的模板方法或者已经实现的某些步骤,子类就会继承这些修改
  2. 实现了最大化代码复用。父类的模板方法和已实现的某些步骤会被子类继承而直接使用。
  3. 既统一了算法,也提供了很大的灵活性。父类的模板方法确保了算法的结构保持不变,同时由子类提供部分步骤的实现。
  4. 该模式的不足之处:每一个不同的实现都需要一个子类实现,导致类的个数增加,使得系统更加庞大
  5. 一般模板方法都加上 final 关键字, 防止子类重写模板方法.
  6. 模板方法模式使用场景:当要完成在某个过程,该过程要执行一系列步骤 ,这一系列的步骤基本相同,但其个别步骤在实现时可能不同,通常考虑用模板方法模式来处理

二、命令模式

1. 基本介绍

  1. 命令模式(Command Pattern):在软件设计中,我们经常需要向某些对象发送请求,但是并不知道请求的接收者是谁,也不知道被请求的操作是哪个, 我们只需在程序运行时指定具体的请求接收者即可,此时,可以使用命令模式来进行设计
  2. 命名模式使得请求发送者与请求接收者消除彼此之间的耦合,让对象之间的调用关系更加灵活,实现解耦。
  3. 在命令模式中,会将一个请求封装为一个对象,以便使用不同参数来表示不同的请求(即命名),同时命令模式也支持可撤销的操作。
  4. 通俗易懂的理解:将军发布命令,士兵去执行。其中有几个角色:将军(命令发布者)、士兵(命令的具体执行者)、命令(连接将军和士兵)。 Invoker 是调用者(将军),Receiver 是被调用者(士兵)MyCommand 是命令,实现了 Command 接口,持有接收对象

对原理类图的说明-即(命名模式的角色及职责)

  1. Invoker 是调用者角色
  2. Command: 是命令角色,需要执行的所有命令都在这里,可以是接口或抽象类
  3. Receiver: 接收者角色,知道如何实施和执行一个请求相关的操作
  4. ConcreteCommand: 将一个接受者对象与一个动作绑定,调用接受者相应的操作,实现 execute

2. 应用案例一:智能生活问题

需求

  1. 我们买了一套智能家电,有照明灯、风扇、冰箱、洗衣机,我们只要在手机上安装 app 就可以控制对这些家电工作。
  2. 这些智能家电来自不同的厂家,我们不想针对每一种家电都安装一个 App,分别控制,我们希望只要一个 app 就可以控制全部智能家电。
  3. 要实现一个 app 控制所有智能家电的需要,则每个智能家电厂家都要提供一个统一的接口给 app 调用,这时 就可以考虑使用命令模式。
  4. 命令模式可将“动作的请求者”从“动作的执行者”对象中解耦出来.
  5. 在我们的例子中,动作的请求者是手机 app,动作的执行者是每个厂商的一个家电产品

代码实现

ICommand 抽象命令者(Command角色)

public interface ICommand {
    void execute();//执行
    void undo();//撤销
}

电灯开关命令(ConcreteCommand)

public class LightOnCommand implements ICommand {
    LightReceiver receiver;

    public LightOnCommand(LightReceiver receiver) {
        this.receiver = receiver;
    }

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

    @Override
    public void undo() {
        receiver.off();
    }
}
public class LightOffCommand implements ICommand {
    LightReceiver receiver;

    public LightOffCommand(LightReceiver receiver) {
        this.receiver = receiver;
    }

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

    @Override
    public void undo() {
        receiver.on();
    }
}
public class NoCommand implements ICommand {
    @Override
    public void execute() {
    }
    @Override
    public void undo() {

    }
}

电灯对象 (接收者 Receiver角色)

public class LightReceiver {

    public void on(){
        System.out.println("开灯请睁眼");
    }
    public void off(){
        System.out.println("关灯请闭眼");
    }
}

遥控器(调用者角色 Invoker角色)

public class RemoteController {
    //开关按钮
    ICommand[] onCommands;
    ICommand[] offCommands;
    //撤销按钮
    ICommand undoCommand;

    public RemoteController() {
        onCommands  = new ICommand[5];
        offCommands  = new ICommand[5];
        for (int i = 0; i < 5; i++) {
            onCommands[i] = new NoCommand();
            offCommands[i] = new NoCommand();
        }

    }

    // 给我们的按钮设置你需要的命令
    public void setCommand(int no, ICommand onCommand, ICommand offCommand) {
        onCommands[no] = onCommand;
        offCommands[no] = offCommand;
    }

    public void onButtonClicked(int no){
        onCommands[no].execute();
        undoCommand = onCommands[no];
    }

    public void offButtonClicked(int no){
        offCommands[no].execute();
        undoCommand = offCommands[no];
    }

    public void undoButtonClicked(){
        undoCommand.undo();
    }
    
}

电视机对象

# 编写第2种家电
public class TVReceiver {
    public void on() {
        System.out.println(" 电视机打开了.. ");
    }
    
    public void off() {
        System.out.println(" 电视机关闭了.. ");
    }
}

电视机开关命令

public class TVOffCommand implements Command {

    // 聚合TVReceiver
    TVReceiver tv;

    // 构造器
    public TVOffCommand(TVReceiver tv) {
        super();
        this.tv = tv;
    }

    @Override
    public void execute() {
        // TODO Auto-generated method stub
        // 调用接收者的方法
        tv.off();
    }

    @Override
    public void undo() {
        // TODO Auto-generated method stub
        // 调用接收者的方法
        tv.on();
    }
}
public class TVOnCommand implements Command {

    // 聚合TVReceiver
    TVReceiver tv;

    // 构造器
    public TVOnCommand(TVReceiver tv) {
        super();
        this.tv = tv;
    }

    @Override
    public void execute() {
        // TODO Auto-generated method stub
        // 调用接收者的方法
        tv.on();
    }

    @Override
    public void undo() {
        // TODO Auto-generated method stub
        // 调用接收者的方法
        tv.off();
    }
}

客户端调用

public class Client {
    public static void main(String[] args) {
        //创建电灯的对象 (接收者)
        LightReceiver receiver = new LightReceiver();
        //创建电灯的开关命令
        ICommand onCommand = new LightOnCommand(receiver);
        ICommand offCommand = new LightOffCommand(receiver);
        //创建遥控器
        RemoteController controller = new RemoteController();
        //给遥控器设置相关命令
        controller.setCommand(0,onCommand,offCommand);
        System.out.println("----按下开灯按钮----");
        controller.onButtonClicked(0);
        System.out.println("----按下关灯按钮----");
        controller.offButtonClicked(0);
        System.out.println("----按下撤销按钮----");
        controller.undoButtonClicked();

        System.out.println("----------开始操作电视机----------");
        TVReceiver tvReceiver = new TVReceiver();
        ICommand tvOnCommand = new TVOnCommand(tvReceiver);
        ICommand tvOffCommand = new TVOffCommand(tvReceiver);
        controller.setCommand(1,tvOnCommand,tvOffCommand);
        controller.onButtonClicked(1);
        controller.offButtonClicked(1);
        controller.undoButtonClicked();

    }
}

3. 常见应用

Thread

实际上Thread的使用就是一个简单的命令模式,先看下Thread的使用:

 new Thread(new Runnable() {
            @Override
            public void run() {
                //doSomeThing
            }
        }).start();

Thread的start()方法即命令的调用者,同时Thread的内部会调用Runnable的run(),这里Thread又

充当了具体的命令角色,最后的Runnable则是接受者了,负责最后的功能处理。

Android 中的 Handler

另一个比较典型的常用到命令模式就是Handler了,这里就不贴代码了,简单分析下各个类的角

色:

  • 接收者:Handler,执行消息的处理操作。
  • 调用者:Looper,调用消息的的处理方法。
  • 命令角色:Message,消息类。

4. 知识小结

  1. 将发起请求的对象与执行请求的对象解耦。发起请求的对象是调用者,调用者只要调用命令对象的execute()方法就可以让接收者工作,而不必知道具体的接收者对象是谁、是如何实现的,命令对象会负责让接收者执行请求的动作,也就是说:”请求发起者”和“请求执行者”之间的解耦是通过命令对象实现的,命令对象起到了纽带桥梁的作用。
  2. 容易设计一个命令队列。只要把命令对象放到列队,就可以多线程的执行命令
  3. 容易实现对请求的撤销和重做
  4. 命令模式不足:可能导致某些系统有过多的具体命令类,增加了系统的复杂度,这点在在使用的时候要注意
  5. 空命令也是一种设计模式,它为我们省去了判空的操作。在上面的实例中,如果没有用空命令,我们每按下一个按键都要判空,这给我们编码带来一定的麻烦。
  6. 命令模式经典的应用场景:界面的一个按钮都是一条命令、模拟 CMD(DOS 命令)订单的撤销/恢复、触发- 反馈机制

三、访问者模式

1. 基本介绍

  1. 访问者模式(Visitor Pattern),封装一些作用于某种数据结构的各元素的操作,它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。
  2. 主要将数据结构与数据操作分离,解决数据结构和操作耦合性问题
  3. 访问者模式的基本工作原理是:在被访问的类里面加一个对外提供接待访问者的接口
  4. 访问者模式主要应用场景是:需要对一个对象结构中的对象进行很多不同操作(这些操作彼此没有关联),同时需要避免让这些操作"污染"这些对象的类,可以选用访问者模式解决

对原理类图的说明-即(访问者模式的角色及职责)

  1. Visitor 是抽象访问者,为该对象结构中的 ConcreteElement 的每一个类声明一个 visit 操作
  2. ConcreteVisitor :是一个具体的访问值 实现每个有 Visitor 声明的操作,是每个操作实现的部分.
  3. ObjectStructure 能枚举它的元素, 可以提供一个高层的接口,用来允许访问者访问元素
  4. Element 定义一个 accept 方法,接收一个访问者对象
  5. ConcreteElement 为具体元素,实现了 accept 方法

2. 应用案例一:歌手测评问题

需求

完成测评系统需求

  1. 将观众分为男人和女人,对歌手进行测评,当看完某个歌手表演后,得到他们对该歌手不同的评价(评价 有不同的种类,比如 成功、失败 等)
  2. 传统方案

传统方式的问题分析

  1. 如果系统比较小,还是 ok 的,但是考虑系统增加越来越多新的功能时,对代码改动较大,违反了 ocp 原则, 不利于维护
  2. 扩展性不好,比如 增加了 新的人员类型,或者管理方法,都不好做
  3. 引出我们会使用新的设计模式 – 访问者模式

代码实现

  1. 将人分为男人和女人,对歌手进行测评,当看完某个歌手表演后,得到他们对该歌手不同的评价(评价 有不同的种类,比如 成功、失败 等),请使用访问者模式来说实现
  2. 思路分析和图解(类图)

① 抽象访问者(Visitor角色)

public abstract class Action {
    //得到男性测评结果
    abstract void getManResult(Man man);
    //得到女性评测结果
    abstract void getWomanResult(Woman man);
}

② 具体访问者 (ConcreteVisitor角色)

public class Success extends Action{
    @Override
    void getManResult(Man man) {
        System.out.println(man.getName()+",这个男人给的评价是很成功");
    }

    @Override
    void getWomanResult(Woman woman) {
        System.out.println(woman.getName()+",这个女人给的评价是很成功");
    }
}

public class Fail extends Action{
    @Override
    void getManResult(Man man) {
        System.out.println(man.getName()+",这个男人给的评价是失败了");
    }

    @Override
    void getWomanResult(Woman woman) {
        System.out.println(woman.getName()+",这个女人给的评价是失败了");
    }
}

③ 抽象接收者(Element角色)

public abstract class Person {
    //提供一个方法 让访问者可以访问
    public abstract void accept(Action action);
}

④ 具体接收者

/**
 * 说明:
 * 1. 这里使用到了双分派,即首先在客户端程序中,将具体的状态作为参数传递到Woman或者Man中(第一次分派)
 * 2. 然后Woman类调用了作为参数的"具体方法"中方法getWomanResult,同时将自己(this)作为参数传入,完成了第二次分派
 */
public class Woman extends Person {
    @Override
    public void accept(Action action) {
        action.getWomanResult(this);
    }
}

public class Man extends Person {

    @Override
    public void accept(Action action) {
        action.getManResult(this);
    }
}

⑤ 数据结构 (ObjectStructure 角色)

/**
 * @description 数据结构,管理很多人(Man  Woman)
 */
public class ObjectStructure {
    //维护了一个集合
    private List<Person> persons = new LinkedList<>();

    //增加到list
    public void attach(Person person){
        persons.add(person);
    }

    //删除
    public void detach(Person person){
        persons.remove(person);
    }

    //显示测评结果
    public void display(Action action){
        for (Person p: persons) {
            p.accept(action);
        }
    }
}

⑥ 客户端调用

public class Client {
    public static void main(String[] args) {
        //创建objectStructure
        ObjectStructure objectStructure = new ObjectStructure();
        objectStructure.attach(new Man("张三"));
        objectStructure.attach(new Man("李四"));
        objectStructure.attach(new Woman("王小花"));
        //成功
        Action success = new Success();
        objectStructure.display(success);

        //失败
        Action fail = new Fail();
        objectStructure.display(fail);

    }
}

输出

张三,这个男人给的评价是很成功
李四,这个男人给的评价是很成功
王小花,这个女人给的评价是很成功
张三,这个男人给的评价是失败了
李四,这个男人给的评价是失败了
王小花,这个女人给的评价是失败了
张三,这个男人给的评价是待定
李四,这个男人给的评价是待定
王小花,这个女人给的评价是待定

双分派

  • 上面提到了双分派,所谓双分派是指不管类怎么变化,我们都能找到期望的方法运行。双分派意味着得到执行的操作取决于请求的种类和两个接收者的类型
  • 以上述实例为例,假设我们要添加一个 Wait 的状态类,考察 Man 类和 Woman 类的反应,由于使用了双分派,只需增加一个 Action 子类即可在客户端调用即可,不需要改动任何其他类的代码

如: 新增待定评价

public class Wait extends Action {
    @Override
    void getManResult(Man man) {
        System.out.println(man.getName()+",这个男人给的评价是待定");
    }

    @Override
    void getWomanResult(Woman woman) {
        System.out.println(woman.getName()+",这个女人给的评价是待定");
    }
}

调用

main(...){
    //待定
    Action wait = new Wait();
    objectStructure.display(wait);
}

3. 知识小结

优点

  1. 访问者模式符合单一职责原则、让程序具有优秀的扩展性、灵活性非常高
  2. 访问者模式可以对功能进行统一,可以做报表、UI、拦截器与过滤器,适用于数据结构相对稳定的系统缺点
  3. 具体元素对访问者公布细节,也就是说访问者关注了其他类的内部细节,这是迪米特法则所不建议的, 这样造成了具体元素变更比较困难
  4. 违背了依赖倒转原则。访问者依赖的是具体元素,而不是抽象元素
  5. 因此,如果一个系统有比较稳定的数据结构,又有经常变化的功能需求,那么访问者模式就是比较合适的.

四、迭代器模式

1. 基本介绍

  1. 迭代器模式(Iterator Pattern)是常用的设计模式,属于行为型模式
  2. 如果我们的集合元素是用不同的方式实现的,有数组,还有 java 的集合类,或者还有其他方式,当客户端要遍历这些集合元素的时候就要使用多种遍历方式,而且还会暴露元素的内部结构,可以考虑使用迭代器模式解决。
  3. 迭代器模式,提供一种遍历集合元素的统一接口,用一致的方法遍历集合元素,不需要知道集合对象的底层表示,即:不暴露其内部的结构。

对原理类图的说明-即(迭代器模式的角色及职责)

  1. Iterator : 迭代器接口,是系统提供,含义 hasNext, next, remove
  2. ConcreteIterator : 具体的迭代器类,管理迭代
  3. Aggregate :一个统一的聚合接口, 将客户端和具体聚合解耦
  4. ConcreteAggreage : 具体的聚合持有对象集合, 并提供一个方法,返回一个迭代器, 该迭代器可以正确遍历集合
  5. Client :客户端, 通过 Iterator 和 Aggregate 依赖子类

2. 应用案例一:学校院系结构问题

需求

编写程序展示一个学校院系结构:需求是这样,要在一个页面中展示出学校的院系组成,一个学校

有多个学院, 一个学院有多个系。

传统的方式的问题分析

  1. 将学院看做是学校的子类,系是学院的子类,这样实际上是站在组织大小来进行分层次的
  2. 实际上我们的要求是:在一个页面中展示出学校的院系组成,一个学校有多个学院,一个学院有多个系,因此这种方案,不能很好实现的遍历的操作
  3. 解决方案:=> 迭代器模式

3. 代码实现

  1. 应用实例要求 编写程序展示一个学校院系结构:需求是这样,要在一个页面中展示出学校的院系组成,一个学校有多个学院, 一个学院有多个系。
  2. 设计思路分析

代码实现

① 迭代器接口Iterator 使用jdk提供的java.util.Iterator

② 具体的迭代器类(ConcreteIterator 角色)

public class InfoCollegeIterator implements Iterator {

    List<Department> departmentList;//信息工程学院是以List方式存放系
    int index = -1;//遍历的位置

    public InfoCollegeIterator(List<Department> departmentList) {
        this.departmentList = departmentList;
    }

    @Override
    public boolean hasNext() {
        if (index>=departmentList.size()-1){
            return false;
        }
        index += 1;
        return true;
    }

    @Override
    public Object next() {
        Department department = departmentList.get(index);
        return department;
    }

    //删除方法默认空实现
    @Override
    public void remove() {

    }
}
public class ComputerCollegeIterator implements Iterator {

    //需要知道Department是以怎样的方式存放 => 数组
    Department[] departments;
    int position = 0;//遍历的位置

    public ComputerCollegeIterator(Department[] departments) {
        this.departments = departments;
    }

    @Override
    public boolean hasNext() {
        if (position>=departments.length||departments[position]==null){
            return false;
        }
        return true;
    }

    @Override
    public Object next() {
        Department department = departments[position];
        position += 1;
        return department;
    }

    //删除方法默认空实现
    @Override
    public void remove() {

    }
}

③ 统一的聚合接口 (Aggregate 角色)

public interface College {
    public String getName();
    //增加系的方法
    public void addDepartment(String name,String desc);
    //返回一个迭代器 遍历
    public Iterator createIterator();
}

④ 具体的聚合持有对象集合 (ConcreteAggreage 角色)

public class ComputerColleage implements College {

    Department[] departments;
    int numOfDepartment = 0;//保存当前数组的对象个数

    public ComputerColleage() {
        departments = new Department[5];
        addDepartment("Java","java专业");
        addDepartment("PHP","PHP专业");
        addDepartment("大数据","大数据专业");
    }

    @Override
    public String getName() {
        return "计算机学院";
    }

    @Override
    public void addDepartment(String name, String desc) {
        Department department = new Department(name,desc);
        departments[numOfDepartment] = department;
        numOfDepartment += 1;
    }

    @Override
    public Iterator createIterator() {
        return new ComputerCollegeIterator(departments);
    }
}
public class InfoCollegeIterator implements Iterator {

    List<Department> departmentList;//信息工程学院是以List方式存放系
    int index = -1;//遍历的位置

    public InfoCollegeIterator(List<Department> departmentList) {
        this.departmentList = departmentList;
    }

    @Override
    public boolean hasNext() {
        if (index>=departmentList.size()-1){
            return false;
        }
        index += 1;
        return true;
    }

    @Override
    public Object next() {
        Department department = departmentList.get(index);
        return department;
    }

    //删除方法默认空实现
    @Override
    public void remove() {

    }
}

⑤ 输出类(个人认为有点像外观模式中的外观类)

public class OutputImpl {
    //学院集合
    List<College> collegeList;
    public OutputImpl(List<College> collegeList) {
        this.collegeList = collegeList;
    }

    //遍历所有的许愿  然后调用printDepartment 输出各个学院的系
    public void printCollege(){
        //从collegeList去除所有学院
        //java 中的List已经实现了iterator
        Iterator<College> iterator = collegeList.iterator();
        while (iterator.hasNext()){
            College c = (College)iterator.next();
            System.out.println(c.getName());
            printDepartment(c.createIterator());
        }
    }
    
    //输出 学院输出系
    public void printDepartment(Iterator iterator){
        while (iterator.hasNext()){
            Department d = (Department)iterator.next();
            System.out.println(d.getName()+" -- "+d.getDesc());
        }
    }
}

⑥ 客户端调用

public class Client {
    public static void main(String[] args) {
        //创建学院
        ArrayList<College> collegeList = new ArrayList<>();
        ComputerColleage computerColleage = new ComputerColleage();
        InfoColleage infoColleage = new InfoColleage();
        collegeList.add(computerColleage);
        collegeList.add(infoColleage);
        OutputImpl output = new OutputImpl(collegeList);
        output.printCollege();
    }
}

4. JDK源码(ArrayList)

JDK 的 ArrayList集合中就使用了迭代器模式

public class IteratorDemo {
    public static void main(String[] args) {
        List<String> a = new ArrayList<>();
        a.add("jack");
        a.add("tom");
        Iterator<String> iterator = a.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

对类图的角色分析和说明

  • 内部类 Itr 充当具体实现迭代器 Iterator 的类, 作为 ArrayList 内部类
  • List 就是充当了聚合接口,含有一个 iterator() 方法,返回一个迭代器对象
  • ArrayList 是实现聚合接口 List 的子类,实现了 iterator()
  • Iterator 接口系统提供
  • 迭代器模式解决了 不同集合(ArrayList ,LinkedList) 统一遍历问题

5. 知识小结

优点

  1. 提供一个统一的方法遍历对象,客户不用再考虑聚合的类型,使用一种方法就可以遍历对象了。
  2. 隐藏了聚合的内部结构,客户端要遍历聚合的时候只能取到迭代器,而不会知道聚合的具体组成。
  3. 提供了一种设计思想,就是一个类应该只有一个引起变化的原因(叫做单一责任原则)。在聚合类中,我们把迭代器分开,就是要把管理对象集合和遍历对象集合的责任分开,这样一来集合改变的话,只影响到聚合对象。而如果遍历方式改变的话,只影响到了迭代器。
  4. 当要展示一组相似对象,或者遍历一组相同对象时使用, 适合使用迭代器模式

缺点

  1. 每个聚合对象都要一个迭代器,会生成多个迭代器不好管理类

五、观察者模式

1. 基本介绍

  1. 观察者模式类似订牛奶业务
  2. 奶站/气象局:Subject
  3. 用户/第三方网站:Observer
  • Subject:登记注册、移除和通知
  • registerObserver: 注 册
  • removeObserver: 移除
  • notifyObservers(): 通知所有的注册的用户,根据不同需求,可以是更新数据,让用户来取,也可能是实施推送, 看具体需求定Observer:接收输入
  • 观察者模式:对象之间多对一依赖的一种设计方案,被依赖的对象为 Subject,依赖的对象为Observer,Subject 通知 Observer 变化,比如这里的奶站是 Subject,是 1 的一方。用户时 Observer,是多的一方。

2. 应用案例一:天气预报问题

需求

天气预报项目需求,具体要求如下

  1. 气象站可以将每天测量到的温度,湿度,气压等等以公告的形式发布出去(比如发布到自己的网站或第三方)。
  2. 需要设计开放型 API,便于其他第三方也能接入气象站获取数据。
  3. 提供温度、气压和湿度的接口
  4. 测量数据更新时,要能实时的通知给第三方

传统方案

或者

传统方式代码实现

天气情况 CurrentConditions

public class CurrentConditions {
    // 温度,气压,湿度
    private float temperature;
    private float pressure;
    private float humidity;

    //更新 天气情况,是由 WeatherData 来调用,我使用推送模式
    public void update(float temperature, float pressure, float humidity) {
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        display();
    }

    //显示
    public void display() {
        System.out.println("***Today mTemperature: " + temperature + "***");
        System.out.println("***Today mPressure: " + pressure + "***");
        System.out.println("***Today mHumidity: " + humidity + "***");
    }
}

天气核心类 WeatherData

/**
 * 类是核心
 * 1. 包含最新的天气情况信息
 * 2. 含有 CurrentConditions 对象
 * 3.  当数据有更新时,就主动的调用	CurrentConditions 对象 update 方法(含 display),  这样他们(接入方)就看到最新的信息
 *
 * @author Administrator
 */
public class WeatherData {
    private float temperatrue;
    private float pressure;
    private float humidity;
    private CurrentConditions currentConditions;
    //加入新的第三方
    public WeatherData(CurrentConditions currentConditions) {
        this.currentConditions = currentConditions;
    }

    public float getTemperature() {
        return temperatrue;
    }

    public float getPressure() {
        return pressure;
    }

    public float getHumidity() {
        return humidity;
    }

    public void dataChange() {
    //调用 接入方的 update
        currentConditions.update(getTemperature(), getPressure(), getHumidity());
    }

    //当数据有更新时,就调用 setData
    public void setData(float temperature, float pressure, float humidity) {
        this.temperatrue = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        //调用 dataChange, 将最新的信息 推送给 接入方 currentConditions
        dataChange();
    }
}

客户端测试

public class Client {
    public static void main(String[] args) {
        //创建接入方 currentConditions
        CurrentConditions currentConditions = new CurrentConditions();
        //创建 WeatherData 并将 接入方 currentConditions 传递到 WeatherData 中
        WeatherData weatherData = new WeatherData(currentConditions);

        //更新天气情况
        weatherData.setData(30, 150, 40);
        //天气情况变化
        System.out.println("============天气情况变化=============");
        weatherData.setData(40, 160, 20);

    }
}
传统方式问题分析
  1. 其他第三方接入气象站获取数据的问题
  2. 无法在运行时动态的添加第三方 (新浪网站)
  3. 违反 ocp 原则=>观察者模式//在 WeatherData 中,当增加一个第三方,都需要创建一个对应的第三方的公告板对象,并加入到 dataChange, 不利于维护,也不是动态加入

观测者模式实现

① Subject角色(主题) ,登记注册、移除和通知

抽象主题

public interface Subject {
    public void registerObserver(Observer observer);
    public void removeObserver(Observer observer);
    public void notifyObservers();
}

具体主题

/**
 * 类是核心
 * 1. 包含最新的天气情况信息
 * 2. 含有 观察者 使用ArrayList管理
 * 3.  当数据有更新时,就主动的调用	ArrayList  这样他们(接入方)就看到最新的信息
 *
 * @author Administrator
 */
public class WeatherData implements Subject{
    private float temperatrue;
    private float pressure;
    private float humidity;
    //观察者集合
    private ArrayList<Observer> observers;

    public WeatherData() {
        observers = new ArrayList<>();
    }

    public float getTemperature() {
        return temperatrue;
    }

    public float getPressure() {
        return pressure;
    }

    public float getHumidity() {
        return humidity;
    }

    //当数据有更新时,就调用 setData
    public void setData(float temperature, float pressure, float humidity) {
        this.temperatrue = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        dataChange();
    }

    public void dataChange() {
        notifyObservers();
    }

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        if (observers.contains(observer)){
            observers.remove(observer);
        }
    }

    @Override
    public void notifyObservers() {
        for (Observer observer: observers) {
            observer.update(getTemperature(),getPressure(),getHumidity());
        }
    }


}

② Observer:接收输入

抽象观察者

/**
 * @description 观察者接口,由观察者来实现
 */
public interface Observer {
    public void update(float temperature,float pressure,float humidity);
}

具体观察者

public class CurrentConditions implements Observer {
    // 温度,气压,湿度
    private float temperature;
    private float pressure;
    private float humidity;

    //更新 天气情况,是由 WeatherData 来调用,我使用推送模式
    public void update(float temperature, float pressure, float humidity) {
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        display();
    }

    //显示
    public void display() {
        System.out.println("***Today mTemperature: " + temperature + "***");
        System.out.println("***Today mPressure: " + pressure + "***");
        System.out.println("***Today mHumidity: " + humidity + "***");
    }
}

具体观察者,扩展天气服务站点

public class BaiduSite implements Observer {
    // 温度,气压,湿度
    private float temperature;
    private float pressure;
    private float humidity;

    //更新 天气情况,是由 WeatherData 来调用,我使用推送模式
    public void update(float temperature, float pressure, float humidity) {
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        display();
    }

    //显示
    public void display() {
        System.out.println("***百度数据 气温: " + temperature + "***");
        System.out.println("***百度数据 气压: " + pressure + "***");
        System.out.println("***百度数据 湿度: " + humidity + "***");
    }
}

③ 客户端调用

public class Client {
    public static void main(String[] args) {
        //创建一个WeatherData
        Subject subject = new WeatherData();
        //创建观察者
        Observer observer = new CurrentConditions();
        Observer observer2 = new BaiduSite();
        //注册到weatherData
        subject.registerObserver(observer);
        subject.registerObserver(observer2);
        //通知各个注册的观察者
        ((WeatherData)subject).setData(10f,20f,30f);
    }
}

3. JDK源码(Observable)

Jdk 的 Observable 类就使用了观察者模式

public interface Observer {//(抽象观察者
    //只定义了一个update方法
    void update(Observable o, Object arg);
}

public class Observable {//抽象被观察者
    private boolean changed = false;//定义改变状态,默认为false
    private final ArrayList<Observer> observers;//定义一个观察者list

    public Observable() {//构造函数,初始化一个观察者list来保存观察者
        observers = new ArrayList<>();
    }
    //添加观察者,带同步字段的,所以是线程安全的
    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!observers.contains(o)) {
            observers.add(o);
        }
    }

    //删除观察者
    public synchronized void deleteObserver(Observer o) {
        observers.remove(o);
    }

    //通知所以观察者,无参数
    public void notifyObservers() {
        notifyObservers(null);
    }

     //通知所有观察者,带参数
    public void notifyObservers(Object arg) {

        Observer[] arrLocal;
        //加synchronized字段,保证多线程下操作没有问题
        synchronized (this) {
            if (!hasChanged())//这里做了是否发生改变的判断,是为了防止出现无意义的更新
                return;

            arrLocal = observers.toArray(new Observer[observers.size()]);//ArrayList转换成一个临时的数组,这样就防止了通知,添加,移除同时发生可能导致的异常
            clearChanged();///清除改变状态,设置为false
        }
        //遍历逐一通知
        for (int i = arrLocal.length-1; i>=0; i--)
            arrLocal[i].update(this, arg);
    }

    //清楚所有观察者
    public synchronized void deleteObservers() {
        observers.clear();
    }

    //设置被观察者为改变状态,设置为true
    protected synchronized void setChanged() {
        changed = true;
    }

    //清除改变状态,设置为false
    protected synchronized void clearChanged() {
        changed = false;
    }

    //返回当前的改变状态
    public synchronized boolean hasChanged() {
        return changed;
    }

    //观察者数量
    public synchronized int countObservers() {
        return observers.size();
    }
}

模式角色分析

  • Observable 的作用和地位等价于 我们前面讲过Subject
  • Observable 是类,不是接口,类中已经实现了核心的方法 ,即管理 Observer 的方法 add.. delete ..notify...
  • Observer 的作用和地位等价于我们前面讲过的 Observer, 有 update
  • Observable 和 Observer 的使用方法和前面讲过的一样,只是 Observable 是类,通过继承来实现观察者模式

4. 知识小结

优点

  1. 观察者模式设计后,会以集合的方式来管理用户(Observer),包括注册,移除和通知。
  2. 这样,我们增加观察者(这里可以理解成一个新的公告板),就不需要去修改核心类 WeatherData 不会修改代码, 遵守了 ocp 原则。
  3. 解除观察者与主题之间的耦合。让耦合的双方都依赖于抽象,而不是依赖具体。从而使得各自的变化都不会影响另一边的变化。
  4. 易于扩展,对同一主题新增观察者时无需修改原有代码。

缺点

  • 依赖关系并未完全解除,抽象主题仍然依赖抽象观察者。
  • 使用观察者模式时需要考虑一下开发效率和运行效率的问题,程序中包括一个被观察者、多个观察者,开发、调试等内容会比较复杂,而且在Java中消息的通知一般是顺序执行,那么一个观察者卡顿,会影响整体的执行效率,在这种情况下,一般会采用异步实现。
  • 可能会引起多余的数据通知。

六、中介者模式

1. 基本介绍

  1. 中介者模式(Mediator Pattern),用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互
  2. 中介者模式属于行为型模式,使代码易于维护
  3. 比如 MVC 模式,C(Controller 控制器)是 M(Model 模型)和 V(View 视图)的中介者,在前后端交互时起到了中间人的作用

原理类图

对原理类图的说明-即(中介者模式的角色及职责)

  1. Mediator 就是抽象中介者,定义了同事对象到中介者对象的接口
  2. Colleague 是抽象同事类
  3. ConcreteMediator 具体的中介者对象, 实现抽象方法, 他需要知道所有的具体的同事类,即以一个集合来管理 HashMap,并接受某个同事对象消息,完成相应的任务
  4. ConcreteColleague 具体的同事类,会有很多, 每个同事只知道自己的行为, 而不了解其他同事类的行为(方法), 但是他们都依赖中介者对象

2. 应用案例一:智能家庭管理问题

需求

  1. 智能家庭包括各种设备,闹钟、咖啡机、电视机、窗帘 等
  2. 主人要看电视时,各个设备可以协同工作,自动完成看电视的准备工作,比如流程为:闹铃响起->咖啡机开始做咖啡->窗帘自动落下-电视机开始播放

传统方式解决

传统的方式的问题分析
  1. 当各电器对象有多种状态改变时,相互之间的调用关系会比较复杂
  2. 各个电器对象彼此联系,你中有我,我中有你,不利于松耦合.
  3. 各个电器对象之间所传递的消息(参数),容易混乱
  4. 当系统增加一个新的电器对象时,或者执行流程改变时,代码的可维护性、扩展性都不理想考虑中介者模式

代码实现

完成前面的智能家庭的项目,使用中介者模式

中介者模式一智能家庭的操作流程:

创建ConcreMediator对象

public abstract class Mediator {
//将给中介者对象,加入到集合中
public abstract void Register(String colleagueName, Colleague colleague);

//接收消息, 具体的同事对象发出
public abstract void GetMessage(int stateChange, String colleagueName);


public abstract void SendMessage();
}

创建各个同事类对象,比如: Alarm、CoffeeMachine. TV..

在创建同事类对象的时候,就直接通过构造器,加入到 colleagueMap

public abstract class Colleague {
    private Mediator mediator;
    public String name;

    public Colleague(Mediator mediator, String name) {
        this.mediator = mediator;
        this.name = name;
    }

    public Mediator getMediator() {
        return mediator;
    }
    
    public abstract void SendMessage(int stateChange);
}
public class TV extends Colleague {

    public TV(Mediator mediator, String name) {
        super(mediator, name);
        mediator.Register(name, this);
    }

    @Override
    public void SendMessage(int stateChange) {
        this.GetMediator().GetMessage(stateChange, this.name);
    }

    public void StartTv() {
        System.out.println("It's time to StartTv!");
    }

    public void StopTv() {
        System.out.println("StopTv!");
    }
}

//具体的同事类
public class Alarm extends Colleague {

    //构造器
    public Alarm(Mediator mediator, String name) {
        super(mediator, name);
        //在创建 Alarm 同事对象时,将自己放入到 ConcreteMediator 对象中[集合]
        mediator.Register(name, this);
    }
    
    public void SendAlarm(int stateChange) {
        SendMessage(stateChange);
    }
    
    @Override
    public void SendMessage(int stateChange) {
        this.GetMediator().GetMessage(stateChange, this.name);
    }
    
}

public class CoffeeMachine extends Colleague {

    public CoffeeMachine(Mediator mediator, String name) {
        super(mediator, name);


        mediator.Register(name, this);
    }
    
    @Override
    public void SendMessage(int stateChange) {
        this.GetMediator().GetMessage(stateChange, this.name);
    }
    
    public void StartCoffee() {
        System.out.println("It's time to startcoffee!");
    }
    
    public void FinishCoffee() {
        System.out.println("After 5 minutes!");
        System.out.println("Coffee is ok!");
        SendMessage(0);
    }
}

public class Curtains extends Colleague {
    
    public Curtains(Mediator mediator, String name) { super(mediator, name);
          mediator.Register(name, this);
    }
    
    @Override
    public void SendMessage(int stateChange) {
          this.GetMediator().GetMessage(stateChange, this.name);
    }

    public void UpCurtains() {
        System.out.println("I am holding Up Curtains!");
    }
    
}

同事类对象,可以调用sendMessage ,最终会去调用 ConcreteMediator的 getMessage方法

//具体的中介者类
public class ConcreteMediator extends Mediator {
    //集合,放入所有的同事对象
    private HashMap<String, Colleague> colleagueMap;
    private HashMap<String, String> interMap;
    
    public ConcreteMediator() {
        colleagueMap = new HashMap<String, Colleague>();
        interMap = new HashMap<String, String>();
    }

    @Override
    public void Register(String colleagueName, Colleague colleague) {
        colleagueMap.put(colleagueName, colleague);
        if (colleague instanceof Alarm) {
            interMap.put("Alarm", colleagueName);
        } else if (colleague instanceof CoffeeMachine) {
            interMap.put("CoffeeMachine", colleagueName);
        } else if (colleague instanceof TV) {
            interMap.put("TV", colleagueName);
        } else if (colleague instanceof Curtains) {
            interMap.put("Curtains", colleagueName);
        }
    }

    //具体中介者的核心方法
    //1. 根据得到消息,完成对应任务
    //2. 中介者在这个方法,协调各个具体的同事对象,完成任务
    @Override
    public void GetMessage(int stateChange, String colleagueName) {
        //处理闹钟发出的消息
        if (colleagueMap.get(colleagueName) instanceof Alarm) {
            if (stateChange == 0) {
                ((CoffeeMachine) (colleagueMap.get(interMap
                        .get("CoffeeMachine")))).StartCoffee();
                ((TV) (colleagueMap.get(interMap.get("TV")))).StartTv();
            } else if (stateChange == 1) {
                ((TV) (colleagueMap.get(interMap.get("TV")))).StopTv();
            }


        } else if (colleagueMap.get(colleagueName) instanceof CoffeeMachine) {
            ((Curtains) (colleagueMap.get(interMap.get("Curtains"))))
                    .UpCurtains();

        } else if (colleagueMap.get(colleagueName) instanceof TV) {//如果 TV 发现消息


        } else if (colleagueMap.get(colleagueName) instanceof Curtains) {
            //如果是以窗帘发出的消息,这里处理...
        }

    }
    
    @Override
    public void SendMessage() {

    }


}

getMessage会根据接收到的同事对象发出的消息来协调调用其它的同事对象 ,完成任务

可以看到getMessage是核心方法,完成相应任务

public class Client {
    public static void main(String[] args) {
        //创建一个中介者对象
        Mediator mediator = new ConcreteMediator();

        //创建 Alarm  并且加入到	ConcreteMediator 对象的 HashMap
        Alarm alarm = new Alarm(mediator, "alarm");
        //创建了 CoffeeMachine 对象,并	且加入到	ConcreteMediator 对象的 HashMap
        CoffeeMachine coffeeMachine = new CoffeeMachine(mediator, "coffeeMachine");
        //创建  Curtains , 并	且加入到	ConcreteMediator 对象的 HashMap
        Curtains curtains = new Curtains(mediator, "curtains");
        TV tV = new TV(mediator, "TV");

        //让闹钟发出消息
         alarm.SendAlarm(0);
         coffeeMachine.FinishCoffee();
         alarm.SendAlarm(1);
    }
}

3. 知识小结

  1. 多个类相互耦合,会形成网状结构,使用中介者模式将网状结构分离为星型结构,进行解耦
  2. 减少类间依赖,降低了耦合,符合迪米特原则
  3. 中介者承担了较多的责任,一旦中介者出现了问题,整个系统就会受到影响
  4. 如果设计不当,中介者对象本身变得过于复杂,这点在实际使用时,要特别注意

七、备忘录模式

1. 基本介绍

  1. 备忘录模式(Memento Pattern)在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态
  2. 可以这里理解备忘录模式:现实生活中的备忘录是用来记录某些要去做的事情,或者是记录已经达成的共同意见的事情,以防忘记了。而在软件层面,备忘录模式有着相同的含义,备忘录对象主要用来记录一个对象的某种状态,或者某些数据,当要做回退时,可以从备忘录对象里获取原来的数据进行恢复操作
  3. 备忘录模式属于行为型模式

2. 基本原理

原理图

对原理类图的说明-即(备忘录模式的角色及职责)

  1. originator : 对象(需要保存状态的对象)
  2. Memento : 备忘录对象,负责保存好记录,即 Originator 内部状态
  3. Caretaker: 守护者对象,负责保存多个备忘录对象, 使用集合管理,提高效率
  4. 说明:如果希望保存多个 originator 对象的不同时间的状态,也可以,只需要要 HashMap <String, 集合>

3. 代码实现

① Originator 需要保存状态的对象

public class Originator {

    private String state;//状态信息

    public String getState() {
        return state;
    }

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

    //编写一个方法,可以保存一个状态对象Memento
    // 因此编写一个方法,返回Memento
    public Memento saveStateMemento(){
        return new Memento(state);
    }

    //通过备忘录对象,恢复状态
    public String getStateFromMemento(Memento memento){
        state = memento.getState();
        return state;
    }

}

② Memento 备忘录对象 即Originator的内部状态

public class Memento {
    private String state;

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }
}

③ Caretaker 守护者对象

public class Caretaker {

    //在list集合中会有很多的备忘录
    private List<Memento> mementoList = new ArrayList<>();

    public void add(Memento memento){
        mementoList.add(memento);
    }

    //获取到第index个Originator的备忘录对象
    public Memento get(int index){
        return mementoList.get(index);
    }

}

④ 客户端调用

public class Client {
    public static void main(String[] args) {
        Originator originator = new Originator();
        Caretaker caretaker = new Caretaker();
        originator.setState(" 状态#1 血槽全满 ");
        //保存了当前的状态
        caretaker.add(originator.saveStateMemento());
        originator.setState(" 状态#2 血槽还剩80% ");
        caretaker.add(originator.saveStateMemento());
        originator.setState(" 状态#3 血槽还剩50% ");
        caretaker.add(originator.saveStateMemento());
        
        System.out.println("当前的状态是=="+originator.getState());
        //希望恢复到状态1
        System.out.println("恢复到状态1=="+originator.getStateFromMemento(caretaker.get(0)));
    }
}

4. 应用案例一:游戏角色状态恢复问题

需求提出

游戏角色有攻击力和防御力,在大战 Boss 前保存自身的状态(攻击力和防御力),当大战 Boss 后

攻击力和防御力下降,从备忘录对象恢复到大战前的状态

传统的方式的问题分析

  1. 一个对象,就对应一个保存对象状态的对象, 这样当我们游戏的对象很多时,不利于管理,开销也很大.
  2. 传统的方式是简单地做备份,new 出另外一个对象出来,再把需要备份的数据放到这个新对象,但这就暴露了对象内部的细节
  3. 解决方案: => 备忘录模式

代码实现

游戏角色有攻击力和防御力,在大战 Boss 前保存自身的状态(攻击力和防御力),当大战 Boss 后

攻击力和防御力下降,从备忘录对象恢复到大战前的状态

备忘录对象(Originator内部状态)

public class Memento {

    private int vit;//攻击力
    private int def;//防御力

    public Memento(int vit, int def) {
        this.vit = vit;
        this.def = def;
    }

    public int getVit() {
        return vit;
    }
    
    public int getDef() {
        return def;
    }
    
}

游戏角色 (originator角色,需要保存状态的对象)

public class GameRole {

    private int vit;
    private int def;

    public void setDef(int def) {
        this.def = def;
    }

    public void setVit(int vit) {
        this.vit = vit;
    }

    public Memento createMemento(){
        return new Memento(vit,def);
    }

    //恢复gameRole的状态
    public void recoverGameRoleFromMemento(Memento memento){
        this.vit = memento.getVit();
        this.def = memento.getDef();
    }

    //显示当前游戏角色的状态
    public void display(){
        System.out.println("游戏角色当前的攻击力:"+this.vit+",当前游戏角色的防御力:"+this.def);
    }


}

Caretaker: 守护者对象,负责保存多个备忘录对象

//守护者对象,保存游戏角色的状态
public class Caretaker {

    //对游戏角色保存状态
    private Memento memento;

    public Memento getMemento() {
        return memento;
    }

    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}

客户端测试代码

public class Client {
    public static void main(String[] args) {
        //创建游戏角色
        GameRole gameRole = new GameRole();
        gameRole.setVit(100);
        gameRole.setDef(100);
        System.out.println("和boss大战前的状态");
        gameRole.display();
        //把当前状态保存caretaker
        Caretaker caretaker = new Caretaker();
        caretaker.setMemento(gameRole.createMemento());
        System.out.println("和boss开始大战");
        gameRole.setDef(30);
        gameRole.setVit(30);
        gameRole.display();
        System.out.println("大战后,使用备忘录恢复元气");
        gameRole.recoverGameRoleFromMemento(caretaker.getMemento());
        gameRole.display();
    }
}

输出

和boss大战前的状态
游戏角色当前的攻击力:100,当前游戏角色的防御力:100
和boss开始大战
游戏角色当前的攻击力:30,当前游戏角色的防御力:30
大战后,使用备忘录恢复元气
游戏角色当前的攻击力:100,当前游戏角色的防御力:100

5. 知识小结

  1. 给用户提供了一种可以恢复状态的机制,可以使用户能够比较方便地回到某个历史的状态
  2. 实现了信息的封装,使得用户不需要关心状态的保存细节
  3. 如果类的成员变量过多,势必会占用比较大的资源,而且每一次保存都会消耗一定的内存, 这个需要注意
  4. 适用的应用场景:1、后悔药。 2、打游戏时的存档。 3、Windows 里的 ctri + z。 4、IE 中的后退。
  5. 数据库的事务管理

为了节约内存,备忘录模式可以和原型模式配合使用

八、解释器模式

1. 基本介绍

1、在编译原理中,一个算术表达式通过词法分析器形成词法单元,而后这些词法单元再通过语法

分析器构建语法分析树,最终形成一颗抽象的语法分析树。这里的词法分析器和语法分析器都可以

看做是解释器

2、解释器模式(Interpreter Pattern):是指给定一个语言(表达式),定义它的文法的一种表示,

并定义一个解释器,使用该解释器来解释语言中的句子(表达式)

3、应用场景

  • 应用可以将一个需要解释执行的语言中的句子表示为一个抽象语法树
  • 一些重复出现的问题可以用一种简单的语言来表达
  • 一个简单语法需要解释的场景

4、这样的例子还有,比如编译器、运算表达式计算、正则表达式、机器人等

2. 基本原理

对原理类图的说明-即(解释器模式的角色及职责)

  1. Context: 是环境角色,含有解释器之外的全局信息.
  2. AbstractExpression: 抽象表达式, 声明一个抽象的解释操作,这个方法为抽象语法树中所有的节点所共享
  3. TerminalExpression: 为终结符表达式, 实现与文法中的终结符相关的解释操作
  4. NonTermialExpression: 为非终结符表达式,为文法中的非终结符实现解释操作.
  5. 说明: 输入 Context 和 TerminalExpression 信息通过 Client 输入即可

3. 应用案例一:四则运算问题

需求

通过解释器模式来实现四则运算,如计算 a+b-c 的值,具体要求

  1. 先输入表达式的形式,比如 a+b+c-d+e, 要求表达式的字母不能重复
  2. 在分别输入 a ,b, c, d, e 的值

传统方案解决四则运算问题分析

  1. 编写一个方法,接收表达式的形式,然后根据用户输入的数值进行解析,得到结果
  2. 问题分析:如果加入新的运算符,比如 * / ( 等等,不利于扩展,另外让一个方法来解析会造成程序结构混乱, 不够清晰.
  3. 解决方案:可以考虑使用解释器模式, 即: 表达式 -> 解释器(可以有多种) -> 结果

代码实现

  1. 应用实例要求 通过解释器模式来实现四则运算, 如计算 a+b-c 的值
  2. 思路分析和图解(类图)

① 抽象表达式

/**
 * @description 抽象类表达式,通过hashmap键值对,可以获取到变量的值
 */
public abstract class Expression {
    // a + b - c
    //解释公式和数值,key就是公式(表达式) 参数[a,b,c],value 就是具体值
    //hashmap {a=10,b=20}
    public abstract int interpreter(HashMap<String,Integer> var);
}

② 具体表达式

/**
 * 抽象运算符号解析器这里,每个运算符号都只和自己左右两个数字有关系,
 * 但左右两个数字有可能也是一个解析的结果,无论何种类型,都是Expression类的实现类
 */
public class SymbolExpression extends Expression{
    protected Expression left;
    protected Expression right;

    public SymbolExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    //SymbolExpression 是让他的子类来实现的,因此interpreter是一个默认实现
    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return 0;
    }
}

/**
 * 变量的解释器
 */
public class VarExpression extends Expression {
    private String key; //key = a,key = b,key = c,

    public VarExpression(String key) {
        this.key = key;
    }

    //interpreter根据变量名称  返回对应值
    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return var.get(key);
    }
}

③ 符号解释器

/**
 * 加法解释器
 */
public class AddExpression extends SymbolExpression {

    public AddExpression(Expression left, Expression right) {
        super(left, right);
    }

    //处理相加
    @Override
    public int interpreter(HashMap<String, Integer> var) {
        //        返回left表达式对应的值        返回right表达式对应的值
        return super.left.interpreter(var)+super.right.interpreter(var);
    }
}

/**
 * @description
 */
public class SubExpression extends SymbolExpression {
    public SubExpression(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return super.left.interpreter(var)-super.right.interpreter(var);
    }
}

④ 计算器

public class Calculator {

    // 定义表达式
    private Expression expression;
    // 构造函数传参,并解析
    public Calculator(String expStr) { // expStr = a+b
        // 安排运算先后顺序
        Stack<Expression> stack = new Stack<>();
        // 表达式拆分成字符数组
        char[] charArray = expStr.toCharArray();// [a, +, b]
        Expression left = null;
        Expression right = null;
        //遍历我们的字符数组,  即遍历	[a, +, b]
        //针对不同的情况,做处理
        for (int i = 0; i < charArray.length; i++) {
            switch (charArray[i]) {
                case '+': //
                    left = stack.pop();// 从 stack 取 出 left => "a"
                    right = new VarExpression(String.valueOf(charArray[++i]));// 取出右表达式 "b"
                    stack.push(new AddExpression(left, right));// 然后根据得到 left 和 right 构建 AddExpresson 加入stack
                    break;
                case '-': //
                    left = stack.pop();
                    right = new VarExpression(String.valueOf(charArray[++i]));
                    stack.push(new SubExpression(left, right));
                    break;
                default:
                    //如果是一个 Var 就创建要给 VarExpression 对象,并 push 到 stack
                    stack.push(new VarExpression(String.valueOf(charArray[i])));
                    break;
            }
        }
        //当遍历完整个 charArray  数组后,stack 就得到最后 Expression
         this.expression = stack.pop();
    }

    public int run(HashMap<String, Integer> var) {
        //最后将表达式 a+b 和 var = {a=10,b=20}
        //然后传递给 expression 的 interpreter 进行解释执行
        return this.expression.interpreter(var);
    }

}

⑤ 客户端测试代码

/**
 * @description 解释器模式测试代码
 */
public class Client {

    public static void main(String[] args) throws IOException {
        String expStr = getExpStr(); // a+b
        HashMap<String, Integer> var = getValue(expStr);// var {a=10, b=20}
        Calculator calculator = new Calculator(expStr);
        System.out.println("运算结果:" + expStr + "=" + calculator.run(var));
    }

    // 获得表达式
    public static String getExpStr() throws IOException {
        System.out.print("请输入表达式:");
        return (new BufferedReader(new InputStreamReader(System.in))).readLine();
    }

    // 获得值映射
    public static HashMap<String, Integer> getValue(String expStr) throws IOException {
        HashMap<String, Integer> map = new HashMap<>();

        for (char ch : expStr.toCharArray()) {
            if (ch != '+' && ch != '-') {
                if (!map.containsKey(String.valueOf(ch))) {
                    System.out.print("请输入" + String.valueOf(ch) + "的值:");
                    String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
                    map.put(String.valueOf(ch), Integer.valueOf(in));
                }
            }
        }

        return map;
    }

}

输出

请输入表达式:a+b-c
请输入a的值:10
请输入b的值:5
请输入c的值:3
运算结果:a+b-c=12

4. 知识小结

  1. 当有一个语言需要解释执行,可将该语言中的句子表示为一个抽象语法树,就可以考虑使用解释器模式,

让程序具有良好的扩展性

  1. 应用场景:编译器、运算表达式计算、正则表达式、机器人等
  2. 使用解释器可能带来的问题:解释器模式会引起类膨胀、解释器模式采用递归调用方法,将会导致调试非

常复杂、效率可能降低.

九、状态模式

1. 基本介绍

  1. 状态模式(State Pattern):它主要用来解决对象在多种状态转换时,需要对外输出不同的行为的问题。状态和行为是一一对应的,状态之间可以相互转换
  2. 当一个对象的内在状态改变时,允许改变其行为,这个对象看起来像是改变了其类

2. 基本原理

原理类图

对原理类图的说明-即(状态模式的角色及职责)

  1. Context 类为环境角色, 用于维护 State 实例,这个实例定义当前状态
  2. State 是抽象状态角色,定义一个接口封装与 Context 的一个特点接口相关行为
  3. ConcreteState 具体的状态角色,每个子类实现一个与 Context 的一个状态相关行为

3. 应用案例一:APP 抽奖活动问题

需求提出

请编写程序完成 APP 抽奖活动 具体要求如下:

  1. 假如每参加一次这个活动要扣除用户 50 积分,中奖概率是 10%
  2. 奖品数量固定,抽完就不能抽奖
  3. 活动有四个状态: 可以抽奖、不能抽奖、发放奖品和奖品领完
  4. 活动的四个状态转换关系图(右图)

代码实现

  1. 应用实例要求 完成 APP 抽奖活动项目,使用状态模式.
  2. 思路分析和图解(类图) -定义出一个接口叫状态接口,每个状态都实现它。 -接口有扣除积分方法、抽奖方法、发放奖品方法

① 抽象状态(State角色)

public abstract class State {
    abstract void deduceMoney();//扣除积分 -50
    abstract boolean raffle();//是否抽中奖品
    abstract void dispensePrize();//发放奖品
}

② 具体状态 (ConcreteState角色)

public class CanRaffleState extends State {

    RaffleActivity activity;

    public CanRaffleState(RaffleActivity activity) {
        this.activity = activity;
    }

    //已经扣除了积分,不能再扣
    @Override
    public void deduceMoney() {
        System.out.println("已经扣取过了积分");
    }

    //可以抽奖, 抽完奖后,根据实际情况,改成新的状态
    @Override
    public boolean raffle() {
        System.out.println("正在抽奖,请稍等!");
        Random r = new Random();
        int num = r.nextInt(10);
        // 10%中奖机会
        if (num == 0) {
            // 改 变 活 动 状 态 为 发 放 奖 品 context
            activity.setState(activity.getDispenseState());
            return true;
        } else {
            System.out.println("很遗憾没有抽中奖品!");
            // 改变状态为不能抽奖
            activity.setState(activity.getNoRafflleState());
            return false;
        }
    }

    // 不能发放奖品
    @Override
    public void dispensePrize() {
        System.out.println("没中奖,不能发放奖品");
    }

}


public class NoRaffleState extends State {

    // 初始化时传入活动引用,扣除积分后改变其状态
    RaffleActivity activity;

    public NoRaffleState(RaffleActivity activity) {
        this.activity = activity;
    }

    //当前状态是可以扣积分的,扣除后,将状态设置成抽象状态
    @Override
    public void deduceMoney() {
        System.out.println("扣除 50 积分成功,您可以抽奖了");
        activity.setState(activity.getCanRaffleState());
    }

    @Override
    public boolean raffle() {
        System.out.println("扣了积分才能抽奖喔!");
        return false;
    }

    @Override
    public void dispensePrize() {
        System.out.println("不能发放奖品");
    }
}


public class DispenseState extends State {

    // 初始化时传入活动引用,发放奖品后改变其状态
    RaffleActivity activity;

    public DispenseState(RaffleActivity activity) {
        this.activity = activity;
    }


    @Override
    public void deduceMoney() {
        System.out.println("不能扣除积分");
    }

    @Override
    public boolean raffle() {
        System.out.println("不能抽奖");
        return false;
    }

    @Override
    public void dispensePrize() {
        if (activity.getCount() > 0) {
            System.out.println("恭喜中奖了");
            // 改变状态为不能抽奖
            activity.setState(activity.getNoRafflleState());
        } else {
            System.out.println("很遗憾,奖品发送完了");
            // 改变状态为奖品发送完毕, 后面我们就不可以抽奖
            activity.setState(activity.getDispensOutState());
            //System.out.println("抽奖活动结束");
            //System.exit(0);
        }

    }
}


public class DispenseOutState extends State {

    // 初始化时传入活动引用
    RaffleActivity activity;

    public DispenseOutState(RaffleActivity activity) {
        this.activity = activity;
    }


    @Override
    public void deduceMoney() {
        System.out.println("奖品发送完了,请下次再参加");
    }

    @Override
    public boolean raffle() {
        System.out.println("奖品发送完了,请下次再参加");
        return false;
    }

    @Override
    public void dispensePrize() {
        System.out.println("奖品发送完了,请下次再参加");
    }
}

③ 环境 (Context角色)

public class RaffleActivity {

    // state 表示活动当前的状态,是变化
    State state = null;

    // 奖品数量
    int count = 0;

    // 四个属性,表示四种状态
    State noRafflleState = new NoRaffleState(this);
    State canRaffleState = new CanRaffleState(this);
    State dispenseState = new DispenseState(this);
    State dispensOutState = new DispenseOutState(this);

    //构造器
    //1. 初始化当前的状态为 noRafflleState(即不能抽奖的状态)
    //2. 初始化奖品的数量
    public RaffleActivity(int count) {
        this.state = getNoRafflleState();
        this.count = count;
    }

    //扣分, 调用当前状态的 deductMoney
    public void debuctMoney() {
        state.deduceMoney();
    }

    //抽奖
    public void raffle() {
        // 如果当前的状态是抽奖成功
        if (state.raffle()) {
            //领取奖品
            state.dispensePrize();
        }
    }


    public State getState() {
        return state;
    }


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

    //这里请大家注意,每领取一次奖品,count--
    public int getCount() {
        int curCount = count;
        count--;
        return curCount;
    }


    public void setCount(int count) {
        this.count = count;
    }


    public State getNoRafflleState() {
        return noRafflleState;
    }


    public void setNoRafflleState(State noRafflleState) {
        this.noRafflleState = noRafflleState;
    }


    public State getCanRaffleState() {
        return canRaffleState;
    }


    public void setCanRaffleState(State canRaffleState) {
        this.canRaffleState = canRaffleState;
    }


    public State getDispenseState() {
        return dispenseState;
    }


    public void setDispenseState(State dispenseState) {
        this.dispenseState = dispenseState;
    }

    public State getDispensOutState() {
        return dispensOutState;


    }


    public void setDispensOutState(State dispensOutState) {
        this.dispensOutState = dispensOutState;
    }
}

④ 客户端测试代码

public class Client {
    public static void main(String[] args) {
        // 创建活动对象,奖品有 1 个奖品
        RaffleActivity activity = new RaffleActivity(1);
        // 我们连续抽 300 次奖
        for (int i = 0; i < 30; i++) {
            System.out.println("--------第" + (i + 1) + "次抽奖----------");
            // 参加抽奖,第一步点击扣除积分
            activity.debuctMoney();
            // 第二步抽奖
            activity.raffle();
        }
    }
}

4. 源码剖析(借贷平台 )

需求提出

  1. 借贷平台的订单,有审核-发布-抢单 等等 步骤,随着操作的不同,会改变订单的状态, 项目中的这个模块实现就会使用到状态模式
  2. 使用状态模式完成 借贷平台项目的审核模块 [设计+代码]

代码实现

① 状态接口

public interface State {
    /**
     * 电 审
     */
    void checkEvent(Context context);
    
    /**
     * 电审失败
     */
    void checkFailEvent(Context context);
    
    /**
     * 定价发布
     */
    void makePriceEvent(Context context);
    
    /**
     * 接 单
     */
    void acceptOrderEvent(Context context);
    
    /**
     * 无人接单失效
     */
    void notPeopleAcceptEvent(Context context);

    /**
     * 付 款
     */
    void payOrderEvent(Context context);
    
    /**
     * 接单有人支付失效
     */
    void orderFailureEvent(Context context);
    
    /**
     * 反 馈
     */
    void feedBackEvent(Context context);
    
    String getCurrentState();
}
public abstract class AbstractState implements State {

    protected static final RuntimeException EXCEPTION = new RuntimeException("操作流程不允许");

    //抽象类,默认实现了 State 接口的所有方法
    //该类的所有方法,其子类(具体的状态类),可以有选择的进行重写

    @Override
    public void checkEvent(Context context) { throw EXCEPTION;
    }


    @Override
    public void checkFailEvent(Context context) { throw EXCEPTION;
    }


    @Override
    public void makePriceEvent(Context context) { throw EXCEPTION;
    }


    @Override
    public void acceptOrderEvent(Context context) { throw EXCEPTION;
    }


    @Override
    public void notPeopleAcceptEvent(Context context) { throw EXCEPTION;
    }


    @Override


    public void payOrderEvent(Context context) { throw EXCEPTION;
    }


    @Override
    public void orderFailureEvent(Context context) { throw EXCEPTION;
    }


    @Override
    public void feedBackEvent(Context context) { throw EXCEPTION;
    }
}

② 具体状态及枚举

public enum  StateEnum {
    //订单生成
    GENERATE(1, "GENERATE"),

    //已审核
    REVIEWED(2, "REVIEWED"),

    //已发布
    PUBLISHED(3, "PUBLISHED"),

    //待付款
    NOT_PAY(4, "NOT_PAY"),

    //已付款
    PAID(5, "PAID"),

    //已完结
    FEED_BACKED(6, "FEED_BACKED");

    private int key; private String value;

    StateEnum(int key, String value) { this.key = key;
        this.value = value;
    }
    public int getKey() {return key;} public String getValue() {return value;}

}


//各种具体状态类
class FeedBackState extends AbstractState {

    @Override
    public String getCurrentState() {
        return StateEnum.FEED_BACKED.getValue();
    }
}

public class GenerateState extends AbstractState {
    @Override
    public void checkEvent(Context context) { context.setState(new ReviewState());
    }


    @Override
    public void checkFailEvent(Context context) { context.setState(new FeedBackState());
    }


    @Override
    public String getCurrentState() {
        return StateEnum.GENERATE.getValue();
    }

}


public class NotPayState extends AbstractState{
    @Override
    public void payOrderEvent(Context context) { context.setState(new PaidState());
    }

    @Override
    public void feedBackEvent(Context context) { context.setState(new FeedBackState());
    }


    @Override
    public String getCurrentState() {
        return StateEnum.NOT_PAY.getValue();
    }
    
}


public class PaidState extends AbstractState {
    @Override
    public void feedBackEvent(Context context) { context.setState(new FeedBackState());
    }
    
    @Override
    public String getCurrentState() {
        return StateEnum.PAID.getValue();
    }

}


public class PublishState extends AbstractState {

    @Override
    public void acceptOrderEvent(Context context) {
    //把当前状态设置为	NotPayState。。。
    //至于应该变成哪个状态,有流程图来决定
        context.setState(new NotPayState());
    }

    @Override
    public void notPeopleAcceptEvent(Context context) { context.setState(new FeedBackState());
    }

    @Override
    public String getCurrentState() {
        return StateEnum.PUBLISHED.getValue();
    }

}


public class ReviewState extends AbstractState{
    @Override
    public void makePriceEvent(Context context) { context.setState(new PublishState());
    }

    @Override
    public String getCurrentState() {
        return StateEnum.REVIEWED.getValue();
    }
}

③ 上下文环境

public class Context extends AbstractState{
    //当前的状态 state, 根据我们的业务流程处理,不停的变化
    private State state;


    @Override
    public void checkEvent(Context context) { state.checkEvent(this); getCurrentState();
    }


    @Override
    public void checkFailEvent(Context context) { state.checkFailEvent(this); getCurrentState();
    }

    @Override
    public void makePriceEvent(Context context) { state.makePriceEvent(this); getCurrentState();
    }


    @Override
    public void acceptOrderEvent(Context context) { state.acceptOrderEvent(this); getCurrentState();
    }


    @Override
    public void notPeopleAcceptEvent(Context context) { state.notPeopleAcceptEvent(this); getCurrentState();
    }

    @Override
    public void payOrderEvent(Context context) { state.payOrderEvent(this); getCurrentState();
    }

    @Override
    public void orderFailureEvent(Context context) { state.orderFailureEvent(this); getCurrentState();
    }


    @Override
    public void feedBackEvent(Context context) { state.feedBackEvent(this); getCurrentState();
    }


    public State getState() { return state;
    }


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


    @Override
    public String getCurrentState() {
        System.out.println("当前状态 : " + state.getCurrentState()); return state.getCurrentState();
    }

}

④ 客户端测试

public class ClientTest {


    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //创建 context 对象
        Context context = new Context();
        //将当前状态设置为 PublishState
        context.setState(new PublishState());
        System.out.println(context.getCurrentState());


        //		//publish --> not pay
        context.acceptOrderEvent(context);
        //		//not pay --> paid
        context.payOrderEvent(context);
        //	// 失败, 检测失败时,会抛出异常
        try {
            context.checkFailEvent(context);
            System.out.println("流程正常..");
        } catch (Exception e) {

            //	// TODO: handle exception
            //	System.out.println(e.getMessage());
            //	}

        }

    }
}

输出

当前状态 : PUBLISHED
PUBLISHED
当前状态 : NOT_PAY
当前状态 : PAID

5. 知识小结

  1. 代码有很强的可读性。状态模式将每个状态的行为封装到对应的一个类中
  2. 方便维护。将容易产生问题的 if-else 语句删除了,如果把每个状态的行为都放到一个类中,每次调用方法时都要判断当前是什么状态,不但会产出很多 if-else 语句,而且容易出错
  3. 符合“开闭原则”。容易增删状态
  4. 会产生很多类。每个状态都要一个对应的类,当状态过多时会产生很多类,加大维护难度
  5. 应用场景:当一个事件或者对象有很多种状态,状态之间会相互转换,对不同的状态要求有不同的行为的时候, 可以考虑使用状态模式

十、策略模式

1. 基本介绍

  1. 策略模式(Strategy Pattern)中,定义算法族(策略组),分别封装起来,让他们之间可以互相替换,此模式让算法的变化独立于使用算法的客户
  2. 这算法体现了几个设计原则,第一、把变化的代码从不变的代码中分离出来;第二、针对接口编程而不是具体类(定义了策略接口);第三、多用组合/聚合,少用继承(客户通过组合方式使用策略)

说明:从上图可以看到,客户 context 有成员变量 strategy 或者其他的策略接口 ,至于需要使用到

哪个策略,我们可以在构造器中指定

2. 应用案例一:鸭子飞行

需求分析

编写鸭子项目,具体要求如下:

  1. 有各种鸭子(比如 野鸭、北京鸭、水鸭等, 鸭子有各种行为,比如 叫、飞行等)
  2. 显示鸭子的信息

传统方式解决问题类图

传统的方式实现的问题分析和解决方案

  1. 其它鸭子,都继承了 Duck 类,所以 fly 让所有子类都会飞了,这是不正确的
  2. 上面说的 1 的问题,其实是继承带来的问题:对类的局部改动,尤其超类的局部改动,会影响其他部分。会有溢出效应
  3. 为了改进 1 问题,我们可以通过覆盖 fly 方法来解决 => 覆盖解决
  4. 问题又来了,如果我们有一个玩具鸭子 ToyDuck, 这样就需要 ToyDuck 去覆盖 Duck 的所有实现的方法=> 解决思路 -> 策略模式 (strategy pattern)

代码实现

① 行为接口

public interface FlyBehavior {
    void fly();
}

② 具体行为

public class GoodFlyBehavior implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("自由飞翔,飞翔能力max");
    }
}


public class BadFlyBehavior implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("飞翔技术不太行");
    }
}


public class NoFlyBehavior implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("不会飞");
    }
}

③ 行为执行者 组合不同的行为

public class WildDuck extends Duck {

    public WildDuck() {
        flyBehavior = new GoodFlyBehavior();
    }

    @Override
    void display() {
        System.out.println("野鸭子");
    }

}


public class PekingDuck extends Duck {

    public PekingDuck() {
        flyBehavior = new BadFlyBehavior();
    }

    @Override
    void display() {
        System.out.println("北京鸭");
    }

}


public class ToyDuck extends Duck{

    public ToyDuck() {
        flyBehavior = new NoFlyBehavior();
    }

    @Override
    void display() {
        System.out.println("玩具鸭");
    }

}

④ 客户端测试

public class Client {
    public static void main(String[] args) {
        WildDuck wildDuck = new WildDuck();
        wildDuck.display();
        wildDuck.fly();
        PekingDuck pekingDuck = new PekingDuck();
        pekingDuck.display();
        pekingDuck.fly();
    }
}

3. 应用案例二:旅游出行

简介

先看下面的图片,我们去旅游选择出行模式有很多种,可以骑自行车、可以坐汽车、可以坐火车、可以坐飞

机。

作为一个程序猿,开发需要选择一款开发工具,当然可以进行代码开发的工具有很多,可以选择

Idea进行开发,也可以使用eclipse进行开发,也可以使用其他的一些开发工具。

定义:

该模式定义了一系列算法,并将每个算法封装起来,使它们可以相互替换,且算法的变化不会影响

使用算法的客户。策略模式属于对象行为模式,它通过对算法进行封装,把使用算法的责任和算法

的实现分割开来,并委派给不同的对象对这些算法进行管理。

结构

策略模式的主要角色如下:

  • 抽象策略(Strategy)类:这是一个抽象角色,通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。
  • 具体策略(Concrete Strategy)类:实现了抽象策略定义的接口,提供具体的算法实现或行为。
  • 环境(Context)类:持有一个策略类的引用,最终给客户端调用。

三案例实现

【例】促销活动

一家百货公司在定年度的促销活动。针对不同的节日(春节、中秋节、圣诞节)推出不同的促销活

动,由促销员将促销活动展示给客户。

类图如下:

聚合关系可以用带空心菱形的实线来表示

代码如下:

定义百货公司所有促销活动的共同接口

public interface Strategy {
    void show();
}

定义具体策略角色(Concrete Strategy):每个节日具体的促销活动

//为春节准备的促销活动A
public class StrategyA implements Strategy {

    public void show() {
        System.out.println("买一送一");
    }
}

//为中秋准备的促销活动B
public class StrategyB implements Strategy {

    public void show() {
        System.out.println("满200元减50元");
    }
}

//为圣诞准备的促销活动C
public class StrategyC implements Strategy {

    public void show() {
        System.out.println("满1000元加一元换购任意200元以下商品");
    }
}

定义环境角色(Context):用于连接上下文,即把促销活动推销给客户,这里可以理解为销售员

public class SalesMan {                        
    //持有抽象策略角色的引用                              
    private Strategy strategy;                 
                                               
    public SalesMan(Strategy strategy) {       
        this.strategy = strategy;              
    }                                          
                                               
    //向客户展示促销活动                                
    public void salesManShow(){                
        strategy.show();                       
    }                                          
}                                              

4. 应用案例三:综合案例

简介

下图是gitee的登录的入口,其中有多种方式可以进行登录

  • 用户名密码登录
  • 短信验证码登录
  • 微信登录
  • QQ登录
  • ....

目前已实现的代码

(1)登录接口

说明

请求方式

POST

路径

/api/user/login

参数

LoginReq

返回值

LoginResp

请求参数:LoginReq

@Data
public class LoginReq {

    private String name;
    private String password;

    private String phone;
    private String validateCode;//手机验证码

    private String wxCode;//用于微信登录
    /**
     * account : 用户名密码登录
     * sms : 手机验证码登录
     * we_chat : 微信登录
     */
    private String type;
}

响应参数:LoginResp

@Data
public class LoginResp{
    private Integer userId;
    private String userName;
    private String roleCode;
    private String token; //jwt令牌
    private boolean success;

}

控制层LoginController

@RestController
@RequestMapping("/api/user")
public class LoginController {

    @Autowired
    private UserService userService;


    @PostMapping("/login")
    public LoginResp login(@RequestBody LoginReq loginReq){
        return userService.login(loginReq);
    }
}

业务层UserService

@Service
public class UserService {

    public LoginResp login(LoginReq loginReq){

        if(loginReq.getType().equals("account")){
            System.out.println("用户名密码登录");

            //执行用户密码登录逻辑

            return new LoginResp();

        }else if(loginReq.getType().equals("sms")){
            System.out.println("手机号验证码登录");

            //执行手机号验证码登录逻辑

            return new LoginResp();
        }else if (loginReq.getType().equals("we_chat")){
            System.out.println("微信登录");

            //执行用户微信登录逻辑

            return new LoginResp();
        }
        LoginResp loginResp = new LoginResp();
        loginResp.setSuccess(false);
        System.out.println("登录失败");
        return loginResp;
    }
}

注意:我们重点讲的是设计模式,并不是登录的逻辑,所以以上代码并没有真正的实现登录功能

(2)问题分析

  • 业务层代码大量使用到了if...else,在后期阅读代码的时候会非常不友好,大量使用if...else性能也不高
  • 如果业务发生变更,比如现在新增了QQ登录方式,这个时候需要修改业务层代码,违反了开闭原则

解决:使用工厂方法设计模式+策略模式解决

代码改造(工厂+策略)

(1)整体思路

改造之后,不在service中写业务逻辑,让service调用工厂,然后通过service传递不同的参数来获

取不同的登录策略(登录方式)

(2)具体实现

抽象策略类:UserGranter

/**
 * 抽象策略类
 */
public interface UserGranter{

   /**
    * 获取数据
    * @param loginReq 传入的参数
    * @return map值
    */
   LoginResp login(LoginReq loginReq);
}

具体的策略:AccountGranter、SmsGranter、WeChatGranter

/**
 * 	策略:账号登录
 **/
@Component
public class AccountGranter implements UserGranter{

    @Override
    public LoginResp login(LoginReq loginReq) {

        System.out.println("登录方式为账号登录" + loginReq);
        // TODO
        // 执行业务操作 
        
        return new LoginResp();
    }
}
/**
 * 策略:短信登录
 */
@Component
public class SmsGranter implements UserGranter{

    @Override
    public LoginResp login(LoginReq loginReq)  {

        System.out.println("登录方式为短信登录" + loginReq);
        // TODO
        // 执行业务操作

        return new LoginResp();
    }
}
/**
 * 策略:微信登录
 */
@Component
public class WeChatGranter implements UserGranter{

    @Override
    public LoginResp login(LoginReq loginReq)  {

        System.out.println("登录方式为微信登录" + loginReq);
        // TODO
        // 执行业务操作
        
        return new LoginResp();
    }
}

工程类:UserLoginFactory

/**
 * 操作策略的上下文环境类 工具类
 * 将策略整合起来 方便管理
 */
@Component
public class UserLoginFactory implements ApplicationContextAware {

    private static Map<String, UserGranter> granterPool = new ConcurrentHashMap<>();

    @Autowired
    private LoginTypeConfig loginTypeConfig;

    /**
     * 从配置文件中读取策略信息存储到map中
     * {
     * account:accountGranter,
     * sms:smsGranter,
     * we_chat:weChatGranter
     * }
     *
     * @param applicationContext
     * @throws BeansException
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        loginTypeConfig.getTypes().forEach((k, y) -> {
            granterPool.put(k, (UserGranter) applicationContext.getBean(y));
        });
    }

    /**
     * 对外提供获取具体策略
     *
     * @param grantType 用户的登录方式,需要跟配置文件中匹配
     * @return 具体策略
     */
    public UserGranter getGranter(String grantType) {
        UserGranter tokenGranter = granterPool.get(grantType);
        return tokenGranter;
    }

}

在application.yml文件中新增自定义配置

login:
  types:
    account: accountGranter
    sms: smsGranter
    we_chat: weChatGranter

新增读取数据配置类

Getter
@Setter
@Configuration
@ConfigurationProperties(prefix = "login")
public class LoginTypeConfig {

    private Map<String,String> types;

}

改造service代码

@Service
public class UserService {

    @Autowired
    private UserLoginFactory factory;

    public LoginResp login(LoginReq loginReq){

        UserGranter granter = factory.getGranter(loginReq.getType());
        if(granter == null){
            LoginResp loginResp = new LoginResp();
            loginResp.setSuccess(false);
            return loginResp;
        }
        LoginResp loginResp = granter.login(loginReq);
        return loginResp;
    }
}

大家可以看到我们使用了设计模式之后,业务层的代码就清爽多了,如果后期有新的需求改动,比如加入了QQ登录,我们只需要添加对

应的策略就可以,无需再改动业务层代码。

举一反三

其实像这样的需求,在日常开发中非常常见,场景有很多,以下的情景都可以使用工厂模式+策略模式解决比

如:

  • 订单的支付策略
    • 支付宝支付
    • 微信支付
    • 银行卡支付
    • 现金支付
  • 解析不同类型excel
    • xls格式
    • xlsx格式
  • 打折促销
    • 满300元9折
    • 满500元8折
    • 满1000元7折
  • 物流运费阶梯计算
    • 5kg以下
    • 5kg-10kg
    • 10kg-20kg
    • 20kg以上

一句话总结:只要代码中有冗长的 if-else 或 switch 分支判断都可以采用策略模式优化

5. JDK源码(Arrays)

JDK 的 Arrays 的 Comparator 就使用了策略模式

public class Strategy {
    public static void main(String[] args) {
        //数组
        Integer[] data = {9, 1, 2, 8, 4, 3};
        // 实现降序排序,返回-1 放左边,1 放右边,0 保持不变
        // 说 明
        // 1.  实现了 Comparator 接口(策略接口) , 匿名类 对象 new Comparator<Integer>(){..}
        // 2.  对象 new Comparator<Integer>(){..}  就是实现了 策略接口 的对象
        // 3. public int compare(Integer o1, Integer o2){} 指定具体的处理方式
        Comparator<Integer> comparator = new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                if (o1 > o2) {
                    return -1;
                } else {
                    return 1;
                }
            }

            ;
        };

        // 说 明
        /*
        public static <T> void sort(T[] a, Comparator<? super T> c) {
            if (c == null) {
                sort(a);
            } else {
                if (LegacyMergeSort.userRequested)
                    legacyMergeSort(a, c);
                else
                    TimSort.sort(a, 0, a.length, c, null, 0, 0);
            }
        }
         */

        //方式 1
        Arrays.sort(data, comparator);
        System.out.println(Arrays.toString(data)); // 降序排序

        //方式 2- 同时 lambda 表达式实现 策略模式
        Integer[] data2 = {19, 11, 12, 18, 14, 13};
        Arrays.sort(data2, (var1, var2) -> {
            if (var1.compareTo(var2) > 0) {
                return -1;
            } else {
                return 1;
            }
        });

        System.out.println("data2=" + Arrays.toString(data2));

    }
}

在Android中,使用ListView时都需要设置一个Adapter,而这个Adapter根据我们实际的需求可以

用ArrayAdapter、SimpleAdapter等等,这里就运用到策略模式。

6. 知识小结

  1. 策略模式的关键是:分析项目中变化部分与不变部分
  2. 策略模式的核心思想是:多用组合/聚合 少用继承;用行为类组合,而不是行为的继承。更有弹性
  3. 体现了“对修改关闭,对扩展开放”原则,客户端增加行为不用修改原有代码,只要添加一种策略(或者行为) 即可,避免了使用多重转移语句(if..else if..else)
  4. 提供了可以替换继承关系的办法: 策略模式将算法封装在独立的 Strategy 类中使得你可以独立于其Context 改变它,使它易于切换、易于理解、易于扩展
  5. 需要注意的是:每添加一个策略就要增加一个类,当策略过多是会导致类数目庞大

十一、职责链模式

1. 基本介绍

  1. 职责链模式(Chain of Responsibility Pattern), 又叫 责任链模式,为请求创建了一个接收者对象的链(简单示意图)。这种模式对请求的发送者和接收者进行解耦。
  2. 职责链模式通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求,那么它会把相同的请求传给下一个接收者,依此类推。
  3. 这种类型的设计模式属于行为型模式

对原理类图的说明-即(职责链模式的角色及职责)

  1. Handler : 抽象的处理者, 定义了一个处理请求的接口, 同时含义另外 Handler
  2. ConcreteHandlerA , B 是具体的处理者, 处理它自己负责的请求, 可以访问它的后继者(即下一个处理者), 如果可以处理当前请求,则处理,否则就将该请求交个 后继者去处理,从而形成一个职责链
  3. Request , 含义很多属性,表示一个请求

2. 应用案例一:学校OA系统采购审批

需求分析

需求:学校 OA 系统的采购审批项目

采购员采购教学器材

  1. 如果金额 小于等于 5000, 由教学主任审批 (0<=x<=5000)
  2. 如果金额 小于等于 10000, 由院长审批 (5000<x<=10000)
  3. 如果金额 小于等于 30000, 由副校长审批 (10000<x<=30000)
  4. 如果金额 超过 30000 以上,有校长审批 ( 30000<x) 请设计程序完成采购审批项目

传统设计方案:

传统方案解决 OA 系统审批问题分析

  1. 传统方式是:接收到一个采购请求后,根据采购金额来调用对应的 Approver (审批人)完成审批。
  2. 传统方式的问题分析 : 客户端这里会使用到 分支判断(比如 switch) 来对不同的采购请求处理, 这样就存在如下问题 (1) 如果各个级别的人员审批金额发生变化,在客户端的也需要变化 (2) 客户端必须明确的知道 有多少个审批级别和访问这样 对一个采购请求进行处理 和 Approver (审批人) 就存在强耦合关系,不利于代码的扩展和维护
  3. 解决方案 => 职责链模式

代码实现

① 编写请求 (Request角色)

public class PurchaseRequest {
    private int type = 0;
    private float price = 0.0f;
    private int id = 0;

    public PurchaseRequest(int id, int type, float price) {
        this.type = type;
        this.id = id;
        this.price = price;
    }

    public int getType() {
        return type;
    }

    public float getPrice() {
        return price;
    }

    public int getId() {
        return id;
    }
}

② 抽象的请求处理者 (Handler角色)

public abstract class Approver {

    protected Approver approver;//下一个处理者
    protected String name;//名字

    public Approver(String name) {
        this.name = name;
    }

    public void setApprover(Approver approver) {
        this.approver = approver;
    }

    abstract void processRequest(PurchaseRequest request);
}

③ 具体的请求处理者 (ConcreteHandler角色)

public class DepartmentApprover extends Approver{

    public DepartmentApprover(String name) {
        super(name);
    }


    @Override
    void processRequest(PurchaseRequest request) {
        if (request.getPrice()<=5000){
            System.out.println("请求编号id="+request.getId()+" 被 "+this.name+"处理");
        }else {
            System.out.println(this.name+"无法处理,交给上一级处理 -> "+approver.name);
            approver.processRequest(request);
        }
    }

}


public class CollegeApprover extends Approver{

    public CollegeApprover(String name) {
        super(name);
    }
    
    @Override
    void processRequest(PurchaseRequest request) {
        if (request.getPrice()>5000&&request.getPrice()<=10000){
            System.out.println("请求编号id="+request.getId()+" 被 "+this.name+"处理");
        }else {
            System.out.println(this.name+"无法处理,交给上一级处理 -> "+approver.name);
            approver.processRequest(request);
        }
    }
}

public class ViceSchoolMasterApprover extends Approver{

    public ViceSchoolMasterApprover(String name) {
        super(name);
    }

    @Override
    void processRequest(PurchaseRequest request) {
        if (request.getPrice()>10000&&request.getPrice()<=30000){
            System.out.println("请求编号id="+request.getId()+" 被 "+this.name+"处理");
        }else {
            System.out.println(this.name+"无法处理,交给上一级处理 -> "+approver.name);
            approver.processRequest(request);
        }
    }

}


public class SchoolMasterApprover extends Approver{

    public SchoolMasterApprover(String name) {
        super(name);
    }

    @Override
    void processRequest(PurchaseRequest request) {
        if (request.getPrice()>30000){
            System.out.println("请求编号id="+request.getId()+" 被 "+this.name+"处理");
        }else {
            System.out.println(this.name+"无法处理,交给下一级处理 -> "+approver.name);
            approver.processRequest(request);
        }
    }

}

④ 客户端调用

public class Client {
    public static void main(String[] args) {
    
        //创建一个审批请求
        PurchaseRequest request = new PurchaseRequest(1,1,13200);
        //创建相关的审批人
        DepartmentApprover departmentApprover = new DepartmentApprover("主任");
        CollegeApprover collegeApprover = new CollegeApprover("院长");
        ViceSchoolMasterApprover viceSchoolMasterApprover = new ViceSchoolMasterApprover("副校长");
        SchoolMasterApprover schoolMasterApprover = new SchoolMasterApprover("校长");
        //需要将各个审批节点的下一级设置好
        departmentApprover.setApprover(collegeApprover);
        collegeApprover.setApprover(viceSchoolMasterApprover);
        viceSchoolMasterApprover.setApprover(schoolMasterApprover);
        schoolMasterApprover.setApprover(departmentApprover);
        //处理请求
        departmentApprover.processRequest(request);

    }
}

输出

主任无法处理,交给上一级处理 -> 院长
院长无法处理,交给上一级处理 -> 副校长
请求编号id=1 被 副校长处理

3. 应用案例二:订单处理

基本介绍

在现实生活中,常常会出现这样的事例:一个请求有多个对象可以处理,但每个对象的处理条件或

权限不同。

例如,公司员工请假,可批假的领导有部门负责人、副总经理、总经理等,但每个领导能批准的天

数不同,员工必须根据自己要请假的天数去找不同的领导签名,也就是说员工必须记住每个领导的

姓名、电话和地址等信息,这增加了难度。这样的例子还有很多,如找领导出差报销、生活中

的“击鼓传花”游戏等。

定义:

又名职责链模式,为了避免请求发送者与多个请求处理者耦合在一起,将所有请求的处理者通过前

一对象记住其下一个对象的引用而连成一条链;当有请求发生时,可将请求沿着这条链传递,直到

有对象处理它为止。

比较常见的springmvc中的拦截器,web开发中的filter过滤器

基本结构

职责链模式主要包含以下角色:

  • 抽象处理者(Handler)角色:定义一个处理请求的接口,包含抽象处理方法和一个后继连接。
  • 具体处理者(Concrete Handler)角色:实现抽象处理者的处理方法,判断能否处理本次请求,如果可以处理请求则处理,否则将该请求转给它的后继者。
  • 客户类(Client)角色:创建处理链,并向链头的具体处理者对象提交请求,它不关心处理细节和请求的传递过程。

案例实现

处理订单的操作

类图:

代码:

抽象处理者

package com.itheima.designpattern.chain;

/**
 * 抽象处理者
 */
public abstract class Handler {

    protected Handler handler;

    public void setNext(Handler handler) {
        this.handler = handler;
    }

    /**
     * 处理过程
     * 需要子类进行实现
     */
    public abstract void process(OrderInfo order);
}

订单信息类:

package com.itheima.designpattern.chain;


import java.math.BigDecimal;

public class OrderInfo {

    private String productId;
    private String userId;

    private BigDecimal amount;

    public String getProductId() {
        return productId;
    }

    public void setProductId(String productId) {
        this.productId = productId;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public BigDecimal getAmount() {
        return amount;
    }

    public void setAmount(BigDecimal amount) {
        this.amount = amount;
    }
}

具体处理者:

/**
 * 订单校验
 */
public class OrderValidition extends Handler {

    @Override
    public void process(OrderInfo order) {
        System.out.println("校验订单基本信息");
        //校验
        handler.process(order);
    }

}

/**
 * 补充订单信息
 */
public class OrderFill extends Handler {
    @Override
    public void process(OrderInfo order) {
        System.out.println("补充订单信息");
        handler.process(order);
    }

}

/**
 * 计算金额
 */
public class OrderAmountCalcuate extends Handler {
    @Override
    public void process(OrderInfo order) {
        System.out.println("计算金额-优惠券、VIP、活动打折");
        handler.process(order);
    }

}

/**
 * 订单入库
 */
public class OrderCreate extends Handler {
    @Override
    public void process(OrderInfo order) {
        System.out.println("订单入库");
    }
}

客户类:

public class Application {

    public static void main(String[] args) {
        //检验订单
        Handler orderValidition = new OrderValidition();
        //补充订单信息
        Handler orderFill = new OrderFill();
        //订单算价
        Handler orderAmountCalcuate = new OrderAmountCalcuate();
        //订单落库
        Handler orderCreate = new OrderCreate();

        //设置责任链路
        orderValidition.setNext(orderFill);
        orderFill.setNext(orderAmountCalcuate);
        orderAmountCalcuate.setNext(orderCreate);

        //开始执行
        orderValidition.process(new OrderInfo());
    }

}

优缺点

优点

  • 降低了对象之间的耦合度该模式降低了请求发送者和接收者的耦合度。
  • 增强了系统的可扩展性可以根据需要增加新的请求处理类,满足开闭原则。
  • 增强了给对象指派职责的灵活性当工作流程发生变化,可以动态地改变链内的成员或者修改它们的次序,也可动态地新增或者删除责任。
  • 责任链简化了对象之间的连接一个对象只需保持一个指向其后继者的引用,不需保持其他所有处理者的引用,这避免了使用众多的 if 或者 if···else 语句。
  • 责任分担每个类只需要处理自己该处理的工作,不能处理的传递给下一个对象完成,明确各类的责任范围,符合类的单一职责原则。

缺点:

  • 不能保证每个请求一定被处理。由于一个请求没有明确的接收者,所以不能保证它一定会被处理,该请求可能一直传到链的末端都得不到处理。
  • 对比较长的职责链,请求的处理可能涉及多个处理对象,系统性能将受到一定影响。
  • 职责链建立的合理性要靠客户端来保证,增加了客户端的复杂性,可能会由于职责链的错误设置而导致系统出错,如可能会造成循环调用。

举一反三

  • 订单创建

4. Andorid 应用

Android中的事件分发机制就是类似于责任链模式。

另外,OKhttp中对请求的处理也是用到了责任链模式。

5. 知识小结

  1. 将请求和处理分开,实现解耦,提高系统的灵活性
  2. 简化了对象,使对象不需要知道链的结构
  3. 性能会受到影响,特别是在链比较长的时候,因此需控制链中最大节点数量,一般通过在 Handler 中设置一个最大节点数量,在 setNext()方法中判断是否已经超过阀值,超过则不允许该链建立,避免出现超长链无意识地破坏系统性能
  4. 调试不方便。采用了类似递归的方式,调试时逻辑可能比较复杂
  5. 最佳应用场景:有多个对象可以处理同一个请求时,比如:多级请求、请假/加薪等审批流程、Java Web中 Tomcat 对 Encoding 的处理、拦截器

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/2279145.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

Android BitmapShader实现狙击瞄具十字交叉线准星,Kotlin

Android BitmapShader实现狙击瞄具十字交叉线准星&#xff0c;Kotlin <?xml version"1.0" encoding"utf-8"?> <RelativeLayout xmlns:android"http://schemas.android.com/apk/res/android"xmlns:tools"http://schemas.android.…

【QT】: 初识 QWidget 控件 | QWidget 核心属性(API) | qrc 文件

&#x1f525; 目录 1. 控件概述 控件体系的发展阶段 2. QWidget 核心属性 2.1 核心属性概览2.2 用件可用&#xff08;Enabled&#xff09; 2.3 坐标系&#xff08;Geometry&#xff09; **实例 1: 控制按钮的位置**实例 2: 表白 程序 2.4 窗口标题&#xff08;windowTiltle&a…

复健第二天之[MoeCTF 2022]baby_file

打开题目在线环境可以看到&#xff1a; 感觉要用伪协议去求&#xff0c;但是我们并不知道flag的位置&#xff0c;这里我选择用dirsearch去扫一下&#xff1a; 最像的应该就是flag.php了 于是就构建payload&#xff1a; **?filephp://filter/convert.base64-encode/resource…

Spring Boot + Apache POI 实现 Excel 导出:BOM物料清单生成器(支持中文文件名、样式美化、数据合并)

目录 引言 Apache POI操作Excel的实用技巧 1.合并单元格操作 2.设置单元格样式 1. 创建样式对象 2. 设置边框 3. 设置底色 4. 设置对齐方式 5. 设置字体样式 6.设置自动换行 7. 应用样式到单元格 3. 定位和操作指定单元格 4.实现标签-值的形式 5.列宽设置 1. 设…

【Web】2025西湖论剑·中国杭州网络安全安全技能大赛题解(全)

目录 Rank-l Rank-U sqli or not Rank-l username存在报错回显&#xff0c;发现可以打SSTI 本地起一个服务&#xff0c;折半查找fuzz黑名单&#xff0c;不断扔给fenjing去迭代改payload from flask import Flask, request, render_template_stringapp Flask(__name__)app…

索引(MySQL)

1. 没有索引&#xff0c;可能会有什么问题 索引&#xff1a;提高数据库的性能&#xff0c;索引是物美价廉的东西了。不用加内存&#xff0c;不用改程序&#xff0c;不用调sql&#xff0c;只要执行 正确的 create index &#xff0c;查询速度就可能提高成百上千倍。但是天下没有…

C#在Json序列化时将key和value转为对应的中文

在C#中&#xff0c;实体类可以通过System.Text.Json或Newtonsoft.Json库等方式直接序列化为json字符串&#xff0c;key为字段&#xff08;属性&#xff09;名&#xff0c;value为值。 上面的方式虽然实现简单&#xff0c;但是有个缺陷&#xff0c;就是转化后的json给外人展示时…

23- TIME-LLM: TIME SERIES FORECASTING BY REPRO- GRAMMING LARGE LANGUAGE MODELS

解决问题 用LLM来解决时序预测问题&#xff0c;并且能够将时序数据映射&#xff08;reprogramming&#xff09;为NLP token&#xff0c;并且保持backbone的大模型是不变的。解决了时序序列数据用于大模型训练数据稀疏性的问题。 方法 Input Embedding 输入&#xff1a; X …

使用 Java 开发 Android 应用:Kotlin 与 Java 的混合编程

使用 Java 开发 Android 应用&#xff1a;Kotlin 与 Java 的混合编程 在开发 Android 应用程序时&#xff0c;我们通常可以选择使用 Java 或 Kotlin 作为主要的编程语言。然而&#xff0c;有些开发者可能会想要在同一个项目中同时使用这两种语言&#xff0c;这就是所谓的混合编…

左神算法基础提升--4

文章目录 树形dp问题Morris遍历 树形dp问题 求解这个问题需要用到我们在基础班上学到的从节点的左子树和右子树上拿信息的方法。 求最大距离主要分为两种情况&#xff1a;1.当前节点参与最大距离的求解&#xff1b;2.当前节点不参与最大距离的求解&#xff1b; 1.当前节点参与最…

拆分工作簿转换PDF格式文件一步到位-Excel易用宝

今天一大早老板急匆匆的跑进办公室说&#xff0c;快快快&#xff0c;&#xff0c;快把这个工作簿中的工作表拆分出来&#xff0c;然后转换成PDF格式文件发给客户。 我一看这么多工作表&#xff0c;又是拆分表格&#xff0c;又是转换文件&#xff0c;这么复杂的工作&#xff0c…

SSM课设-学生管理系统

【课设者】SSM课设-学生管理系统 技术栈: 后端: SpringSpringMVCMybatisMySQLJSP 前端: HtmlCssJavaScriptEasyUIAjax 功能: 学生端: 登陆 学生信息管理 个人信息管理 老师端: 多了教师信息管理 管理员端: 多了班级信息管理 多了年级信息管理 多了系统用户管理

Python调用go语言编译的库

要在 Python 中调用用 Go 语言编写的库&#xff0c;可以使用 Go 语言的 cgo 特性将 Go 代码编译成共享库&#xff08;如 .so 文件&#xff09;&#xff0c;然后在 Python 中通过 ctypes 或 cffi 模块加载和调用这个共享库。 新建main.go文件&#xff0c;使用go语言编写如下代码…

JavaWeb简单开发

JavaWeb 开发是指基于 Java 技术栈进行 Web 应用开发的过程&#xff0c;主要依赖于 Java EE 或者 Spring 框架来构建服务器端应用。JavaWeb 的技术栈比较广泛&#xff0c;通常包括以下几个部分&#xff1a; 示例&#xff1a;简单的 JavaWeb 应用&#xff08;Spring Boot Thyme…

[Mac + Icarus Verilog + gtkwave] Mac运行Verilog及查看波形图

目录 1. MAC安装环境 1. 1 Icarus Verilog 编译 1. 2 gtkwave 查看波形 2. 安装遇到的问题 2. 1 macOS cannot verify that this app is free from malware 2. 2 gtkwave-bin is not compatible with macOS 14 or later 3. 运行示例 3. 1 源代码 3. 2 编译Verilog 3. 3 生成.v…

Phi小模型开发教程:用C#开发本地部署AI聊天工具,只需CPU,不需要GPU,3G内存就可以运行,不输GPT-3.5

大家好&#xff0c;我是编程乐趣。 行业诸多大佬一直在说&#xff1a;“‌2025年将是AI应用元年‌”&#xff0c;虽然说大佬的说法不一定对&#xff0c;但AI趋势肯定没错的。 对于我们程序员来说&#xff0c;储备AI应用开发技能&#xff0c;不管对找工作、接项目、创业肯定是…

物联网网关Web服务器--Boa服务器移植与测试

1、Boa服务器介绍 BOA 服务器是一个小巧高效的web服务器&#xff0c;是一个运行于unix或linux下的&#xff0c;支持CGI的、适合于嵌入式系统的单任务的http服务器&#xff0c;源代码开放、性能高。 Boa 嵌入式 web 服务器的官方网站是http://www.boa.org/。 特点 轻量级&#x…

Maven的多模块架构设计诺依的多模块

Maven的多模块架构设计 多模块架构设计&#xff0c;本文采用 诺依的多模块架构设计分析

.Net 6.0 .Net7.0 .Net8.0 .Net9.0 使用 Serilog 按日志等级写入日志及 appsetting.json 配置方式实现

前言 最近使用最新版的Serilog记录日志时&#xff0c;发现以前有些关于Serilog的Nuget弃用了&#xff0c;最关键的是有些配置写法也改变&#xff0c;于是就整理了一下最新版的Serilog配置方式(appsetting.json)的使用 说明&#xff1a;我是用的.Net6&#xff0c;最新长期支持…

数字化时代,传统代理模式的变革之路

在数字化飞速发展的今天&#xff0c;线上线下融合&#xff08;O2O&#xff09;成了商业领域的大趋势。这股潮流&#xff0c;正猛烈冲击着传统代理模式&#xff0c;给它带来了新的改变。 咱们先看看线上线下融合现在啥情况。线上渠道那是越来越多&#xff0c;企业纷纷在电商平台…