设计模式-结构型模式篇

设计模式

目录：

一.代理模式
二.适配器模式
三.装饰者模式
四.桥接模式
五.外观模式
六.组合模式
七.享元模式
注：学习视频：黑马程序员Java设计模式

结构型模式

结构性模式描述如何将类或对象按照某种布局组成撑大的结构，它分为类结构型模式和对象结构型模式，前者是采用继承机制来实现，后者采用组合或聚合的方式来实现。

结构型模式分为以下7类：

• 代理模式
• 适配器模式
• 装饰者模式
• 桥接模式
• 外观模式
• 组合模式
• 享元模式

一、代理模式

1.1 概述

由于某些原因，需提供一个代理对象来控制对目标对象的访问，或者访问对象不能暴露给调用者直接调用，代理对象就可以作为中介，客户可以通过代理对象来调用目标对象，就像买房的时候，不是直接找到房屋开发商，而是找房屋中介买房。

1.2 结构

代理（Proxy）模式分为三大角色：

• 抽象主题类： 通过接口或抽象类声明真实主题和代理对象实现的业务方法
• 真实主题类： 实现抽象主题类，用来给代理对象调用真实主题的方法。
• 代理类： 实现了抽象主题类，但是实现方法的时候，调用的是真实主题类的方法，并且在真实主题类方法的基础上增强。

1.3 静态代理

这里就采用买房子来演示这个案例，房屋开发商作为真实主题类，房屋中介作为代理类，声明一个抽象主题类，让真实主题类和代理类实现接口方法。

代码实现如下：

// 抽象主题类
public interface SellHouse {
    void sellHouse();
}

// 房屋开发商（真实主题类）
public class HouseDeveloper implements SellHouse {

    public void sellHouse() {
        System.out.println("卖房子");
    }
}

// 中介（代理类）
public class HouseAgent implements SellHouse{

    // 声明一个真实主题类
    private HouseDeveloper houseDeveloper = new HouseDeveloper();
    public void sellHouse() {
        // 对真实主题类增强，也就是作为中介从中收取一点费用
        System.out.println("中介卖房子收取费用");
        houseDeveloper.sellHouse();
    }
}

// 测试类
public class Client {
    public static void main(String[] args) {
        // 声明一个代理类
        HouseAgent houseAgent = new HouseAgent();
        houseAgent.sellHouse();
    }
}

// 测试结果
中介卖房子收取费用 // 代理类增强部分
卖房子 // 调用仍然是调用真实主题类

说明：

根据上面代码可以看出，真实主题类（HouseDeveloper）和代理类（HouseAgent）都实现了抽象主题类（SellHouse）,代理类最终调用的还是真实主题类中的方法，代理类只是帮助调用和增强。

1.4 JDK动态代理

动态代理不是自己创建类，采用jdk动态代理方式实现，是jdk内存中帮助我们创建，我们可以采用工厂来获取这个创建好的代理对象，这个方式实现必须要有抽象主题类。

代码如下：

// 抽象主题类
public interface SellHouse {
    void sellHouse();
}

// 房屋开发商（真实主题类）
public class HouseDeveloper implements SellHouse {

    public void sellHouse() {
        System.out.println("房屋开发商卖房子");
    }
}

// 代理工厂
public class ProxyFactory {
    // 声明一个真实主题类，给代理类调用
    private HouseDeveloper houseDeveloper = new HouseDeveloper();

    // 返回值是抽象主题类或抽象接口
    public SellHouse getProxyInstance(){
        // 创建一个代理对象 以下三个参数
        /**
         * ClassLoader loader : 真是主题类的类加载器
         * Class<?>[] interfaces : 真是主题类实现的接口字节码
         * InvocationHandler h : 代理类处理对象，最后代理类的处理方法将会在这里执行
         */
        SellHouse houseAgent = (SellHouse) Proxy.newProxyInstance(houseDeveloper.getClass().getClassLoader(),
                houseDeveloper.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     *
                     * @param proxy 就是当前创建的代理对象
                     * @param method 代理对象中的代理方法，因为采用反射调用，所有任何真是主题类方法，都在这里调用
                     * @param args 调用真是主题类所需的参数
                     * @return 调用真是主题类的返回值
                     * @throws Throwable
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // 代理类增强
                        System.out.println("房屋中介卖房子收取费用");
                        // 反射调用真是主题类方法
                        Object obj = method.invoke(houseDeveloper, args);
                        return obj;
                    }
                });
        return houseAgent;
    }
}

// 测试类
public class Client {
    public static void main(String[] args) {
        // 通过代理工厂类获取代理类
        SellHouse houseAgent = new ProxyFactory().getProxyInstance();
        // 调用方法
        houseAgent.sellHouse();
    }
}
// 测试结果
房屋中介卖房子收取费用 // 调用了invoke方法
房屋开发商卖房子

说明：

采用jdk动态代理方式必须要有抽象主题类，采用反射实现方法的调用，可以将抽象主题类中的方法全部聚合到一个方法invoke 中处理。

动态代理底层创建的代理对象代码(删减):

public final class $Proxy0 extends Proxy implements SellHouse {
    private static Method m3;
    public $Proxy0(InvocationHandler invocationHandler) {
        super(invocationHandler);
    }

