深入解析结构型设计模式：适配器、桥接与组合

在软件开发中，设计模式是解决常见问题的标准化方案。结构型设计模式主要用于处理对象的组合和组织，帮助开发者构建更加灵活、可扩展的系统。本文将详细探讨三种结构型设计模式：适配器模式、桥接模式和组合模式。通过实际案例和代码实现，帮助读者更好地理解和应用这些模式。

一、适配器模式（Adapter Pattern）

（一）概念

适配器模式是一种结构型设计模式，用于将一个类的接口转换成客户端所期望的另一种接口。它使得原本因接口不兼容而无法一起工作的类可以协同工作。

（二）应用场景

1. 系统集成：当需要将旧系统与新系统集成时，适配器模式可以解决接口不兼容的问题。例如，JDBC通过适配器模式，使得不同数据库厂商的驱动程序可以与通用的JDBC接口协同工作。

2. 第三方库集成：在使用第三方库时，适配器模式可以将第三方库的接口转换为系统所需的接口，从而实现无缝集成。

（三）实现方式

适配器模式主要有三种实现方式：

1. 类的适配器模式：通过继承原有类并实现新接口来实现适配。这种方式要求适配器类继承原有类并实现目标接口。

2. 对象的适配器模式：通过创建一个适配器类，持有原有类的实例，并在适配器类中调用原有类的方法来实现适配。

3. 接口的适配器模式：当不需要实现接口中的所有方法时，可以通过创建一个适配器类实现所有方法，其他类继承适配器类来实现部分方法的实现。

（四）案例分析

假设有一个电商支付项目，客户端A调用生产环境的登录接口B，但公司收购了另一个项目，其客户端C的协议与接口B不兼容。解决方案如下：

1. 修改接口B以兼容客户端C的协议（可能影响现有系统稳定性）。

2. 新增一个全新的登录接口F，采用客户端C的协议（会导致业务逻辑重复）。

3. 新增一个转换协议接口，客户端C通过该接口转换协议后调用接口B（推荐使用适配器模式）。

（五）代码实现

以下是类的适配器模式的代码示例：

// 老的类，里面有一个方法
public class OldModule {
    public void methodA() {
        System.out.println("OldModule methodA");
    }
}

// 目标接口，包含老类的方法和新方法
public interface TargetModule {
    void methodA(); // 和老类的方法名一样
    void methodB(); // 新的方法
    void methodC(); // 新的方法
}

// 适配器类，继承老类并实现目标接口
public class Adapter extends OldModule implements TargetModule {
    @Override
    public void methodB() {
        System.out.println("Adapter methodB");
    }

    @Override
    public void methodC() {
        System.out.println("Adapter methodC");
    }
}

// 测试代码
public static void main(String[] args) {
    TargetModule targetModule = new Adapter();
    targetModule.methodA(); // 调用老类的方法
    targetModule.methodB(); // 调用适配器类的新方法
    targetModule.methodC(); // 调用适配器类的新方法
}

（六）优点与缺点

• 优点：可以将原本不兼容的类组合在一起工作，提高系统的灵活性和复用性，符合开闭原则。

• 缺点：增加了类的调用链路，可能会使系统结构变得复杂。

二、桥接模式（Bridge Pattern）

（一）概念

桥接模式是一种结构型设计模式，用于将抽象部分与实现部分分离，使它们可以独立变化。通过桥接模式，可以避免因多维度变化导致的类爆炸问题。

（二）应用场景

1. 多维度变化：当一个类具有多个变化维度时，桥接模式可以将这些维度分离，从而减少类的数量。例如，手机品牌和颜色的变化可以通过桥接模式实现。

2. 系统扩展：当需要在构件的抽象化角色和具体化角色之间增加更多灵活性时，桥接模式是一个很好的选择。

（三）实现方式

桥接模式的核心是通过组合的方式将抽象部分与实现部分连接起来。例如，定义一个抽象类（如Phone），并在其中通过组合的方式引入实现部分（如Color）。具体实现类（如BlueColor）则实现相应的接口。

（四）案例分析

假设需要构建一个手机类，手机有多个品牌和颜色。传统方式通过继承会导致类数量激增（品牌2，颜色3，就需要6个类）。通过桥接模式，可以将品牌和颜色分离，减少类的数量并提高系统的灵活性。

（五）代码实现

以下是桥接模式的代码示例：

// 抽象角色：手机
public abstract class Phone {
    protected Color color;

    public void setColor(Color color) {
        this.color = color;
    }

    public abstract void run();
}

// 颜色维度
public interface Color {
    void useColor();
}

