// 账号密码登录
User user = userMapper.selectOne(new LambdaQueryWrapper<User>()
    .eq(User::getUsername, username));

// 手机号登录
User user = userMapper.selectOne(new LambdaQueryWrapper<User>()
    .eq(User::getMobile, mobile));

// 微信登录
User user = userMapper.selectOne(new LambdaQueryWrapper<User>()
    .eq(User::getWechatOpenid, openid));

// GitHub 登录
User user = userMapper.selectOne(new LambdaQueryWrapper<User>()
    .eq(User::getGithubId, githubId));

// 支付宝登录
User user = userMapper.selectOne(new LambdaQueryWrapper<User>()
    .eq(User::getAlipayUid, alipayUid));

public User login(String loginType, String identifier, String credential) {
    User user = null;

    if ("username".equals(loginType)) {
        user = userMapper.selectOne(new LambdaQueryWrapper<User>()
            .eq(User::getUsername, identifier));
    } else if ("mobile".equals(loginType)) {
        user = userMapper.selectOne(new LambdaQueryWrapper<User>()
            .eq(User::getMobile, identifier));
    } else if ("wechat".equals(loginType)) {
        user = userMapper.selectOne(new LambdaQueryWrapper<User>()
            .eq(User::getWechatOpenid, identifier));
    } else if ("github".equals(loginType)) {
        user = userMapper.selectOne(new LambdaQueryWrapper<User>()
            .eq(User::getGithubId, identifier));
    } else {
        throw new RuntimeException("不支持的登录方式");
    }

    // 验证密码...
    return user;
}

@TableId(type = IdType.ASSIGN_ID)  // MyBatis-Plus 自动使用雪花算法
private Long id;

try {
    authMapper.insert(auth);
} catch (DuplicateKeyException e) {
    throw new RuntimeException("该手机号已被其他账号绑定");
}

// 查询用户的所有登录方式
List<Auth> authList = authMapper.selectList(new LambdaQueryWrapper<Auth>()
    .eq(Auth::getUserId, userId));

package com.example.auth.core.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.time.LocalDateTime;

/**
 * 用户主体实体类
 */
@Data
@TableName("sys_user")
public class User {

    /**
     * 用户 ID（雪花算法生成）
     */
    @TableId(type = IdType.ASSIGN_ID)
    private Long id;

    /**
     * 用户昵称
     */
    private String nickname;

    /**
     * 头像 URL
     */
    private String avatar;

    /**
     * 状态：0-禁用 1-启用 2-未激活
     */
    private Integer status;

    /**
     * 创建时间
     */
    private LocalDateTime createTime;

    /**
     * 更新时间
     */
    private LocalDateTime updateTime;
}

package com.example.auth.core.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.time.LocalDateTime;

/**
 * 用户认证凭证实体类
 */
@Data
@TableName("sys_auth")
public class Auth {

    /**
     * 主键 ID
     */
    @TableId(type = IdType.AUTO)
    private Long id;

    /**
     * 关联的用户 ID
     */
    private Long userId;

    /**
     * 认证类型：PASSWORD/MOBILE/EMAIL/WECHAT/GITHUB
     */
    private String identityType;

    /**
     * 标识符（账号/手机号/邮箱/OpenID）
     */
    private String identifier;

    /**
     * 凭证（密码哈希/Token，OAuth 登录可为空）
     */
    private String credential;

    /**
     * 是否已验证：0-未验证 1-已验证
     */
    private Integer verified;

    /**
     * 创建时间
     */
    private LocalDateTime createTime;

    /**
     * 更新时间
     */
    private LocalDateTime updateTime;
}

package com.example.auth.core.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.auth.core.entity.User;
import org.apache.ibatis.annotations.Mapper;

/**
 * 用户 Mapper
 */
@Mapper
public interface UserMapper extends BaseMapper<User> {
}

package com.example.auth.core.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.auth.core.entity.Auth;
import org.apache.ibatis.annotations.Mapper;

/**
 * 认证凭证 Mapper
 */
@Mapper
public interface AuthMapper extends BaseMapper<Auth> {
}

package com.example.auth.web;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication(scanBasePackages = "com.example.auth")
@MapperScan("com.example.auth.core.mapper")
public class AuthApplication {

    public static void main(String[] args) {
        SpringApplication.run(AuthApplication.class, args);
    }
}

package com.example.auth.web.mapper;