    static {
        m3 = Class.forName("com.itheima.proxy.dynamic.jdk.SellHouse").getMethod("sell", new Class[0]);
    }

    public final void sell() {
            this.h.invoke(this, m3, null);
    }
}

• 代理类（$Proxy0）实现了抽象主题类（SellHouse），和静态代理一样，需要实现抽象主题类
• 代理类（$Proxy0）向父类传递了我们自定义的匿名类。

执行流程：

1. 在测试类中通过代理对象调用sell()方法
2. 根据多态的特性，执行的是代理类（$Proxy0）中的sell()方法
3. 代理类（$Proxy0）中的sell()方法中又调用了InvocationHandler接口的子实现类对象的invoke方法
4. invoke方法通过反射执行了真实对象所属类(HouseDeveloper)中的sell()方法

1.5 CGLIB 动态代理

如果没有抽象主题类，我们就可以采用Cglib来实现动态代理。

Cglib是第三方的包，引入以下依赖：

<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

代码如下：

// 房屋开发商（真实主题类）
public class HouseDeveloper implements SellHouse {

    public void sellHouse() {
        System.out.println("房屋开发商卖房子");
    }
}

// 代理工厂类
public class ProxyFactory implements MethodInterceptor {
    private HouseDeveloper houseDeveloper = new HouseDeveloper();

    public HouseDeveloper getProxyObj(){
        // 创建一个enhancer对象，类似于JDK实现中的Proxy
        Enhancer enhancer = new Enhancer();
        // 设置真实主题类的字节码对象，cglib是继承真实主题类实现的，所以要设置父类字节码
        enhancer.setSuperclass(houseDeveloper.getClass());
        // 设置回调函数,将自己作为回调函数，回调函数类似于JDK里面的Invoke
        // 需要实现MethodInterceptor接口
        enhancer.setCallback(this);
        // 生成代理对象返回
        HouseDeveloper houseAgent = (HouseDeveloper) enhancer.create();
        return houseAgent;
    }

    /**
     * 代理对象的具体增强方法
     * @param obj
     * @param method
     * @param args
     * @param proxy
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 代理对象增强
        System.out.println("房屋中介卖房子收取费用");
        // 反射调用方法
        Object result = method.invoke(houseDeveloper, args);
        return result;
    }
}

// 测试类
public class Client {
    public static void main(String[] args) {
        HouseDeveloper houseAgent = new ProxyFactory().getProxyObj();
        houseAgent.sellHouse();
    }
}

// 测试结果
房屋中介卖房子收取费用 // 调用了intercept方法
房屋开发商卖房子

1.6 三种代理对比

• JDK动态代理和CGLIB动态代理

使用cglib实现动态代理，底层采用ASM字节码生成框架，使用字节码技术生成代理类，在Jdk1.6之前比Jdk实现速度快,不需要抽象主题类就可以实现。

在Jdk1.8优化以后，性能已经高于Cglib，需要有抽象主题类的才能实现.

• 动态代理和静态代理

动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。

如果接口增加一个方法，静态代理模式除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。而动态代理不会出现该问题

1.7 优缺点

优点：

• 保护作用： 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
• 扩展作用： 代理对象可以扩展目标对象的功能；
• 降低耦合度： 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度；

缺点：

• 增加了系统复杂度

1.8 使用场景

• 远程（Remote）代理

本地服务通过网络请求远程服务。为了实现本地到远程的通信，我们需要实现网络通信，处理其中可能的异常。为良好的代码设计和可维护性，我们将网络通信部分隐藏起来，只暴露给本地服务一个接口，通过该接口即可访问远程服务提供的功能，而不必过多关心通信部分的细节。

• 防火墙（Firewall）代理

当你将浏览器配置成使用代理功能时，防火墙就将你的浏览器的请求转给互联网；当互联网返回响应时，代理服务器再把它转给你的浏览器。

• 保护（Protect or Access）代理

控制对一个对象的访问，如果需要，可以给不同的用户提供不同级别的使用权限。

二、适配器模式

2.1 概述

将一个类的接口装换为客户希望的另一个接口，使原本由于接口不兼容而不能一起工作的类能够一起工作。

2.2 结构

• 目标接口： 当前系统业务所期待的接口，它可以是抽象类或接口。
• 适配者类： 它是被访问和适配的现存组件库中的组件接口。
• 适配器类： 它是一个转换器，通过继承或者引用的适配者对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。

2.3 类适配器模式

实现方式：

定义一个适配器类，通过继承适配者类，同时实现目标接口的方法。实现的方法体内调用继承过来的方法，实现适配者类转换为目标接口类。

【例】读卡器

现在有一台电
脑只能读取SD卡，如果需要读取TF卡的话，就需要使用适配器模式了，创建一个读卡器，将TF中的内容读取出来返回。

类图：

代码如下：

/**
 * SD卡接口类（目标接口）
 */
public interface SDCard {
    // 从sd卡中读取数据
    String read();
    // 写入sd卡
    void  write(String msg);
}

/**
 * 目标接口实现类
 */
public class SDCardImpl implements SDCard{
    @Override
    public String read() {
        String msg = "SD card read msg : hello word SD";
        return msg;
    }

