1. 定义

桥接模式(BridgePatten)也称为桥梁模式,接口(nterfce)模式或柄体(HandleandBody)模式,是将抽象部分与它的具体实现部分分离,使它们都可以独立地变化,属于结构型模式

原文∶Decouple an abstraction from its implementation so that the two can vary independently
解释∶解耦抽象和实现，使得两者可以独立的变化

桥接模式主要目的是通过组合的方式建立两个类之间的联系,而不是继承.但又类似于多重继承方案,但是多重继承方案往往违背了类得单一职责原则,其复用性比较差,桥接模式是比多重继承更好的替代方案.桥接模式的核心在于解耦抽象和实现

注∶此处的抽象并不是指抽象类或接口这种高层概念,实现也不是继承或接口实现.抽象与实现其实指的是两种独立变化的维度.其中,抽象包含实现,因此,一个抽象类的变化可能涉及到多种维度的变化导致的

从 UML 类图中,我们可以看到,桥接模式主要包含四种角色

• 抽象(Abstraction)∶该类持有一个对实现角色的引用,抽象角色中的方法需要实现角色来实现.抽象角色一般为抽象类(构造函数规定子类要传入一个实现对象)
• 修正抽象(RefinedAbstraction)∶Abstraction 的具体实现,对 Abstraction 的方法进行完善和扩展
• 实现(Implementor)∶确定实现维度的基本操作,提供给 Abstraction 使用.该类一般为接口或抽象类
• 具体实现(Concretelmplementor)∶Implementor 的具体实现

2. 桥接模式的通用写法

创建抽象角色 Abstraction 类

public abstract class Abstraction {

    protected IImplementor mImplementor;

    public Abstraction(IImplementor implementor) {
        this.mImplementor = implementor;
    }

    public void operation() {
        this.mImplementor.operationImpl();
    }
}

创建修正抽象角色 RefinedAbstraction 类

public class RefinedAbstraction extends Abstraction {
    public RefinedAbstraction(IImplementor implementor) {
        super(implementor);
    }

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

创建实现角色 IImplementor 类

public interface IImplementor {
    void operationImpl();
}

建具体实现 ConcretelmplementorA 类

public class ConcreteImplementorA implements IImplementor {

    public void operationImpl() {
        System.out.println("I'm ConcreteImplementor A");
    }
}

客户端测试代码

public class Test {
    public static void main(String[] args) {
        // 来一个实现化角色
        IImplementor imp = new ConcreteImplementorA();
        // 来一个抽象化角色，聚合实现
        Abstraction abs = new RefinedAbstraction(imp);
        // 执行操作
        abs.operation();
    }
}

3. 桥接模式的应用场景

当一个类内部具备两种或多种变化维度时,使用桥接模式可以解耦这些变化的维度,使高层代码架构稳定.桥接模式适用于以下几种业务场景∶

• 在抽象和具体实现之间需要增加更多的灵活性的场景
• 一个类存在两个(或多个)独立变化的维度,而这两个(或多个)维度都需要独立进行扩展
• 不希望使用继承,或因为多层继承导致系统类的个数剧增

注∶桥接模式的一个常用使用场景就是为了替换继承,我们知道,继承拥有很多优点,比如抽象,封装,多态等,父类封装共性,子类实现特性.继承可以很好地帮助我们实现代码复用（封装）的功能,但是同时,这也是继承的一大缺点.国为父类拥有的方法,子类也会继承得到,无论子类需不需要,这说明了继承具备强侵入性(父类代码侵入子类),同时会导致子类臃肿....因此,在设计模式中,有一个原则为∶优先使用组合/聚合的方式,而不是继承

但是,设计模式是死的,人是活的.很多时候,你分不清该使用继承还是组合/聚合或其他方式等,可以从现实语义进行思考,因为软件(代码)最终还是提供给现实生活中的人用的,是服务于人类社会的,软件(代码)是具备现实场景的,单你从纯代码角度无法看清问题时,现实角度可能会给你提供更加开阔的思路

在生活场景中的桥接模式也随处可见,比如连接起两个空间维度的桥,比如链接虚拟网络与真实网络的连接

4. 桥接模式在业务场景中的应用

举个例子,我们平时办公的时候经常通过发邮件消息,短信消息或者系统内消息和同事进行沟通.尤其是在走一些审批流程的时候,我们需要记录这些过程以备查.我们根据消息的类别来划分的话,可以分为邮件消息,短信消息和系统内消息.但是,根据消息的紧急程度来划分的话,可以分为普通消息,紧急消息和特急消息.显然,整个消息体统可以划分为两个维度,如下图∶

如果,我们用继承的话情况就复杂了,而且也不利于扩展.邮件信息可以是普通的,也可以是紧急的;短信消息可以是普通的,也可以是紧急的.下面我们用桥接模式来解决这个问题

首先创建一个 IMessage 接口担任桥接的角色

public interface IMessage {
    //发送消息的内容和接收人
    void send(String message,String toUser);
}

创建邮件消息实现 EmailMessage 类

public class EmailMessage implements IMessage {
    public void send(String message, String toUser) {
        System.out.println("使用邮件消息发送" + message + "给" + toUser);
    }
}

创建手机短信实现 SmsMessage 类

public class SmsMessage implements IMessage {
    public void send(String message, String toUser) {
        System.out.println("使用短信消息发送" + message + "给" + toUser);
    }
}

然后,再创建桥接抽象角色 AbstractMessage 类

public abstract class AbastractMessage {
    private IMessage message;

