当前位置：首页 > article >正文

桥接（桥梁）模式

article 2024/11/19 13:32:03

简介

桥接模式（Bridge Pattern）又叫作桥梁模式、接口（Interface）模式或柄体（Handle and Body）模式，指将抽象部分与具体实现部分分离，使它们都可以独立地变化，属于结构型设计模式。

常用用于替换继成

通用模板

创建实现接口：确定实现维度的基本操作，提供给Abstraction使用。该类一般为接口或抽象类。
```
// 抽象实现
public interface IImplementor {
    void operationImp();
}
```

创建具体实现类：Implementor的具体实现。

// 具体实现类A
public class ConcreteImplementorA implements IImplementor{
    @Override
    public void operationImp() {
        System.out.println("I am ConcreteImplementorA");
    }
}


// 具体实现类B
public class ConcreteImplementorB implements IImplementor {
    @Override
    public void operationImp() {
        System.out.println("I am ConcreteImplementorB");
    }
}

创建抽象类：该类持有一个对实现角色的引用，抽象角色中的方法需要实现角色来实现。抽象角色一般为抽象类（构造函数规定子类要传入一个实现对象）。

// 抽象
public abstract class Abstraction {
    private IImplementor iImplementor;

    public Abstraction(IImplementor iImplementor) {
        this.iImplementor = iImplementor;
    }

    public void operation() {
        iImplementor.operationImp();
    }
}

创建修正抽象类：Abstraction的具体实现，对Abstraction的方法进行完善和扩展。

// 修正抽象类
public class RefineAbstraction extends Abstraction {
    public RefineAbstraction(IImplementor iImplementor) {
        super(iImplementor);
    }

    @Override
    public void operation() {
        super.operation();
        System.out.println("refine operation");
    }
}

创建修正实现类：RefineAbstraction的具体实现

// 修正抽象实现类
public class ConcreteRefineAbstractionA extends RefineAbstraction {
    public ConcreteRefineAbstractionA(IImplementor iImplementor) {
        super(iImplementor);
    }

    @Override
    public void operation() {
        super.operation();
        System.out.println("ConcreteRefineAbstraction");
    }
}

模板测试

测试代码

public class Client {
    public static void main(String[] args) {
        // 创建一个具体的角色
        ConcreteImplementorA imp = new ConcreteImplementorA();
        // 创建一个抽象的角色，聚合实现
        RefineAbstraction abs = new ConcreteRefineAbstractionA(imp);
        // 执行操作
        abs.operation();
    }
}

结果

I am ConcreteImplementorA
refine operation
ConcreteRefineAbstraction

应用场景

在生活场景中，桥接模式随处可见，比如连接起两个空间维度的桥、连接虚拟网络与真实网络的链接。
当一个类内部具备两种或多种变化维度时，使用桥接模式可以解耦这些变化的维度，使高层代码架构稳定。
桥接模式适用于以下几种业务场景。
（1）在抽象和具体实现之间需要增加更多灵活性的场景。
（2）一个类存在两个（或多个）独立变化的维度，而这两个（或多个）维度都需要独立进行扩展。（3）不希望使用继承，或因为多层继承导致系统类的个数剧增。

注：桥接模式的一个常见使用场景就是替换继承。我们知道，继承拥有很多优点，比如，抽象、封装、多态等，父类封装共性，子类实现特性。继承可以很好地实现代码复用（封装）的功能，但这也是继承的一大缺点。因为父类拥有的方法，子类也会继承得到，无论子类需不需要，这说明继承具备强侵入性（父类代码侵入子类），同时会导致子类臃肿。因此，在设计模式中，有一个原则为优先使用组合/聚合，而不是继承。很多时候，我们分不清该使用继承还是组合/聚合或其他方式等，其实可以从现实语义进行思考。因为软件最终还是提供给现实生活中的人使用的，是服务于人类社会的，软件是具备现实场景的。当我们从纯代码角度无法看清问题时，现实角度可能会提供更加开阔的思路。