    @Override
    public void write(String msg) {
        System.out.println("SD card write msg : " + msg);
    }
}

/**
 * 适配者类
 */
public interface TFCard {
    // 从TF卡中读取数据
    String read();
    // 写入TF卡
    void  write(String msg);
}

/**
 * 适配者类实现类
 */
public class TFCardImpl implements TFCard{
    @Override
    public String read() {
        String msg = "TF card read msg : hello word TF";
        return msg;
    }

    @Override
    public void write(String msg) {
        System.out.println("TF card write msg : " + msg);
    }
}

/**
 * 类适配器类,继承TF实现类，实现 SDCard 接口
 */
public class SDAdapterTF extends TFCardImpl implements SDCard {

    @Override
    public String read() {
        return super.read();
    }

    @Override
    public void write(String msg) {
        super.write(msg);
    }
}

/**
 * 计算机类
 */
public class Computer {
    // 目标接口类，这里直接接受SDCard的子实现类，TFCard不能传入
    private SDCard sdCard;
    public Computer(SDCard sdCard){
        this.sdCard = sdCard;
    }
    // 读取SDCard方法
    public void  read(){
        System.out.println(sdCard.read());
    }
}

// 测试类
public class Client {
    public static void main(String[] args) {
        // 创建计算机对象，传入 SDCard 的实现类
        Computer computer = new Computer(new SDCardImpl());
        // 调用计算机读取SD卡内容
        computer.read();
        System.out.println("=================================");
        // 用适配器类作为目标接口传入
        Computer computer1 = new Computer(new SDAdapterTF());
        computer1.read();
    }
}

// 测试结果
SD card read msg : hello word SD
=================================
TF card read msg : hello word TF

2.4 对象适配者模式

对象适配器模式，只需在类适配器的基础上修改即可，将继承 适配者类实现类（TFCardImpl） 变成聚合适配者类实现类（TFCardImpl）。

代码如下：

/**
 * 类适配器类,继承TF实现类，实现 SDCard 接口
 */
public class SDAdapterTF implements SDCard {
    private TFCard tfCard;

    public SDAdapterTF(TFCard tfCard){
        this.tfCard =tfCard;
    }
    @Override
    public String read() {
        return tfCard.read();
    }

    @Override
    public void write(String msg) {
        tfCard.write(msg);
    }
}
// 测试类
public class Client {
    public static void main(String[] args) {
        // 创建计算机对象，传入 SDCard 的实现类
        Computer computer = new Computer(new SDCardImpl());
        // 调用计算机读取SD卡内容
        computer.read();
        System.out.println("=================================");
        // 用适配器类作为目标接口传入
        Computer computer1 = new Computer(new SDAdapterTF(new TFCardImpl()));
        computer1.read();
    }
}

//测试结果
SD card read msg : hello word SD
=================================
TF card read msg : hello word TF

说明：

还有一个适配器模式是接口适配器模式，可以通过同时是实现适配者接口和目标接口，来实现适配器。

2.5 应用场景

• 以前开发的系统存在满足新系统功能需求的类，但其接口同新系统的接口不一致。
• 使用第三方提供的组件，但组件接口定义和自己要求的接口定义不同。

2.6 JDK源码解析

Reader（字符流）、InputStream（字节流）的适配使用的是InputStreamReader。

• InputStreamReader是对同样实现了Reader的StreamDecoder的封装。其实就是将字节流转换为字符流的过程

结论：

Reader是读取字符流的接口，也就是目标接口，而InputStream是读取字节流的实现类，而StreamDecoder就是适配器，就是引用了InputStream和实现了Reader接口，典型的对象适配器模式。

三、装饰者模式

3.1 概述

一个快餐店的例子，快餐店里面有炒饭、炒面，炒饭和炒面都可以加配料鸡蛋、培根。计算总价一般都不一样的。

使用继承实现存在的问题：

• 扩展性不好

如果要再加入一种配料，就需要创建所有的产品都添加该配料的实现类，可能会造成类爆炸

• 产生过多的子类

定义：

指在不改变对象结构的情况下，动态地给该对象增加一些职责（即增加而外的功能）和模式。

3.2 结构

装饰者模式（Decorator）的角色如下：

• 抽象构件角色：定义一个抽象接口以规范准备接收附加责任的对象。
• 具体构件角色：实现抽象构件，通过装饰角色为其添加一些职责。
• 抽象装饰角色：继承或是是实现抽象构建，并聚合了抽象构件角色，可以其子类扩展具体构件的功能。
• 具体装饰角色：实现抽象装饰的相关方法，并给具体构件对象添加附加职责。

3.3 案例

采用装饰者类来是实现快餐店案例

具体实现过程：

1. 首先确定对拿一个对象进行增强
2. 创建一个抽象装饰者角色，继承需要增强的对象，并引用需要增强的对象，给出构造方法，将需要增强的对象传入。
3. 编写抽象装饰者角色的具体装饰者类，通过调用传入对象调用它来的方法，在它原来的方法的前后进行增强。

类图如下：

代码如下：

/**
 * 快餐类 （抽象装饰部件角色）
 */
public abstract class FastFood {
    // 价格
    private double price;
    // 描述
    private String desc;

    public FastFood() {
    }
    // 提供构造方法
    public FastFood(double price, String desc) {
        this.price = price;
        this.desc = desc;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }
    // 定义一个抽象方法，计算价格由子类来实现
    public abstract double cost();
}


/**
 * 炒饭类（具体装饰角色）
 */
public class FireRice extends FastFood {


