设计模式（2）— 结构型模式

2. 结构型模式

  结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者采用组合或聚合来组合对象。

  由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象结构型模式比类结构型模式具有更大的灵活性。

结构型模式分以下7种

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

案例：https://github.com/Kaiyko/DesignPattern

1.1 代理模式

1. 概述

  由于某些原因需要给某对象提供一个代理以控制该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和莫表对象之间的中介。

  Java中的代理按照代理类生成时机不同又分为静态代理和动态代理。静态代理代理类在编译器就生成，而动态代理代理类则是在Java运行时动态生成。动态代理又又JDK代理和CGLib代理两种

2. 结构

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

• 抽象主题类（Subject）：通过接口或抽象类声明真实主题和代理对象实现的业务方法。
• 真实主题类（Real Subject）：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
• 代理类（Proxy）：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。

3. 静态代理

//	卖火车票的接口
public interface SellTickets {
    void sell();
}

//	火车站类
public class TrainStation implements SellTickets {
    @Override
    public void sell() {
        System.out.println("火车站买票");
    }
}

//	代理售票点类
public class ProxyPoint implements SellTickets {
    private TrainStation station = new TrainStation();
    @Override
    public void sell() {
        System.out.println("代售点收取一点服务费用");
        station.sell();
    }
}

//	测试类
public class TestClient {
    public static void main(String[] args) {
        //  创建代售点对象
        ProxyPoint proxyPoint = new ProxyPoint();
        //  调用方法进行买票
        proxyPoint.sell();
    }
}

  访问对象直接访问的是ProxyPoint类对象，也就是ProxyPoint作为访问对象和目标对象的中介。同时也对sell方法进行了增强（代理店收取一些服务费用）。

4. JDK动态代理

  Java中提供了一个动态代理类Proxy，Proxy并不是我们上述所说的代理对象的类，而是提供了一个创建代理对象的静态方法（newProxyInstance方法）来获取代理对象。

//	卖火车票的接口
public interface SellTickets {
    void sell();
}

//	火车站类
public class TrainStation implements SellTickets {
    @Override
    public void sell() {
        System.out.println("火车站买票");
    }
}

//	获取代理对象的工厂类 代理类也实现了对应的接口
public class ProxyFactory {

    //  声明目标对象
    private TrainStation station = new TrainStation();

    //  获取代理对象的方法
    public SellTickets getProxyObject() {
        //  返回代理对象
        return  (SellTickets) Proxy.newProxyInstance(
                station.getClass().getClassLoader(),
                station.getClass().getInterfaces(),
                (proxy, method, args) -> {
                    System.out.println("jdk代售点收取小费");
                    System.out.println("invoke方法");
                    return method.invoke(station, args);
                }
        );
    }
}

//	测试类
public class TestClient {
    public static void main(String[] args) {
        //  1、创建代理工厂对象
        ProxyFactory factory = new ProxyFactory();
        //  2、使用factory对象的方法获取代理对象
        SellTickets proxyObject = factory.getProxyObject();
        //  3、调用卖票的方法
        proxyObject.sell();
    }
}

ProxyFactory不是代理模式中的代理类，而代理类是程序在运行过程中生成的类。

5. CGLIB动态代理

略

6. 三种代理的对比

• JDK代理和CGLIB代理

  使用CGLIB实现动态代理，CGLIB底层采用ASM字节码生成框架，使用字节码技术生成代理类，在JDK1.6之前比使用Java反射效率高。唯一需要注意的是，CGLIB不能对声明为final的类或者方法进行代理，因为CGLIB的原理是动态生成被代理类的子类。

  子啊JDK1.6、JDK1.7、JDK1.8逐步对JDK动态代理优化之后，在调用次数较少的情况下，JDK代理效率高于CGLIB代理效率，只有惊醒大量调用的时候，JDK1.6和JDK1.7比CGLIB代理效率低一点，但是到JDK1.8的时候，JDK代理效率高于CGLIB。所以有接口则使用JDK动态代理，如果没有接口则使用CGLIB代理。

• 动态代理和静态代理

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

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

7. 优缺点

