MySQL驱动程序详解：连接、性能与安全配置

1. MySQL驱动程序概述

MySQL驱动程序是连接应用程序与MySQL数据库的桥梁，它实现了数据库通信协议，使开发者能够用各种编程语言操作MySQL数据库。作为数据库生态中的关键组件，驱动程序的选择直接影响应用的性能、稳定性和安全性。

目前主流的MySQL驱动程序包括：

• JDBC驱动：Java应用的标配，支持连接池和事务管理
• ODBC驱动：跨平台通用接口，适合Windows生态
• .NET驱动：微软技术栈的官方选择
• 原生驱动：如PHP的mysqli、Python的mysql-connector

注意：驱动程序版本必须与MySQL服务器版本兼容，否则可能出现连接失败或功能异常。建议优先选择MySQL官方维护的驱动。

2. 核心驱动程序解析

2.1 JDBC驱动详解

MySQL Connector/J是官方JDBC实现，最新版本(8.0+)主要特性：

• 支持全部MySQL 8.0功能（如窗口函数、JSON操作）
• 默认使用更安全的X协议通信
• 改进的连接池实现（兼容HikariCP等主流池化方案）

典型连接配置示例：

java复制String url = "jdbc:mysql://localhost:3306/mydb?useSSL=false&serverTimezone=UTC";
Properties props = new Properties();
props.setProperty("user", "root");
props.setProperty("password", "secret");
Connection conn = DriverManager.getConnection(url, props);

2.2 ODBC驱动配置要点

MySQL Connector/ODBC在Windows环境下的安装注意事项：

1. 区分32位/64位版本
2. 安装后需在"ODBC数据源管理器"配置DSN
3. 推荐启用"Enable Dynamic Loading"提升性能

连接字符串示例：

code复制Driver={MySQL ODBC 8.0 Unicode Driver};Server=localhost;Database=mydb;User=root;Password=secret;Option=3;

2.3 各语言驱动性能对比

测试环境：MySQL 8.0.32, 16核CPU/32GB内存

3. 驱动安装与安全配置

3.1 安装最佳实践

Linux系统安装JDBC驱动：

bash复制# Debian/Ubuntu
sudo apt-get install libmysql-java

# 手动安装
wget https://dev.mysql.com/get/Downloads/Connector-J/mysql-connector-j-8.0.33.tar.gz
tar -xzf mysql-connector-j-8.0.33.tar.gz
sudo cp mysql-connector-j-8.0.33/mysql-connector-j-8.0.33.jar /usr/share/java/

Windows系统常见问题处理：

• 驱动程序签名验证失败：在设备管理器右键驱动→属性→数字签名→安装证书
• 版本冲突：彻底卸载旧版驱动后再安装新版

3.2 安全加固方案

1. 加密连接配置：

   • 必须启用SSL/TLS（useSSL=true）
   • 推荐配置证书验证（verifyServerCertificate=true）

2. 权限最小化原则：

   sql复制CREATE USER 'appuser'@'%' IDENTIFIED BY 'complex_password';
   GRANT SELECT, INSERT ON mydb.* TO 'appuser'@'%';
   

3. 防注入措施：

   • 所有驱动都必须使用参数化查询
   • 禁止拼接SQL语句

4. 性能调优实战

4.1 连接池配置

HikariCP推荐配置（适用于JDBC）：

java复制HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
config.setUsername("user");
config.setPassword("password");
config.setMaximumPoolSize(20);
config.setConnectionTimeout(30000);
config.setIdleTimeout(600000);
config.setMaxLifetime(1800000);
config.addDataSourceProperty("cachePrepStmts", "true");
config.addDataSourceProperty("prepStmtCacheSize", "250");
config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");

4.2 批量操作优化

使用JDBC批量插入的两种方式对比：

Statement方式：

java复制Statement stmt = conn.createStatement();
stmt.addBatch("INSERT INTO users VALUES(1, 'Alice')");
stmt.addBatch("INSERT INTO users VALUES(2, 'Bob')");
int[] counts = stmt.executeBatch();

