• 【再探】设计模式—中介者模式、观察者模式及模板方法模式

     中介者模式让多对多的复杂引用关系变成一对多，同时能通过中间类来封装多个类中的行为，观察者模式在目标状态更新时能自动通知给订阅者，模版方法模式则是控制方法的执行顺序，子类在不改变算法的结构基础上可以扩展功能实现。

    1 中介者模式

    需求：1）系统中对象之间存在复杂的引用关系，比如一对多，多对多等。系统结构耦合度很高，结构混乱且难以理解。2）想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。在中间类中定义对象交互的公共行为。

    1.1 中介者模式介绍

    用一个中介对象来封装一系列的对象交互。使得各个对象不需要显式地相互引用，从而使其耦合度松散，而且可以独立地改变它们之间的交互。

    图 中介者模式 UML

    需求描述：在前端开发中，有三个组件 Button、View, 及Text. View 用来展示信息，Text 用于输入编辑信息，Button用来提交更新。用户在Text输入好内容后，点击Button后，内容会更新到View. 而点击View时，会把内容输入到Text。

    图 需求分析图

    图 需求分析UML

    1. public class NoMediatorPattern {
    2.  
    3.     public static void main(String[] args) {
    4.         Text text = new Text();
    5.         Button button = new Button();
    6.         View view = new View();
    7.  
    8.         button.setText(text);
    9.         button.setView(view);
    10.         view.setText(text);
    11.  
    12.         button.click();
    13.         view.click();
    14.         button.click();
    15.     }
    16.  
    17.     private static class Button {
    18.  
    19.         private Text text;
    20.         private View view;
    21.  
    22.         public void setText(Text text) {
    23.             this.text = text;
    24.         }
    25.  
    26.         public void setView(View view) {
    27.             this.view = view;
    28.         }
    29.  
    30.         void click() {
    31.             if (text != null && view != null) {
    32.                 view.onRefresh(text.generateText());
    33.             }
    34.         }
    35.     }
    36.  
    37.     private static class Text  {
    38.  
    39.         private String content;
    40.  
    41.         private String generateText() {
    42.             if (content == null) content = "";
    43.             Random random = new Random();
    44.             content += random.nextInt();
    45.             return content;
    46.         }
    47.  
    48.         void onRefresh(String text) {
    49.             content = text;
    50.         }
    51.     }
    52.  
    53.     private static class View{
    54.  
    55.         private Text text;
    56.  
    57.         private String content;
    58.  
    59.         public void setText(Text text) {
    60.             this.text = text;
    61.         }
    62.  
    63.         void click() {
    64.             if (text != null) {
    65.                 text.onRefresh(content);
    66.             }
    67.         }
    68.  
    69.         void onRefresh(String text) {
    70.             this.content = text; // 更新信息
    71.             System.out.println("View中显示信息:" + text);
    72.         }
    73.     }
    74.  
    75. }

    上面代码中，需要考虑Button 与 Text、View，View 与Text 的交互。这使得系统逻辑变得更复杂。

    图 中介者模式思维下的需求分析

    图 中介者模式思维下的 UML

    中介者模式下，只需要考虑中介者与各同事类的交互。

    1. public class MediatorPattern {
    2.  
    3.     public static void main(String[] args) {
    4.  
    5.         Mediator mediator = new ContentMediator();
    6.  
    7.         Component text = new Text(mediator, "text");
    8.         Component button = new Button(mediator,"button");
    9.         Component view = new View(mediator,"view");
    10.  
    11.         mediator.registry(text);
    12.         mediator.registry(button);
    13.         mediator.registry(view);
    14.  
    15.         button.onClick();
    16.         button.onClick();
    17.         view.onClick();
    18.         button.onClick();
    19.     }
    20.  
    21.     private static abstract class Mediator {
    22.  
    23.         protected final Set components = new HashSet<>();
    24.  
    25.         public void registry(Component component) {
    26.             if (component != null) {
    27.                 components.add(component);
    28.             }
    29.         }
    30.  
    31.         abstract void update(String content,String target);
    32.  
    33.     }
    34.  
    35.     private static class ContentMediator extends Mediator{
    36.  
    37.         @Override
    38.         public void update(String content,String target) {
    39.             if (content == null) {
    40.                 Text text = getText();
    41.                 if (text == null) throw new RuntimeException("没有更新内容");
    42.                 content = text.getContent();
    43.             }
    44.             for (Component component : components) {
    45.                 if (component.getTag().equals(target)) {
    46.                     component.onRefresh(content);
    47.                 }
    48.             }
    49.         }
    50.  
    51.         private Text getText() {
    52.             for (Component component : components) {
    53.                 if ("text".equals(component.getTag())) return (Text) component;
    54.             }
    55.             return null;
    56.         }
    57.     }
    58.  
    59.     private static abstract class Component {
    60.         protected final Mediator mediator;
    61.         private final String tag;
    62.  
    63.         protected Component(Mediator mediator, String tag) {
    64.             this.mediator = mediator;
    65.             this.tag = tag;
    66.         }
    67.  
    68.         public String getTag() {
    69.             return tag;
    70.         }
    71.  
    72.         abstract void onClick();
    73.  
    74.         abstract void onRefresh(String content);
    75.     }
    76.  
    77.     private static class Text extends Component {
    78.  
    79.         private String content;
    80.  
    81.         protected Text(Mediator mediator, String tag) {
    82.             super(mediator, tag);
    83.         }
    84.  
    85.         @Override
    86.         void onClick() { // 输入操作
    87.             throw new RuntimeException("暂不支持Text的点击事件");
    88.         }
    89.  
    90.         @Override
    91.         void onRefresh(String content) {
    92.             this.content = content;
    93.         }
    94.  
    95.         public String getContent() {
    96.             Random random = new Random();
    97.             String temp = content;
    98.             if (temp == null) temp = "";
    99.             temp += random.nextInt() + "@";
    100.             content = null;
    101.             return temp;
    102.         }
    103.     }
    104.  
    105.     private static class View extends Component {
    106.  
    107.         private String content;
    108.  
    109.         protected View(Mediator mediator, String tag) {
    110.             super(mediator, tag);
    111.         }
    112.  
    113.         @Override
    114.         void onClick() {
    115.             mediator.update(content,"text");
    116.         }
    117.  
    118.         @Override
    119.         void onRefresh(String content) {
    120.             this.content = content;
    121.             System.out.println("view更新："+ content);
    122.         }
    123.     }
    124.  
    125.     private static class Button extends Component {
    126.  
    127.         protected Button(Mediator mediator, String tag) {
    128.             super(mediator, tag);
    129.         }
    130.  
    131.         @Override
    132.         void onClick() {
    133.             mediator.update(null,"view");
    134.         }
    135.  
    136.         @Override
    137.         void onRefresh(String content) {
    138.             throw new RuntimeException("暂不支持Button的更新操作");
    139.         }
    140.     }
    141.  
    142. }

    1.2 优缺点

    优点：

    1. 简化了对象之间的交互，将原本多对多的交互改成一对多。使得对象之间解耦。
    2. 可以通过中介者类来扩展对象的交互行为，当需要添加或改变交互行为时，只需要添加对应的中介者子类即可，符合开闭原则。
    3. 同事类可以更专注自身业务，而不必关心与其他同事类的交互。

    缺点：

    1. 中介者类包含同事类之间大量的交互细节，使得该类变得非常复杂，不符合单一职责原则。
    2. 中介者类与同事类的耦合度高。

    2 观察者模式

    需求：当目标更新时，能自动通知给订阅者。

    2.1 观察者模式介绍

    当目标对象的状态发生改变时，它的所有观察者都会收到通知。

    图 观察者模式 UML

    1. public class ObserverPattern {
    2.  
    3.     public static void main(String[] args) {
    4.         Subject subject = new School();
    5.  
    6.         Observer observer1 = new Teacher();
    7.         Observer observer2 = new Student();
    8.         subject.attach(observer1);
    9.         subject.attach(observer2);
    10.  
    11.         subject.notifyObserverList("快高考啦！");
    12.         subject.notifyObserverList("六一放假");
    13.     }
    14.  
    15.     private static abstract class Subject {
    16.         protected final Set<Observer> observerList = new HashSet<>();
    17.  
    18.         public void attach(Observer observer) {
    19.             observerList.add(observer);
    20.         }
    21.  
    22.         public void detach(Observer observer) {
    23.             observerList.remove(observer);
    24.         }
    25.  
    26.         public void notifyObserverList(String content) {
    27.             beforeNotify(content);
    28.             for (Observer observer : observerList) observer.update(content);
    29.             afterNotify(content);
    30.         }
    31.  
    32.         public abstract void beforeNotify(String content);
    33.  
    34.         public abstract void afterNotify(String content);
    35.  
    36.     }
    37.  
    38.     private static class School extends Subject {
    39.  
    40.         @Override
    41.         public void beforeNotify(String content) {
    42.             System.out.println("通知时间：" + new Date());
    43.         }
    44.  
    45.         @Override
    46.         public void afterNotify(String content) {
    47.             System.out.println("通知完成");
    48.         }
    49.     }
    50.  
    51.     private interface Observer {
    52.         void update(String content);
    53.     }
    54.  
    55.     private static class Student implements Observer {
    56.         @Override
    57.         public void update(String content) {
    58.             if (content.contains("放假")) System.out.println("学生，耶耶耶！");
    59.             else System.out.println("学生，哦哦哦");
    60.         }
    61.     }
    62.  
    63.     private static class Teacher implements Observer {
    64.  
    65.         @Override
    66.         public void update(String content) {
    67.             System.out.println("老师，收到：" + content);
    68.         }
    69.     }
    70.  
    71. }

    2.2 优缺点

    优点：

    1. 当目标状态更新时，能自动发生通知给订阅者。
    2. 观察者与被观察者耦合度低，符合依赖倒置原则。

    缺点：

    1. 当观察者数量较多时，通知耗时会加长。一个观察者的卡顿会影响整体执行效率

    3 模版方法模式

    需求：对方法的执行顺序有要求，而某些特定方法由子类去实现。例如想写排序算法，算法内部中方法的执行顺序相同，但具体排序算法由不同子类实现。

    3.1 模版方法模式介绍

    定义一个操作中的算法框架，将一些步骤延迟到子类中，子类在不改变算法的结构基础上重定义该算法的某些特定步骤。

    图 模版方法模式 UML

    1. public class TemplateMethodPattern {
    2.  
    3.     public static void main(String[] args) {
    4.         Worker programmer = new Programmer();
    5.         programmer.work();
    6.     }
    7.  
    8.     private static abstract class Worker {
    9.  
    10.         public void work() {
    11.             punch("上班");
    12.             duty();
    13.             punch("下班");
    14.         }
    15.  
    16.         protected abstract void duty();
    17.  
    18.         protected void punch(String content) {
    19.             System.out.println("打卡:" + content);
    20.         }
    21.     }
    22.  
    23.     private static class Programmer extends Worker {
    24.  
    25.         @Override
    26.         protected void duty() {
    27.             System.out.println("写bug AND 解决bug");
    28.         }
    29.     }
    30.  
    31. }

    3.2 优缺点

    优点：

    1. 可以控制方法执行顺序，当要增加新的方法实现时，只需要添加特定子类。符合开闭原则及里氏替换原则。

    缺点：

    1. 增加了类的个数。
  • 相关阅读:
    我要给你讲的简单明了，Java就是值传递，不服来辩
    MySQL—优化数据库
    一键自助建站系统源码带安装教程 傻瓜式部署搭建,让您的建站更高效
    ES6及更新版本的新特性
    铸坯火焰自动切割系统的设计状况及存在的问题
    力扣-1984. 学生分数的最小差值
    申请实用新型专利有什么好处？及实用新型专利申请流程
    mysql内置功能（走开发的看）
    1463_英飞凌TC275开发板例程覆盖梳理
    【数据可视化】第四章—— 基于pandas的数据可视化（pandas数据结构）
  • 原文地址：https://blog.csdn.net/qq_25308331/article/details/139335658