import com.example.auth.core.entity.User;
import com.example.auth.core.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testInsert() {
        User user = new User();
        user.setNickname("测试用户");
        user.setAvatar("https://cdn.example.com/avatar.jpg");
        user.setStatus(1);

        userMapper.insert(user);
        System.out.println("插入成功，用户 ID: " + user.getId());
    }

    @Test
    public void testSelect() {
        User user = userMapper.selectById(1L);
        System.out.println("查询结果: " + user);
    }
}

String password = "123456";
String md5Hash = DigestUtils.md5Hex(password);
// 输出: e10adc3949ba59abbe56e057f20f883e

String password = "123456";
String salt = "random_salt_123";
String saltedPassword = password + salt;
String md5Hash = DigestUtils.md5Hex(saltedPassword);
// 输出: 7c6a180b36896a0a8c02787eeafb0e4c

String password = "123456";
String bcryptHash = BCrypt.hashpw(password, BCrypt.gensalt());
// 输出: $2a$ 10$rQ7R8kN5J6X7Z8Y9W0V1U.2Q3R4S5T6U7V8W9X0Y1Z2A3B4C5D6E7F

// MD5：每秒可以计算数十亿次
String md5Hash = DigestUtils.md5Hex("123456");

// BCrypt：每秒只能计算几十次
String bcryptHash = BCrypt.hashpw("123456", BCrypt.gensalt(10));

// 成本因子 10：每次哈希需要 2^10 = 1024 次迭代
String hash10 = BCrypt.hashpw("123456", BCrypt.gensalt(10));

// 成本因子 12：每次哈希需要 2^12 = 4096 次迭代
String hash12 = BCrypt.hashpw("123456", BCrypt.gensalt(12));

package com.example.auth.core.util;

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Component;

/**
 * 密码加密工具类
 * 封装 BCrypt 算法
 */
@Component
public class PasswordEncoder {

    private final BCryptPasswordEncoder encoder = new BCryptPasswordEncoder(12);

    /**
     * 加密密码
     *
     * @param rawPassword 明文密码
     * @return BCrypt 哈希值
     */
    public String encode(String rawPassword) {
        return encoder.encode(rawPassword);
    }

    /**
     * 验证密码
     *
     * @param rawPassword     明文密码
     * @param encodedPassword BCrypt 哈希值
     * @return true 表示密码正确，false 表示密码错误
     */
    public boolean matches(String rawPassword, String encodedPassword) {
        return encoder.matches(rawPassword, encodedPassword);
    }
}

@Test
public void testBCrypt() {
    PasswordEncoder encoder = new PasswordEncoder();

    // 加密密码
    String rawPassword = "123456";
    String hash1 = encoder.encode(rawPassword);
    String hash2 = encoder.encode(rawPassword);

    System.out.println("哈希值 1: " + hash1);
    System.out.println("哈希值 2: " + hash2);

    // 验证密码
    System.out.println("验证结果 1: " + encoder.matches(rawPassword, hash1));
    System.out.println("验证结果 2: " + encoder.matches(rawPassword, hash2));
    System.out.println("验证错误密码: " + encoder.matches("wrong", hash1));
}

package com.example.auth.core.constant;

/**
 * Redis Key 常量类
 */
public class RedisKeyConstants {
    /**
     * 验证码相关 Key 前缀
     */
    public static final String CAPTCHA_PREFIX = "auth:captcha:";
}

package com.example.auth.core.service;

import cn.hutool.captcha.CaptchaUtil;
import cn.hutool.captcha.LineCaptcha;
import com.example.auth.core.constant.RedisKeyConstants;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

