架构师必修设计模式——结构型模式

结构型模式基本概念

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

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

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

• 代理（Proxy）模式： 为某对象提供一种代理以控制对该对象的访问；即客户端通过代理间接地访问该对象，从而限制、增强或修改该对象的一些特性

• 适配器（Adapter）模式: 将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作

• 桥接（Bridge）模式： 将抽象与实现分离，使它们可以独立变化；它是用组合关系代替继承关系来实现的，从而降低了抽象和实现这两个可变维度的耦合度

• 装饰（Decorator）模式： 动态地给对象增加一些职责，即增加其额外的功能

• 外观（Facade）模式：为多个复杂的子系统提供一个一致的接口，使这些子系统更加容易被访问

• 享元（Flyweight）模式： 运用共享技术来有效地支持大量细粒度对象的复用

• 组合（Composite）模式： 将对象组合成树状层次结构，使用户对单个对象和组合对象具有一致的访问性

代理模式

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

代理模式的结构比较简单： 主要是通过定义一个继承抽象主题的代理来包含真实主题，从而实现对真实主题的访问，下面来分析其基本结构和实现方法

代理模式的主要角色如下：

• 抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法

• 真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象

• 代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能

一般代理会被理解为代码增强，实际上就是在原代码逻辑前后增加一些代码逻辑，而使调用者无感知

根据代理的创建时期，代理模式可分为 静态代理和动态代理

• 静态：由程序员创建代理类或特定工具自动生成源代码再对其编译，在程序运行前代理类的 .class 文件就已经存在了

• 动态：在程序运行时，运用反射机制动态创建而成

代码如下：

package proxy;

public class ProxyTest {
    public static void main(String[] args) {
        Proxy proxy = new Proxy();
        proxy.Request();
    }
}

//抽象主题
interface Subject {
    void Request();
}

//真实主题
class RealSubject implements Subject {
    public void Request() {
        System.out.println("访问真实主题方法...");
    }
}

//代理
class Proxy implements Subject {
    private RealSubject realSubject;

    public void Request() {
        if (realSubject == null) {
            realSubject = new RealSubject();
        }
        preRequest();
        realSubject.Request();
        postRequest();
    }

    public void preRequest() {
        System.out.println("访问真实主题之前的预处理。");
    }

    public void postRequest() {
        System.out.println("访问真实主题之后的后续处理。");
    }
}

适配器模式（Adapter模式）

适配器模式（Adapter）的定义如下： 将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作

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

类适配器模式可采用多重继承方式实现： 如 C++可定义一个适配器类来同时继承当前系统的业务接口和现有组件库中已经存在的组件接口；[Java] 不支持多继承，但可以定义一个适配器类来实现当前系统的业务接口，同时又继承现有组件库中已经存在的组件

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

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

• 目标（Target）接口：当前系统业务所期待的接口，它可以是抽象类或接口

• 适配者（Adaptee）类：它是被访问和适配的现存组件库中的组件接口

• 适配器（Adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者

类适配器模式的代码：

package adapter;
//目标接口
interface Target
{
    public void request();
}
//适配者接口
class Adaptee
{
    public void specificRequest()
    {       
        System.out.println("适配者中的业务代码被调用！");
    }
}
//类适配器类
class ClassAdapter extends Adaptee implements Target
{
    public void request()
    {
        specificRequest();
    }
}
//客户端代码
public class ClassAdapterTest
{
    public static void main(String[] args)
    {
        System.out.println("类适配器模式测试：");
        Target target = new ClassAdapter();
        target.request();
    }
}

对象适配器模式的代码：

package adapter;
//对象适配器类
class ObjectAdapter implements Target
{
    private Adaptee adaptee;
    public ObjectAdapter(Adaptee adaptee)
    {
        this.adaptee=adaptee;
    }
    public void request()
    {
        adaptee.specificRequest();
    }
}
//客户端代码
public class ObjectAdapterTest
{
    public static void main(String[] args)
    {
        System.out.println("对象适配器模式测试：");
        Adaptee adaptee = new Adaptee();
        Target target = new ObjectAdapter(adaptee);
        target.request();
    }
}

对象适配器模式中的“目标接口”和“适配者类”的代码同类适配器模式一样，只要修改适配器类和客户端的代码即可

桥接模式（Bridge模式）

桥接（Bridge）模式的定义如下： 将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度

• 桥接模式遵循了里氏替换原则和依赖倒置原则，最终实现了开闭原则，对修改关闭，对扩展开放

• 桥接模式将抽象化部分与实现化部分分开，取消二者的继承关系，改用组合关系

桥接模式的结构

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

• 抽象化（Abstraction）角色：定义抽象类，并包含一个对实现化对象的引用

• 扩展抽象化（Refined Abstraction）角色：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法

• 实现化（Implementor）角色：定义实现化角色的接口，供扩展抽象化角色调用

• 具体实现化（Concrete Implementor）角色：给出实现化角色接口的具体实现

代码如下：

package bridge;

public class BridgeTest {
    public static void main(String[] args) {
        Implementor imple = new ConcreteImplementorA();
        Abstraction abs = new RefinedAbstraction(imple);
        abs.Operation();
    }
}

//实现化角色
interface Implementor {
    public void OperationImpl();
}

//具体实现化角色
class ConcreteImplementorA implements Implementor {
    public void OperationImpl() {
        System.out.println("具体实现化(Concrete Implementor)角色被访问");
    }
}

//抽象化角色
abstract class Abstraction {
    protected Implementor imple;

    protected Abstraction(Implementor imple) {
        this.imple = imple;
    }

    public abstract void Operation();
}

//扩展抽象化角色
class RefinedAbstraction extends Abstraction {
    protected RefinedAbstraction(Implementor imple) {
        super(imple);
    }

    public void Operation() {
        System.out.println("扩展抽象化(Refined Abstraction)角色被访问");
        imple.OperationImpl();
    }
}

以上就是今天关于结构型模式的相关内容

技术是无止境的，你需要对自己提交的每一行代码、使用的每一个工具负责，不断挖掘其底层原理，才能使自己的技术升华到更高的层面

Android 架构师之路还很漫长，与君共勉