设计模式系列（10）：结构型模式

系列导读：在学习了接口适配后，我们来看如何处理抽象与实现的分离问题。桥接模式解决的是"多维度变化"的设计难题。

解决什么问题：将抽象部分与实现部分分离，使它们都可以独立变化。避免在多个维度上变化时出现类爆炸问题。

想象一下，你要设计一个图形绘制系统，既要支持不同的形状（圆形、矩形），又要支持不同的绘制方式（Windows绘制、Linux绘制）。如果用继承，你需要WindowsCircle、LinuxCircle、WindowsRectangle、LinuxRectangle等类，随着形状和平台的增加，类的数量会爆炸式增长。

桥接模式通过将"形状"和"绘制方式"分离成两个独立的层次结构，用组合代替继承，让两个维度可以独立变化和扩展。

本文在系列中的位置：

前置知识：适配器模式
系列角色：结构型模式核心
难度等级：★★★★☆（概念较抽象，需要理解抽象与实现分离）
后续学习：组合模式

1. 模式概述

桥接模式是一种结构型设计模式，它将抽象部分与实现部分分离，使它们可以独立变化。这种模式通过组合的方式，而不是继承的方式，来实现抽象和实现的解耦。桥接模式常用于需要多维度扩展的系统，能够有效避免类爆炸问题。

定义

桥接模式将抽象部分与实现部分分离，使它们都可以独立地变化。通过在抽象层中持有实现层的引用，实现抽象和实现的解耦，便于系统的扩展和维护。

目的

分离抽象与实现，避免继承导致的类爆炸
支持抽象和实现的独立扩展，提升系统灵活性
降低系统耦合度，便于维护和升级

2. 使用场景

桥接模式适用于以下场景：

抽象和实现分离
- 需要将抽象和实现分离，便于独立扩展。
- 需要支持多种实现方式，避免继承的局限性。
- 需要在运行时切换实现。
多维度变化
- 系统存在多个变化维度，如形状和颜色、平台和功能等。
- 需要避免因多维扩展导致的类爆炸。
- 需要灵活组合不同维度的实现。
运行时绑定
- 需要在运行时动态切换实现。
- 需要支持插件化、可插拔架构。
- 需要动态改变实现方式。

真实业务背景举例：

跨平台UI库，既要支持多种控件类型（如按钮、文本框），又要支持多种操作系统（如Windows、Linux、Mac），通过桥接模式实现控件与平台的解耦。
图形绘制系统，既要支持多种图形（如圆形、矩形），又要支持多种绘图API（如OpenGL、DirectX），通过桥接模式灵活组合。
云存储平台支持多种存储后端（如本地磁盘、阿里云OSS、亚马逊S3），通过桥接模式灵活切换存储实现。

3. 优缺点分析

优点

解耦：抽象和实现分离，降低代码耦合度。提高代码可维护性和扩展性。支持独立演化和升级。
扩展性：支持多维度独立扩展，符合开闭原则。避免继承导致的类爆炸。易于添加新的抽象或实现。
灵活性：支持运行时切换实现，提升系统灵活性。支持动态组合不同实现。便于实现插件化架构。

缺点

复杂性提升：增加系统结构复杂度。需要合理设计抽象和实现层次。增加理解和维护难度。
设计难度：需要合理划分抽象和实现。需要处理两者之间的关系。需要保持接口一致性。
维护成本：需要维护多个类和接口。需要处理版本兼容和扩展问题。需要保证系统整体一致性。

4. 实际应用案例

GUI框架：跨平台控件（如按钮、文本框在不同操作系统下的实现）、主题切换（如不同UI主题的动态切换）、控件风格扩展（如扁平风格、拟物风格等）。
数据库访问：支持多种数据库类型（MySQL、Oracle、SQL Server等）、多种连接方式（JDBC、ODBC等）、多种查询方式（SQL、NoSQL等）。
消息系统：支持多种消息类型（文本、图片、视频等）、多种发送方式（HTTP、MQ、WebSocket等）、多种处理方式（同步、异步等）。
文件系统：支持多种存储方式（本地、云端、分布式等）、多种文件格式（txt、pdf、doc等）、多种访问方式（读、写、删除等）。

5. 结构与UML类图

@startuml
package "Bridge Pattern" #DDDDDD {interface DrawingAPI {+ drawCircle(x: int, y: int, radius: int): void+ drawRectangle(x: int, y: int, width: int, height: int): void}class WindowsDrawingAPI implements DrawingAPIclass LinuxDrawingAPI implements DrawingAPIabstract class Shape {# drawingAPI: DrawingAPI+ draw(): void}class Circle extends Shapeclass Rectangle extends ShapeDrawingAPI <|.. WindowsDrawingAPIDrawingAPI <|.. LinuxDrawingAPIShape <|-- CircleShape <|-- RectangleShape o-- DrawingAPI : drawingAPI
}
@enduml

