大型Java进阶专题(八) 设计模式之适配器模式、装饰者模式、观察者模式

前言

​ 今天开始我们专题的第八课了。本章节将介绍：三个设计模式，适配器模式、装饰者模式和观察者模式。通过学习适配器模式，可以优雅的解决代码功能的兼容问题。另外有重构需求的人群一定需要掌握装饰者模式。本章节参考资料书籍《Spring 5核心原理》中的第一篇 Spring 内功心法（Spring中常用的设计模式）（没有电子档，都是我取其精华并结合自己的理解，一个字一个字手敲出来的，如果觉得本文对你有用，请点个推荐）。

适配器模式

适配器模式的应用场景

​ 适配器模式（Adapter Pattern）是指将一个类的接口转换成客户期望的另一个接口，使原本的接口不兼容的类可以一起工作，属于结构型设计模式。
适配器适用于以下几种业务场景：
​ 1、已经存在的类，它的方法和需求不匹配（方法结果相同或相似）的情况。
​ 2、适配器模式不是软件设计阶段考虑的设计模式，是随着软件维护，由于不同产品、不同厂家造成功能类似而接口不相同情况下的解决方案。有点亡羊补牢的感觉。生活中也非常的应用场景，例如电源插转换头、手机充电转换头、显示器转接头。

在中国民用电都是 220V 交流电，但我们手机使用的锂电池使用的 5V 直流电。因此，我 们给手机充电时就需要使用电源适配器来进行转换。下面我们有代码来还原这个生活场 景，创建 AC220 类，表示 220V 交流电

package com.study;

/**
 * @author wangzhongyuan
 */
public class AC220 {
    public int outputAC220V(){
        int output = 220;
        System.out.println("提供220V交流电");
        return output;
    }
}

创建5V电源的接口：

package com.study;

/**
 * @author wangzhongyuan
 */
public interface DC5 {
    int output5V();
}

创建提供5V电源的适配器：

package com.study;

/**
 * @author wangzhongyuan
 */
public class PowerAdapter implements DC5{
    AC220 ac220;

    public PowerAdapter(AC220 ac220) {
        this.ac220 = ac220;
    }

    @Override
    public int output5V() {
        int outputAC220V = ac220.outputAC220V();
        System.out.println("将220v转换成5v");
        return outputAC220V/44;
    }
}

测试代码：

package com.study;

/**
 * @author wang.zhongyuan
 * @version 1.0
 * @date 2020/7/20 11:17 下午
 */
public class DemoTest {

    public static void main(String[] args) {
        DC5 powerAdapter = new PowerAdapter(new AC220());
        powerAdapter.output5V();
    }
}

输出结果：

从上面的代码样式可以看出，适配器就是通过增加一个适配器类持有原有提供者的对象，实现了二者的兼容。

适配模式的优缺点

优点：

1、能提高类的透明性和复用，现有的类复用但不需要改变。

2、目标类和适配器类解耦，提高程序的扩展性。

3、在很多业务场景中符合开闭原则。

缺点：

1、适配器编写过程需要全面考虑，可能会增加系统的复杂性。

2、增加代码阅读难度，降低代码可读性，过多使用适配器会使系统代码变得凌乱。

装饰者模式

装饰者模式的应用场景

​ 装饰者模式（Decorator Pattern）是指在不改变原有对象的基础之上，将功能附加到对 象上，提供了比继承更有弹性的替代方案（扩展原有对象的功能），属于结构型模式。 装饰者模式在我们生活中应用也比较多如给煎饼加鸡蛋；给蛋糕加上一些水果；给房子 装修等，为对象扩展一些额外的职责。装饰者在代码程序中适用于以下场景：

1、用于扩展一个类的功能或给一个类添加附加职责。

2、动态的给一个对象添加功能，这些功能可以再动态的撤销。

代码实现

来看一个这样的场景，上班族白领其实大多有睡懒觉的习惯，每天早上上班都是踩点，于是很多小伙伴为了多赖一会儿床都不吃早餐。那么，也有些小伙伴可能在上班路上碰 到卖煎饼的路边摊，都会顺带一个到公司茶水间吃早餐。卖煎饼的大姐可以给你的煎饼 加鸡蛋，也可以加香肠。

创建煎饼类：

package com.study;

/**
 * @author wang.zhongyuan
 * @version 1.0
 * @date 2020/7/20 11:57 下午
 */
public class Battercake {

    public String getMsg(){
        return "煎饼";
    }

    public int getPrice(){
        return 5;
    }
}

给煎饼加个蛋：

package com.study;

/**
 * @author wang.zhongyuan
 * @version 1.0
 * @date 2020/7/20 11:59 下午
 */
public class BattercakeWithEgg extends Battercake{
    @Override
    public String getMsg() {
        return super.getMsg() + "加鸡蛋";
    }

