架构师内功心法,连接两个空间维度的桥接模式详解

时间:2020-05-30
本文章向大家介绍架构师内功心法,连接两个空间维度的桥接模式详解,主要包括架构师内功心法,连接两个空间维度的桥接模式详解使用实例、应用技巧、基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋友可以参考一下。

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

桥接模式(Bridge Pattern)也成为桥梁模式、接口模式或柄体(Handle And Body)模式,是将抽象部分与它的具体实现部分分离,使得它们都可以独立地变化。

一、桥接模式的应用场景

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

1.1 桥接模式的角色

接下来我们看下桥接模式通用的UML图:

从UML图中可以看出桥接模式主要包含四种角色:

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

下面来看具体实现的代码:

首先创建抽象 Abstraction 类:

public abstract class Abstraction {

    protected IImplementor iImplementor;

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

    void operation(){
        this.iImplementor.operationImpl();
    }

}

创建修正抽象 RefinedAbstraction 类:

public class RefinedAbstraction extends Abstraction {

    public RefinedAbstraction(IImplementor iImplementor) {
        super(iImplementor);
    }

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

}

创建角色实现 IImplementor 接口:

public interface IImplementor {

    void operationImpl();
}

创建具体实现ConcreteImplementorA、ConcreteImplementorB 类:

public class ConcreteImplementorA implements IImplementor {
    @Override
    public void operationImpl() {
        System.out.println("concreteImplementor A");
    }
}
public class ConcreteImplementorB implements IImplementor {
    @Override
    public void operationImpl() {
        System.out.println("concreteImplementor B");
    }
}

测试main方法:

   public static void main(String[] args) {
    
    IImplementor iImplementorA = new ConcreteImplementorA();
    IImplementor iImplementorB = new ConcreteImplementorB();

    Abstraction absA = new RefinedAbstraction(iImplementorA);
    Abstraction absB = new RefinedAbstraction(iImplementorB);

    absA.operation();
    absB.operation();
}

桥接模式有以下几个应用场景:

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

1.2 桥接模式的业务实现案例

我们在平时办公的时候经常需要通过发送邮件消息、钉钉消息或者系统内消息和同事进行沟通。尤其是在使用一些流程审批的时候,我们需要记录这些过程以备查。可以根据消息的类型来进行划分,可以分为邮件消息,钉钉消息和系统内消息。但是,如果根据消息的紧急程度来划分的话,可以分为普通消息、紧急消息和特急消息。显然,整个消息系统可以划分为两个大维度。

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

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

/**
 * 实现消息发送的统一接口
 */
public interface IMessage {

    /**
     * 发送消息
     * @param message
     *                  内容
     * @param user
     *                  接收人
     */
   public void send(String message, String user);
}

创建邮件消息类实现IMessage接口:

/**
 * 邮件信息实现类
 */
public class EmailMessage implements IMessage {
    @Override
    public void send(String message, String user) {
        System.out.println(String.format("使用邮件的方式发送消息 %s 给 %s", message, user));
    }
}

创建钉钉消息类也实现IMessage接口:

/**
 * 钉钉信息实现类
 */
public class DingMessage implements IMessage {
    @Override
    public void send(String message, String user) {
        System.out.println(String.format("使用钉钉的方式发送消息 %s 给 %s", message, user));
    }
}

然后在创建抽象角色 AbstractMessage 类,

/**
 * 抽象消息类
 */
public abstract class AbstractMessage {

    //实现对象
    IMessage message;

    //构造方法传入实现部分的对象
    public AbstractMessage(IMessage message) {
        this.message = message;
    }

    /**
     * 发送消息,委派给实现对象的方法
     * @param message
     * @param user
     */
    public void sendMessage(String message, String user) {
        this.message.send(message, user);
    }
}

创建具体的普通消息实现 NormalMessage 类:

/**
 * 普通消息类
 */
public class NormalMessage extends AbstractMessage {

    //构造方法传入实现的对象
    public NormalMessage(IMessage message) {
        super(message);
    }

    /**
     * 发送消息,直接调用父类的方法即可
     * @param message
     * @param user
     */
    public void sendMessage(String message, String user) {
        super.sendMessage(message, user);
    }
}

创建具体的紧急消息实现 UrgencyMessage 类:

/**
 * 紧急消息类
 */
public class UngencyMessage extends AbstractMessage {
    public UngencyMessage(IMessage message) {
        super(message);
    }

    /**
     * 发送消息,直接调用父类的方法即可
     * @param message
     * @param user
     */
    public void sendMessage(String message, String user) {
        super.sendMessage(message, user);
    }

    /**
     * 扩展自己的功能,监控消息的状态
     * @param messageId
     * @return
     */
    public Object watch(String messageId) {
        return null;
    }
}

测试main方法:

public static void main(String[] args) {

    IMessage message = new EmailMessage();
    AbstractMessage abstractMessage = new NormalMessage(message);
    abstractMessage.sendMessage("周末加班申请", "张三");

    message = new DingMessage();
    abstractMessage = new UngencyMessage(message);
    abstractMessage.sendMessage("请假申请", "李四");
}

运行结果:

在上面的案例中,我们采用了桥接模式解耦了“消息类型”和“消息紧急程度”这两个独立变化的维度。如果需要扩展这两个维度的内容,按照上述代码的方式进行扩展就好了。

二、桥接模式的源码体现

JDBC中的Driver类

我们都非常熟悉JDBC的API,其中有个Driver类就是桥接类。在使用的时候通过Class.forName() 方法可以动态的加载各个数据库厂商实现的Driver类。具体代码我们以mysql客户端为例:

