一、高并发注册的噩梦

公司APP正在做推广活动，用户注册量激增，每秒有上千个注册请求。问题也随之而来：

• 重复注册：同一个用户账号被注册了多次
• 数据不一致：用户表中有大量重复的邮箱和手机号
• 性能下降：注册接口的响应时间从100ms飙升到了500ms以上
• 数据库压力：MySQL的CPU使用率居高不下

已经在代码里做了查重逻辑，但高并发下还是会出现重复注册。"这样的场景，作为后端开发的你，是不是也遇到过？

二、传统方案的局限性

为了防止重复注册，我们通常会使用以下方案：

1. 查询后插入

// 1. 先查询用户是否存在User existUser = userRepository.findByUsername(username);if (existUser != null) {    throw new RuntimeException("用户名已存在");}// 2. 如果不存在，则插入新用户User newUser = new User();newUser.setUsername(username);userRepository.save(newUser);

这种方案的问题：

• 并发问题 ：两个线程同时查询，都发现用户不存在，然后都插入，导致重复注册
• 性能问题 ：需要两次数据库操作（一次查询，一次插入）
• 死锁风险 ：在高并发下，查询和插入之间可能产生死锁

2. 分布式锁

// 1. 获取分布式锁String lockKey = "register:lock:" + username;boolean locked = redisTemplate.opsForValue().setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS);if (!locked) {    thrownew RuntimeException("操作频繁，请稍后再试");}try {    // 2. 查询用户是否存在    User existUser = userRepository.findByUsername(username);    if (existUser != null) {        thrownew RuntimeException("用户名已存在");    }        // 3. 插入新用户    User newUser = new User();    newUser.setUsername(username);    userRepository.save(newUser);} finally {    // 4. 释放分布式锁    redisTemplate.delete(lockKey);}

这种方案的问题：

• 性能开销 ：需要额外的Redis操作，增加了网络开销
• 锁竞争 ：高并发下，大量线程竞争同一个锁，导致性能下降
• 锁超时 ：如果锁超时时间设置不当，可能导致死锁或重复注册
• 系统复杂度 ：需要维护Redis集群，增加了系统复杂度

3. 数据库唯一索引

CREATE TABLE`user` (`id`bigint(20) NOTNULL AUTO_INCREMENT,`username`varchar(50) NOTNULL,`email`varchar(100) NOTNULL,`phone`varchar(20) NOTNULL,  PRIMARY KEY (`id`),UNIQUEKEY`uk_username` (`username`),UNIQUEKEY`uk_email` (`email`),UNIQUEKEY`uk_phone` (`phone`)) ENGINE=InnoDBDEFAULTCHARSET=utf8mb4;

这种方案的问题：

• 异常处理 ：插入重复数据时，会抛出数据库异常，需要捕获和处理
• 用户体验差 ：用户需要等待整个插入操作完成后才知道重复，体验不好
• 事务回滚 ：如果在事务中插入重复数据，整个事务会回滚

三、终极方案：唯一索引 + ON DUPLICATE KEY

今天，我要和大家分享一个在实战中验证过的解决方案： SpringBoot + MySQL 唯一索引 + ON DUPLICATE KEY 。

这套方案的核心思想是：

1. 唯一索引 ：在用户名、邮箱、手机号等字段上创建唯一索引，保证数据的唯一性
2. ON DUPLICATE KEY ：使用MySQL的INSERT ... ON DUPLICATE KEY UPDATE语法，实现原子性的插入或更新操作
3. 性能优化 ：减少数据库操作次数，提高并发性能

四、方案详解

1. 数据库设计

（1）用户表设计