PreparedStatement方式（推荐）：

java复制PreparedStatement pstmt = conn.prepareStatement("INSERT INTO users VALUES(?, ?)");
pstmt.setInt(1, 1);
pstmt.setString(2, "Alice");
pstmt.addBatch();

pstmt.setInt(1, 2);
pstmt.setString(2, "Bob");
pstmt.addBatch();

int[] counts = pstmt.executeBatch();

测试表明PreparedStatement方式比Statement快3-5倍，且更安全。

5. 故障排查手册

5.1 常见错误代码处理

5.2 连接泄漏检测

Java应用检测方法：

1. 添加JVM参数：-Dcom.mysql.jdbc.traceProtocol=true
2. 使用JDBC拦截器记录连接生命周期
3. 定期检查SHOW PROCESSLIST输出

Python示例（使用连接池）：

python复制import mysql.connector
from mysql.connector import pooling

dbconfig = {
  "host":"localhost",
  "user":"root",
  "password":"secret",
  "database":"mydb"
}

connection_pool = pooling.MySQLConnectionPool(
  pool_name="mypool",
  pool_size=5,
  **dbconfig
)

# 获取连接时必须使用with语句
with connection_pool.get_connection() as conn:
    cursor = conn.cursor()
    cursor.execute("SELECT * FROM users")
    for row in cursor:
        print(row)

6. 多版本兼容策略

6.1 驱动与MySQL版本匹配

6.2 降级兼容方案

当必须使用旧版驱动连接新版MySQL时：

1. 在MySQL配置中添加：

   ini复制[mysqld]
   default_authentication_plugin=mysql_native_password
   

2. 连接字符串添加：

   code复制allowPublicKeyRetrieval=true&useSSL=false
   

3. 用户密码策略修改：

   sql复制ALTER USER 'username'@'host' IDENTIFIED WITH mysql_native_password BY 'password';
   

7. 高级特性应用

7.1 读写分离实现

使用JDBC驱动配置多数据源：

java复制@Configuration
public class DataSourceConfig {
    
    @Bean
    @Primary
    public DataSource masterDataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://master:3306/mydb");
        return new HikariDataSource(config);
    }
    
    @Bean
    public DataSource slaveDataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://slave:3306/mydb");
        return new HikariDataSource(config);
    }
}

7.2 分布式事务处理

基于XA协议的实现示例：

java复制// 获取XA连接
XADataSource xaDataSource = new MysqlXADataSource();
xaDataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
XAConnection xaCon = xaDataSource.getXAConnection("user", "pwd");
XAResource xaRes = xaCon.getXAResource();

// 开始事务
Xid xid = new MyXid(100, new byte[]{0x01}, new byte[]{0x02});
xaRes.start(xid, XAResource.TMNOFLAGS);

// 执行SQL
Connection conn = xaCon.getConnection();
PreparedStatement ps = conn.prepareStatement("UPDATE accounts SET balance=? WHERE id=?");
ps.setBigDecimal(1, new BigDecimal("100.00"));
ps.setInt(2, 1);
ps.executeUpdate();

// 提交事务
xaRes.end(xid, XAResource.TMSUCCESS);
int ret = xaRes.prepare(xid);
if (ret == XAResource.XA_OK) {
    xaRes.commit(xid, false);
}

8. 监控与诊断

8.1 驱动级监控指标

关键监控项包括：

• 连接获取时间
• 执行中查询数量
• 连接池使用率
• 平均查询耗时

Prometheus配置示例：

yaml复制- pattern: 'com.mysql.cj.jdbc.ConnectionImpl.<init>(..)'
  name: 'mysql_connection_create'
  help: 'MySQL connection creation'
  labels:
    pool: '$1'
- pattern: 'com.mysql.cj.jdbc.StatementImpl.executeQuery(..)'
  name: 'mysql_query_execute'
  help: 'MySQL query execution'
  labels:
    query: '$1'

8.2 慢查询日志分析

在驱动端启用执行时间记录：

java复制// JDBC配置
String url = "jdbc:mysql://localhost:3306/mydb?profileSQL=true&logger=Slf4JLogger";