private Vector<Connection> pool;
private String url = "jdbc:mysql://localhost:3306/testDB";
private String username = "root";
private String password = "123456";
private String driverClassName = "com.mysql.jdbc.Driver";
private int poolSize = 100;
public ConnectionPool() {
    pool = new Vector<Connection>(poolSize);
    try{
        Class.forName(driverClassName);
        for (int i = 0; i < poolSize; i++) {
            Connection conn = DriverManager.getConnection(url,username,password);
            pool.add(conn);
        }
    }catch (Exception e){
        e.printStackTrace();
    }
}

首先来看一下Driver接口的定义:

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

public class Driver extends NonRegisteringDriver implements java.sql.Driver { 
    public Driver() throws SQLExeption {}
    static { 
        try { 
            DriverManager.registerDriver(new Driver()) ; 
        } catch (SQLE xception var1) { 
            throw new RuntimeExcept ion("Can't register driver!"); 
        }
    }
}

当我们执行Class.forName("com.mysql.jdbc.Driver")方法的时候,就会执行上面类的静态块中的代码。而静态块只是调用了DriverManager的registerDriver()方法,然后将Driver对象注册到DriverManager中。接下来看一下DriverManager中相关的源代码:

/**
     * Registers the given driver with the {@code DriverManager}.
     * A newly-loaded driver class should call
     * the method {@code registerDriver} to make itself
     * known to the {@code DriverManager}. If the driver is currently
     * registered, no action is taken.
     *
     * @param driver the new JDBC Driver that is to be registered with the
     *               {@code DriverManager}
     * @exception SQLException if a database access error occurs
     * @exception NullPointerException if {@code driver} is null
     */
    public static synchronized void registerDriver(java.sql.Driver driver)
        throws SQLException {

        registerDriver(driver, null);
    }

    /**
     * Registers the given driver with the {@code DriverManager}.
     * A newly-loaded driver class should call
     * the method {@code registerDriver} to make itself
     * known to the {@code DriverManager}. If the driver is currently
     * registered, no action is taken.
     *
     * @param driver the new JDBC Driver that is to be registered with the
     *               {@code DriverManager}
     * @param da     the {@code DriverAction} implementation to be used when
     *               {@code DriverManager#deregisterDriver} is called
     * @exception SQLException if a database access error occurs
     * @exception NullPointerException if {@code driver} is null
     * @since 1.8
     */
    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() 方法获得连接对象,看下源代码:

/**
     * Attempts to establish a connection to the given database URL.
     * The <code>DriverManager</code> attempts to select an appropriate driver from
     * the set of registered JDBC drivers.
     *<p>
     * <B>Note:</B> If a property is specified as part of the {@code url} and
     * is also specified in the {@code Properties} object, it is
     * implementation-defined as to which value will take precedence.
     * For maximum portability, an application should only specify a
     * property once.
     *
     * @param url a database url of the form
     * <code> jdbc:<em>subprotocol</em>:<em>subname</em></code>
     * @param info a list of arbitrary string tag/value pairs as
     * connection arguments; normally at least a "user" and
     * "password" property should be included
     * @return a Connection to the URL
     * @exception SQLException if a database access error occurs or the url is
     * {@code null}
     * @throws SQLTimeoutException  when the driver has determined that the
     * timeout value specified by the {@code setLoginTimeout} method
     * has been exceeded and has at least tried to cancel the
     * current database connection attempt
     */
    @CallerSensitive
    public static Connection getConnection(String url,
        java.util.Properties info) throws SQLException {

        return (getConnection(url, info, Reflection.getCallerClass()));
    }

    /**
     * Attempts to establish a connection to the given database URL.
     * The <code>DriverManager</code> attempts to select an appropriate driver from
     * the set of registered JDBC drivers.
     *<p>
     * <B>Note:</B> If the {@code user} or {@code password} property are
     * also specified as part of the {@code url}, it is
     * implementation-defined as to which value will take precedence.
     * For maximum portability, an application should only specify a
     * property once.
     *
     * @param url a database url of the form
     * <code>jdbc:<em>subprotocol</em>:<em>subname</em></code>
     * @param user the database user on whose behalf the connection is being
     *   made
     * @param password the user's password
     * @return a connection to the URL
     * @exception SQLException if a database access error occurs or the url is
     * {@code null}
     * @throws SQLTimeoutException  when the driver has determined that the
     * timeout value specified by the {@code setLoginTimeout} method
     * has been exceeded and has at least tried to cancel the
     * current database connection attempt
     */
    @CallerSensitive
    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()));
    }

    /**
     * Attempts to establish a connection to the given database URL.
     * The <code>DriverManager</code> attempts to select an appropriate driver from
     * the set of registered JDBC drivers.
     *
     * @param url a database url of the form
     *  <code> jdbc:<em>subprotocol</em>:<em>subname</em></code>
     * @return a connection to the URL
     * @exception SQLException if a database access error occurs or the url is
     * {@code null}
     * @throws SQLTimeoutException  when the driver has determined that the
     * timeout value specified by the {@code setLoginTimeout} method
     * has been exceeded and has at least tried to cancel the
     * current database connection attempt
     */
    @CallerSensitive
    public static Connection getConnection(String url)
        throws SQLException {

        java.util.Properties info = new java.util.Properties();
        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()方法获得连接对象。这样巧妙的避开了使用继承,为不同的数据库提供了相同的接口。

三、桥接模式的优缺点

桥接模式很好的遵循了里氏替换原则和依赖倒置原则,最终实现了开闭原则,对修改关闭,对扩展开发。优缺点总结如下:

优点:

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

缺点:

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

来源:迅闻网

原文地址:https://www.cnblogs.com/1994july/p/12994267.html