// 具体颜色：蓝色
public class BlueColor implements Color {
    @Override
    public void useColor() {
        System.out.println("蓝色");
    }
}

// 具体颜色：红色
public class RedColor implements Color {
    @Override
    public void useColor() {
        System.out.println("红色");
    }
}

// 具体手机：华为手机
public class HWPhone extends Phone {
    public HWPhone(Color color) {
        super.setColor(color);
    }

    @Override
    public void run() {
        color.useColor();
        System.out.println("华为手机");
    }
}

// 具体手机：苹果手机
public class ApplePhone extends Phone {
    public ApplePhone(Color color) {
        super.setColor(color);
    }

    @Override
    public void run() {
        color.useColor();
        System.out.println("苹果手机");
    }
}

// 测试代码
public static void main(String[] args) {
    HWPhone blueHwPhone = new HWPhone(new BlueColor());
    blueHwPhone.run();

    HWPhone redHwPhone = new HWPhone(new RedColor());
    redHwPhone.run();

    ApplePhone applePhone = new ApplePhone(new RedColor());
    applePhone.run();
}

（六）优点与缺点

• 优点：实现抽象与实现的分离，提高系统的扩展能力，符合开闭原则。

• 缺点：增加了系统的理解和设计难度，需要开发者针对抽象进行设计与编程。

三、组合模式（Composite Pattern）

（一）概念

组合模式是一种结构型设计模式，用于将对象组合成树形结构以表示“部分-整体”的层次结构。通过组合模式，用户可以使用一致的方式操作单个对象和组合对象。

（二）应用场景

1. 层次结构管理：当需要管理具有层次结构的对象时，组合模式可以提供一致的操作方式。例如，银行总行、分行和支行的管理，文件夹和文件的管理等。

2. 部分-整体关系：当对象之间存在部分-整体关系时，组合模式可以简化操作。

（三）实现方式

组合模式的核心是定义一个抽象组件类（如Root），并定义添加、删除和显示等操作。具体组件类（如Folder和File）继承抽象组件类并实现具体的操作。

（四）案例分析

假设需要实现一个文件管理系统，文件夹和文件都有添加、删除和显示等操作。通过组合模式，可以将文件夹和文件组合成树形结构，并提供一致的操作方式。

（五）代码实现

以下是组合模式的代码示例：

// 抽象组件类：根节点
public abstract class Root {
    private String name;

    public Root(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public abstract void addFile(Root root);
    public abstract void removeFile(Root root);
    public abstract void display(int depth);
}

// 具体组件类：文件夹
public class Folder extends Root {
    private List folders = new ArrayList<>();

    public Folder(String name) {
        super(name);
    }

    public List getFolders() {
        return folders;
    }

    public void setFolders(List folders) {
        this.folders = folders;
    }

    @Override
    public void addFile(Root root) {
        folders.add(root);
    }

    @Override
    public void removeFile(Root root) {
        folders.remove(root);
    }

    @Override
    public void display(int depth) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < depth; i++) {
            sb.append("-");
        }
        System.out.println(sb.toString() + this.getName());
        for (Root r : folders) {
            r.display(depth + 2);
        }
    }
}

// 具体组件类：文件
public class File extends Root {
    public File(String name) {
        super(name);
    }

    @Override
    public void addFile(Root root) {
        // 文件不支持添加子节点
    }

    @Override
    public void removeFile(Root root) {
        // 文件不支持删除子节点
    }

    @Override
    public void display(int depth) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < depth; i++) {
            sb.append("-");
        }
        System.out.println(sb.toString() + this.getName());
    }
}

// 测试代码
public static void main(String[] args) {
    // 创建根文件夹
    Root root1 = new Folder("C://");

    // 创建子文件夹
    Root desktop = new Folder("桌面");
    Root myComputer = new Folder("我的电脑");

    // 创建文件
    Root javaFile = new File("HelloWorld.java");

    // 建立文件夹关系
    root1.addFile(desktop);
    root1.addFile(myComputer);

    // 建立文件关系
    myComputer.addFile(javaFile);

    // 从0级开始展示，每下一级，多2条横线
    root1.display(0);
}

（六）优点与缺点

• 优点：客户端只需要面对一致的对象，而不用考虑整体部分或者节点叶子的问题，方便创建复杂的层次结构。

• 缺点：客户端需要花更多时间理清类之间的层次关系。

四、总结

适配器模式、桥接模式和组合模式都是结构型设计模式，它们在解决系统结构问题时各有优势。适配器模式主要用于解决接口不兼容问题，桥接模式用于分离抽象与实现，组合模式用于管理层次结构。在实际开发中，合理选择和应用这些模式可以提高系统的灵活性、扩展性和可维护性。