// 日志输出示例
[DEBUG] Executing: SELECT * FROM large_table
[DEBUG] Execution time: 2456ms

9. 替代方案评估

9.1 不同驱动技术对比

9.2 连接池选型建议

1. HikariCP：Spring Boot默认选择，极致性能
2. Druid：阿里开源，带监控功能
3. Tomcat JDBC：适合嵌入式场景
4. C3P0：老牌稳定，但性能较差

配置示例（Druid）：

java复制@Bean
public DataSource dataSource() {
    DruidDataSource ds = new DruidDataSource();
    ds.setUrl("jdbc:mysql://localhost:3306/mydb");
    ds.setUsername("user");
    ds.setPassword("pwd");
    ds.setInitialSize(5);
    ds.setMaxActive(20);
    ds.setTimeBetweenEvictionRunsMillis(60000);
    ds.setMinEvictableIdleTimeMillis(300000);
    return ds;
}

10. 实际案例分享

10.1 电商系统优化实践

某电商平台使用MySQL Connector/J 8.0后：

• 查询延迟从120ms降至45ms
• 连接池效率提升40%
• 内存占用减少25%

关键优化点：

1. 启用prepareStatement缓存
2. 配置合理的fetchSize（100-500）
3. 使用ServerPreparedStatement减少网络往返

10.2 金融系统容灾方案

某银行系统采用多驱动冗余设计：

• 主链路：JDBC + HikariCP
• 备链路：ODBC + Windows连接池
• 自动切换机制：当JDBC连接失败时自动尝试ODBC

切换逻辑实现：

java复制public Connection getFailoverConnection() throws SQLException {
    try {
        return jdbcPool.getConnection(); // 首选JDBC
    } catch (SQLException e) {
        log.warn("JDBC连接失败，尝试ODBC");
        return odbcDataSource.getConnection(); // 降级到ODBC
    }
}

11. 未来演进方向

MySQL驱动技术的最新发展趋势：

1. 异步驱动：支持非阻塞IO（如MySQL Connector/J的异步模式）
2. 云原生适配：优化Kubernetes环境下的连接管理
3. 智能路由：基于负载自动选择主从节点
4. 协议压缩：减少网络传输量

异步查询示例（Connector/J 8.0+）：

java复制CompletableFuture<ResultSet> future = CompletableFuture.supplyAsync(() -> {
    try {
        Statement stmt = conn.createStatement();
        return stmt.executeQuery("SELECT * FROM large_table");
    } catch (SQLException e) {
        throw new CompletionException(e);
    }
});