/**
 * 验证码服务
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class CaptchaService {
    private final StringRedisTemplate redisTemplate;

    @Value("${auth.captcha.expire-minutes:5}")
    private long expireMinutes; // 验证码有效期（分钟）
    @Value("${auth.captcha.width:200}")
    private int width; // 验证码宽度
    @Value("${auth.captcha.height:100}")
    private int height; // 验证码高度
    @Value("${auth.captcha.code-count:4}")
    private int codeCount; // 验证码字符数量
    @Value("${auth.captcha.line-count:20}")
    private int lineCount; // 验证码干扰线数量

    /**
     * 生成验证码
     *
     * @param key 验证码 Key（通常是用户的唯一标识，如 sessionId 或 UUID）
     * @return 验证码图片的 Base64 编码
     */
    public String generateCaptcha(String key) {
        // 1. 生成验证码图片
        LineCaptcha captcha = CaptchaUtil.createLineCaptcha(width, height, codeCount, lineCount);

        // 2. 获取验证码文本
        String code = captcha.getCode();

        log.info("生成验证码: key={}, code={}", key, code);
        // 3. 将验证码存入 Redis
        String redisKey = RedisKeyConstants.CAPTCHA_PREFIX + key;
        redisTemplate.opsForValue().set(redisKey, code, expireMinutes, TimeUnit.MINUTES);
        // 4. 返回验证码图片的 Base64 编码
        return captcha.getImageBase64();
    }

    /**
     * 验证验证码
     *
     * @param key  验证码 Key
     * @param code 用户输入的验证码
     * @return true 表示验证通过，false 表示验证失败
     */
    public boolean verifyCaptcha(String key, String code) {
        // 1. 从 Redis 中获取验证码
        String redisKey = RedisKeyConstants.CAPTCHA_PREFIX + key;
        String storedCode = redisTemplate.opsForValue().get(redisKey);
        // 2. 验证码不存在或已过期
        if (storedCode == null) {
            log.warn("验证码不存在或已过期: key={}", key);
            return false;
        }
        // 3. 验证码错误（忽略大小写）
        if (!storedCode.equalsIgnoreCase(code)) {
            log.warn("验证码错误: key={}, expected={}, actual={}", key, storedCode, code);
            return false;
        }
        // 4. 验证通过，立即删除验证码（一次性使用）
        redisTemplate.delete(redisKey);
        log.info("验证码验证通过: key={}", key);
        return true;
    }
}

package com.example.auth.web.controller;

import cn.hutool.core.util.IdUtil;
import com.example.auth.common.model.Result;
import com.example.auth.core.service.CaptchaService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

/**
 * 验证码控制器
 */
@Slf4j
@RestController
@RequestMapping("/captcha")
@RequiredArgsConstructor
public class CaptchaController {
    private final CaptchaService captchaService;

    /**
     * 生成验证码
     *
     * @return 验证码图片的 Base64 编码和验证码 Key
     */
    @GetMapping("/generate")
    public Result<Map<String, String>> generate() {
        // 生成唯一的验证码 Key
        String key = IdUtil.fastSimpleUUID();

        // 生成验证码图片
        String imageBase64 = captchaService.generateCaptcha(key);

        // 返回验证码 Key 和图片
        Map<String, String> data = new HashMap<>();
        data.put("key", key);
        data.put("image", "data:image/png;base64," + imageBase64);
        return Result.ok(data);
    }
    /**
     * 验证验证码（测试接口）
     *
     * @param key  验证码 Key
     * @param code 用户输入的验证码
     * @return 验证结果
     */
    @GetMapping("/verify")
    public Result<Map<String, Boolean>> verify(@RequestParam String key, @RequestParam String code) {
        boolean valid = captchaService.verifyCaptcha(key, code);

        Map<String, Boolean> data = new HashMap<>();
        data.put("valid", valid);

        return Result.ok(data);
    }
}

String sign = HMAC_SHA256(userId + timestamp + secret);

package com.example.auth.core.util;

import cn.hutool.crypto.SecureUtil;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * HMAC 签名工具类
 */
@Component
public class HmacUtil {

    /**
     * 密钥（从配置文件读取）
     */
    @Value("${auth.hmac.secret:default_secret_key_change_in_production}")
    private String secret;

    /**
     * 生成签名
     *
     * @param data 待签名的数据
     * @return 签名字符串
     */
    public String sign(String data) {
        return SecureUtil.hmacSha256(secret).digestHex(data);
    }

    /**
     * 验证签名
     *
     * @param data 待验证的数据
     * @param sign 签名字符串
     * @return true 表示签名有效，false 表示签名无效
     */
    public boolean verify(String data, String sign) {
        String expectedSign = sign(data);
        return expectedSign.equals(sign);
    }
}

package com.example.auth.core.event;

import lombok.Getter;
import org.springframework.context.ApplicationEvent;

/**
 * 邮件发送事件
 */
@Getter
public class EmailEvent extends ApplicationEvent {

    /**
     * 收件人邮箱
     */
    private final String to;

    /**
     * 邮件主题
     */
    private final String subject;

    /**
     * 邮件内容（HTML 格式）
     */
    private final String content;

    public EmailEvent(Object source, String to, String subject, String content) {
        super(source);
        this.to = to;
        this.subject = subject;
        this.content = content;
    }
}

package com.example.auth.core.listener;

import com.example.auth.core.event.EmailEvent;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.event.EventListener;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

import jakarta.mail.MessagingException;
import jakarta.mail.internet.MimeMessage;