CREATE TABLE`user` (`id`bigint(20) NOTNULL AUTO_INCREMENT COMMENT'用户ID',`username`varchar(50) NOTNULLCOMMENT'用户名',`password`varchar(100) NOTNULLCOMMENT'密码',`email`varchar(100) NOTNULLCOMMENT'邮箱',`phone`varchar(20) NOTNULLCOMMENT'手机号',`nickname`varchar(50) DEFAULTNULLCOMMENT'昵称',`avatar`varchar(200) DEFAULTNULLCOMMENT'头像',`status`tinyint(4) NOTNULLDEFAULT'0'COMMENT'状态：0-未激活，1-已激活，2-已禁用',`create_time` datetime NOTNULLDEFAULTCURRENT_TIMESTAMPCOMMENT'创建时间',`update_time` datetime NOTNULLDEFAULTCURRENT_TIMESTAMPONUPDATECURRENT_TIMESTAMPCOMMENT'更新时间',  PRIMARY KEY (`id`),UNIQUEKEY`uk_username` (`username`) COMMENT'用户名唯一索引',UNIQUEKEY`uk_email` (`email`) COMMENT'邮箱唯一索引',UNIQUEKEY`uk_phone` (`phone`) COMMENT'手机号唯一索引',KEY`idx_create_time` (`create_time`) COMMENT'创建时间索引') ENGINE=InnoDBDEFAULTCHARSET=utf8mb4 COMMENT='用户表';

（2）注册日志表设计

CREATE TABLE`register_log` (`id`bigint(20) NOTNULL AUTO_INCREMENT COMMENT'日志ID',`username`varchar(50) DEFAULTNULLCOMMENT'用户名',`email`varchar(100) DEFAULTNULLCOMMENT'邮箱',`phone`varchar(20) DEFAULTNULLCOMMENT'手机号',`ip`varchar(50) DEFAULTNULLCOMMENT'IP地址',`status`tinyint(4) NOTNULLCOMMENT'状态：0-失败，1-成功',`error_msg`varchar(200) DEFAULTNULLCOMMENT'错误信息',`create_time` datetime NOTNULLDEFAULTCURRENT_TIMESTAMPCOMMENT'创建时间',  PRIMARY KEY (`id`),KEY`idx_create_time` (`create_time`) COMMENT'创建时间索引') ENGINE=InnoDBDEFAULTCHARSET=utf8mb4 COMMENT='注册日志表';

2. SpringBoot 实现

（1）用户实体类

