从零开始：用桥接模式设计一个支持Oracle和SQLServer的PDF/TXT/XML转换器

从零构建：基于桥接模式的多数据库多格式数据转换器实战

最近在重构一个遗留的数据导出服务时，我遇到了一个典型的扩展难题：原有的系统只能从MySQL数据库导出CSV文件，但业务部门突然要求支持Oracle和SQLServer数据库，并且输出格式要扩展到PDF、TXT和XML。如果按照传统的继承方式硬编码，我可能需要创建OracleToPDFExporter、SQLServerToTXTExporter等十几个类，维护成本会急剧上升。

正是在这个背景下，我重新审视了设计模式中的桥接模式，发现它完美契合这种“多维度变化”的场景。桥接模式的核心思想是将抽象部分与实现部分分离，使它们可以独立变化。在数据转换这个场景中，“数据来源”（数据库类型）和“转换目标”（文件格式）就是两个独立变化的维度。

这篇文章将带你从零开始，用Java实现一个支持Oracle、SQLServer数据库和PDF、TXT、XML文件格式的数据转换器。我不会只给你看最终的类图，而是会分享我在实际编码中遇到的坑、调试的技巧，以及如何让这个模式真正“活”起来。

1. 理解桥接模式：为什么是它而不是其他模式？

在开始写代码之前，我们需要先搞清楚一个问题：为什么选择桥接模式，而不是策略模式、适配器模式或者简单的继承？

1.1 桥接模式 vs 多层继承

假设我们用传统的继承方式来实现这个需求，类结构可能会变成这样：

DataConverter
├── OracleConverter
│   ├── OracleToPDFConverter
│   ├── OracleToTXTConverter
│   └── OracleToXMLConverter
└── SQLServerConverter
    ├── SQLServerToPDFConverter
    ├── SQLServerToTXTConverter
    └── SQLServerToXMLConverter

这种设计的致命缺陷在于：

• 类爆炸：每增加一个数据库类型或文件格式，类的数量呈乘积增长
• 代码重复：每个类中可能都有相似的数据库连接逻辑或文件生成逻辑
• 难以维护：修改数据库连接方式需要改动所有相关子类

注意：当变化维度超过两个时，继承的复杂度会呈指数级增长。这就是所谓的“组合爆炸”问题。

1.2 桥接模式的核心思想

桥接模式通过“组合优于继承”的原则来解决这个问题。它将系统分为两个独立的层次结构：

1. 抽象化(Abstraction)：定义高层的业务逻辑，在我们的例子中就是“文件转换”
2. 实现化(Implementor)：定义底层的平台相关操作，在我们的例子中就是“数据读取”

这两个层次通过一个“桥”（引用关系）连接起来，可以独立扩展。用更通俗的话说：抽象层决定“做什么”，实现层决定“怎么做”，两者通过组合而非继承关联。

1.3 实际场景中的权衡

在实际项目中，我考虑过几种替代方案：

经过分析，桥接模式是唯一能优雅处理两个独立变化维度的方案。下面这张表能帮你快速理解各个维度的变化点：

2. 架构设计：从需求到类图的完整推导

理解了为什么用桥接模式后，我们来设计具体的类结构。我不会直接给你最终的类图，而是带你一起推导出这个设计。

2.1 识别独立变化的维度

首先分析需求中的变化点：

1. 数据库类型会变化：今天要支持Oracle和SQLServer，明天可能还要支持MySQL、PostgreSQL
2. 文件格式会变化：现在需要PDF、TXT、XML，未来可能需要Excel、JSON、CSV
3. 转换逻辑相对稳定：无论什么数据库、什么格式，基本流程都是：连接→查询→转换→输出

基于这个分析，我们可以确定：

• 实现层(Implementor)：数据读取，对应数据库类型的变化
• 抽象层(Abstraction)：文件转换，对应文件格式的变化

2.2 设计类结构

基于桥接模式，我们设计出以下核心类：

// 实现层接口：定义数据读取的契约
public interface DataReader {
    void connect();
    ResultSet executeQuery(String sql);
    void disconnect();
}

// 抽象层基类：定义文件转换的框架
public abstract class FileConverter {
    protected DataReader dataReader;  // 桥接的关键：持有实现层的引用
    
    public FileConverter(DataReader reader) {
        this.dataReader = reader;
    }
    
    public abstract void convert(String query, String outputPath);
    
    // 模板方法：定义转换的固定流程
    public final void process(String query, String outputPath) {
        dataReader.connect();
        ResultSet result = dataReader.executeQuery(query);
        convertResult(result, outputPath);
        dataReader.disconnect();
    }
    
    protected abstract void convertResult(ResultSet result, String outputPath);
}

这个设计有几个关键点：

1. FileConverter持有DataReader的引用，这是桥接的核心
2. 使用模板方法模式定义了固定的处理流程
3. 具体的转换逻辑在convertResult方法中实现

2.3 完整的类图关系

让我们看看完整的类层次结构：

实现层 (数据读取)
├── OracleDataReader
├── SQLServerDataReader
└── (未来可扩展) MySQLDataReader

抽象层 (文件转换)
├── PDFConverter
├── TXTConverter
├── XMLConverter
└── (未来可扩展) ExcelConverter

客户端
└── 组合使用：new PDFConverter(new OracleDataReader())

这种设计的优势在于：

• 增加新的数据库：只需实现新的DataReader，不影响现有的转换器
• 增加新的文件格式：只需继承FileConverter，可以复用所有数据库支持
• 修改数据库连接逻辑：只需修改对应的DataReader实现

3. 代码实现：从接口定义到具体实现

理论讲完了，现在进入实战环节。我会分享一些在实际编码中遇到的细节问题和解决方案。