/**
 * 邮件发送监听器
 * 监听 EmailEvent 事件，异步发送邮件
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class EmailEventListener {

    private final JavaMailSender mailSender;

    /**
     * 处理邮件发送事件
     *
     * @param event 邮件事件
     */
    @Async
    @EventListener
    public void handleEmailEvent(EmailEvent event) {
        try {
            log.info("开始发送邮件: to={}, subject={}", event.getTo(), event.getSubject());

            // 创建邮件消息
            MimeMessage message = mailSender.createMimeMessage();
            MimeMessageHelper helper = new MimeMessageHelper(message, true, "UTF-8");

            // 设置发件人（从配置文件读取）
            helper.setFrom("your_email@qq.com");
            // 设置收件人
            helper.setTo(event.getTo());
            // 设置邮件主题
            helper.setSubject(event.getSubject());
            // 设置邮件内容（HTML 格式）
            helper.setText(event.getContent(), true);

            // 发送邮件
            mailSender.send(message);

            log.info("邮件发送成功: to={}", event.getTo());
        } catch (MessagingException e) {
            log.error("邮件发送失败: to={}, error={}", event.getTo(), e.getMessage(), e);
        }
    }
}

package com.example.auth.core.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

/**
 * 异步配置
 * 配置 Spring Event 的异步线程池
 */
@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 核心线程数
        executor.setCorePoolSize(5);
        // 最大线程数
        executor.setMaxPoolSize(10);
        // 队列容量
        executor.setQueueCapacity(100);
        // 线程名称前缀
        executor.setThreadNamePrefix("async-email-");
        // 初始化
        executor.initialize();
        return executor;
    }
}

package com.example.auth.core.service;

import com.example.auth.core.event.EmailEvent;
import com.example.auth.core.util.HmacUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;