优点：

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

缺点：

• 增加了系统的复杂度。

8. 使用场景

• 远程代理（Remote）

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

• 防火墙代理（Firewall）

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

• 保护代理（Protect or Access）

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

1.2 适配器模式

1. 概述

定义：将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。

适配器模式分为类适配器模式和对象是佩秋模式，前者类之间耦合度比后者高，且要求程序员了解现有组件库中的相关组件的内容结构，所以应用相对较少些。

2. 结构

适配器模式（Adapter）包含以下主要角色：

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

3. 类适配器模式

定义一个适配器类来实现当前系统的业务接口，同时又继承现有组件库中已经存在的组件。

实现略

类适配器模式违背了合成复用原则。类适配器是客户类有一个接口规范的情况下可用，反之不可用。

4. 对象适配器模式

  对象适配器模式可采用将现有组件库中已经实现的组件引入适配器类中，该类同时实现当前系统的业务接口

  还有一个适配器模式是接口适配器模式。当不希望实现一个接口中所有的方法时，可以创建一个抽象类Adapter，实现所有方法，而此时我们只需要继承该抽象类即可

5. 应用场景

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

6. 拓展

  JDK源码中Read（字符流）、InputStream（字节流）的适配使用的就是InputStreamReader和OutputStreamWrite分别继承自java.io包中的Reader，对其中的抽象的为实现的方法给出实现。

1.3 装饰者模式

1. 概述

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

2. 结构

装饰（Decorator）模式中的角色：

• 抽象构件角色（Component）：定义一个抽象接口以规范准备接收附加职责的对象
• 具体构件角色（Concrte Component）：实现抽象构件，通过装饰角色为其添加一些职责。
• 抽象装饰角色（Decorator）：继承或实现抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。
• 具体装饰角色（Concrete Decorator）：实现抽线装饰的相关方法，并给具体构件对象添加附加的责任。

3. 案例

略

好处：

• 装饰者模式可以带来比继承更加灵活的扩展功能，使用更加方便，可以通过组合不同的装饰者对象来获取具有不同行为状态的多样化的结果。装饰者模式比继承具有更良好的扩展性，完美的遵循开闭原则，继承是静态的附加职责，装饰则是动态的附加职责。
• 装饰类和被装饰类可以独立发展，不会互相耦合，装饰者模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

4. 使用场景

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

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

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

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

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

5. 代理和装饰者的区别

静态代理和装饰者模式的区别：

• 相同点：

  • 都要实现和目标类相同的业务接口
  • 在两个类中都要声明目标对象
  • 都可以在不修改目标类的前提下增强目标的方法

• 不同点：

  • 目的不同

    装饰者是为了增强目标对象

    静态代理是为了保护和隐藏目标对象

  • 获取目标对象构件的地方不同

    装饰者是由外界传递进来，可以通过构造方法传递

    静态代理是在代理类内部创建，以此来隐藏目标对象

1.4 桥接模式

1. 概述

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

2. 结构

桥接模式（Bridge）包含以下主要角色：

• 抽象化角色（Abstraction）：定义抽象类，并包含一个对实现化对象的引用。
• 扩展抽象化角色（Refined Abstraction）：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色的业务方法。
• 实现化角色（Implementor）：定义实现化角色的接口，供扩展抽象化角色调用。
• 具体实现化角色（Concrete Implementor）：给出实现化角色的具体实现。

3. 案例

略

好处：

• 桥接模式提高了系统的可扩充性，在两个变化维度中任意扩展一个维度，都不需要修改原有系统。
• 实现细节对客户透明

4. 使用场景

• 当一个类存在两个独立变化的维度，且这两个维度都需要进行扩展时。

• 当一个系统不希望继续使用继承或因为多层次继承导致系统类的个数急剧增加时。

• 当一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性时。避免在两个层次之间建立静态的继承联系，通过桥接模式可以使它们在抽象层建立一个关联关系。

1.5 外观模式

1. 概述

  外观模式又名门面模式，是一种通过多个复杂子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口，外部应用程序不用关心内部子系统的具体细节，这样会大大降低应用程序的复杂度，提高了程序的可维护性。