    public AbastractMessage(IMessage message) {
        this.message = message;
    }
    void sendMessage(String message,String toUser){
        this.message.send(message,toUser);
    }
}

创建具体实现普通消息 NomalMessage 类

public class NomalMessage extends AbastractMessage {
    public NomalMessage(IMessage message) {
        super(message);
    }
}

创建具体实现紧急消息 UrgencyMessage

public class UrgencyMessage extends AbastractMessage {
    public UrgencyMessage(IMessage message) {
        super(message);
    }

    void sendMessage(String message, String toUser){
        message = "【加急】" + message;
        super.sendMessage(message,toUser);
    }

    public Object watch(String messageId){
        return null;
    }
}

编写客户端测试代码

public class Test {
    public static void main(String[] args) {
        IMessage message = new SmsMessage();
        AbastractMessage abastractMessage = new NomalMessage(message);
        abastractMessage.sendMessage("加班申请","王总");

        message = new EmailMessage();
        abastractMessage = new UrgencyMessage(message);
        abastractMessage.sendMessage("加班申请","王总");
    }
}

运行结果如下

使用短信消息发送加班申请给王总
使用邮件消息发送【加急】加班申请给王总

上面的案例中,我们采用桥接模式解耦了消息类型"和"消息紧急程度"这两个独立变化的维度.后续如果有更多的消息类型,比如微信,钉钉等,那么直接新建一个类继承 IMessage 即可;如果是紧急程度需要新增,那么同样只需新建一个类实现 AbstractMessage 类即可

5. 桥接模式在源码中的应用

大家非常熟悉的 JDBC API,其中有一个 Driver 类就是桥接对象.我们都知道,我们在使用的时候通过 Clas.forName0 方法可以动态加载各个数据库厂商实现的 Driver 类.具体客户端应用代码如下,以 MySQL 的实现为例

//1.加款驱
Class.forName("com.mysq1.dbc.Driver");
//反射机制加载驳阶类
// 2.获取连接 Connection //主机∶增口号/数据库名
Connection conn=DriverManager.getconnection("jdbc:ysq1:/localhost:3386/test","rot","rot");
//3.得到执行 sq1 语句的对象 statement
Statement stmt=conn.createstatement();
// 4.执行 sq1l 语气句，并退回键果
Resultset rs=stmt.executeQuery("select"from table");

首先,我们来看一下 Driver 接口的定义

public interface Driver {
    Connection connect(String url, java.util.Properties info) throws SQLException;

    boolean acceptsURL(String url) throws SQLException;

    DriverPropertyInfo[] getPropertyInfo(String url, java.util.Properties info) throws SQLException;

    int getMajorVersion();

    int getMinorVersion();

    boolean jdbcCompliant();

    public Logger getParentLogger() throws SQLFeatureNotSupportedException;
}

Driver 在 JDBC 中并没有做任何实现,具体的功能实现由各厂商完成,我们以 MySQL 的实现为例

public class Driver extends Nonegisteringpriver implements java.sq1.Driver (
    public Driver() throws sQLException {}
    static{
        try {
            DriverManager.registerDriver(new Driver());
        } catch(SQLException var1) {
            throw new RuntimeException("Can't register driver!");
        }
    }
}

当我们执行 Class.forName(“com.mysqljdbc.Driver”)方法的时候,就会执行 com.mysqjdbc.Driver 这个类的静态块中的代码.而静态块中的代码只是调用了一下 DriverManager 的 registerDriver(方法,然后将 Driver 对象注册到 DriverManager 中.我们可以继续跟进到 DriverManager 这个类中,来看相关的代码

public class DriverManager {
    // List of registered JDBC drivers
    private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
    ...
    private DriverManager(){}

    static {
        loadInitialDrivers();
        println("JDBC DriverManager initialized");
    }

    public static synchronized void registerDriver(java.sql.Driver driver) throws SQLException {
        registerDriver(driver, null);
    }

    public static synchronized void registerDriver(java.sql.Driver driver, DriverAction da) throws SQLException {
        /* Register the driver if it has not already been added to our list */
        if(driver != null) {
            registeredDrivers.addIfAbsent(new DriverInfo(driver, da));
        } else {
            // This is for compatibility with the original DriverManager
            throw new NullPointerException();
        }
        println("registerDriver: " + driver);
    }
    ...
}

在注册之前,将传过来的 Driver 对象,封装成了一个 DriverInfo 对象.接下来继续执行客户端代码的第二步,调用 DriverManager 的 getConnection()方法获取连接对象,我们跟进源码

public class DriverManager {
    @CallerSensitive
    public static Connection getConnection(String url, java.util.Properties info) throws SQLException {
        return (getConnection(url, info, Reflection.getCallerClass()));
    }

    private static Connection getConnection(
        String url, java.util.Properties info, Class<?> caller) throws SQLException {
        /*
         * When callerCl is null, we should check the application's
         * (which is invoking this class indirectly)
         * classloader, so that the JDBC driver class outside rt.jar
         * can be loaded from here.
         */
        ClassLoader callerCL = caller != null ? caller.getClassLoader() : null;
        synchronized(DriverManager.class) {
            // synchronize loading of the correct classloader.
            if (callerCL == null) {
                callerCL = Thread.currentThread().getContextClassLoader();
            }
        }

        if(url == null) {
            throw new SQLException("The url cannot be null", "08001");
        }

        println("DriverManager.getConnection(\"" + url + "\")");

        // Walk through the loaded registeredDrivers attempting to make a connection.
        // Remember the first exception that gets raised so we can reraise it.
        SQLException reason = null;

        for(DriverInfo aDriver : registeredDrivers) {
            // If the caller does not have permission to load the driver then
            // skip it.
            if(isDriverAllowed(aDriver.driver, callerCL)) {
                try {
                    println("    trying " + aDriver.driver.getClass().getName());
                    Connection con = aDriver.driver.connect(url, info);
                    if (con != null) {
                        // Success!
                        println("getConnection returning " + aDriver.driver.getClass().getName());
                        return (con);
                    }
                } catch (SQLException ex) {
                    if (reason == null) {
                        reason = ex;
                    }
                }

            } else {
                println("    skipping: " + aDriver.getClass().getName());
            }

        }

        // if we got here nobody could connect.
        if (reason != null)    {
            println("getConnection failed: " + reason);
            throw reason;
        }

        println("getConnection: no suitable driver found for "+ url);
        throw new SQLException("No suitable driver found for "+ url, "08001");
    }
}

在 getConnection() 中就又会调用各自厂商实现的 Driver 的 connect() 方法获得连接对象.这样的话,就巧妙地避开了使用继承,为不同的数据库提供了相同的接口.JDBC API 中 DrverManager 就是桥,如下图所示

6. 桥接模式的优缺点

通过上面的例子,我们能很好地感知到桥接模式遵循了里氏替换原则和依赖倒置原则,最终实现了开闭原则,对修改关闭,对扩展开放.这里将桥接模式的优缺点总结如下

6.1 优点

• 分离抽象部分及其具体实现部分
• 提高了系统的扩展性
• 符合开闭原则
• 符合合成复用原则

6.2 缺点

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