Java设计模式之桥接模式-Java开发

这篇文章介绍了Java设计模式之桥接模式，文中通过示例代码介绍的非常详细。对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下

本文通过老王和小王买车，引出设计模式中的结构型设计之桥接模式，接着说明设计型模式的概念和代码实现，为了加深理解，会说明适配器设计模式在JDBC中的应用，最后谈谈桥接模式和适配器模式的总结。

读者可以拉取完整代码到本地进行学习，实现代码均测试通过后上传到码云，本地源码下载。

一、引出问题

老王和小王去奔驰4S店买车，奔驰4S店的各种品牌型号琳琅满目，老王想试驾奔驰E、小王想试驾奔驰G，并且提出两种奔驰型号的各种颜色都想体验一把，这让店小二犯了难，两两组合就是很多种，4S店压根放不下。

无奈店小二求救经理，经理出了一个注意：将奔驰E和G开的品牌抽象出来，将颜色也抽象出来，通过品牌和颜色的组合代替继承关系，减少了颜色和品牌的耦合，且减少了车的个数，只需要两台就够了。

果然经理不愧是经理。

经理所说的其实就是桥接模式。这种模式涉及到一个作为桥接的接口，使得实体类的功能独立于接口实现类。这两种类型的类可被结构化改变而互不影响。

二、概念与使用

我们看一些概念：桥接（Bridge）是用于把抽象化与实现化解耦，使得二者可以独立变化。这种类型的设计模式属于结构型模式，它通过提供抽象化和实现化之间的桥接结构，来实现二者的解耦。

在该模式中应该涉及到四个角色：

①实现类接口（Implementor）：定义实现角色的接口，供扩展抽象化角色使用，例如抽象出奔驰品牌benz 可以扩展出 benzE benzG

②具体实现角色（ConcreteImplementor）：实现类的具体实现，例如各种奔驰品牌

③抽象化（Abstraction）角色：定义一个抽象类，其中引用了实现化角色（想要组合），例如汽车产品

④扩展抽象化（RefinedAbstraction）角色：抽象化角色子类，实现父类方法，且通过组合关系调用实现化角色中的业务方法，例如具体奔驰产品，红色奔驰、白色奔驰

根据该模式的定义，我们将奔驰品牌抽象出来，然后各品牌有各自的实现，每个颜色的车把车品牌组合进来，在客户端中每个相机类型和相机品牌都能两两组合。

我们看具体的代码实现：

实现类接口：

/**
 * 奔驰品牌类
 * @author tcy
 * @Date 05-08-2022
 */
public interface BenzBrand {
    void showInfo();
}

具体实现角色1：

/**
 * @author tcy
 * @Date 05-08-2022
 */
public class BenzE implements BenzBrand{
    @Override
    public void showInfo() {
        System.out.print("【奔驰E】颜色是:");
    }
}

具体实现角色2：

/**
 * @author tcy
 * @Date 05-08-2022
 */
public class BenzG implements BenzBrand{
    @Override
    public void showInfo() {
        System.out.print("【奔驰G】颜色是:");

    }
}

抽象化角色：

/**
 * 抽象奔驰类
 * @author tcy
 * @Date 05-08-2022
 */
public abstract class Benz {
    // 将品牌组合进来
    protected BenzBrand benzBrand;

    public Benz(BenzBrand benzBrand) {
        this.benzBrand = benzBrand;
    }

    public void showInfo(){
        benzBrand.showInfo();
    }
}

扩展抽象化1：

/**
 * @author tcy
 * @Date 05-08-2022
 */
public class BlackBenz extends Benz {
    public BlackBenz(BenzBrand benzBrand) {
        super(benzBrand);
    }

    @Override
    public void showInfo() {
        super.showInfo();

        System.out.println("黑色...");
    }
}

扩展抽象化2：

/**
 * @author tcy
 * @Date 05-08-2022
 */
public class RedBenz extends Benz {
    public RedBenz(BenzBrand benzBrand) {
        super(benzBrand);
    }
    @Override
    public void showInfo() {
        super.showInfo();
        System.out.println("红色...");
    }
}

客户端调用：

/**
 * @author tcy
 * @Date 05-08-2022
 */
public class Client {

    public static void main(String[] args) {
        // 黑色奔驰E
        Benz benz1 = new BlackBenz(new BenzE());
        benz1.showInfo();
        // 黑色奔驰G
        Benz benz2 = new BlackBenz(new BenzG());
        benz2.showInfo();
        // 红色奔驰E
        Benz benz3 = new RedBenz(new BenzE());
        benz3.showInfo();
        // 红色奔驰G
        Benz benz4 = new RedBenz(new BenzG());
        benz4.showInfo();
    }
}

【奔驰E】颜色是:黑色...
【奔驰G】颜色是:黑色...
【奔驰E】颜色是:红色...
【奔驰G】颜色是:红色...

这样即使老王提出来新的颜色、新的车型，只需要增加相应的具体实现角色或者扩展抽象化角色即可。

顾名思义，桥接模式就像是一个桥，可以用来连接两个不同地方，这两个地方自由发展，中间的贸易是通过一座桥来连接。

这种方法的缺点也很显著，汽车能很快的确立型号和颜色两个维度，在实际业务开发中，识别出系统两个独立变化的维度就不简单了。

不难看出，列举的例子有些过于强求，在现实世界中是永远不可能发生的，为了加深理解我找了大量在JDK亦或是Spirng等各种框架对桥接模式的应用，只找到了桥接模式在Jdbc中的应用。

三、应用

我们都知道通过JDBC可以完成Java对关系型数据库的SQL操作，我们在连接数据数据库时，想必都接触过Driver，在连接MySQL和Oracle的Driver都是不同的，这些都是实现接口类。

我们看一下MySQL中实现的Driver类。

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    public Driver() throws SQLException {
    }

    static {
        try {
            DriverManager.registerDriver(new Driver());
        } catch (SQLException var1) {
            throw new RuntimeException("Can't register driver!");
        }
    }
}

在该类中实际上有两个作用，一是调用了DriverManager中的registerDriver方法来注册驱动，二是当驱动注册完成后，我们就会开始调用DriverManager中的getConnection方法了。

我们看DriverManager的完整代码：

    public class DriverManager {
    
    public static Connection getConnection(String url,
        String user, String password) throws SQLException {
        java.util.Properties info = new java.util.Properties();
    if (user != null) {
        info.put("user", user);
    }
    if (password != null) {
        info.put("password", password);
    }

    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");
}
}
}

在Java中通过Connection提供给各个数据库一样的操作接口，这里的Connection可以看作抽象类。

可以说我们用来操作不同数据库的方法都是相同的，不过MySQL有自己的ConnectionImpl类，同样Oracle也有对应的实现类。

这里Driver和Connection之间是通过DriverManager类进行桥接的，这种桥接模式和我们上面可以清晰的看出来各个角色是不同的。