    public FireRice() {
        super(10, "炒饭");
    }
    // 重写方法，返回炒饭的价格
    @Override
    public double cost() {
        return getPrice();
    }
}

/**
 * 炒面（具体装饰构件角色）
 */
public class FireNoodles extends FastFood{
    public FireNoodles() {
        super(12,"炒面");
    }

    @Override
    public double cost() {
        return super.getPrice();
    }
}

/**
 * 配料类 （抽象装饰角色）
 * 继承并聚合抽象装饰者角色FastFood
 */
public class Garnish extends FastFood{

    // 聚合抽象装饰者角色,给具体装饰者类来使用
    private FastFood fastFood;

    public Garnish(FastFood fastFood,double price,String desc) {
        super(price,desc);
        this.fastFood = fastFood;
    }

    @Override
    public double cost() {
        return getPrice();
    }

    public FastFood getFastFood() {
        return fastFood;
    }

    public void setFastFood(FastFood fastFood) {
        this.fastFood = fastFood;
    }
}

/**
 * 鸡蛋配料类（具体装饰角色）
 */
public class Egg extends Garnish{
    public Egg(FastFood fastFood) {
        super(fastFood, 1, "鸡蛋");
    }

    @Override
    public double cost() {
        return super.cost() + super.getFastFood().cost();
    }

    @Override
    public String getDesc() {
        return  super.getDesc() + super.getFastFood().getDesc();
    }
}

/**
 * 具体装饰角色
 */
public class Bacon extends Garnish{
    public Bacon(FastFood fastFood) {
        super(fastFood, 2, "培根");
    }

    @Override
    public double cost() {
        return super.cost() + super.getFastFood().cost();
    }

    @Override
    public String getDesc() {
        return super.getDesc() + super.getFastFood().getDesc();
    }
}

// 测试类
public class Client {
    public static void main(String[] args) {
        // 创建普通炒面对象
        FastFood food = new FireNoodles();
        // 输出描述和价格
        System.out.println(food.getDesc() + "  " + food.cost());

        System.out.println("===========添加鸡蛋配料后==============");
        food = new Egg(food);
        System.out.println(food.getDesc() + "  " + food.cost());
        System.out.println("===========添加培根配料后==============");
        food = new Bacon(food);
        System.out.println(food.getDesc() + "  " + food.cost());
    }
}

// 测试结果
炒面  12.0
===========添加鸡蛋配料后==============
鸡蛋炒面  13.0
===========添加培根配料后==============
培根鸡蛋炒面  15.0

说明：

装饰者模式是在不修改原来组件的情况下，增加组件的功能，装饰类和被装饰类都有独立发张，不会相互耦合，装饰模式是继承的一个代替模式，装饰模式可以动态的扩展一个是实现类的功能。

3.4 使用场景

• 当不能采用继承的方式对系统进行扩充或者采用继承不利于系统扩展和维护时。

  不能采用继承的情况主要有两类：

  • 第一类是系统中存在大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长；
  • 第二类是因为类定义不能继承（如final类）

• 在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。

• 当对象的功能要求可以动态地添加，也可以再动态地撤销时。

3.5 JDK源码分析

IO流中的包装类使用到了装饰者模式。BufferedInputStream，BufferedOutputStream，BufferedReader，BufferedWriter。

我们以BufferedWriter举例来说明，先看看如何使用BufferedWriter

public class Demo {
    public static void main(String[] args) throws Exception{
        //创建BufferedWriter对象
        //创建FileWriter对象
        FileWriter fw = new FileWriter("C:\\Users\\Think\\Desktop\\a.txt");
        // 这里的BufferWriter就是装饰者类，具体装饰部件FileWriter进行功能扩展，使其实现了缓存。
        BufferedWriter bw = new BufferedWriter(fw);

        //写数据
        bw.write("hello Buffered");

        bw.close();
    }
}

类图：

这里的BufferWriter就是装饰者类，具体装饰部件FileWriter进行功能扩展，使其实现了缓存。

3.6 代理和装饰者模式的区别

静态代理和装饰着的区别：

• 相同点：
  • 都是实现与目标类向的业务接口
  • 在两个类中都声明了目标对象
  • 都可以在不修改目标类的前提下增强目标方法
• 不同点：
  • 目的不同：装饰者模式是为了增强目标功能，而静态代理时为了保护和隐藏目标对象
  • 获取目标的构件方式不一样: 静态代理为了保证安全性，目标对象是自己创建出来的，而装饰者是由构造方法传递进来的,为了扩展装饰着部件的功能

四、桥接模式

4.1 概述

现有一个需求，首先我们需要绘制不同的图形，其次，我们不同的图形有不同的颜色。

为改进类图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wPpnAFCV-1650622192123)(C:/Users/安逸i/Desktop/Course Notes/java/Design mode/img/image-20200207194617620.png)]

从上图中可以看出， 这个构建方式需要使用两层的继承关系，并且类的数量非常大。如果需要增加一中形状的图形的话，那么就需要再增加它的三个子类，这样的话，容易造成类爆炸。

所以我们就可以将其中的一个维度进行桥接扩展

