桥接模式

最新推荐文章于 2021-12-19 15:15:11 发布

GongFuBoy丶

最新推荐文章于 2021-12-19 15:15:11 发布

阅读量293

点赞数

分类专栏：设计模式文章标签：设计模式

本文链接：https://blog.youkuaiyun.com/zhou199211/article/details/74928191

版权

设计模式专栏收录该内容

10 篇文章

订阅专栏

桥梁模式

桥梁模式是对象的结构模式。又称为柄体模式或接口模式。桥梁模式的用意是“将抽象化与实现化脱耦，使得二者可以独立的变化” ——《Java与模式》

桥梁模式概述

桥梁模式：主要是作用在抽象化（也就是接口）与实现化（也就是具体的实现类）两者联系起来，而将两者联系起来的这个方式就是桥梁模式。

我们最为常见的桥梁模式就是JDBC实现，JDBC实现方式，首先注册Driver（驱动），当然这里你去连接不懂的数据库，就去注册不同的Driver（驱动）；然后通过DriverManager去加载你注册的驱动，然后通过DriverManager获取链接，这里我简单实现一版JDBC

JDBC简单实现

public interface Driver {

    /**
     * 获取链接
     */
    Connection getConnection();
}

public class MysqlDriver implements Driver {

    private Connection connection;

    public MysqlDriver(Connection connection) {
        super();
        this.connection = connection;
    }

    @Override
    public Connection getConnection() {
        return connection;
    }

}

public class OracleDriver implements Driver {

    private Connection connection;

    public OracleDriver(Connection connection) {
        super();
        this.connection = connection;
    }

    @Override
    public Connection getConnection() {
        return connection;
    }

}

public interface Connection {

    /**
     * 打印链接名称
     */
    void printName();
}

public class MysqlConnection implements Connection {

    @Override
    public void printName() {
        System.out.println("我是mysql链接");
    }

}

public class OracleConnection implements Connection {

    @Override
    public void printName() {
        System.out.println("我是oracle链接");
    }

}

public abstract class Manager {

    private Driver driver;

    public Manager(Driver driver) {
        super();
        this.driver = driver;
    }

    public Connection getConnection() {
        return driver.getConnection();
    }
}

public class DriverManager extends Manager{

    public DriverManager(Driver driver) {
        super(driver);
    }

    @Override
    public Connection getConnection() {
        return super.getConnection();
    }

}

public class Client {

    public static void main(String[] args) {
        Connection mysqlConnection = new MysqlConnection();
        Driver mysqlDriver = new MysqlDriver(mysqlConnection);
        Manager manager = new DriverManager(mysqlDriver);
        Connection tempConnection = manager.getConnection();
        tempConnection.printName();

        Connection oracleConnection = new OracleConnection();
        Driver oracleDriver = new OracleDriver(oracleConnection);
        /**这里是同一个manager，进行了不同的注册，获取的到的链接应该是不一致的*/
        manager = new DriverManager(oracleDriver);
        Connection tempConnection2 = manager.getConnection();
        tempConnection2.printName();
    }

}

桥梁模式场景分析

假设我们先有一个实际的需求场景是：在我们系统中需要加入一个发送消息和邮件的功能。
假设我们需要加入一个对加入一个加急的消息，且对消息是否被查看进行监控。
这里假设我们有需要加入一个特殊的消息，这个消息需要加入催收的功能
然后我这里假设还需要加入一个给指定用户发送短信的功能
随着系统的业务逻辑越来越复杂，我们需要加入的东西越来越多，代码变得越来越臃肿，想要维护变得愈发的困难。

面临类似这样的问题的时候我们可以使用桥接模式解决该问题

这里可以看出来业务功能的变化是两个维度的变化，一个维度是抽象的消息，包括普通的消息，需要监控的消息与需要催收的消息，然后另一个维度是系统的内部的消息通知，邮件和手机短信；可以看出来这几个方式是平等的，可以随意切换的

Markdown

这里我们可以这么设计

Markdown

代码实现

public interface MessageSender {

    /**
     * 标准化发送消息
     * @param messageContent
     * @param user
     */
    void sendMessage(String messageContent, String user);
}

public abstract class AbstractMessage {

    protected MessageSender messageSender;

    public AbstractMessage(MessageSender messageSender) {
        super();
        this.messageSender = messageSender;
    }

    public void sendMessage(String message, String user) {
        this.messageSender.sendMessage(message, user);
    }
}

public class MessageSMS implements MessageSender {

    @Override
    public void sendMessage(String messageContent, String user) {
        System.out.println("发送普通站内消息：" + messageContent + "给指定的用户：" + user);
    }

}

public class MessageEmail implements MessageSender {

    @Override
    public void sendMessage(String messageContent, String user) {
        System.out.println("发送邮件内容为：" + messageContent + "给指定的用户" + user);
    }

}

public class NormalMessage extends AbstractMessage {

    public NormalMessage(MessageSender messageSender) {
        super(messageSender);
    }

    @Override
    public void sendMessage(String message, String user) {
        System.out.println("我是一条普通的消息");
        super.sendMessage(message, user);
    }
}

public class UrgencyMessage extends AbstractMessage {

    public UrgencyMessage(MessageSender messageSender) {
        super(messageSender);
    }

    @Override
    public void sendMessage(String message, String user) {
        System.out.println("这是一条加急消息");
        super.sendMessage(message, user);
    }

    /**
     * 监听指定的id的消息
     * @param messageId
     * @return
     */
    public Object watch(String messageId) {
        return null;
    }
}

public class Test {

    public static void main(String[] args) {
        MessageSender messageSMSSender = new MessageSMS();
        AbstractMessage tempMessage = new NormalMessage(messageSMSSender);
        tempMessage.sendMessage("xxxxxxxx", "小王");

        /**这里加急消息需要监听的话，需要强制转型成子类*/
        AbstractMessage tempMessage1 = new UrgencyMessage(messageSMSSender);
        tempMessage1.sendMessage("xxxxxxxx", "小王");
        if (tempMessage1 instanceof UrgencyMessage) {
            UrgencyMessage realTempMessage = (UrgencyMessage) tempMessage1;
            realTempMessage.watch("我是一个假的messageId");
        }

        MessageSender messageSender1 = new MessageEmail();
        tempMessage = new NormalMessage(messageSender1);
        tempMessage.sendMessage("********", "小张");

        tempMessage1 = new UrgencyMessage(messageSender1);
        tempMessage1.sendMessage("xxxxxxxx", "小张");
        if (tempMessage1 instanceof UrgencyMessage) {
            UrgencyMessage realTempMessage = (UrgencyMessage) tempMessage1;
            realTempMessage.watch("我是一个假的messageId");
        }

    }
}