桥接模式

最新推荐文章于 2023-11-07 09:14:36 发布
最新推荐文章于 2023-11-07 09:14:36 发布
阅读量129 收藏
点赞数
分类专栏： 设计模式 文章标签： java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011337793/article/details/108536354
版权

设计模式引入

手机操作问题：

现在对不同手机类型的不同品牌实现操作编程(比如:开机、关机、上网，打电话等)，如图:

如果按照我们初学Java编程可以很容易实现，思路呢类似于以下图：

从功能上来说，这样设计是可以的。但是，若是增加一种新的样式，那么同样的它也会新增不同品牌手机的子类，这样就会导致类爆炸的问题。

如果添加一个旋转系列的手机，就会做如下操作

传统方案解决手机操作问题分析：

  1. 扩展性问题(类爆炸)，如果我们再增加手机的样式(旋转式)，就需要增加各个品牌手机的类，同样如果我们增加一个手机品牌，也要在各个手机样式类下增加

  2. 违反了单一职责原则，当我们增加手机样式时，要同时增加所有品牌的手机，这样增加了代码维护成本。

  3. 可以通过桥接模式解决这个问题。

    桥接模式

    基本介绍

    1. 桥接模式(Bridge模式)是指：将实现和抽象放在两个不同的层次类中，使两个层次的类可以独立改变；

    2. 桥接模式是一种结构设计模式；

    3. Bridge模式基于类的最小设计原则，通过使用封装、聚合及继承等行为让不同的类承担不同的职责。它的主要特点是把抽象(Abstraction)与行为实现(Implementation)分离开来，从而可以保持各部分的独立性以及应对他们的功能扩展；

    桥接模式原理图

    原理类图说明

    1. Client类：桥接模式的调用者;

    2. 抽象类(Abstraction) :维护了Implementor /即它的实现类ConcreteImplementorA..,二者是聚合关系, Abstraction充当桥接类;

    3. RedefinedAbstraction：是Abstraction抽象类的子类；

    4. Implementor：行为实现类的接口；

    5. ConcreteImplementorA/B：行为的具体实现类。

    从UML类图中可以看出，这里的抽象类和接口是聚合的关系，也就是调用和被调用的关系。

    解决引入的手机问题

    类图

    源码

    1. 品牌 接口

     // 接口
 public interface Brand {
     void open();
     void close();
     void call();
 }// 接口
 public interface Brand {
     void open();
     void close();
     void call();
 }
     public abstract class Phone {
     //组合品牌
     private Brand brand;
 ​
     //构造器
     public Phone(Brand brand) {
         super();
         this.brand = brand;
     }
 ​
     protected void open() {
         this.brand.open();
     }
     protected void close() {
         brand.close();
     }
     protected void call() {
         brand.call();
     }
 }public abstract class Phone {
     //组合品牌
     private Brand brand;
 ​
     //构造器
     public Phone(Brand brand) {
         super();
         this.brand = brand;
     }
 ​
     protected void open() {
         this.brand.open();
     }
     protected void close() {
         brand.close();
     }
     protected void call() {
         brand.call();
     }
 }
     public class XiaoMi implements Brand {
 ​
     @Override
     public void open() {
         System.out.println(" 小米手机开机 ");
     }
 ​
     @Override
     public void close() {
         System.out.println(" 小米手机关机 ");
     }
 ​
     @Override
     public void call() {
         System.out.println(" 小米手机打电话 ");
     }
 }public class XiaoMi implements Brand {
 ​
     @Override
     public void open() {
         System.out.println(" 小米手机开机 ");
     }
 ​
     @Override
     public void close() {
         System.out.println(" 小米手机关机 ");
     }
 ​
     @Override
     public void call() {
         System.out.println(" 小米手机打电话 ");
     }
 }
     public class HuaWei implements Brand {
 ​
     @Override
     public void open() {
         System.out.println(" 华为手机开机 ");
     }
 ​
     @Override
     public void close() {
         System.out.println(" 华为手机关机 ");
     }
 ​
     @Override
     public void call() {
         System.out.println(" 华为手机打电话 ");
     }
 }public class HuaWei implements Brand {
 ​
     @Override
     public void open() {
         System.out.println(" 华为手机开机 ");
     }
 ​
     @Override
     public void close() {
         System.out.println(" 华为手机关机 ");
     }
 ​
     @Override
     public void call() {
         System.out.println(" 华为手机打电话 ");
     }
 }
     public class UpRightPhone extends Phone {
     //构造器
     public UpRightPhone(Brand brand) {
         super(brand);
     }
 ​
     public void open() {
         super.open();
         System.out.println(" 直立样式手机 ");
     }
 ​
     public void close() {
         super.close();
         System.out.println(" 直立样式手机 ");
     }
 ​
     public void call() {
         super.call();
         System.out.println(" 直立样式手机 ");
     }
 }public class UpRightPhone extends Phone {
     //构造器
     public UpRightPhone(Brand brand) {
         super(brand);
     }
 ​
     public void open() {
         super.open();
         System.out.println(" 直立样式手机 ");
     }
 ​
     public void close() {
         super.close();
         System.out.println(" 直立样式手机 ");
     }
 ​
     public void call() {
         super.call();
         System.out.println(" 直立样式手机 ");
     }
 }
     //折叠式手机类，继承 抽象类 Phone
 public class FoldedPhone extends Phone {
     public FoldedPhone(Brand brand) {
         super(brand);
     }
 ​
     public void open() {
         super.open();
         System.out.println(" 折叠样式手机 ");
     }
 ​
     public void close() {
         super.close();
         System.out.println(" 折叠样式手机 ");
     }
 ​
     public void call() {
         super.call();
         System.out.println(" 折叠样式手机 ");
     }
 }//折叠式手机类，继承 抽象类 Phone
 public class FoldedPhone extends Phone {
     public FoldedPhone(Brand brand) {
         super(brand);
     }
 ​
     public void open() {
         super.open();
         System.out.println(" 折叠样式手机 ");
     }
 ​
     public void close() {
         super.close();
         System.out.println(" 折叠样式手机 ");
     }
 ​
     public void call() {
         super.call();
         System.out.println(" 折叠样式手机 ");
     }
 }
     public class Client {
 ​
     public static void main(String[] args) {
         //获取折叠式手机 (样式 + 品牌 )
         Phone phoneXiaomi = new FoldedPhone(new XiaoMi());
 ​
         phoneXiaomi.open();
         phoneXiaomi.call();
         phoneXiaomi.close();
 ​
         System.out.println("=======================");
         Phone phoneHuaWei= new FoldedPhone(new HuaWei());
 ​
         phoneHuaWei.open();
         phoneHuaWei.call();
         phoneHuaWei.close();
         System.out.println("=======================");
 ​
         UpRightPhone phone3 = new UpRightPhone(new XiaoMi());
 ​
         phone3.open();
         phone3.call();
         phone3.close();
     }
 }public class Client {
 ​
     public static void main(String[] args) {
         //获取折叠式手机 (样式 + 品牌 )
         Phone phoneXiaomi = new FoldedPhone(new XiaoMi());
 ​
         phoneXiaomi.open();
         phoneXiaomi.call();
         phoneXiaomi.close();
 ​
         System.out.println("=======================");
         Phone phoneHuaWei= new FoldedPhone(new HuaWei());
 ​
         phoneHuaWei.open();
         phoneHuaWei.call();
         phoneHuaWei.close();
         System.out.println("=======================");
 ​
         UpRightPhone phone3 = new UpRightPhone(new XiaoMi());
 ​
         phone3.open();
         phone3.call();
         phone3.close();
     }
 }
     Class.forName("com.mysql.jdbc.Driver");
 Connection conn= DriverManager.getConnection(url,user,password);Class.forName("com.mysql.jdbc.Driver");
 Connection conn= DriverManager.getConnection(url,user,password);

    一个类存在两个独立变化的维度，且这两个维度都需要进行扩展。可以考虑桥接模式。在设计系统的时候，尤其是对外开放的系统，一定要考虑这种变化可能带来的影响。以前没注意过这个jdbc的实现，粗浅得了解了下，真佩服啊… 设计模式的学习不要拘泥于局部代码，要从整体去把握。

    思考

     

    1. JDBC 驱动程序

    2. 银行转账系统：

      1. 转账分类：网上转账、柜台转账、ATM转账

      2. 转账用户类型：普通用户、金卡用户、钻石用户

    3. 消息关系

      1. 消息类型：即时消息、延时消息

      2. 消息分类：手机短信、邮件消息、QQ消息

    应用场景

     

    1. 实现了抽象和实现部分的分离，从而极大的提供了系统的灵活性，让抽象部分和实现部分独立开来，这有助于系统进行分层设计，从而产生更好的结构化系统；

    2. 对于系统的高层部分，只需要知道抽象部分和实现部分的接口就可以了，其它的部分由具体业务来完成；

    3. 桥接模式替代多层继承方案，可以减少子类的个数，降低系统的管理和维护成本。

    4. 桥接模式的引入增加了系统的理解和设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设计和编程；

    5. 桥接模式要求正确识别出系统中两个独立变化的维度，因此其使用范围有一定的局限性，即需要有这样的应用场景。

    桥接模式的注意事项和细节

     

    对于应用程序而言，只要选用不同的驱动，就可以让程序操作不同的数据库，而无需更改应用程序，从而实现在不同的数据库上移植； 对于驱动程序而言，为数据库实现不同的驱动程序，并不会影响应用程序

    1. 数据库驱动

    2. 应用程序的数据库连接信息（可能是mysql,可能是oracel等）

    我们分析下，这里和桥接模式有什么关系。 回顾一下桥接模式的定义：将抽象部分与实现部分分离，使它们可以独立地进行定义。 为两个独立变化的维度设计两个独立的继承等级结构，并在抽象层建立一个抽象关联。 这里两个独立变化的维度：

    public class DriverManager {
    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);
   }
    
}

    Class.forName会把类加载进来，执行类的静态方法（类加载的初始化阶段）。我们看到mysql Driver的static块，调用了java.sql.DriverManager的registerDriver方法

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

    com.mysql.jdbc.Driver 源码

    加载com.mysql.jdbc.Driver类

    源码剖析

    我们知道jdbc只提出了一系列接口规范，具体的实现由数据库提供者去实现。所以，当我们在连接mysql的时候，需要添加jdbc-mysql.jar，在连接oracel的时候，需要添加ojdbc.jar（不确定jar名有没有写错，没在代码里用过oracel）。然后去载入驱动，再进行连接

    JDBC源码中使用的桥接模式

    由上面的类图我们可以看出来，当我们增加苹果手机品牌和旋转样式的时候，只需要增加两个类。并不需要像传统模式那样添加N多类和方法了，节省了大量的开发时间，也变得合理了很多很多。

    看完上述代码，我们可以体会到桥接模式的妙处了~

    1. 客户端

    1. 折叠式手机 实现

    1. 直立式手机 实现

    1. 具体手机品牌 - 华为

    1. 具体手机品牌 - 小米

    1. 手机样式 抽象类