定义：

将抽象与实现分离，使它们可以独立的变化，它使用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合性。

4.2 结构

桥接（Bridge）模式包括以下角色：

• 抽象化角色：定义抽象列， 并包含一个对实现化对象的引用
• 扩展抽象类：实现抽象化角色，并且通过组合关系调用实现化角色中的业务方法
• 实现化角色：定义实现化角色的接口，提供扩展抽象化角色需要的调用方法。
• 具体实现化角色：给出实现化角色接口的具体实现。

4.3 案例

就以上面的绘图作为案例，改进成桥接模式

具体实现过程：

1. 首先我们需要一个抽象化角色 形状（Shape）
2. 其次需要一个实现化角色图形颜色（ShapeColor）
3. 定义颜色维度的具体实现化角色（XXXShapeColor）
4. 定义扩展角色（XXXShape）,并且调用实现化角色

代码如下:

/**
 * 图形类（抽象化角色）
 */
public abstract class Shape {
    // 引用/聚合实现化角色
    private ShapeColor shapeColor;
    private String name;

    public Shape(ShapeColor shapeColor, String name) {
        this.shapeColor = shapeColor;
        this.name = name;
    }

    // 定义一个画图方法由子类（扩展化角色来实现）
    abstract void draw();

    public ShapeColor getShapeColor() {
        return shapeColor;
    }

    public void setShapeColor(ShapeColor shapeColor) {
        this.shapeColor = shapeColor;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

/**
 * 绘制线的扩展类
 */
public class LineShape extends Shape{

    public LineShape(ShapeColor shapeColor) {
        super(shapeColor, "线");
    }

    @Override
    void draw() {
        System.out.println(getShapeColor().drawColor() + getName());
    }
}

/**
 * 圆形（扩展类对象）
 */
public class RoundShape extends Shape{

    public RoundShape(ShapeColor shapeColor) {
        super(shapeColor, "圆");
    }

    @Override
    void draw() {
        System.out.println(getShapeColor().drawColor() + getName());
    }
}

/**
 * 图形颜色（实现化角色）
 */
public interface ShapeColor {
    String  drawColor();
}

/**
 * 绿色的（具体实现化类）
 */
public class GreenShapeColor implements ShapeColor{
    @Override
    public String drawColor() {
        return "绿";
    }
}

/**
 * 红色（具体实现化类）
 */
public class RedShapeColor implements ShapeColor{
    @Override
    public String drawColor() {
        return "红";
    }
}

// 测试类
public class Client {
    public static void main(String[] args) {
        GreenShapeColor greenShapeColor = new GreenShapeColor();
        RedShapeColor redShapeColor = new RedShapeColor();
        LineShape greenLine = new LineShape(greenShapeColor);
        RoundShape redRound = new RoundShape(redShapeColor);
        greenLine.draw();
        redRound.draw();
    }
}

// 测试结果
绿线
红圆

好处：

桥接模式提高了系统的可扩充性，在两个变化维度中任意扩展一个维度，都不需要修改原有系统。

如：如果现在还有一种视频文件类型wmv，我们只需要再定义一个类实现VideoFile接口即可，其他类不需要发生变化。

实现细节对客户透明

4.4 使用场景

• 当一个类存在两个独立变化的维度，且这两个维度都需要进行扩展时。
• 当一个系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时。
• 当一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性时。避免在两个层次之间建立静态的继承联系，通过桥接模式可以使它们在抽象层建立一个关联关系

五、外观模式

5.1 概述

如果你想投资理财，但是你没有经验，往往很容易亏钱，但是你可以将钱交给基金，基金会帮你进行股票、债券、外汇等投资，这里的基金就像是外观模式的外观角色，而投资项目就是子系统，我们只需要跟基金互动，就可以完成投资的操作。

外观（Facade）模式是“迪米特法则”的典型应用：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6T0iearb-1650622192124)(C:/Users/安逸i/Desktop/Course Notes/java/Design mode/img/外观模式引入.jpg)]

5.2 结构

外观模式包含一下角色：

• 外观角色：为多个子系统对外提供一个共同的接口。
• 子系统角色：实现系统的部分功能，客户可以通过外观角色访问。提供给外观模式调用

5.3案例

智能家电控制

通过外观类来实现多个家电的一键开启和一键关闭。

类图如下：

代码如下：

/**
 * 电视类
 */
public class TV {
    // 打开电视
    public void on(){
        System.out.println("电视打开了...");
    }
    // 关闭电视
    public void off(){
        System.out.println("电视关闭了...");
    }
}

/**
 * 灯类
 */
public class Light {
    // 打开灯
    public void on(){
        System.out.println("灯打开了...");
    }
    // 关闭灯
    public void off(){
        System.out.println("灯关闭了...");
    }
}

/**
 * 空调类
 */
public class AirCondition {
    // 打开空调
    public void on(){
        System.out.println("空调打开了...");
    }
    // 关闭空调
    public void off(){
        System.out.println("空调关闭了...");
    }
}

/**
 * 外观类
 */
public class SmartApplicationFacade {
    private TV tv;
    private Light light;
    private AirCondition airCondition;