6. 代码示例

6.1 基本结构示例

业务背景： 实现抽象与实现分离的基本结构，支持运行时切换实现。

package com.example.patterns.bridge;import java.util.Objects;// 实现接口，定义实现层的操作
public interface Implementor {/*** 实现层的具体操作* 业务含义：底层平台或品牌的具体实现*/void operationImpl();/*** 获取实现类型*/String getType();
}// 具体实现A，实现Implementor接口
public class ConcreteImplementorA implements Implementor {@Overridepublic void operationImpl() {try {// 具体实现A的业务逻辑System.out.println("ConcreteImplementorA operation - 执行实现A的业务逻辑");} catch (Exception e) {System.err.println("ImplementorA operation failed: " + e.getMessage());throw new RuntimeException("实现A操作失败", e);}}@Overridepublic String getType() {return "ImplementorA";}
}// 具体实现B，实现Implementor接口
public class ConcreteImplementorB implements Implementor {@Overridepublic void operationImpl() {try {// 具体实现B的业务逻辑System.out.println("ConcreteImplementorB operation - 执行实现B的业务逻辑");} catch (Exception e) {System.err.println("ImplementorB operation failed: " + e.getMessage());throw new RuntimeException("实现B操作失败", e);}}@Overridepublic String getType() {return "ImplementorB";}
}// 抽象类，持有实现接口的引用
public abstract class Abstraction {protected final Implementor implementor;/*** 构造方法注入实现层，便于运行时切换*/public Abstraction(Implementor implementor) {this.implementor = Objects.requireNonNull(implementor, "Implementor cannot be null");}/*** 抽象层的操作，由子类实现* 业务含义：对外暴露的统一接口*/public abstract void operation();/*** 获取当前实现类型*/public String getImplementorType() {return implementor.getType();}
}// 扩展抽象类，实现具体的业务操作
public class RefinedAbstraction extends Abstraction {public RefinedAbstraction(Implementor implementor) {super(implementor);}@Overridepublic void operation() {try {// 调用实现层的操作，实现桥接System.out.println("RefinedAbstraction: 准备调用实现层");implementor.operationImpl();System.out.println("RefinedAbstraction: 完成调用实现层");} catch (Exception e) {System.err.println("Abstraction operation failed: " + e.getMessage());throw new RuntimeException("抽象层操作失败", e);}}
}

6.2 企业级应用场景：消息推送系统

业务背景： 企业级消息推送系统需要支持多种消息类型（短信、邮件、推送通知）和多种推送平台（阿里云、腾讯云、华为云），通过桥接模式实现消息类型与推送平台的解耦。

package com.example.patterns.bridge.message;import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
import java.time.LocalDateTime;// 推送平台接口
public interface MessagePlatform {/*** 发送消息* @param recipient 接收者* @param content 消息内容* @param metadata 元数据* @return 推送结果*/PushResult sendMessage(String recipient, String content, Map<String, Object> metadata);/*** 获取平台名称*/String getPlatformName();/*** 检查平台状态*/boolean isAvailable();
}// 推送结果封装
public class PushResult {private boolean success;private String messageId;private String platformName;private String errorMessage;private LocalDateTime timestamp;public PushResult(boolean success, String messageId, String platformName, String errorMessage) {this.success = success;this.messageId = messageId;this.platformName = platformName;this.errorMessage = errorMessage;this.timestamp = LocalDateTime.now();}// Getter方法public boolean isSuccess() { return success; }public String getMessageId() { return messageId; }public String getPlatformName() { return platformName; }public String getErrorMessage() { return errorMessage; }public LocalDateTime getTimestamp() { return timestamp; }@Overridepublic String toString() {return String.format("PushResult{success=%s, messageId='%s', platform='%s', error='%s', time=%s}", success, messageId, platformName, errorMessage, timestamp);}
}// 阿里云推送平台实现
public class AliyunMessagePlatform implements MessagePlatform {private boolean available = true;@Overridepublic PushResult sendMessage(String recipient, String content, Map<String, Object> metadata) {try {if (!isAvailable()) {return new PushResult(false, null, getPlatformName(), "阿里云平台暂不可用");}// 模拟阿里云推送逻辑String messageId = "aliyun_" + System.currentTimeMillis();System.out.println("阿里云推送: 发送到 " + recipient + ", 内容: " + content);return new PushResult(true, messageId, getPlatformName(), null);} catch (Exception e) {return new PushResult(false, null, getPlatformName(), "阿里云推送异常: " + e.getMessage());}}@Overridepublic String getPlatformName() {return "阿里云";}@Overridepublic boolean isAvailable() {return available;}public void setAvailable(boolean available) {this.available = available;}
}// 腾讯云推送平台实现
public class TencentMessagePlatform implements MessagePlatform {private boolean available = true;@Overridepublic PushResult sendMessage(String recipient, String content, Map<String, Object> metadata) {try {if (!isAvailable()) {return new PushResult(false, null, getPlatformName(), "腾讯云平台暂不可用");}// 模拟腾讯云推送逻辑String messageId = "tencent_" + System.currentTimeMillis();System.out.println("腾讯云推送: 发送到 " + recipient + ", 内容: " + content);return new PushResult(true, messageId, getPlatformName(), null);} catch (Exception e) {return new PushResult(false, null, getPlatformName(), "腾讯云推送异常: " + e.getMessage());}}@Overridepublic String getPlatformName() {return "腾讯云";}@Overridepublic boolean isAvailable() {return available;}public void setAvailable(boolean available) {this.available = available;}
}// 华为云推送平台实现
public class HuaweiMessagePlatform implements MessagePlatform {private boolean available = true;@Overridepublic PushResult sendMessage(String recipient, String content, Map<String, Object> metadata) {try {if (!isAvailable()) {return new PushResult(false, null, getPlatformName(), "华为云平台暂不可用");}// 模拟华为云推送逻辑String messageId = "huawei_" + System.currentTimeMillis();System.out.println("华为云推送: 发送到 " + recipient + ", 内容: " + content);return new PushResult(true, messageId, getPlatformName(), null);} catch (Exception e) {return new PushResult(false, null, getPlatformName(), "华为云推送异常: " + e.getMessage());}}@Overridepublic String getPlatformName() {return "华为云";}@Overridepublic boolean isAvailable() {return available;}public void setAvailable(boolean available) {this.available = available;}
}// 消息抽象类
public abstract class Message {protected final MessagePlatform platform;protected String title;protected String content;protected List<String> recipients;protected Map<String, Object> metadata;public Message(MessagePlatform platform) {this.platform = Objects.requireNonNull(platform, "MessagePlatform cannot be null");this.recipients = new ArrayList<>();this.metadata = new HashMap<>();}public Message setTitle(String title) {this.title = title;return this;}public Message setContent(String content) {this.content = content;return this;}public Message addRecipient(String recipient) {if (recipient != null && !recipient.trim().isEmpty()) {this.recipients.add(recipient);}return this;}public Message addMetadata(String key, Object value) {this.metadata.put(key, value);return this;}/*** 发送消息的抽象方法，由子类实现*/public abstract List<PushResult> send();/*** 格式化消息内容，由子类实现*/protected abstract String formatContent();
}// 短信消息实现
public class SmsMessage extends Message {public SmsMessage(MessagePlatform platform) {super(platform);}@Overridepublic List<PushResult> send() {List<PushResult> results = new ArrayList<>();String formattedContent = formatContent();for (String recipient : recipients) {try {PushResult result = platform.sendMessage(recipient, formattedContent, metadata);results.add(result);} catch (Exception e) {PushResult errorResult = new PushResult(false, null, platform.getPlatformName(), "发送短信异常: " + e.getMessage());results.add(errorResult);}}return results;}@Overrideprotected String formatContent() {return "【短信通知】" + (title != null ? title + ": " : "") + content;}
}// 邮件消息实现
public class EmailMessage extends Message {public EmailMessage(MessagePlatform platform) {super(platform);}@Overridepublic List<PushResult> send() {List<PushResult> results = new ArrayList<>();String formattedContent = formatContent();for (String recipient : recipients) {try {// 邮件特有的元数据Map<String, Object> emailMetadata = new HashMap<>(metadata);emailMetadata.put("subject", title);emailMetadata.put("type", "email");PushResult result = platform.sendMessage(recipient, formattedContent, emailMetadata);results.add(result);} catch (Exception e) {PushResult errorResult = new PushResult(false, null, platform.getPlatformName(), "发送邮件异常: " + e.getMessage());results.add(errorResult);}}return results;}@Overrideprotected String formatContent() {StringBuilder html = new StringBuilder();html.append("<html><body>");if (title != null) {html.append("<h2>").append(title).append("</h2>");}html.append("<p>").append(content).append("</p>");html.append("</body></html>");return html.toString();}
}// 推送通知消息实现
public class PushNotification extends Message {public PushNotification(MessagePlatform platform) {super(platform);}@Overridepublic List<PushResult> send() {List<PushResult> results = new ArrayList<>();String formattedContent = formatContent();for (String recipient : recipients) {try {// 推送通知特有的元数据Map<String, Object> pushMetadata = new HashMap<>(metadata);pushMetadata.put("title", title);pushMetadata.put("type", "push");pushMetadata.put("badge", 1);PushResult result = platform.sendMessage(recipient, formattedContent, pushMetadata);results.add(result);} catch (Exception e) {PushResult errorResult = new PushResult(false, null, platform.getPlatformName(), "发送推送通知异常: " + e.getMessage());results.add(errorResult);}}return results;}@Overrideprotected String formatContent() {return content;}
}// 消息工厂
public class MessageFactory {public static Message createSmsMessage(MessagePlatform platform) {return new SmsMessage(platform);}public static Message createEmailMessage(MessagePlatform platform) {return new EmailMessage(platform);}public static Message createPushNotification(MessagePlatform platform) {return new PushNotification(platform);}
}// 平台工厂
public class PlatformFactory {public static MessagePlatform createAliyunPlatform() {return new AliyunMessagePlatform();}public static MessagePlatform createTencentPlatform() {return new TencentMessagePlatform();}public static MessagePlatform createHuaweiPlatform() {return new HuaweiMessagePlatform();}
}

6.3 绘图系统场景

业务背景： 跨平台绘图系统，支持多种形状和多种绘图API的组合。

package com.example.patterns.bridge.graphics;import java.awt.Color;// 绘图API接口
public interface DrawingAPI {void drawCircle(double x, double y, double radius, Color color);void drawRectangle(double x, double y, double width, double height, Color color);void drawLine(double x1, double y1, double x2, double y2, Color color);String getApiName();
}// Windows绘图API实现
public class WindowsDrawingAPI implements DrawingAPI {@Overridepublic void drawCircle(double x, double y, double radius, Color color) {System.out.printf("Windows API: 绘制圆形 at (%.1f,%.1f) radius=%.1f color=%s%n", x, y, radius, color.toString());}@Overridepublic void drawRectangle(double x, double y, double width, double height, Color color) {System.out.printf("Windows API: 绘制矩形 at (%.1f,%.1f) size=%.1fx%.1f color=%s%n", x, y, width, height, color.toString());}@Overridepublic void drawLine(double x1, double y1, double x2, double y2, Color color) {System.out.printf("Windows API: 绘制直线 from (%.1f,%.1f) to (%.1f,%.1f) color=%s%n", x1, y1, x2, y2, color.toString());}@Overridepublic String getApiName() {return "Windows GDI";}
}// Linux绘图API实现
public class LinuxDrawingAPI implements DrawingAPI {@Overridepublic void drawCircle(double x, double y, double radius, Color color) {System.out.printf("Linux X11: 绘制圆形 at (%.1f,%.1f) radius=%.1f color=%s%n", x, y, radius, color.toString());}@Overridepublic void drawRectangle(double x, double y, double width, double height, Color color) {System.out.printf("Linux X11: 绘制矩形 at (%.1f,%.1f) size=%.1fx%.1f color=%s%n", x, y, width, height, color.toString());}@Overridepublic void drawLine(double x1, double y1, double x2, double y2, Color color) {System.out.printf("Linux X11: 绘制直线 from (%.1f,%.1f) to (%.1f,%.1f) color=%s%n", x1, y1, x2, y2, color.toString());}@Overridepublic String getApiName() {return "Linux X11";}
}// 形状抽象类
public abstract class Shape {protected final DrawingAPI drawingAPI;protected double x, y;protected Color color;public Shape(DrawingAPI drawingAPI, double x, double y, Color color) {this.drawingAPI = Objects.requireNonNull(drawingAPI, "DrawingAPI cannot be null");this.x = x;this.y = y;this.color = color != null ? color : Color.BLACK;}public abstract void draw();public abstract double getArea();public void move(double deltaX, double deltaY) {this.x += deltaX;this.y += deltaY;}public void setColor(Color color) {this.color = color != null ? color : Color.BLACK;}public String getApiName() {return drawingAPI.getApiName();}
}// 圆形实现
public class Circle extends Shape {private double radius;public Circle(DrawingAPI drawingAPI, double x, double y, double radius, Color color) {super(drawingAPI, x, y, color);this.radius = Math.max(0, radius);}@Overridepublic void draw() {drawingAPI.drawCircle(x, y, radius, color);}@Overridepublic double getArea() {return Math.PI * radius * radius;}public void setRadius(double radius) {this.radius = Math.max(0, radius);}public double getRadius() {return radius;}
}// 矩形实现
public class Rectangle extends Shape {private double width, height;public Rectangle(DrawingAPI drawingAPI, double x, double y, double width, double height, Color color) {super(drawingAPI, x, y, color);this.width = Math.max(0, width);this.height = Math.max(0, height);}@Overridepublic void draw() {drawingAPI.drawRectangle(x, y, width, height, color);}@Overridepublic double getArea() {return width * height;}public void setSize(double width, double height) {this.width = Math.max(0, width);this.height = Math.max(0, height);}public double getWidth() { return width; }public double getHeight() { return height; }
}// 客户端使用示例
public class BridgeClient {public static void main(String[] args) {// 消息推送系统示例MessagePlatform aliyun = PlatformFactory.createAliyunPlatform();Message smsMessage = MessageFactory.createSmsMessage(aliyun).setTitle("系统通知").setContent("您有一条新消息").addRecipient("13800138000").addRecipient("13900139000");List<PushResult> results = smsMessage.send();results.forEach(System.out::println);// 绘图系统示例DrawingAPI windowsAPI = new WindowsDrawingAPI();DrawingAPI linuxAPI = new LinuxDrawingAPI();Shape circle1 = new Circle(windowsAPI, 10, 10, 5, Color.RED);Shape circle2 = new Circle(linuxAPI, 20, 20, 8, Color.BLUE);System.out.println("绘制图形:");circle1.draw();circle2.draw();System.out.printf("圆形1面积: %.2f (使用%s)%n", circle1.getArea(), circle1.getApiName());System.out.printf("圆形2面积: %.2f (使用%s)%n", circle2.getArea(), circle2.getApiName());}// 总结：通过桥接模式，消息类型与推送平台、形状与绘图API实现了解耦，便于灵活扩展和组合。
}

7. 测试用例

业务背景： 验证桥接模式的核心功能，包括基本桥接功能、消息推送系统和绘图系统。

package com.example.patterns.bridge.test;import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import static org.junit.jupiter.api.Assertions.*;
import java.awt.Color;
import java.util.List;public class BridgePatternTest {private MessagePlatform aliyunPlatform;private MessagePlatform tencentPlatform;private DrawingAPI windowsAPI;private DrawingAPI linuxAPI;@BeforeEachpublic void setUp() {aliyunPlatform = PlatformFactory.createAliyunPlatform();tencentPlatform = PlatformFactory.createTencentPlatform();windowsAPI = new WindowsDrawingAPI();linuxAPI = new LinuxDrawingAPI();}@Testpublic void testBasicBridgePattern() {// 测试基本桥接模式Implementor implA = new ConcreteImplementorA();Implementor implB = new ConcreteImplementorB();Abstraction abstractionA = new RefinedAbstraction(implA);Abstraction abstractionB = new RefinedAbstraction(implB);// 验证可以正常调用assertDoesNotThrow(() -> {abstractionA.operation();abstractionB.operation();});// 验证实现类型正确assertEquals("ImplementorA", abstractionA.getImplementorType());assertEquals("ImplementorB", abstractionB.getImplementorType());}@Testpublic void testAbstractionWithNullImplementor() {// 测试空实现异常处理assertThrows(NullPointerException.class, () -> {new RefinedAbstraction(null);});}@Testpublic void testSmsMessageSending() {// 测试短信消息发送Message smsMessage = MessageFactory.createSmsMessage(aliyunPlatform).setTitle("测试通知").setContent("这是一条测试短信").addRecipient("13800138000").addRecipient("13900139000");List<PushResult> results = smsMessage.send();assertNotNull("发送结果不应为空", results);assertEquals("应该有两条发送结果", 2, results.size());for (PushResult result : results) {assertTrue("发送应该成功", result.isSuccess());assertEquals("平台应为阿里云", "阿里云", result.getPlatformName());assertNotNull("消息ID不应为空", result.getMessageId());assertTrue("消息ID应以aliyun开头", result.getMessageId().startsWith("aliyun_"));}}@Testpublic void testEmailMessageSending() {// 测试邮件消息发送Message emailMessage = MessageFactory.createEmailMessage(tencentPlatform).setTitle("重要通知").setContent("这是一封重要邮件").addRecipient("test@example.com").addMetadata("priority", "high");List<PushResult> results = emailMessage.send();assertNotNull("发送结果不应为空", results);assertEquals("应该有一条发送结果", 1, results.size());PushResult result = results.get(0);assertTrue("发送应该成功", result.isSuccess());assertEquals("平台应为腾讯云", "腾讯云", result.getPlatformName());assertNotNull("时间戳不应为空", result.getTimestamp());}@Testpublic void testPushNotificationSending() {// 测试推送通知发送MessagePlatform huaweiPlatform = PlatformFactory.createHuaweiPlatform();Message pushMessage = MessageFactory.createPushNotification(huaweiPlatform).setTitle("系统更新").setContent("新版本已可用").addRecipient("user123").addMetadata("action", "update");List<PushResult> results = pushMessage.send();assertNotNull("发送结果不应为空", results);assertEquals("应该有一条发送结果", 1, results.size());PushResult result = results.get(0);assertTrue("发送应该成功", result.isSuccess());assertEquals("平台应为华为云", "华为云", result.getPlatformName());assertTrue("消息ID应以huawei开头", result.getMessageId().startsWith("huawei_"));}@Testpublic void testMessageWithUnavailablePlatform() {// 测试平台不可用时的处理AliyunMessagePlatform aliyun = new AliyunMessagePlatform();aliyun.setAvailable(false);Message smsMessage = MessageFactory.createSmsMessage(aliyun).setContent("测试消息").addRecipient("13800138000");List<PushResult> results = smsMessage.send();assertNotNull("发送结果不应为空", results);assertEquals("应该有一条发送结果", 1, results.size());PushResult result = results.get(0);assertFalse("发送应该失败", result.isSuccess());assertEquals("错误信息应正确", "阿里云平台暂不可用", result.getErrorMessage());}@Testpublic void testMessageWithNullPlatform() {// 测试空平台异常处理assertThrows(NullPointerException.class, () -> {MessageFactory.createSmsMessage(null);});}@Testpublic void testMessageBuilderPattern() {// 测试消息构建器模式Message message = MessageFactory.createSmsMessage(aliyunPlatform).setTitle("测试").setContent("内容").addRecipient("13800138000").addRecipient("") // 空接收者应被忽略.addRecipient(null) // null接收者应被忽略.addMetadata("key1", "value1").addMetadata("key2", "value2");List<PushResult> results = message.send();// 应该只有一条有效的接收者assertEquals("应该只有一条发送结果", 1, results.size());}@Testpublic void testCircleDrawing() {// 测试圆形绘制Shape circle1 = new Circle(windowsAPI, 10, 10, 5, Color.RED);Shape circle2 = new Circle(linuxAPI, 20, 20, 8, Color.BLUE);// 验证可以正常绘制assertDoesNotThrow(() -> {circle1.draw();circle2.draw();});// 验证API名称assertEquals("Windows GDI", circle1.getApiName());assertEquals("Linux X11", circle2.getApiName());// 验证面积计算assertEquals(Math.PI * 25, circle1.getArea(), 0.001);assertEquals(Math.PI * 64, circle2.getArea(), 0.001);}@Testpublic void testRectangleDrawing() {// 测试矩形绘制Shape rect1 = new Rectangle(windowsAPI, 0, 0, 10, 20, Color.GREEN);Shape rect2 = new Rectangle(linuxAPI, 5, 5, 15, 25, Color.YELLOW);// 验证可以正常绘制assertDoesNotThrow(() -> {rect1.draw();rect2.draw();});// 验证面积计算assertEquals(200, rect1.getArea(), 0.001);assertEquals(375, rect2.getArea(), 0.001);}@Testpublic void testShapeWithNullAPI() {// 测试空绘图API异常处理assertThrows(NullPointerException.class, () -> {new Circle(null, 0, 0, 5, Color.RED);});assertThrows(NullPointerException.class, () -> {new Rectangle(null, 0, 0, 10, 20, Color.BLUE);});}@Testpublic void testShapeMovement() {// 测试形状移动Circle circle = new Circle(windowsAPI, 10, 10, 5, Color.RED);circle.move(5, 3);// 注意：这里我们无法直接验证移动结果，因为x,y是protected// 在实际项目中，可以添加getter方法或测试绘制输出assertDoesNotThrow(() -> circle.draw());}@Testpublic void testShapeColorChange() {// 测试形状颜色变更Circle circle = new Circle(windowsAPI, 10, 10, 5, Color.RED);circle.setColor(Color.BLUE);circle.setColor(null); // 应设置为默认黑色assertDoesNotThrow(() -> circle.draw());}@Testpublic void testCircleRadiusValidation() {// 测试圆形半径验证Circle circle = new Circle(windowsAPI, 0, 0, -5, Color.RED);// 负半径应被修正为0assertEquals(0, circle.getRadius(), 0.001);circle.setRadius(10);assertEquals(10, circle.getRadius(), 0.001);circle.setRadius(-3); // 应被修正为0assertEquals(0, circle.getRadius(), 0.001);}@Testpublic void testRectangleSizeValidation() {// 测试矩形尺寸验证Rectangle rect = new Rectangle(windowsAPI, 0, 0, -10, -20, Color.BLUE);// 负尺寸应被修正为0assertEquals(0, rect.getWidth(), 0.001);assertEquals(0, rect.getHeight(), 0.001);assertEquals(0, rect.getArea(), 0.001);rect.setSize(15, 25);assertEquals(15, rect.getWidth(), 0.001);assertEquals(25, rect.getHeight(), 0.001);assertEquals(375, rect.getArea(), 0.001);}@Testpublic void testMessageFactoryCreation() {// 测试消息工厂创建Message sms = MessageFactory.createSmsMessage(aliyunPlatform);Message email = MessageFactory.createEmailMessage(aliyunPlatform);Message push = MessageFactory.createPushNotification(aliyunPlatform);assertTrue("应创建短信消息", sms instanceof SmsMessage);assertTrue("应创建邮件消息", email instanceof EmailMessage);assertTrue("应创建推送通知", push instanceof PushNotification);}@Testpublic void testPlatformFactoryCreation() {// 测试平台工厂创建MessagePlatform aliyun = PlatformFactory.createAliyunPlatform();MessagePlatform tencent = PlatformFactory.createTencentPlatform();MessagePlatform huawei = PlatformFactory.createHuaweiPlatform();assertTrue("应创建阿里云平台", aliyun instanceof AliyunMessagePlatform);assertTrue("应创建腾讯云平台", tencent instanceof TencentMessagePlatform);assertTrue("应创建华为云平台", huawei instanceof HuaweiMessagePlatform);assertEquals("阿里云", aliyun.getPlatformName());assertEquals("腾讯云", tencent.getPlatformName());assertEquals("华为云", huawei.getPlatformName());}@Testpublic void testPushResultToString() {// 测试推送结果字符串表示PushResult result = new PushResult(true, "test123", "阿里云", null);String resultString = result.toString();assertNotNull("字符串表示不应为空", resultString);assertTrue("应包含成功状态", resultString.contains("success=true"));assertTrue("应包含消息ID", resultString.contains("messageId='test123'"));assertTrue("应包含平台名称", resultString.contains("platform='阿里云'"));}
}

8. 常见误区与反例

8.1 常见误区

误区1 ：过度使用桥接模式

// 错误示例：为简单功能滥用桥接模式
public interface SimpleOperation {void doSomething();
}public class SimpleImplementation implements SimpleOperation {public void doSomething() { System.out.println("简单操作"); }
}// 不必要的抽象层
public abstract class UnnecessaryAbstraction {protected SimpleOperation operation;public UnnecessaryAbstraction(SimpleOperation operation) {this.operation = operation;}public abstract void execute();
}

正确做法：只在真正需要多维度扩展时使用桥接模式。

误区2 ：抽象与实现边界不清

// 错误示例：抽象层包含具体实现逻辑
public class BadAbstraction {private Implementation impl;public void operation() {// 错误：在抽象层处理具体业务逻辑validateInput();logOperation();impl.doWork();updateDatabase();}
}

正确做法：抽象层只做接口转换，具体逻辑放在实现层。

误区3 ：忽略运行时切换的线程安全

// 错误示例：非线程安全的实现切换
public class UnsafeAbstraction {private Implementation impl;public void setImplementation(Implementation impl) {this.impl = impl; // 可能导致并发问题}
}

8.2 反例分析

反例1 ：硬编码实现选择
在抽象层中硬编码选择具体实现，失去了桥接模式的灵活性。
反例2 ：实现层相互依赖
不同实现之间存在耦合，违反了桥接模式的解耦原则。
反例3 ：抽象层过于复杂
抽象层包含过多业务逻辑，模糊了抽象与实现的边界。

9. 最佳实践

9.1 设计原则

清晰的职责分离 ：明确抽象和实现的边界

// 推荐：清晰的职责分离
public abstract class PaymentProcessor {protected final PaymentGateway gateway;public PaymentProcessor(PaymentGateway gateway) {this.gateway = Objects.requireNonNull(gateway);}// 抽象层负责流程控制public final PaymentResult process(PaymentRequest request) {validateRequest(request);return doProcess(request);}protected abstract PaymentResult doProcess(PaymentRequest request);protected abstract void validateRequest(PaymentRequest request);
}

接口设计要稳定 ：实现接口应保持向后兼容

// 推荐：版本化接口设计
public interface PaymentGateway {PaymentResult processPayment(PaymentRequest request);// 扩展方法，保持向后兼容default PaymentResult processPayment(PaymentRequest request, PaymentOptions options) {return processPayment(request);}String getGatewayVersion();
}

9.2 实现技巧

使用工厂模式创建桥接 ：简化客户端使用

// 推荐：桥接工厂
public class MessageBridgeFactory {private static final Map<String, MessagePlatform> PLATFORMS = new ConcurrentHashMap<>();static {PLATFORMS.put("aliyun", new AliyunMessagePlatform());PLATFORMS.put("tencent", new TencentMessagePlatform());PLATFORMS.put("huawei", new HuaweiMessagePlatform());}public static Message createMessage(String type, String platform) {MessagePlatform platformImpl = PLATFORMS.get(platform);if (platformImpl == null) {throw new IllegalArgumentException("Unsupported platform: " + platform);}return MessageFactory.createMessage(type, platformImpl);}
}

支持运行时切换 ：提供安全的实现切换机制

// 推荐：线程安全的实现切换
public class SwitchableProcessor {private volatile Implementation impl;private final ReadWriteLock lock = new ReentrantReadWriteLock();public void switchImplementation(Implementation newImpl) {lock.writeLock().lock();try {this.impl = Objects.requireNonNull(newImpl);} finally {lock.writeLock().unlock();}}public void process() {lock.readLock().lock();try {impl.doWork();} finally {lock.readLock().unlock();}}
}

配置化实现选择 ：通过配置管理实现选择

// 推荐：配置化桥接
@Component
public class ConfigurableBridge {@Value("${bridge.implementation.type:default}")private String implementationType;@Autowiredprivate Map<String, Implementation> implementations;@PostConstructpublic void init() {Implementation impl = implementations.get(implementationType);if (impl == null) {throw new IllegalStateException("No implementation found for type: " + implementationType);}setImplementation(impl);}
}

9.3 性能优化

缓存策略 ：合理使用缓存提升性能

// 推荐：带缓存的桥接实现
public class CachedMessageBridge {private final MessagePlatform platform;private final Cache<String, MessageTemplate> templateCache;public CachedMessageBridge(MessagePlatform platform) {this.platform = platform;this.templateCache = Caffeine.newBuilder().maximumSize(1000).expireAfterWrite(Duration.ofMinutes(30)).build();}public PushResult sendTemplateMessage(String templateId, Map<String, Object> params) {MessageTemplate template = templateCache.get(templateId, key -> platform.getTemplate(key));return platform.sendMessage(template.format(params));}
}

异步处理 ：支持异步操作提升吞吐量

// 推荐：异步桥接实现
public class AsyncMessageBridge {private final MessagePlatform platform;private final Executor executor;public CompletableFuture<PushResult> sendMessageAsync(Message message) {return CompletableFuture.supplyAsync(() -> {try {return platform.sendMessage(message);} catch (Exception e) {return new PushResult(false, null, platform.getPlatformName(), e.getMessage());}}, executor);}
}

9.4 架构考虑

监控和日志 ：完善的观察性支持

// 推荐：带监控的桥接实现
public class MonitoredBridge {private static final Logger log = LoggerFactory.getLogger(MonitoredBridge.class);private final MeterRegistry meterRegistry;private final Implementation impl;public void process(Request request) {Timer.Sample sample = Timer.start(meterRegistry);String implType = impl.getClass().getSimpleName();try {log.debug("Processing request with implementation: {}", implType);impl.doWork(request);meterRegistry.counter("bridge.success", "impl", implType).increment();} catch (Exception e) {log.error("Bridge processing failed with implementation: {}", implType, e);meterRegistry.counter("bridge.error", "impl", implType).increment();throw e;} finally {sample.stop(Timer.builder("bridge.duration").tag("impl", implType).register(meterRegistry));}}
}

扩展点设计 ：提供灵活的扩展机制

// 推荐：可扩展的桥接设计
public abstract class ExtensibleBridge {protected final List<BridgeInterceptor> interceptors = new ArrayList<>();protected final Implementation impl;public void addInterceptor(BridgeInterceptor interceptor) {interceptors.add(interceptor);}protected final void process(Request request) {// 前置处理interceptors.forEach(i -> i.beforeProcess(request));try {doProcess(request);// 后置处理interceptors.forEach(i -> i.afterProcess(request));} catch (Exception e) {// 异常处理interceptors.forEach(i -> i.onError(request, e));throw e;}}protected abstract void doProcess(Request request);
}

版本兼容性 ：支持多版本实现共存

// 推荐：版本感知的桥接
public class VersionAwareBridge {private final Map<String, Implementation> implementations;public void process(Request request) {String version = request.getVersion();Implementation impl = implementations.get(version);if (impl == null) {// 降级到默认版本impl = implementations.get("default");}if (impl == null) {throw new UnsupportedOperationException("No implementation for version: " + version);}impl.process(request);}
}