MySQL异常处理实战：优化重复数据插入的逻辑处理

用户8589624

发布于 2025-11-15 17:52:24

1040

文章被收录于专栏：nginxnginx

MySQL异常处理实战：优化重复数据插入的逻辑处理

1. 引言

在数据库操作中，处理重复数据插入是一个常见的需求。特别是在批量插入数据时，可能会遇到主键冲突或唯一键冲突（Duplicate entry）的情况。如何优雅地捕获这类异常并执行相应的业务逻辑，是提高代码健壮性的关键。

本文将以一个实际的Python MySQL数据库操作为例，分析如何优化异常处理逻辑，使得当出现Duplicate entry错误时，能够执行特定的业务方法（如更新记录状态）。同时，我们也会对比Java中的类似处理方式，帮助读者更好地理解不同语言下的异常处理机制。

2. 问题背景

2.1 原始代码分析

原始代码的功能是批量插入手机号数据到MySQL数据库，其核心逻辑如下：

def insert_into_mysql(phone_numbers, prefix, province, city):
    try:
        connection = get_db_connection()
        cursor = connection.cursor()
        
        data_to_insert = []
        for phone_number in phone_numbers:
            if len(phone_number) == 11:
                suffix = phone_number[-4:]
                data_to_insert.append((prefix, suffix, phone_number, province, city))
        
        cursor.executemany(INSERT_QUERY, data_to_insert)
        connection.commit()
        return True
    
    except Exception as e:
        print(f"插入数据失败: {e}")
        if connection:
            connection.rollback()
        return False
    
    finally:
        if cursor:
            cursor.close()
        if connection:
            connection.close()

2.2 存在的问题

异常处理不够精细：仅打印错误信息并回滚，没有针对特定错误（如Duplicate entry）进行特殊处理。
业务逻辑耦合度低：当数据重复时，可能需要执行额外操作（如更新记录状态），但原始代码没有提供这样的扩展点。

3. 优化方案

3.1 目标

捕获特定异常：当错误信息包含Duplicate entry时，执行额外逻辑（如调用update_is_deal方法）。
保持代码健壮性：确保事务回滚和资源释放不受影响。

3.2 优化后的Python代码

def insert_into_mysql(phone_numbers, prefix, province, city, url=None):
    connection = None
    cursor = None
    try:
        connection = get_db_connection()
        if not connection:
            print("数据库连接失败")
            return False

        cursor = connection.cursor()
        data_to_insert = []
        
        for phone_number in phone_numbers:
            if len(phone_number) == 11:
                suffix = phone_number[-4:]
                data_to_insert.append((prefix, suffix, phone_number, province, city))

        if not data_to_insert:
            print("警告: 没有有效的手机号可插入")
            return False

        cursor.executemany(INSERT_QUERY, data_to_insert)
        connection.commit()
        print(f"成功插入 {len(data_to_insert)} 条数据")
        return True

    except Exception as e:
        print(f"插入数据失败: {e}")
        if connection:
            connection.rollback()
        
        # 检查是否是唯一键冲突
        if "Duplicate entry" in str(e):
            if url:  # 确保url有效
                update_is_deal(url, province, city)  # 执行额外逻辑
        
        return False
    
    finally:
        if cursor:
            cursor.close()
        if connection:
            connection.close()

3.3 关键优化点

精细化异常捕获：通过检查异常信息是否包含"Duplicate entry"，判断是否为唯一键冲突。
支持额外参数：新增url参数，确保update_is_deal方法可以正确执行。
事务安全：即使执行额外逻辑，仍然保证事务回滚和资源释放。

4. Java对比实现

在Java中，MySQL的Duplicate entry错误通常对应SQLIntegrityConstraintViolationException，我们可以采用类似的优化策略。

4.1 Java版本优化代码

import java.sql.*;
import java.util.List;

public class PhoneNumberDao {
    private static final String INSERT_QUERY = 
        "INSERT INTO phone_numbers (prefix, suffix, phone_number, province, city) " +
        "VALUES (?, ?, ?, ?, ?)";

    public boolean insertIntoMysql(List<String> phoneNumbers, String prefix, 
                                  String province, String city, String url) {
        Connection connection = null;
        PreparedStatement statement = null;
        
        try {
            connection = DatabaseUtil.getConnection(); // 获取数据库连接
            connection.setAutoCommit(false); // 开启事务
            
            statement = connection.prepareStatement(INSERT_QUERY);
            
            for (String phoneNumber : phoneNumbers) {
                if (phoneNumber.length() == 11) {
                    String suffix = phoneNumber.substring(7); // 后4位
                    statement.setString(1, prefix);
                    statement.setString(2, suffix);
                    statement.setString(3, phoneNumber);
                    statement.setString(4, province);
                    statement.setString(5, city);
                    statement.addBatch(); // 加入批处理
                }
            }
            
            statement.executeBatch(); // 执行批处理
            connection.commit(); // 提交事务
            return true;
            
        } catch (SQLIntegrityConstraintViolationException e) {
            // 捕获唯一键冲突异常
            System.err.println("插入数据失败（唯一键冲突）: " + e.getMessage());
            if (connection != null) {
                try {
                    connection.rollback(); // 回滚事务
                } catch (SQLException ex) {
                    ex.printStackTrace();
                }
            }
            
            if (url != null) {
                updateIsDeal(url, province, city); // 执行额外逻辑
            }
            return false;
            
        } catch (SQLException e) {
            System.err.println("插入数据失败: " + e.getMessage());
            if (connection != null) {
                try {
                    connection.rollback();
                } catch (SQLException ex) {
                    ex.printStackTrace();
                }
            }
            return false;
            
        } finally {
            // 关闭资源
            try {
                if (statement != null) statement.close();
                if (connection != null) connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    private void updateIsDeal(String url, String province, String city) {
        // 实现更新逻辑
        System.out.println("检测到重复数据，更新状态: " + url);
    }
}

4.2 Java优化点

精准捕获SQLIntegrityConstraintViolationException，而不是笼统的SQLException。
批处理优化：使用addBatch()和executeBatch()提高插入效率。
事务管理：显式控制commit()和rollback()，确保数据一致性。

5. 总结与最佳实践

5.1 关键总结

优化点	Python 实现	Java 实现
异常捕获	检查str(e)是否包含"Duplicate entry"	捕获SQLIntegrityConstraintViolationException
事务管理	connection.rollback()	connection.rollback()
资源释放	finally块关闭连接	finally块关闭资源
批处理优化	cursor.executemany()	addBatch() + executeBatch()

5.2 最佳实践

精细化异常处理：不要仅捕获Exception，而应根据业务需求区分不同错误类型。
事务安全：确保异常发生时能正确回滚，避免脏数据。
资源释放：使用try-finally或try-with-resources（Java）确保数据库连接关闭。
日志记录：在异常处理时记录足够的信息，便于排查问题。

6. 扩展思考

是否应该先查询再插入？
- 如果数据量较大，先查询再插入可能影响性能，直接捕获Duplicate entry更高效。
如何优化update_is_deal逻辑？
- 可以引入异步处理（如消息队列），避免影响主流程性能。
是否可以用INSERT IGNORE或ON DUPLICATE KEY UPDATE？
- 取决于业务需求，如果需要静默忽略重复数据，可以使用这些SQL语法。