    public SmartApplicationFacade() {
        this.tv = new TV();
        this.light = new Light();
        this.airCondition = new AirCondition();
    }
    public void on(){
        this.tv.on();
        this.light.on();
        this.airCondition.on();
    }
    public void off(){
        this.tv.off();
        this.light.off();
        this.airCondition.off();
    }
}

/**
 * 测试类
 */
public class Client {
    public static void main(String[] args) {
        SmartApplicationFacade smartApplicationFacade = new SmartApplicationFacade();
        smartApplicationFacade.on();
        System.out.println("=================");
        smartApplicationFacade.off();
    }
}
// 测试结果
电视打开了...
灯打开了...
空调打开了...
=================
电视关闭了...
灯关闭了...
空调关闭了...

好处：

• 降低了子系统与客户端之间的耦合度，使得子系统的变化不会影响调用它的客户类。
• 对客户屏蔽了子系统组件，减少了客户处理对象的数目，并使得子系统使用起来更加的便捷。

5.4 使用场景

• 对分层结构系统构建时，使用外观模式定义子系统中每层的入口点，可以简化子系统之间的依赖关系。
• 当一个复杂系统的子系统很多的时候，外观模式可以为系统设计一个简单的接口供外界访问。
• 当客户端与多个子系统之间存在很大的联系时，引入外观模式可将它们分离，从而提高子系统的独立性和可移植性。

5.5源码分析

使用tomcat容器的时候，会发现有两个类 HttpRequest和HttpServletRequest ，而真正接收网络请求的时候request，那么这两个类一定是进行了封装的，而进行封装的正式RequestFacade对象，这个对象就是一个外观对象，它对request进行了封装，对于一些request的方法进行了屏蔽，保证了安全性。

RequestFacade类就使用了外观模式。先看结构图：

为什么在此处使用外观模式呢？

​ 定义 RequestFacade 类，分别实现 ServletRequest ，同时定义私有成员变量 Request ，并且方法的实现调用 Request 的实现。然后，将 RequestFacade上转为 ServletRequest 传给 servlet 的 service 方法，这样即使在 servlet 中被下转为 RequestFacade ，也不能访问私有成员变量对象中的方法。既用了 Request ，又能防止其中方法被不合理的访问。

六、组合模式

6.1 概述

上图中层级结构是经常能见到的，如果做一个文件系统，这种结构称为树形结构，在树形结构中可以通过调用方法来遍历整个数，树形结构分为树枝结点（容器结点）和叶子结点，因为容器结点和叶子结点属于不同类型的结点，实现的功能也不一样，所以在使用的时候，我们需要区分两个结点，而组合模式就是用来让使用者调对待容器结点和叶子结点能调用同一个接口。

定义：

又称为从部分整体模式，是用于把一组相似的对象当作单一的对象，组合模式依据树形结构来组合对象，用来表示部分以及整体层次，这种设计模式属于结构性模式，它创建了对象组的树形结构。

6.2 结构

组合模式主要包含以下三种角色：

• 抽象根节点（Component）：定义系统层次对象的共有方法，可以预先设定一些默认行为和属性。
• 树枝节点（Composite）：定义树枝结点行为，存储子节点，组合树枝结点和叶子系欸但形成树形结构。
• 叶子节点（Leaf）：叶子节点对象，没有其他分支，是系统中的最小单位。

6.3 案例

• 【例】软件菜单

如下图，我们在访问别的一些管理系统时，经常可以看到类似的菜单。一个菜单可以包含菜单项（菜单项是指不再包含其他内容的菜单条目），也可以包含带有其他菜单项的菜单，因此使用组合模式描述菜单就很恰当，我们的需求是针对一个菜单，打印出其包含的所有菜单以及菜单项的名称。

类图如下：

实现思路：

1. 首先声明一个抽象根节点类，作为菜单项，抽取叶子节点和树枝节点的共有属性和方法。
2. 让树枝节点和叶子节点分别继承抽象根节点类，并且根据情况重写方法
3. 测试调用方法

代码实现：

/**
 * 抽象根节点
 */
public abstract class MenuComponent {
    protected String name;
    protected Integer level;

    public MenuComponent(String name, Integer level) {
        this.name = name;
        this.level = level;
    }

    // 添加节点方法，如果不重写，就不支持改方法
    public void add(MenuComponent menuComponent){
        throw new UnsupportedOperationException("没有该操作");
    }
    // 删除节点
    public void remove(MenuComponent menuComponent){
        throw new UnsupportedOperationException("没有该操作");
    }

    public void getChild(Integer index){
        throw new UnsupportedOperationException("没有该操作");
    }

    // 获取名字
    public String getName() {
        return name;
    }
    // 打印名字以及根节点名字
    public abstract void print();
}

/**
 * 树枝节点类
 */
public class Menu extends MenuComponent {
    // 声明子子节点集合
    private List<MenuComponent> menuComponentList;

    public Menu(String name, Integer level) {
        super(name, level);
        menuComponentList =new ArrayList<>();
    }

    // 添加方法
    @Override
    public void add(MenuComponent menuComponent) {
        menuComponentList.add(menuComponent);
    }

    // 删除方法
    @Override
    public void remove(MenuComponent menuComponent) {
        menuComponentList.remove(menuComponent);
    }

    // 获取子节点方法
    @Override
    public void getChild(Integer index) {
        menuComponentList.get(index);
    }