Wills丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
桥接设计模式
学习技术的路上不断沉淀自己
12-20 979
桥接模式（Bridge Pattern）是一种结构型设计模式，用于将抽象与其实现相分离，以便两者可以独立地进行变化，实现了抽象和具体实现的解耦。
桥接模式介绍
最新发布
qq_25409421的博客
01-16 1678
桥接模式属于结构型模式，它用一种巧妙的方式处理多层继承存在的问题，用抽象关联来取代传统的多层继承，将类之间的静态继承关系转变为动态的组合关系，使得系统更加灵活，并易于扩展，有效的控制了系统中类的个数 (避免了继承层次的指数级爆炸).。今天我们就来介绍下桥接模式。
设计模式04———桥接模式 c#
weixin_69360830的博客
10-31 442
桥接模式
设计模式-桥接模式（Bridge）
miaoyl的博客
11-07 354
桥接模式，也被称为柄体（Handle and Body）模式或接口（Interface）模式，是一种桥接模式，也被称为柄体（Handle and Body）模式或接口（Interface）模式，是一种结构型设计模式。它的主要目的是将抽象部分与它的实现部分分离，使它们都可以独立地变化。这种分离可以通过组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。举个例子，假设有一个几何形状Shape类，从它能扩展出两个子类：圆形Circle和方形Square。
桥接模式（Bridge）
weixin_43956958的博客
06-26 2万+
桥接（Bridge）模式
桥接模式1
08-08
桥接模式是一种设计模式，它的核心思想是将抽象部分与实现部分分离，使得它们可以独立地发展和变化，以此降低系统的复杂性和耦合度。在桥接模式中，抽象部分和实现部分通过组合而非继承来关联，这样可以避免因为继承...
桥接模式源码
02-18
桥接模式是一种设计模式，它将抽象部分与它的实现部分分离，使得它们都可以独立地进行变化。这种模式属于结构型模式，旨在降低不同抽象层次之间的耦合度，提高系统的灵活性和可扩展性。 在桥接模式中，抽象部分...
桥接模式Demo
06-09
桥接模式是一种设计模式，属于结构型模式，它将抽象部分与实现部分分离，使得它们可以独立进行变化。这种模式的主要目的是为了使抽象和实现能够独立演化，从而降低系统的耦合度，提高代码的可扩展性和灵活性。 在...
设计模式之桥接模式详解（附应用举例实现）
pursuit的博客
04-24 4914
设计模式之桥接模式详解（附应用举例实现）
【设计模式从入门到精通】06-桥接模式
VectorX's Blog
10-20 573
桥接模式 1、传统方式解决手机操作问题 2、桥接模式基本介绍 3、桥接模式解决手机操作问题 4、JDK 源码分析 5、注意事项和细节 6、桥接模式其他应用场景
桥接模式（Bridge模式）详解
u012045045的博客
01-06 6436
在现实生活中，某些类具有两个或多个维度的变化，如图形既可按形状分，又可按颜色分。如何设计类似于 Photoshop 这样的软件，能画不同形状和不同颜色的图形呢？如果用继承方式，m 种形状和 n 种颜色的图形就有 m×n 种，不但对应的子类很多，而且扩展困难。 当然，这样的例子还有很多，如不同颜色和字体的文字、不同品牌和功率的汽车、不同性别和职业的男女、支持不同平台和不同文件格式的媒体播放器等。如果...
OPC DA客户端的三种实现方式
热门推荐
gencheng的专栏
07-19 2万+
http://www.dqjsw.com.cn/dianqi/OPC/310.html OPC DA客户端的三种实现方式 时间:2009-09-30 来源:未知 编辑:电气自动化技术网 点击:301次 字体设置: 大 中 小 1  引言      OPC(OLE for Process Control)是一个工业标准，他是许多世界领先的自动化和软、硬件公司与微软公司合作的结晶。管理
设计模式：桥接模式（Bridge）
weixin_34303897的博客
03-28 615
定义：将抽象部分与它的实现部分分离，使它们都可以独立地变化。 意图：将抽象与实现解耦。  桥接模式主要应对的是由于实际的需要，某个类具有两个或者两个以上的维度变化（违反了SRP原则），如果只是用继承将无法实现这种需要，或者使得设计变得相当臃肿。 桥接模式所涉及的角色 1. Abstraction：定义抽象接口，拥有一个Impl...
桥接模式深入解析
"Java 23种设计模式11桥接模式.pdf，主要讲解了Java中的桥接设计模式，由韶关学院计算机系程细柱主讲，书中内容包括模式的动机、结构、实例解析、效果及应用，并指出桥接模式能够减少类的数量，提高系统的可扩展性。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值