2. 结构

外观模式（Facade）包含以下主要角色：

• 外观角色（Facade）：为多个子系统对外提供一个共同的接口。
• 子系统角色（Sub System）：实现系统的部分功能，客户可以通过外观角色访问它。

3. 案例

略

4. 优缺点

优点：

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

缺点：

• 不符合开闭原则，修改很麻烦

5. 使用场景

• 对分层结构系统构建时，使用外观模式定义子系统中每层的入口点可以简化子系统之间的依赖关系。

• 当一个复杂系统的子系统很多时，外观模式可以为系统设计一个简单的接口供外界访问。

• 当客户端与多个子系统之间存在很大的联系时，引入外观模式可将它们分离，从而提高子系统的独立性和可移植性。

1.6 组合模式

1. 概述

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

2. 结构

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

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

3. 案例

略

4. 组合模式的分类

在使用组合模式时，根据抽象构件类的定义形式，我们可将组合模式分为透明组合模式和安全组合模式两种形式。

• 透明组合模式

  透明组合模式中，抽象根节点角色中声明了所有用于管理成员对象的方法。这样可以确保所有的构件类都有相同的接口。透明组合模式也是组合模式的标准形式。

  透明组合模式的缺点是不够安全，因为叶子对象和容器对象在本质上是有区别的，叶子对象不可能有下一个层次的对象，即不可能包含成员对象，因此为其提供相关方法是没有意义的，这在编译阶段不会出错，但在运行阶段如果调用这些方法可能出错（如果没有提供相应的错误处理代码）

• 安全组合模式

  在安全组合模式中，在抽象构件角色中没有声明任何用于管理成员对象的方法，而是在树枝节点中声明并实现这些方法。安全组合模式的缺点是不够透明，因为叶子构件和容器构件具有不同的方法，且容器构件中那些勇于管理成员对象的方法没有在抽象构件类中定义，因此客户端不能完全针对抽象变成，必须有区别地对待叶子构件和容器构件。

5. 优点

• 组合模式可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，它让客户端忽略了层次的差异，方便对整个层次结构进行控制。
• 客户端可以一致地使用一个组合结构或其中单个对象，不必关心处理的是单个对象还是整个组合结构，简化了客户端代码。
• 在组合模式中增加的新的树枝节点和叶子节点都很方便，无需对现有类库进行任何修改，符合“开闭原则”。
• 组合模式为属性结构的面向对象实现提供了一种灵活的解决方案，通过叶子节点和树枝节点的递归组合，可以形成复杂的树形接哦股，但对树形结构的控制却非常简单。

6. 使用场景

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

1.7 享元模式

1. 概述

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

2. 结构

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

• 内部状态，即不会随着环境的改变而改变的可共享部分。
• 外部状态，指随环境改变改变的不可共享的部分。

享元模式的实现要领就是区分应用中的这两种状态，并将外部状态外部化。

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

• 抽象享元角色（Flyweight）：通常是一个接口或抽象类，在抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界提供享元对象的内部数据（内部状态），同事也可以通过这些方法来设置外部数据（外部状态）。
• 具体享元角色（COncrete Flyweight）：它实现了抽象享元类，称为享元对象；在具体享元类中为内部状态提供了存储空间。通常我们可以结合单例模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象。
• 非享元角色（Unsharable Flyweight）：并不是所有的抽象享元类的子类都需要被共享，不能被共享的子类可设计为非共享具体享元类；当需要一个非共享具体享元类的对象可以直接通过实例化创建。

3. 案例

略

4. 优缺点

优点：

• 极大减少内存中相似或相同的对象数量，节约系统资源，提供系统性能
• 享元模式中的外部状态相对独立，且不影响内部状态。

缺点：

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

5.使用场景

• 一个系统有大量相同或者相似的对线，造成内存的大量耗费。

• 对象的大部分状态都可以外部化，可以将这些外部状态传入对象中。

• 在使用享元模式时需要维护一个存储对象的享元池，而者需要耗费一定的系统资源，因此，应当在需要多次重复使用享元对象时才值得使用享元模式。