    @Override
    public int getPrice() {
        return super.getPrice() + 1;
    }
}

再加个烤肠：

package com.study;

/**
 * @author wang.zhongyuan
 * @version 1.0
 * @date 2020/7/21 12:00 上午
 */
public class BatterCakeWithEggAndSausage extends BattercakeWithEgg{
    @Override
    public String getMsg() {
        return super.getMsg() +"加烤肠";
    }

    @Override
    public int getPrice() {
        return super.getPrice() + 3;
    }
}

测试代码：

package com.study;

/**
 * @author wang.zhongyuan
 * @version 1.0
 * @date 2020/7/21 12:01 上午
 */
public class DemoTest {

    public static void main(String[] args) {
        BatterCakeWithEggAndSausage batterCakeWithEggAndSausage = new BatterCakeWithEggAndSausage();
        String msg = batterCakeWithEggAndSausage.getMsg();
        int price = batterCakeWithEggAndSausage.getPrice();
        System.out.println("买了："+msg+"，价格为："+price);
    }
}

输出结果：

​

运行结果没有问题，但是如果用户需要一个加 2 个鸡蛋加 1 根香肠的煎饼，那么用我们现在的类结构是创建不出来的，也无法自动计算出价格，除非再创建一个类做定制。 如果需求再变，一直加定制显然是不科学的。那么下面我们就用装饰者模式来解决上面 的问题。

创建煎饼抽象类：

package com.study;

/**
 * @author wang.zhongyuan
 * @version 1.0
 * @date 2020/7/21 12:18 上午
 */
public abstract class AbstractBatterCake {
    protected abstract String getMsg();
    protected abstract int getPrice();
}

创建基础套餐煎饼：

package com.study;

/**
 * @author wang.zhongyuan
 * @version 1.0
 * @date 2020/7/21 12:19 上午
 */
public class BatterCakeWithBase extends AbstractBatterCake{
    @Override
    protected String getMsg() {
        return "煎饼";
    }

    @Override
    protected int getPrice() {
        return 5;
    }
}

创建额外套餐的抽象装饰类：

package com.study;

/**
 * @author wang.zhongyuan
 * @version 1.0
 * @date 2020/7/21 12:21 上午
 */
public abstract class BatterCakeDecorator extends AbstractBatterCake{
    AbstractBatterCake batterCake;

    public BatterCakeDecorator(AbstractBatterCake batterCake) {
        this.batterCake = batterCake;
    }

    protected abstract void doSomething();

    @Override
    protected String getMsg() {
        return this.batterCake.getMsg();
    }

    @Override
    protected int getPrice() {
        return this.batterCake.getPrice();
    }
}

创建加鸡蛋套餐：

package com.study;

/**
 * @author wang.zhongyuan
 * @version 1.0
 * @date 2020/7/20 11:59 下午
 */
public class BattercakeWithEgg extends BatterCakeDecorator{


    public BattercakeWithEgg(AbstractBatterCake batterCake) {
        super(batterCake);
    }

    @Override
    protected void doSomething() {

    }

    @Override
    public String getMsg() {
        return super.getMsg() + "加鸡蛋";
    }

    @Override
    public int getPrice() {
        return super.getPrice() + 1;
    }
}

创建加烤肠套餐：

package com.study;

/**
 * @author wang.zhongyuan
 * @version 1.0
 * @date 2020/7/21 12:00 上午
 */
public class BatterCakeWithSausage extends BatterCakeDecorator{

    public BatterCakeWithSausage(AbstractBatterCake batterCake) {
        super(batterCake);
    }

    @Override
    protected void doSomething() {

    }

    @Override
    public String getMsg() {
        return super.getMsg() +"加烤肠";
    }

    @Override
    public int getPrice() {
        return super.getPrice() + 3;
    }
}

测试代码：

package com.study;

/**
 * @author wang.zhongyuan
 * @version 1.0
 * @date 2020/7/21 12:01 上午
 */
public class DemoTest {

    public static void main(String[] args) {
        AbstractBatterCake batterCake;
        batterCake = new BatterCakeWithBase();
        batterCake = new BattercakeWithEgg(batterCake);
        batterCake = new BatterCakeWithSausage(batterCake);
        //再加个鸡蛋
        batterCake = new BattercakeWithEgg(batterCake);
        System.out.println(batterCake.getMsg()+"，价格："+batterCake.getPrice());
    }
}

输出结果：

装饰者模式最本质的特征是讲原有类的附加功能抽离出来，简化原有类的逻辑。通过这样两个案例，我们可以总结出来，其实抽象的装饰者是可有可无的，具体可以根据业务模型来选择。

装饰者模式与适配器模式对比

装饰者和适配器模式都是包装模式（Wrapper Pattern），装饰者也是一种特殊的代理模式。

		装饰者模式 															适配器模式 
