// 账号密码登录
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.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.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
     * 与 19.2 的 AuthType.name() 对齐(建议存枚举名)
     */
    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.mapper;

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

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

package com.example.auth.mapper;

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

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

package com.example.auth;

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

@SpringBootApplication
@MapperScan("com.example.auth.mapper")
public class AuthFactoryApplication {

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

package com.example.auth.mapper;

import com.example.auth.entity.User;
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.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.constant;

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

package com.example.auth.service;

import cn.hutool.captcha.CaptchaUtil;
import cn.hutool.captcha.LineCaptcha;
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 = "auth:captcha:" + 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 = "auth:captcha:" + 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.controller;

import cn.hutool.core.util.IdUtil;
import com.example.auth.common.Result;
import com.example.auth.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.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.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.listener;

import com.example.auth.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.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.service;

import com.example.auth.event.EmailEvent;
import com.example.auth.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.enums;

import lombok.Getter;

/**
 * 认证类型枚举
 * 集中管理系统支持的所有登录方式
 */
@Getter
public enum AuthType {
    /**
     * 账号密码登录
     */
    PASSWORD("password", "账号密码登录"),

    /**
     * 手机验证码登录
     */
    SMS("sms", "手机验证码登录"),

    /**
     * 微信扫码登录
     */
    WECHAT("wechat", "微信扫码登录"),

    /**
     * 邮箱(用于激活/找回/绑定等流程)
     */
    EMAIL("email", "邮箱");

    private final String code;
    private final String description;

    AuthType(String code, String description) {
        this.code = code;
        this.description = description;
    }

    public static AuthType fromCode(String code) {
        for (AuthType type : values()) {
            if (type.code.equals(code)) {
                return type;
            }
        }
        throw new IllegalArgumentException("不支持的认证方式: " + code);
    }
}

package com.example.auth.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;
}