future.thenAccept(rs -> {
    try {
        while (rs.next()) {
            System.out.println(rs.getString(1));
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
});

12. 开发注意事项

12.1 资源释放规范

必须遵循的释放顺序：

1. ResultSet
2. Statement/PreparedStatement
3. Connection

正确示例：

java复制try (Connection conn = dataSource.getConnection();
     PreparedStatement pstmt = conn.prepareStatement("SELECT * FROM users");
     ResultSet rs = pstmt.executeQuery()) {
    while (rs.next()) {
        // 处理结果
    }
} // 自动关闭所有资源

12.2 数据类型映射

常见类型处理建议：

• BLOB：使用流式处理避免内存溢出
• DATETIME：明确指定时区参数
• DECIMAL：避免使用float/double接收

最佳实践：

java复制PreparedStatement pstmt = conn.prepareStatement("INSERT INTO docs VALUES(?,?)");
File file = new File("large.pdf");
try (InputStream is = new FileInputStream(file)) {
    pstmt.setInt(1, 1);
    pstmt.setBinaryStream(2, is, (int)file.length());
    pstmt.executeUpdate();
}

13. 性能测试方法论

13.1 基准测试指标

关键测试场景：

1. 连接建立耗时
2. 简单查询吞吐量
3. 大结果集传输效率
4. 并发连接稳定性

JMeter测试配置示例：

xml复制<JDBCConnectionConfiguration 
  poolName="MySQLPool"
  connectionUrl="jdbc:mysql://localhost:3306/test"
  driverClass="com.mysql.cj.jdbc.Driver"
  username="test"
  password="test123"
  poolMax="50"
  transactionIsolation="DEFAULT"
  preinit="true"/>

13.2 真实场景模拟

典型压力测试方案：

1. 70%简单点查询
2. 20%更新操作
3. 10%复杂联表查询
4. 随机间隔（100-500ms）模拟用户思考时间

执行脚本示例：

sql复制-- 预热
SELECT * FROM small_table WHERE id < 100;

-- 正式测试
START TRANSACTION;
UPDATE accounts SET balance=balance-100 WHERE user_id=1;
UPDATE accounts SET balance=balance+100 WHERE user_id=2;
COMMIT;

-- 复杂查询
EXPLAIN ANALYZE SELECT * FROM orders o 
JOIN users u ON o.user_id=u.id 
WHERE o.create_time > NOW() - INTERVAL 30 DAY;

14. 安全审计要点

14.1 驱动漏洞扫描

重点检查项：

1. CVE历史漏洞（如CVE-2022-21363）
2. 加密协议支持情况
3. 默认配置安全性

检测命令示例：

bash复制# 检查驱动版本漏洞
mysql-connector-j --version | grep -E '8.0.2[0-6]' && echo "存在漏洞"

# SSL配置检查
openssl s_client -connect dbhost:3306 -tls1_2 | grep "Certificate chain"

14.2 权限最小化实践

推荐权限矩阵：

创建受限用户示例：

sql复制CREATE USER 'reports'@'%' IDENTIFIED BY 'R3port$2023';
GRANT SELECT ON analytics.* TO 'reports'@'%';
REVOKE ALL PRIVILEGES, GRANT OPTION FROM 'reports'@'%';

15. 云环境适配

15.1 公有云连接优化

AWS RDS最佳配置：

java复制String url = "jdbc:mysql://mydb.123456789012.us-east-1.rds.amazonaws.com:3306/mydb";
url += "?useSSL=true&requireSSL=true";
url += "&socketFactory=com.amazonaws.rds.jdbc.mysql.DriverSocketFactory";
url += "&cloudInstanceIdentifier=my-db-instance";

15.2 连接保持策略

应对云数据库超时断开：

1. 配置连接测试查询：

   java复制config.setConnectionTestQuery("SELECT 1");
   config.setTestOnBorrow(true);
   

2. 设置合理超时：

   ini复制wait_timeout=28800
   interactive_timeout=28800
   

3. 客户端心跳机制：

   java复制config.addDataSourceProperty("socketTimeout", "30000");
   config.addDataSourceProperty("keepaliveTime", "60000");
   

16. 驱动开发进阶

16.1 自定义驱动实现

扩展JDBC驱动的基本步骤：

1. 继承NonRegisteringDriver
2. 实现Connection接口
3. 注册驱动类：

   java复制java.sql.DriverManager.registerDriver(new MyCustomDriver());
   

核心方法重写示例：

java复制public class MyDriver extends NonRegisteringDriver implements Driver {
    static {
        try {
            DriverManager.registerDriver(new MyDriver());
        } catch (SQLException e) {
            throw new RuntimeException("Can't register driver");
        }
    }
    
    @Override
    public Connection connect(String url, Properties info) throws SQLException {
        if (!acceptsURL(url)) return null;
        return new MyConnection(url, info);
    }
}

16.2 协议分析工具

使用Wireshark捕获MySQL协议：

1. 过滤条件：tcp.port == 3306
2. 解析配置：编辑→首选项→Protocols→MySQL
3. 关键字段分析：
   • Client Capabilities
   • Server Status Flags
   • Query Command Type

典型协议交互流程：

code复制Client → Server: Handshake Response
Server → Client: OK Packet
Client → Server: COM_QUERY("SELECT...")
Server → Client: Resultset

17. 多语言生态支持

17.1 Python连接方案

推荐驱动选择：

1. mysql-connector-python：Oracle官方维护
2. PyMySQL：纯Python实现
3. MySQLdb：C扩展，性能最佳

性能对比（1000次简单查询）：

连接池实现示例（使用DBUtils）：

python复制from dbutils.pooled_db import PooledDB
import mysql.connector

pool = PooledDB(
    creator=mysql.connector,
    host='localhost',
    user='root',
    password='secret',
    database='mydb',
    maxconnections=10,
    blocking=True
)

conn = pool.connection()
cursor = conn.cursor()
cursor.execute("SELECT * FROM users")
print(cursor.fetchall())
conn.close()

17.2 Node.js连接方案

常用驱动对比：

TypeScript连接示例：

typescript复制import { createPool } from 'mysql2/promise';

const pool = createPool({
  host: 'localhost',
  user: 'root',
  password: 'secret',
  database: 'mydb',
  waitForConnections: true,
  connectionLimit: 10,
  queueLimit: 0
});

async function queryUsers() {
  const [rows] = await pool.query('SELECT * FROM users LIMIT 10');
  console.log(rows);
}

18. 监控与调优工具

18.1 驱动级监控方案

Java应用监控配置：

1. 添加JMX支持：

   java复制config.addDataSourceProperty("useJMX", "true");
   

2. 关键监控指标：
   • ActiveConnections
   • IdleConnections
   • ConnectionCreationTime

Prometheus监控示例：

yaml复制- pattern: 'com.mysql.cj.jdbc.ConnectionImpl.<init>(.*)'
  name: 'mysql_connection_create'
  help: 'MySQL connection creation time'
  labels:
    pool: '$1'
  value: '$2'

18.2 慢查询分析技巧

在驱动端启用详细日志：

properties复制# log4j.properties
log4j.logger.com.mysql.cj=DEBUG
log4j.logger.com.mysql.cj.jdbc.resultset=WARN

典型慢查询日志分析：

code复制DEBUG [main] (BaseStatement.java:123) - Executing: SELECT * FROM large_table
DEBUG [main] (BaseStatement.java:456) - Execution time: 2345ms
WARN  [main] (SlowQueryLogger.java:89) - Slow query detected: 
  SQL: SELECT * FROM large_table
  Time: 2345ms
  Parameters: []

19. 最佳实践总结

19.1 配置检查清单

生产环境必须验证的项目：

1. [ ] 连接加密（SSL/TLS）已启用
2. [ ] 连接池大小设置合理
3. [ ] 自动重连机制配置
4. [ ] SQL注入防护措施到位
5. [ ] 驱动版本无已知漏洞

19.2 性能优化黄金法则

1. 连接管理：

   • 使用连接池（推荐HikariCP）
   • 设置合理的超时时间
   • 配置连接测试查询

2. 查询优化：

   • 始终使用PreparedStatement
   • 合理设置fetchSize
   • 启用批处理模式

3. 资源控制：

   • 限制最大连接数
   • 监控连接泄漏
   • 及时释放ResultSet

20. 版本升级指南

20.1 从5.1升级到8.0

关键变更点处理：

1. 时区问题：

   java复制// 旧版
   jdbc:mysql://localhost:3306/db
   // 新版必须指定
   jdbc:mysql://localhost:3306/db?serverTimezone=UTC
   

2. 认证插件变更：

   sql复制ALTER USER 'user'@'host' IDENTIFIED WITH mysql_native_password BY 'password';
   

3. API废弃：
   • 移除loadBalanceAutoCommitStatementThreshold
   • 变更useCursorFetch默认值

20.2 兼容性测试方案

升级验证步骤：

1. 功能测试：

   bash复制mvn test -Dtest=com.myapp.dao.*Test
   

2. 性能基准：

   bash复制jmeter -n -t mysql-perf.jmx -l result.jtl
   

3. 长时间稳定性：

   bash复制stressapptest -M 4096 -s 86400
   

21. 异常处理规范

21.1 错误分类处理

21.2 重试机制实现

智能重试示例（Java）：

java复制public <T> T executeWithRetry(Callable<T> task, int maxRetries) throws Exception {
    int retryCount = 0;
    while (true) {
        try {
            return task.call();
        } catch (SQLTransientException e) {
            if (retryCount++ >= maxRetries) throw e;
            Thread.sleep(100 * (1 << retryCount)); // 指数退避
        }
    }
}

22. 架构设计建议

22.1 高可用设计方案

推荐架构模式：

code复制                   +-----------------+
                   |   Load Balancer |
                   +--------+--------+
                            |
           +----------------+----------------+
           |                |                |
+----------+-------+ +------+--------+ +-----+----------+
|  Primary MySQL   | |  Replica 1    | |  Replica 2     |
| (Master)         | | (Read Only)   | | (Read Only)    |
+------------------+ +---------------+ +----------------+

驱动层配置要点：

1. 读写分离路由
2. 故障自动检测
3. 拓扑自动发现

22.2 微服务集成模式

Spring Cloud方案示例：

yaml复制# application.yml
spring:
  datasource:
    url: jdbc:mysql://${DB_HOST:localhost}:3306/mydb
    hikari:
      maximum-pool-size: 20
      connection-timeout: 30000
  cloud:
    circuitbreaker:
      hystrix:
        enabled: true
    loadbalancer:
      configurations: mysql-cluster

23. 安全加固进阶

23.1 证书双向验证

配置步骤：

1. 生成客户端证书：

   bash复制openssl req -newkey rsa:2048 -nodes -keyout client-key.pem -out client-req.pem
   openssl x509 -req -in client-req.pem -CA ca.pem -CAkey ca-key.pem -set_serial 01 -out client-cert.pem
   

2. MySQL服务器配置：

   ini复制[mysqld]
   ssl-ca=ca.pem
   ssl-cert=server-cert.pem
   ssl-key=server-key.pem
   require_secure_transport=ON
   

3. JDBC连接字符串：

   code复制jdbc:mysql://host/db?verifyServerCertificate=true&useSSL=true&requireSSL=true&clientCertificateKeyStoreUrl=file:client-keystore.jks&clientCertificateKeyStorePassword=secret
   

23.2 审计日志集成

使用驱动拦截器记录操作：

java复制public class AuditInterceptor implements StatementInterceptorV2 {
    @Override
    public <T extends Resultset> T postProcess(String sql, Statement interceptedStatement, T originalResultSet, 
            Connection connection, int warningCount, boolean noIndexUsed, boolean noGoodIndexUsed, 
            Exception statementException) throws SQLException {
        auditService.logQuery(sql, connection.getCatalog());
        return originalResultSet;
    }
}

注册拦截器：

java复制Properties props = new Properties();
props.setProperty("statementInterceptors", "com.example.AuditInterceptor");
Connection conn = DriverManager.getConnection(url, props);

24. 云原生适配方案

24.1 Kubernetes服务发现

StatefulSet连接示例：

java复制String host = "${MYSQL_SERVICE_HOST}";
String port = "${MYSQL_SERVICE_PORT}";
String url = "jdbc:mysql://" + host + ":" + port + "/mydb";

24.2 服务网格集成

Istio Sidecar配置：

yaml复制apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: mysql
spec:
  host: mysql.default.svc.cluster.local
  trafficPolicy:
    tls:
      mode: ISTIO_MUTUAL
    connectionPool:
      tcp: 
        maxConnections: 100
        connectTimeout: 30ms
      http: {}

25. 测试驱动开发

25.1 单元测试方案

使用TestContainers的MySQL测试：

java复制@Testcontainers
public class UserDaoTest {
    @Container
    private static final MySQLContainer<?> mysql = new MySQLContainer<>("mysql:8.0");

    @BeforeAll
    static void setup() {
        String jdbcUrl = mysql.getJdbcUrl();
        String username = mysql.getUsername();
        String password = mysql.getPassword();
        // 初始化数据源
    }

    @Test
    void testFindUser() {
        User user = userDao.findById(1);
        assertNotNull(user);
    }
}

25.2 集成测试策略

分层测试方案：

1. 单元测试：Mock驱动层
2. 集成测试：真实数据库连接
3. 性能测试：生产级数据量
4. 故障测试：网络分区、节点宕机

测试数据管理：

java复制@Sql(scripts = "/test-data.sql")
@Transactional
public class UserServiceIT {
    @Autowired
    private UserService userService;

    @Test
    void testComplexQuery() {
        List<User> users = userService.findActiveUsers();
        assertEquals(10, users.size());
    }
}

26. 驱动内部原理

26.1 协议解析流程

MySQL协议工作流程：

1. 握手阶段：
   • 客户端发送能力标志
   • 服务端返回认证方法
2. 命令阶段：
   • COM_QUERY执行SQL
   • COM_STMT_PREPARE预处理
3. 结果集传输：
   • 列定义包
   • 行数据包
   • EOF包结束

26.2 连接建立机制

TCP连接建立过程：

1. 三次握手建立TCP连接
2. 服务端发送初始握手包
3. 客户端响应认证信息
4. 服务端返回OK/ERROR

超时控制要点：

• connectTimeout：TCP连接超时
• socketTimeout：网络读写超时
• loginTimeout：认证阶段超时

27. 定制化开发

27.1 协议扩展实现

自定义命令示例：

java复制public class MyCommand extends Command {
    private byte[] payload;
    
    public MyCommand(byte[] payload) {
        this.payload = payload;
    }
    
    @Override
    public void send(BufferWriter writer) {
        writer.write(payload);
    }
}

// 使用自定义命令
session.getProtocol().sendCommand(new MyCommand(customData), false);

27.2 结果集处理优化

流式结果集实现：

java复制public class StreamingResultSet extends ResultsetImpl {
    @Override
    public boolean next() throws SQLException {
        // 从网络直接读取单行数据
        if (!this.nextRowStreaming) {
            this.row = this.protocol.read(ResultsetRow.class);
        }
        return this.row != null;
    }
}

28. 多数据源管理

28.1 动态路由实现

AbstractRoutingDataSource配置：

java复制@Bean
public DataSource dataSource() {
    Map<Object, Object> targetDataSources = new HashMap<>();
    targetDataSources.put("master", masterDataSource());
    targetDataSources.put("replica", replicaDataSource());
    
    AbstractRoutingDataSource routingDataSource = new AbstractRoutingDataSource() {
        @Override
        protected Object determineCurrentLookupKey() {
            return isReadOnlyTransaction() ? "replica" : "master";
        }
    };
    
    routingDataSource.setTargetDataSources(targetDataSources);
    routingDataSource.setDefaultTargetDataSource(masterDataSource());
    return routingDataSource;
}

28.2 分库分表集成

ShardingSphere配置示例：

yaml复制spring:
  shardingsphere:
    datasource:
      names: ds0,ds1
      ds0:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://localhost:3306/db0
        username: root
        password: 
      ds1:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://localhost:3306/db1
        username: root
        password: 
    sharding:
      tables:
        t_order:
          actual-data-nodes: ds$->{0..1}.t_order_$->{0..15}
          table-strategy:
            inline:
              sharding-column: order_id
              algorithm-expression: t_order_$->{order_id % 16}
          database-strategy:
            inline:
              sharding-column: user_id
              algorithm-expression: ds$->{user_id % 2}

29. 数据迁移方案

29.1 在线迁移工具

使用MySQL Shell的util工具：

javascript复制// 导出元数据
util.dumpInstance("/backup", {dryRun: true})

// 并行导入
util.loadDump("/backup", {threads: 8})

29.2 驱动级增量同步

基于binlog的CDC实现：

java复制BinaryLogClient client = new BinaryLogClient("host", 3306, "user", "password");
client.registerEventListener(event -> {
    if (event instanceof WriteRowsEventData) {
        WriteRowsEventData data = (WriteRowsEventData) event;
        // 处理插入事件
    } else if (event instanceof UpdateRowsEventData) {
        UpdateRowsEventData data = (UpdateRowsEventData) event;
        // 处理更新事件
    }
});
client.connect();

30. 性能