    // 打印节点名字，以及子节点名字
    @Override
    public void print() {
        for (int i = 0; i < level; i++) {
            System.out.print("--");
        }
        // 打印本节点名字
        System.out.println(getName());
        for (MenuComponent menuComponent : menuComponentList) {
            menuComponent.print();
        }
    }
}

/**
* 叶子节点
*/
public class MenuItem extends MenuComponent{
    public MenuItem(String name, Integer level) {
        super(name, level);
    }

    @Override
    public void print() {
        for (int i = 0; i < level; i++) {
            System.out.print("--");
        }
        System.out.println(getName());
    }
}

// 测试类
public class Client {
    public static void main(String[] args) {
        // 创建二级菜单
        Menu menu = new Menu("菜单管理", 2);
        // 创建对应的三级菜单
        menu.add(new MenuItem("页面访问",3));
        menu.add(new MenuItem("展开菜单",3));
        menu.add(new MenuItem("编辑菜单",3));

        Menu menu1 = new Menu("限权配置", 2);

        menu1.add(new MenuItem("页面访问",3));
        menu1.add(new MenuItem("提交保存",3));

        Menu menu2 = new Menu("角色管理", 2);

        menu2.add(new MenuItem("新增角色",3));
        menu2.add(new MenuItem("修改角色",3));

        // 创建根节点
        Menu root = new Menu("系统管理", 1);
        root.add(menu);
        root.add(menu1);
        root.add(menu2);
        root.print();
    }
}
// 测试结果
--系统管理
----菜单管理
------页面访问
------展开菜单
------编辑菜单
----限权配置
------页面访问
------提交保存
----角色管理
------新增角色
------修改角色

6.4 组合模式分类

根据组合模式中用于管理成员对象的方法声明位置可以分为透明组合模式和安全组合模式。

• 透明组合模式

透明组合模式中，抽象根节点角色中声明了所有用于管理成员对象的方法，比如在示例中 MenuComponent 声明了 add、remove 、getChild 方法，这样做的好处是确保所有的构件类都有相同的接口。透明组合模式也是组合模式的标准形式。透明组合模式的缺点是不够安全，因为叶子对象和容器对象在本质上是有区别的，叶子对象不可能有下一个层次的对象，即不可能包含成员对象，因此为其提供 add()、remove() 等方法是没有意义的，这在编译阶段不会出错，但在运行阶段如果调用这些方法可能会出错（如果没有提供相应的错误处理代码）

• 安全组合模式

在安全组合模式中,用于管理成员对象的方法声明在具体的叶子节点中，这种方法虽然可以保证安全性，但是已经不算是标准的组合模式了，叶子节点和树枝节点虽然继承了同一个根节点类，但是两个节点所拥有的方法就不一致了，不能看作一个接口。

6.5 优点

• **可以清楚的表示分层次的复杂对象：**组合模式可以清楚定义分层次的复杂对象，表示全部或部分层次，让客户端忽略层次的差异，方便对整个层次进行控制

• **简化客户端代码：**客户端可以一致地使用一个组合结构或其中单个对象，不必关心处理的是单个对象还是整个组合结构，简化了客户端代码。

• **符合开闭原则，增加方便：**在组合模式中增加新的树枝节点和叶子节点都很方便，无须对现有类库进行任何修改，符合“开闭原则”。

• **可以递归调用，简化控制：**组合模式为树形结构的面向对象实现提供了一种灵活的解决方案，通过叶子节点和树枝节点的递归组合，可以形成复杂的树形结构，但对树形结构的控制却非常简单。

6.6 使用场景

组合模式正是应树形结构而生，所以组合模式的使用场景就是出现树形结构的地方。比如：文件目录显示，多级目录呈现等树形结构数据的操作。

七、享元模式

7.1 概述

定义：

运用共享技术来有效的支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量，避免大量相似对象的开销，从而提高系统资源的利用率。

7.2 结构

享元（Flyweight）模式中存在以下两种状态：

1. 内部状态，即不会随环境的改变而改变的部分。
2. 外部状态，指随环境的改变而改变的不可共享的部分，享元模式的实现的要领就是区分应用中的这两种状态，并将外部状态外部化。

享元模式的主要有以下角色：

• 抽象享元角色（Flyweight）：通常是一个接口或抽象类，在抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界提供享元对象的内部数据（内部状态），同时也可以通过这些方法来设置外部数据（外部状态）。
• 具体享元（Concrete Flyweight）角色 ：它实现了抽象享元类，称为享元对象；在具体享元类中为内部状态提供了存储空间。通常我们可以结合单例模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象。
• 非享元（Unsharable Flyweight)角色 ：并不是所有的抽象享元类的子类都需要被共享，不能被共享的子类可设计为非共享具体享元类；当需要一个非共享具体享元类的对象时可以直接通过实例化创建。
• 享元工厂（Flyweight Factory）角色 ：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

7.3案例实现

• 【例】俄罗斯方块

下面的图片是众所周知的俄罗斯方块中的一个个方块，如果在俄罗斯方块这个游戏中，每个不同的方块都是一个实例对象，这些对象就要占用很多的内存空间，下面利用享元模式进行实现。

类图如下：

代码如下：

形状属于享元对象，是内部状态，而颜色是外部状态。