3.1 实现层：数据库读取器

首先实现数据读取层。这里我使用接口而不是抽象类，因为Java 8+的接口可以包含默认方法，更加灵活。

/**
 * 数据读取器接口
 * 定义所有数据库读取器必须实现的方法
 */
public interface DataReader {
    
    /**
     * 建立数据库连接
     * @throws DatabaseConnectionException 连接失败时抛出
     */
    void connect() throws DatabaseConnectionException;
    
    /**
     * 执行查询语句
     * @param sql SQL查询语句
     * @return 查询结果集
     * @throws QueryExecutionException 查询执行失败时抛出
     */
    ResultSet executeQuery(String sql) throws QueryExecutionException;
    
    /**
     * 关闭数据库连接
     */
    void disconnect();
    
    /**
     * 获取数据库元数据（默认实现）
     * @return 数据库版本等信息
     */
    default String getDatabaseInfo() {
        return "Unknown database";
    }
}

对于Oracle数据库的实现，需要注意Oracle JDBC驱动的特殊性：

/**
 * Oracle数据库读取器
 * 需要添加Oracle JDBC驱动依赖
 */
public class OracleDataReader implements DataReader {
    private Connection connection;
    private static final String DRIVER = "oracle.jdbc.driver.OracleDriver";
    
    public OracleDataReader(String url, String username, String password) {
        // 实际项目中应该使用连接池，这里简化处理
        this.url = url;
        this.username = username;
        this.password = password;
    }
    
    @Override
    public void connect() throws DatabaseConnectionException {
        try {
            Class.forName(DRIVER);
            connection = DriverManager.getConnection(url, username, password);
            System.out.println("成功连接到Oracle数据库");
        } catch (ClassNotFoundException e) {
            throw new DatabaseConnectionException("找不到Oracle JDBC驱动", e);
        } catch (SQLException e) {
            throw new DatabaseConnectionException("Oracle数据库连接失败", e);
        }
    }
    
    @Override
    public ResultSet executeQuery(String sql) throws QueryExecutionException {
        try {
            Statement statement = connection.createStatement();
            return statement.executeQuery(sql);
        } catch (SQLException e) {
            throw new QueryExecutionException("Oracle查询执行失败: " + sql, e);
        }
    }
    
    @Override
    public void disconnect() {
        if (connection != null) {
            try {
                connection.close();
                System.out.println("已断开Oracle数据库连接");
            } catch (SQLException e) {
                System.err.println("关闭Oracle连接时出错: " + e.getMessage());
            }
        }
    }
    
    @Override
    public String getDatabaseInfo() {
        return "Oracle Database";
    }
}

SQLServer的实现类似，但有一些细节差异：

/**
 * SQLServer数据库读取器
 * 注意：SQLServer的JDBC URL格式与Oracle不同
 */
public class SQLServerDataReader implements DataReader {
    private Connection connection;
    private static final String DRIVER = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
    
    @Override
    public void connect() throws DatabaseConnectionException {
        try {
            Class.forName(DRIVER);
            // SQLServer的URL格式：jdbc:sqlserver://[serverName[\instanceName][:portNumber]]
            connection = DriverManager.getConnection(url, username, password);
            System.out.println("成功连接到SQLServer数据库");
        } catch (ClassNotFoundException e) {
            throw new DatabaseConnectionException("找不到SQLServer JDBC驱动", e);
        } catch (SQLException e) {
            throw new DatabaseConnectionException("SQLServer数据库连接失败", e);
        }
    }
    
    // ... 其他方法实现
}

3.2 抽象层：文件转换器

现在实现抽象层。我在这里使用了模板方法模式来定义固定的转换流程：

/**
 * 文件转换器抽象类
 * 使用模板方法定义转换流程
 */
public abstract class FileConverter {
    protected DataReader dataReader;
    protected String outputPath;
    
    public FileConverter(DataReader dataReader) {
        this.dataReader = dataReader;
    }
    
    /**
     * 模板方法：定义完整的转换流程
     * 这个方法被声明为final，防止子类修改流程
     */
    public final void convert(String query, String outputPath) {
        this.outputPath = outputPath;
        
        try {
            // 1. 连接数据库
            dataReader.connect();
            
            // 2. 执行查询
            System.out.println("执行查询: " + query);
            ResultSet resultSet = dataReader.executeQuery(query);
            
            // 3. 转换数据（由子类实现）
            convertResult(resultSet);
            
            // 4. 保存文件
            saveToFile();
            
            System.out.println("转换完成，文件保存至: " + outputPath);
            
        } catch (Exception e) {
            System.err.println("转换过程中出错: " + e.getMessage());
            e.printStackTrace();
        } finally {
            // 5. 断开连接
            dataReader.disconnect();
        }
    }
    
    /**
     * 将结果集转换为特定格式（抽象方法，由子类实现）
     */
    protected abstract void convertResult(ResultSet resultSet) throws SQLException;
    
    /**
     * 保存转换后的数据到文件（抽象方法，由子类实现）
     */
    protected abstract void saveToFile() throws IOException;
    
    /**
     * 公共工具方法：从ResultSet获取所有数据
     * 这个方法可以被所有子类复用
     */
    protected List<Map<String, Object>> extractData(ResultSet resultSet) throws SQLException {
        List<Map<String, Object>> data = new ArrayList<>();
        ResultSetMetaData metaData = resultSet.getMetaData();
        int columnCount = metaData.getColumnCount();
        
        while (resultSet.next()) {
            Map<String, Object> row = new LinkedHashMap<>();
            for (int i = 1; i <= columnCount; i++) {
                String columnName = metaData.getColum