@Entity@Table(name = "user")publicclass User {        @Id    @GeneratedValue(strategy = GenerationType.IDENTITY)    private Long id;        @Column(name = "username", nullable = false, unique = true, length = 50)    private String username;        @Column(name = "password", nullable = false, length = 100)    private String password;        @Column(name = "email", nullable = false, unique = true, length = 100)    private String email;        @Column(name = "phone", nullable = false, unique = true, length = 20)    private String phone;        @Column(name = "nickname", length = 50)    private String nickname;        @Column(name = "avatar", length = 200)    private String avatar;        @Column(name = "status", nullable = false)    private Integer status;        @Column(name = "create_time", nullable = false, updatable = false)    private LocalDateTime createTime;        @Column(name = "update_time", nullable = false)    private LocalDateTime updateTime;        // getter 和 setter 方法}

（2）用户仓库类

@Repositorypublicinterface UserRepository extends JpaRepository<User, Long> {        /**     * 根据用户名查询用户     */    User findByUsername(String username);        /**     * 根据邮箱查询用户     */    User findByEmail(String email);        /**     * 根据手机号查询用户     */    User findByPhone(String phone);        /**     * 使用ON DUPLICATE KEY UPDATE语法插入或更新用户     */    @Modifying    @Query(value = "INSERT INTO user (username, password, email, phone, nickname, avatar, status, create_time, update_time) " +            "VALUES (:username, :password, :email, :phone, :nickname, :avatar, :status, :createTime, :updateTime) " +            "ON DUPLICATE KEY UPDATE " +            "password = VALUES(password), " +            "nickname = VALUES(nickname), " +            "avatar = VALUES(avatar), " +            "update_time = VALUES(update_time)",            nativeQuery = true)    int insertOrUpdateUser(            @Param("username") String username,            @Param("password") String password,            @Param("email") String email,            @Param("phone") String phone,            @Param("nickname") String nickname,            @Param("avatar") String avatar,            @Param("status") Integer status,            @Param("createTime") LocalDateTime createTime,            @Param("updateTime") LocalDateTime updateTime    );}

（3）用户服务类

@Service@Slf4jpublicclass UserService {        @Autowired    private UserRepository userRepository;        @Autowired    private RegisterLogRepository registerLogRepository;        @Autowired    private PasswordEncoder passwordEncoder;        /**     * 用户注册     */    @Transactional    public User register(RegisterRequest request) {        // 记录注册日志        RegisterLog registerLog = new RegisterLog();        registerLog.setUsername(request.getUsername());        registerLog.setEmail(request.getEmail());        registerLog.setPhone(request.getPhone());        registerLog.setIp(request.getIp());        registerLog.setCreateTime(LocalDateTime.now());                try {            // 加密密码            String encodedPassword = passwordEncoder.encode(request.getPassword());                        // 创建用户对象            User user = new User();            user.setUsername(request.getUsername());            user.setPassword(encodedPassword);            user.setEmail(request.getEmail());            user.setPhone(request.getPhone());            user.setNickname(request.getNickname());            user.setAvatar(request.getAvatar());            user.setStatus(1); // 已激活            user.setCreateTime(LocalDateTime.now());            user.setUpdateTime(LocalDateTime.now());                        // 使用ON DUPLICATE KEY UPDATE语法插入或更新用户            int result = userRepository.insertOrUpdateUser(                    user.getUsername(),                    user.getPassword(),                    user.getEmail(),                    user.getPhone(),                    user.getNickname(),                    user.getAvatar(),                    user.getStatus(),                    user.getCreateTime(),                    user.getUpdateTime()            );                        if (result == 0) {                // 插入失败，说明用户已存在                registerLog.setStatus(0);                registerLog.setErrorMsg("用户已存在");                registerLogRepository.save(registerLog);                thrownew RuntimeException("用户名、邮箱或手机号已被注册");            }                        // 注册成功            registerLog.setStatus(1);            registerLogRepository.save(registerLog);                        // 返回注册的用户            return userRepository.findByUsername(user.getUsername());                    } catch (Exception e) {            // 注册失败            registerLog.setStatus(0);            registerLog.setErrorMsg(e.getMessage());            registerLogRepository.save(registerLog);            thrownew RuntimeException("注册失败：" + e.getMessage());        }    }}

（4）用户控制器类

@RestController@RequestMapping("/api/users")@Slf4jpublicclass UserController {        @Autowired    private UserService userService;        /**     * 用户注册     */    @PostMapping("/register")    public ResponseEntity<?> register(@RequestBody RegisterRequest request, HttpServletRequest httpRequest) {        try {            // 获取客户端IP            String ip = getClientIp(httpRequest);            request.setIp(ip);                        // 调用注册服务            User user = userService.register(request);                        return ResponseEntity.ok(Result.success(user));        } catch (Exception e) {            log.error("注册失败", e);            return ResponseEntity.ok(Result.error(e.getMessage()));        }    }        /**     * 获取客户端IP     */    private String getClientIp(HttpServletRequest request) {        String ip = request.getHeader("X-Forwarded-For");        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {            ip = request.getHeader("Proxy-Client-IP");        }        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {            ip = request.getHeader("WL-Proxy-Client-IP");        }        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {            ip = request.getHeader("HTTP_CLIENT_IP");        }        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {            ip = request.getHeader("HTTP_X_FORWARDED_FOR");        }        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {            ip = request.getRemoteAddr();        }        return ip;    }}

3. 性能优化

（1）使用批量插入

@Modifying@Query(value = "INSERT INTO user (username, password, email, phone, nickname, avatar, status, create_time, update_time) " +        "VALUES " +        "<foreach collection='users' item='user' separator=','>" +        "(#{user.username}, #{user.password}, #{user.email}, #{user.phone}, #{user.nickname}, #{user.avatar}, #{user.status}, #{user.createTime}, #{user.updateTime})" +        "</foreach> " +        "ON DUPLICATE KEY UPDATE " +        "password = VALUES(password), " +        "nickname = VALUES(nickname), " +        "avatar = VALUES(avatar), " +        "update_time = VALUES(update_time)",        nativeQuery = true)int batchInsertOrUpdateUsers(@Param("users") List<User> users);

（2）使用连接池

spring:  datasource:    url:jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai    username:root    password:root    driver-class-name:com.mysql.cj.jdbc.Driver    hikari:      maximum-pool-size:20      minimum-idle:5      connection-timeout:30000      idle-timeout:600000      max-lifetime:1800000

（3）使用读写分离

@Configurationpublicclass DataSourceConfig {        @Bean    @ConfigurationProperties(prefix = "spring.datasource.master")    public DataSource masterDataSource() {        return DataSourceBuilder.create().build();    }        @Bean    @ConfigurationProperties(prefix = "spring.datasource.slave")    public DataSource slaveDataSource() {        return DataSourceBuilder.create().build();    }        @Bean    public DataSource routingDataSource() {        Map<Object, Object> targetDataSources = new HashMap<>();        targetDataSources.put("master", masterDataSource());        targetDataSources.put("slave", slaveDataSource());                RoutingDataSource routingDataSource = new RoutingDataSource();        routingDataSource.setTargetDataSources(targetDataSources);        routingDataSource.setDefaultTargetDataSource(masterDataSource());                return routingDataSource;    }}

五、性能对比

1. 测试环境

• CPU: Intel Core i7-10700
• 内存: 16GB
• MySQL: 8.0
• 并发数: 1000

2. 测试结果

从测试结果可以看出，唯一索引 + ON DUPLICATE KEY方案的性能是传统查询后插入方案的5倍以上，同时保证了100%的成功率。

六、最佳实践

1. 索引设计

• 唯一索引 ：在用户名、邮箱、手机号等唯一字段上创建唯一索引
• 复合索引 ：如果经常需要查询多个字段的组合，可以创建复合索引
• 索引覆盖 ：尽量让查询只使用索引，避免回表
• 索引优化 ：定期分析索引使用情况，删除不必要的索引

2. 异常处理

• 唯一索引冲突 ：捕获DuplicateKeyException异常，返回友好的错误信息
• 数据库连接异常 ：捕获数据库连接异常，进行重试或降级
• 事务回滚 ：捕获事务回滚异常，进行相应的处理

3. 监控与告警

• 注册成功率 ：监控注册接口的成功率，及时发现异常
• 响应时间 ：监控注册接口的响应时间，发现性能问题
• 数据库性能 ：监控数据库的CPU、内存、连接数等指标
• 异常日志 ：监控异常日志，及时发现重复注册等问题

4. 安全防护

• 限流 ：对注册接口进行限流，防止恶意刷注册
• 验证码 ：使用图形验证码或短信验证码，防止机器注册
• IP限制 ：对同一IP的注册次数进行限制
• 黑名单 ：将恶意注册的IP或手机号加入黑名单

七、方案优势

1. 高性能 ：减少数据库操作次数，提高并发性能
2. 原子性 ：使用数据库的原子性操作，避免并发问题
3. 一致性 ：通过唯一索引保证数据的唯一性
4. 简单性 ：不需要额外的Redis等组件，实现简单
5. 可靠性 ：利用数据库的ACID特性，保证数据的一致性和可靠性

八、适用场景

1. 用户注册 ：防止重复注册
2. 数据导入 ：批量导入数据时，避免重复数据
3. 数据同步 ：同步数据时，避免重复插入
4. 库存管理 ：防止重复扣减库存
5. 订单处理 ：防止重复下单

九、写在最后

高并发注册的重复提交问题，是互联网应用中常见的挑战。通过使用MySQL的唯一索引和ON DUPLICATE KEY语法，我们可以有效地防止重复注册，同时大幅提升系统性能。

当然，这套方案也不是银弹，它需要根据具体的业务场景进行调整和优化。比如，对于不同的业务数据，我们可能需要设计不同的唯一索引；对于高并发场景，我们可能需要优化数据库的配置和架构。

希望这篇文章能给你带来一些启发，帮助你在实际项目中更好地解决高并发注册的重复提交问题。

如果你在使用这套方案的过程中有其他经验或困惑，欢迎在评论区留言交流！

服务端技术精选 ，专注分享后端开发实战经验，让技术落地更简单。

如果你觉得这篇文章有用，欢迎点赞、在看、分享三连！

关注公众号，回复"高并发注册"，获取完整的代码示例和实现方案。