俄罗斯方块有不同的形状，我们可以对这些形状向上抽取出AbstractBox，用来定义共性的属性和行为。

public abstract class AbstractBox {
    public abstract String getShape();

    public void display(String color) {
        System.out.println("方块形状：" + this.getShape() + " 颜色：" + color);
    }
}

定义不同形状类

// I形状
public class IBox extends AbstractBox {

    @Override
    public String getShape() {
        return "I";
    }
}

// L形状
public class LBox extends AbstractBox {

    @Override
    public String getShape() {
        return "L";
    }
}

// O形状
public class OBox extends AbstractBox {

    @Override
    public String getShape() {
        return "O";
    }
}

抽取出一个工厂类（BoxFactory），用来管理享元对象（也就是抽象享元对象ABstractBox的子类），该工厂类只需要一个，所以结合 饿汉式（静态变量方式）来实现单例。

public class BoxFactory {

    private static HashMap<String, AbstractBox> map;

    // 初始化享元对象集合，相当于缓存，之后如果需要使用享元对象就从这里面取
    private BoxFactory() {
        map = new HashMap<String, AbstractBox>();
        AbstractBox iBox = new IBox();
        AbstractBox lBox = new LBox();
        AbstractBox oBox = new OBox();
        map.put("I", iBox);
        map.put("L", lBox);
        map.put("O", oBox);
    }

    // 单例模式返回对象
    public static final BoxFactory getInstance() {
        return SingletonHolder.INSTANCE;
    }

    private static class SingletonHolder {
        private static final BoxFactory INSTANCE = new BoxFactory();
    }

    // 获取享元对象的方法
    public AbstractBox getBox(String key) {
        return map.get(key);
    }
}

测试类

// 测试类
public class Client {
    public static void main(String[] args) {
        AbstractBox box1= BoxFactory.getInstance.getBox("L");
        box1.display("红");
        AbstractBox box2= BoxFactory.getInstance.getBox("L");
        box1.display("绿");
        System.out.println("box1 和 box2 是同一对象吗？" + (box1 == box2));
    }
}
// 测试结果
方块形状：L 颜色：红
方块形状：L 颜色：绿    
 box1 和 box2 是同一对象吗？ true

7.5 优缺点

优点：

• 极大的减少了内存中相似或相同对象的创建

• 享元模式中的外部状态(上例中的颜色)相对独立，且不影响内部状态

缺点：

• 为了使对象可以共享，需要将享元对象的部分状态外部化，分离内部状态和外部状态，使程序逻辑复杂

7.6 使用场景

• 一个系统有大量相同或者相似的对象，造成内存的大量耗费。
• 对象的大部分状态都可以外部化，可以将这些外部状态传入对象中。
• 在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此，应当在需要多次重复使用享元对象时才值得使用享元模式。

7.7 JDK 源码分析

Integer类使用了享元模式。我们先看下面的例子：

public class Demo {
    public static void main(String[] args) {
        Integer i1 = 127;
        Integer i2 = 127;

        System.out.println("i1和i2对象是否是同一个对象？" + (i1 == i2));

        Integer i3 = 128;
        Integer i4 = 128;

        System.out.println("i3和i4对象是否是同一个对象？" + (i3 == i4));
    }
}

运行上面代码，结果如下：

为什么第一个输出语句输出的是true，第二个输出语句输出的是false？通过反编译软件进行反编译，代码如下：

public class Demo {
    public static void main(String[] args) {
        Integer i1 = Integer.valueOf((int)127);
        Integer i2 Integer.valueOf((int)127);
        System.out.println((String)new StringBuilder().append((String)"i1\u548ci2\u5bf9\u8c61\u662f\u5426\u662f\u540c\u4e00\u4e2a\u5bf9\u8c61\uff1f").append((boolean)(i1 == i2)).toString());
        Integer i3 = Integer.valueOf((int)128);
        Integer i4 = Integer.valueOf((int)128);
        System.out.println((String)new StringBuilder().append((String)"i3\u548ci4\u5bf9\u8c61\u662f\u5426\u662f\u540c\u4e00\u4e2a\u5bf9\u8c61\uff1f").append((boolean)(i3 == i4)).toString());
    }
}

上面代码可以看到，直接给Integer类型的变量赋值基本数据类型数据的操作底层使用的是 valueOf() ，所以只需要看该方法即可

public final class Integer extends Number implements Comparable<Integer> {
    
	public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            // 在范围内就从缓存中获取
            return IntegerCache.cache[i + (-IntegerCache.low)];
        // 如果不在范围内就直接new 一个
        return new Integer(i);
    }
    
    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                }
            }
            high = h;
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }
}

数据类型数据的操作底层使用的是 valueOf() ，所以只需要看该方法即可

public final class Integer extends Number implements Comparable<Integer> {
    
	public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            // 在范围内就从缓存中获取
            return IntegerCache.cache[i + (-IntegerCache.low)];
        // 如果不在范围内就直接new 一个
        return new Integer(i);
    }
    
    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                }
            }
            high = h;
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }
}

可以看到 Integer 默认先创建并缓存 -128 ~ 127 之间数的 Integer 对象，当调用 valueOf 时如果参数在 -128 ~ 127 之间则计算下标并从缓存中返回，否则创建一个新的 Integer 对象。