/**
 * 邮件服务
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class EmailService {

    private final ApplicationEventPublisher eventPublisher;
    private final HmacUtil hmacUtil;

    @Value("${server.port:8080}")
    private String serverPort;

    /**
     * 发送激活邮件
     *
     * @param email  收件人邮箱
     * @param userId 用户 ID
     */
    public void sendActivationEmail(String email, Long userId) {
        // 1. 生成激活链接
        String activationUrl = generateActivationUrl(userId);

        // 2. 构建邮件内容（HTML 格式）
        String content = buildActivationEmailContent(activationUrl);

        // 3. 发布邮件事件（异步发送）
        EmailEvent event = new EmailEvent(this, email, "账号激活", content);
        eventPublisher.publishEvent(event);

        log.info("激活邮件事件已发布: email={}, userId={}", email, userId);
    }

    /**
     * 生成激活链接
     *
     * @param userId 用户 ID
     * @return 激活链接
     */
    private String generateActivationUrl(Long userId) {
        // 1. 生成时间戳（有效期 24 小时）
        long timestamp = System.currentTimeMillis() + 24 * 60 * 60 * 1000;

        // 2. 生成签名
        String data = userId + ":" + timestamp;
        String sign = hmacUtil.sign(data);

        // 3. 构建激活链接
        return String.format("http://localhost:%s/auth/activate?userId=%d&timestamp=%d&sign=%s",
                serverPort, userId, timestamp, sign);
    }

    /**
     * 构建激活邮件内容（HTML 格式）
     *
     * @param activationUrl 激活链接
     * @return 邮件内容
     */
    private String buildActivationEmailContent(String activationUrl) {
        return """
                <!DOCTYPE html>
                <html>
                <head>
                    <meta charset="UTF-8">
                    <style>
                        body { font-family: Arial, sans-serif; line-height: 1.6; }
                        .container { max-width: 600px; margin: 0 auto; padding: 20px; }
                        .header { background-color: #4CAF50; color: white; padding: 20px; text-align: center; }
                        .content { padding: 20px; background-color: #f9f9f9; }
                        .button { display: inline-block; padding: 10px 20px; background-color: #4CAF50; color: white; text-decoration: none; border-radius: 5px; }
                        .footer { padding: 20px; text-align: center; color: #666; font-size: 12px; }
                    </style>
                </head>
                <body>
                    <div class="container">
                        <div class="header">
                            <h1>欢迎注册</h1>
                        </div>
                        <div class="content">
                            <p>您好！</p>
                            <p>感谢您注册我们的服务。请点击下方按钮激活您的账号：</p>
                            <p style="text-align: center; margin: 30px 0;">
                                <a href="%s" class="button">激活账号</a>
                            </p>
                            <p>或者复制以下链接到浏览器打开：</p>
                            <p style="word-break: break-all; color: #666;">%s</p>
                            <p style="color: #999; font-size: 12px;">此链接 24 小时内有效，请尽快激活。</p>
                        </div>
                        <div class="footer">
                            <p>这是一封自动发送的邮件，请勿回复。</p>
                        </div>
                    </div>
                </body>
                </html>
                """.formatted(activationUrl, activationUrl);
    }

    /**
     * 发送找回密码邮件
     *
     * @param email  收件人邮箱
     * @param userId 用户 ID
     */
    public void sendResetPasswordEmail(String email, Long userId) {
        // 1. 生成重置密码链接
        String resetUrl = generateResetPasswordUrl(userId);

        // 2. 构建邮件内容（HTML 格式）
        String content = buildResetPasswordEmailContent(resetUrl);

        // 3. 发布邮件事件（异步发送）
        EmailEvent event = new EmailEvent(this, email, "重置密码", content);
        eventPublisher.publishEvent(event);

        log.info("重置密码邮件事件已发布: email={}, userId={}", email, userId);
    }

    /**
     * 生成重置密码链接
     *
     * @param userId 用户 ID
     * @return 重置密码链接
     */
    private String generateResetPasswordUrl(Long userId) {
        // 1. 生成时间戳（有效期 1 小时）
        long timestamp = System.currentTimeMillis() + 60 * 60 * 1000;

        // 2. 生成签名
        String data = userId + ":" + timestamp;
        String sign = hmacUtil.sign(data);

        // 3. 构建重置密码链接
        return String.format("http://localhost:%s/auth/reset-password?userId=%d&timestamp=%d&sign=%s",
                serverPort, userId, timestamp, sign);
    }

    /**
     * 构建重置密码邮件内容（HTML 格式）
     *
     * @param resetUrl 重置密码链接
     * @return 邮件内容
     */
    private String buildResetPasswordEmailContent(String resetUrl) {
        return """
                <!DOCTYPE html>
                <html>
                <head>
                    <meta charset="UTF-8">
                    <style>
                        body { font-family: Arial, sans-serif; line-height: 1.6; }
                        .container { max-width: 600px; margin: 0 auto; padding: 20px; }
                        .header { background-color: #FF9800; color: white; padding: 20px; text-align: center; }
                        .content { padding: 20px; background-color: #f9f9f9; }
                        .button { display: inline-block; padding: 10px 20px; background-color: #FF9800; color: white; text-decoration: none; border-radius: 5px; }
                        .footer { padding: 20px; text-align: center; color: #666; font-size: 12px; }
                    </style>
                </head>
                <body>
                    <div class="container">
                        <div class="header">
                            <h1>重置密码</h1>
                        </div>
                        <div class="content">
                            <p>您好！</p>
                            <p>我们收到了您的密码重置请求。请点击下方按钮重置密码：</p>
                            <p style="text-align: center; margin: 30px 0;">
                                <a href="%s" class="button">重置密码</a>
                            </p>
                            <p>或者复制以下链接到浏览器打开：</p>
                            <p style="word-break: break-all; color: #666;">%s</p>
                            <p style="color: #999; font-size: 12px;">此链接 1 小时内有效，请尽快重置。</p>
                            <p style="color: #f44336; font-size: 12px;">如果这不是您的操作，请忽略此邮件。</p>
                        </div>
                        <div class="footer">
                            <p>这是一封自动发送的邮件，请勿回复。</p>
                        </div>
                    </div>
                </body>
                </html>
                """.formatted(resetUrl, resetUrl);
    }
}

package com.example.auth.core.model.request;

import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import lombok.Data;

/**
 * 注册请求
 */
@Data
public class RegisterRequest {

    /**
     * 用户名
     * 4-20 位，只能包含字母、数字、下划线
     */
    @NotBlank(message = "用户名不能为空")
    @Pattern(regexp = "^[a-zA-Z0-9_]{4,20}$", message = "用户名格式不正确（4-20位，只能包含字母、数字、下划线）")
    private String username;

    /**
     * 密码
     * 8-20 位，必须包含大小写字母、数字
     */
    @NotBlank(message = "密码不能为空")
    @Pattern(regexp = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)[a-zA-Z\\d]{8,20}$",
            message = "密码格式不正确（8-20位，必须包含大小写字母、数字）")
    private String password;

    /**
     * 邮箱
     */
    @NotBlank(message = "邮箱不能为空")
    @Email(message = "邮箱格式不正确")
    private String email;

    /**
     * 验证码 Key
     */
    @NotBlank(message = "验证码 Key 不能为空")
    private String captchaKey;

    /**
     * 验证码
     */
    @NotBlank(message = "验证码不能为空")
    private String captchaCode;
}