优点

（1）分离抽象部分及其具体实现部分。
（2）提高了系统的扩展性。
（3）符合开闭原则。
（4）符合合成复用原则。

缺点

（1）增加了系统的理解与设计难度。
（2）需要正确地识别系统中两个独立变化的维度。

“生搬硬套”实战

场景描述

桥接模式的定义非常玄乎，直接理解不太容易，所以我们还是举例子。

假设某个汽车厂商生产三种品牌的汽车：Big、Tiny和Boss，每种品牌又可以选择燃油、纯电和混合动力。如果用传统的继承来表示各个最终车型，一共有3个抽象类加9个最终子类：
在这里插入图片描述
如果要新增一个品牌，或者加一个新的引擎（比如核动力），那么子类的数量增长更快。

所以，桥接模式就是为了避免直接继承带来的子类爆炸。

我们来看看桥接模式如何解决上述问题。

在桥接模式中，首先把Car按品牌进行子类化，但是，每个品牌选择什么发动机，不再使用子类扩充，而是通过一个抽象的“修正”类，以组合的形式引入。我们来看看具体的实现。

代码开发

创建实现（这里指引擎）接口

// 实现接口
public interface Engine {
    void start();
}

创建具体实现（这里指的是各种引擎）类

// 混动引擎实现
public class HybridEngine implements Engine {
    public void start() {
        System.out.println("Start Hybrid Engine...");
    }
}

// 油引擎实现
public class FuelEngine implements Engine {
    public void start() {
        System.out.println("Start Fuel Engine...");
    }
}

// 纯电引擎实现
public class PureEngine implements Engine {
    public void start() {
        System.out.println("Start Pure Engine...");
    }
}

创建抽象（这里指的是车）类

// 抽象车类
public abstract class Car {
    // 引用Engine:
    protected Engine engine;

    public Car(Engine engine) {
        this.engine = engine;
    }

    public abstract void drive();
}

创建修正抽象（这里指的是修正车类）类

// 修正车抽象类
public abstract class RefinedCar extends Car{
    public RefinedCar(Engine engine) {
        super(engine);
    }

    @Override
    public void drive() {
        this.engine.start();
        System.out.println("Drive " + getBrand() + " car...");
    }

    public abstract String getBrand();
}

创建修正实现（这里指具体不同品牌的车）类

// Boss品牌车
public class BossCar extends RefinedCar {
    public BossCar(Engine engine) {
        super(engine);
    }

    @Override
    public String getBrand() {
        return "Boss";
    }
}

// Big品牌车
public class BigCar extends RefinedCar {
    public BigCar(Engine engine) {
        super(engine);
    }

    @Override
    public String getBrand() {
        return "Big";
    }
}

// Tiny品牌车
public class TinyCar extends RefinedCar {
    public TinyCar(Engine engine) {
        super(engine);
    }

    @Override
    public String getBrand() {
        return "Tiny";
    }
}

至此，我们就通过“生搬硬套”桥梁模式的模板设计出一套替换继成的桥接模式代码，接下来我们进行测试：

测试代码

public class Test {
    public static void main(String[] args) {
        RefinedCar car = new BossCar(new HybridEngine());
        car.drive();
    }
}

结果

Start Hybrid Engine...
Drive Boss car...

总结

使用桥接模式的好处在于，如果要增加一种引擎，只需要针对Engine派生一个新的子类，如果要增加一个品牌，只需要针对RefinedCar派生一个子类，任何RefinedCar的子类都可以和任何一种Engine自由组合，即一辆汽车的两个维度：品牌和引擎都可以独立地变化。
在这里插入图片描述
桥接模式实现比较复杂，实际应用也非常少，但它提供的设计思想值得借鉴，即不要过度使用继承，而是优先拆分某些部件，使用组合的方式来扩展功能。