形式 是一种非常特别的适配器模式 没有层级关系，		装饰器模式有层级关系 
定义 装饰者和被装饰者都实现同一个接口，					适配器和被适配者没有必然的联系，通 常是采用继承或代理的形式进行包装 
		主要目的是为了扩展之后依旧保 留 OOP 关系 
关系 满足 is-a 的关系 												 满足 has-a 的关系 
功能 注重覆盖、扩展 							 							注重兼容、转换 
设计 前置考虑 									 							后置考虑

装饰者模式的优缺点

优点：

1、装饰者是继承的有力补充，比继承灵活，不改变原有对象的情况下动态地给一个对象扩展功能，即插即用。

2、通过使用不同装饰类以及这些装饰类的排列组合，可以实现不同效果。

3、装饰者完全遵守开闭原则。

缺点：

1、会出现更多的代码，更多的类，增加程序复杂性。

2、动态装饰时，多层装饰时会更复杂。

观察者模式

观察者模式的应用场景

​ 观察者模式（Observer Pattern）定义了对象之间的一对多依赖，让多个观察者对象同 时监听一个主体对象，当主体对象发生变化时，它的所有依赖者（观察者）都会收到通 知并更新，属于行为型模式。观察者模式有时也叫做发布订阅模式。观察者模式主要用 于在关联行为之间建立一套触发机制的场景。

代码实现

​ 小伙伴们肯定都刷过抖音，遇到喜欢的作品都会点个❥喜欢，我们通过模拟喜欢这个事件来实践下观察者模式。当你点击喜欢时，会触发两个事件，一个喜欢数量会增加+1，二是作者会受到消息。你可能会想到MQ，异步队列等，其实JDK本身就提供这样的API。

创建事件模型类，用于区分什么样的事件，观察者可以根据不同事件类型做不同处理：

package com.study.demo4;

/**
 * 事件模型
 * @Author wangzhongyuan
 * @Date 2020/7/21 11:28
 * @Version 1.0
 **/
public enum EventModel {
    LIKE_EVENT("喜欢事件",1,null),
    MCOMENT_ENVET("评论事件",2,null)
    ;

    private String message;
    private int type;
    private Object date;

    EventModel(String message, int type, Object date) {
        this.message = message;
        this.type = type;
        this.date = date;
    }}

创建事件类，被观察者对象，调用方可以向该对象中传送事件：

package com.study.demo4;

import java.util.Observable;

/**
 * 事件总线(被观察者)
 * @Author wangzhongyuan
 * @Date 2020/7/21 11:24
 * @Version 1.0
 **/
public class EventBus extends Observable{
    /**
     * 被观察者方法
     * @param eventModel
     */
    public void postEvent(EventModel eventModel){
        System.out.println("推送事件");
        setChanged();
        //通知观察者
        notifyObservers(eventModel);
    }
}

创建不同业务的观察者:

package com.study.demo4;

import java.util.Observable;
import java.util.Observer;

/**
 * 观察者1
 *
 * @Author 19054253
 * @Date 2020/7/21 11:32
 * @Version 1.0
 **/
public class OneObserver implements Observer {

    public void update(Observable o, Object arg) {
        System.out.println("观察1,监听到了事件,触发:给作者推送消息!");
    }
}

package com.study.demo4;

import java.util.Observable;
import java.util.Observer;

/**
 * 观察者2
 *
 * @Author 19054253
 * @Date 2020/7/21 11:48
 * @Version 1.0
 **/
public class TwoObserver implements Observer {

    public void update(Observable o, Object arg) {
        System.out.println("观察2,监听到了事件,触发:喜欢总数+1");
    }
}

调用测试:

package com.study.demo4;

/**
 * @Author wangzhongyuan
 * @Date 2020/7/21 11:35
 * @Version 1.0
 **/
public class DemoTest {
    public static void main(String[] args) {
        //被观察者
        EventBus eventBus = new EventBus();
        //观察者
        OneObserver oneObserver = new OneObserver();
        TwoObserver twoObserver = new TwoObserver();
        //监听观察者
        eventBus.addObserver(oneObserver);
        eventBus.addObserver(twoObserver);
        //被观察者触发事件
        eventBus.postEvent(EventModel.LIKE_EVENT);
    }
}

输出结果:

从上面代码可以看出来，观察者模式的本质就是，被观察者对象持有观察者对象的引用，由被观察者去通知了观察者去做了某件事。JDK源码中，观察者模式也应用非常多。例如java.awt.Event就是观察者模式的一种，只不过Java很少被用来写桌面程序。以上就是我模拟的事件机制。

观察模式的优缺点

优点：

1、观察者和被观察者之间建立了一个抽象的耦合。
2、观察者模式支持广播通信。

缺点：

1、观察者之间有过多的细节依赖、提高时间消耗及程序的复杂度。
2、使用要得当，要避免循环调用。