腾讯云短信登录注册

package com.example.auth.app.model;

import lombok.Data;

@Data
public class TxSmsConfig {
    private String platform;
    private String secretId;
    private String secretKey;
    private String appId;
    private String templateId;
    private String smsSign;
    private Integer validSeconds;
}

package com.example.auth.app.services.system;

import com.example.auth.app.model.TxSmsConfig;
import nexus.io.tio.utils.environment.EnvUtils;

public class SystemConfigService {
    public TxSmsConfig getLoginSmsConfig() {
        return getSmsConfig(2);
    }

    public TxSmsConfig getSmsConfig(int codeType) {
        String platform = EnvUtils.get("SMS_PLATFORM", "tencent");
        if (!"tencent".equals(platform)) {
            throw new IllegalArgumentException("Unsupported SMS platform for TencentSmsService");
        }
        String templateKey;
        switch (codeType) {
        case 1:
            templateKey = "TENCENT_SMS_REGISTER_TEMPLATE_ID";
            break;
        case 2:
            templateKey = "TENCENT_SMS_LOGIN_TEMPLATE_ID";
            break;
        case 3:
            templateKey = "TENCENT_SMS_BIND_PHONE_TEMPLATE_ID";
            break;
        case 4:
            templateKey = "TENCENT_SMS_RESET_PASSWORD_TEMPLATE_ID";
            break;
        default:
            throw new IllegalArgumentException("Unsupported SMS code type");
        }
        int validSeconds = EnvUtils.getInt("SMS_CODE_VALID_SECONDS", 300);
        if (validSeconds <= 0) {
            throw new IllegalArgumentException("SMS_CODE_VALID_SECONDS must be positive");
        }
        TxSmsConfig config = new TxSmsConfig();
        config.setPlatform(platform);
        config.setSecretId(required("TENCENT_SMS_SECRET_ID"));
        config.setSecretKey(required("TENCENT_SMS_SECRET_KEY"));
        config.setAppId(required("TENCENT_SMS_APP_ID"));
        config.setSmsSign(required("TENCENT_SMS_SIGN_NAME"));
        config.setTemplateId(required(templateKey));
        config.setValidSeconds(validSeconds);
        return config;
    }

    private String required(String key) {
        String value = EnvUtils.get(key);
        if (value == null || value.trim().isEmpty()) {
            throw new IllegalStateException("Missing configuration: " + key);
        }
        return value;
    }
}

import com.example.auth.app.model.TxSmsConfig;
import nexus.io.tio.utils.json.JsonUtils;
import nexus.io.tio.utils.environment.EnvUtils;
import com.tencentcloudapi.common.Credential;
import com.tencentcloudapi.common.exception.TencentCloudSDKException;
import com.tencentcloudapi.common.profile.ClientProfile;
import com.tencentcloudapi.common.profile.HttpProfile;
import com.tencentcloudapi.sms.v20210111.SmsClient;
import com.tencentcloudapi.sms.v20210111.models.SendSmsRequest;
import com.tencentcloudapi.sms.v20210111.models.SendSmsResponse;

import lombok.extern.slf4j.Slf4j;

/**
 * 腾讯云短信服务工具类
 */
@Slf4j
public class TencentSmsUtils {
    /**
     * 发送短信
     *
     * @param sdkAppId      短信应用ID
     * @param secretId      腾讯云账户SecretId
     * @param secretKey     腾讯云账户SecretKey
     * @param signName      短信签名
     * @param templateId    短信模板ID
     * @param params        模板参数
     * @param phoneNumberSet 接收短信的手机号集合
     * @return SendSmsResponse 发送短信的响应
     */
    public static SendSmsResponse sendSMS(String sdkAppId, String secretId, String secretKey, String signName, String templateId,
                                         String[] params, String[] phoneNumberSet) {
        SmsClient client = buildSmsClient(secretId, secretKey);
        SendSmsRequest req = buildSmsRequest(sdkAppId, signName, templateId, params, phoneNumberSet);
        log.info("发送短信请求:{}", JsonUtils.toJson(req));
        try {
            SendSmsResponse res = client.SendSms(req);
            return res;
        } catch (TencentCloudSDKException e) {
            log.error("发送短信失败: {}", e.getMessage());
            throw new RuntimeException(e);
        }
    }

    /**
     * 构建短信请求对象
     */
    private static SendSmsRequest buildSmsRequest(String sdkAppId, String signName, String templateId, String[] params, String[] phoneNumberSet) {
        SendSmsRequest req = new SendSmsRequest();
        req.setSmsSdkAppId(sdkAppId);
        req.setSignName(signName);
        req.setSenderId("");
        req.setSessionContext("");
        req.setExtendCode("");
        req.setTemplateId(templateId);
        req.setPhoneNumberSet(phoneNumberSet);
        req.setTemplateParamSet(params);
        return req;
    }

    /**
     * 构建短信客户端
     */
    private static SmsClient buildSmsClient(String secretId, String secretKey) {
        Credential cred = new Credential(secretId, secretKey);
        HttpProfile httpProfile = new HttpProfile();
        httpProfile.setReqMethod("POST");
        httpProfile.setConnTimeout(60);
        httpProfile.setEndpoint(EnvUtils.get("TENCENT_SMS_ENDPOINT", "sms.tencentcloudapi.com"));

        ClientProfile clientProfile = new ClientProfile();
        clientProfile.setSignMethod("HmacSHA256");
        clientProfile.setHttpProfile(httpProfile);

        SmsClient client = new SmsClient(cred, EnvUtils.get("TENCENT_SMS_REGION", "ap-guangzhou"), clientProfile);
        return client;
    }

    /**
     * 批量发送短信
     */
    public static SendSmsResponse sendSmsBat(TxSmsConfig config, String[] phoneList, String[] params) {
        return sendSMS(config.getAppId(), config.getSecretId(), config.getSecretKey(),
                config.getSmsSign(), config.getTemplateId(), params, phoneList);
    }

    /**
     * 发送单条短信
     */
    public static SendSmsResponse sendSms(TxSmsConfig config, String areaCode, String phone, String code) {
        String[] phoneList = new String[]{areaCode + phone};
        String[] params = {code};
        return sendSMS(config.getAppId(), config.getSecretId(), config.getSecretKey(),
                config.getSmsSign(), config.getTemplateId(), params, phoneList);
    }
}

import org.junit.Test;

import com.example.auth.app.config.EnoteMysqlDbConfig;
import com.example.auth.app.model.TxSmsConfig;
import com.example.auth.app.services.system.SystemConfigService;
import com.example.auth.app.utils.TencentSmsUtils;
import nexus.io.jfinal.aop.Aop;
import nexus.io.tio.boot.tesing.TioBootTest;
import nexus.io.tio.utils.json.JsonUtils;
import nexus.io.tio.utils.environment.EnvUtils;
import com.tencentcloudapi.sms.v20210111.models.SendSmsResponse;

public class TencentSmsUtilsTest {

    @Test
    public void testSendSms() {
        TioBootTest.runWith(EnoteMysqlDbConfig.class);
        SystemConfigService systemConfigService = Aop.get(SystemConfigService.class);
        TxSmsConfig txSmsConfig = systemConfigService.getLoginSmsConfig();
        SendSmsResponse sendSms = TencentSmsUtils.sendSms(txSmsConfig, "86", "15836475191", "123456");
        System.out.println(JsonUtils.toJson(sendSms));
    }
}

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

public enum SmsCodeType {
    REGISTER(1, "注册"),
    LOGIN(2, "登录"),
    CHANGE_PHONE(3, "更换手机号码"),
    RESET_PWD(4, "重置登录密码");

    private Integer type;
    private String desc;

    SmsCodeType(Integer type, String desc) {
        this.type = type;
        this.desc = desc;
    }

    public Integer getType() {
        return type;
    }

    public String getDesc() {
        return desc;
    }

    public static String getDesc(int type) {
        for (SmsCodeType item : SmsCodeType.values()) {
            if (item.getType().equals(type)) {
                return item.getDesc();
            }
        }
        return "";
    }

    public static Map<Integer, String> getMap() {
        Map<Integer, String> map = new HashMap<>();
        for (SmsCodeType item : SmsCodeType.values()) {
            map.put(item.getType(), item.getDesc());
        }
        return map;
    }
}

package com.example.auth.app.enums;

public enum PhoneType {
    MAIN_LAND("86", "大陆手机号码"),
    HK("852", "香港手机号码");

    private String code;
    private String desc;

    PhoneType(String code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    public String getCode() {
        return code;
    }

    public String getDesc() {
        return desc;
    }

    public static PhoneType getPhoneType(String areaCode) {
        if (areaCode != null && !areaCode.isEmpty()) {
            if (areaCode.equals("+852") || areaCode.equals("852")) {
                return HK;
            }
        }
        return MAIN_LAND;
    }
}

import com.example.auth.app.db.model.SysSmsCode;
import com.example.auth.app.model.TxSmsConfig;
import com.example.auth.app.services.system.SystemConfigService;
import com.example.auth.app.utils.TencentSmsUtils;
import com.jfinal.kit.Kv;
import nexus.io.db.activerecord.Db;
import nexus.io.jfinal.aop.Aop;
import nexus.io.model.body.RespBodyVo;
import nexus.io.tio.utils.hutool.RandomUtils;
import nexus.io.tio.utils.snowflake.SnowflakeIdUtils;

public class TencentSmsService {

    /**
     * 发送短信验证码
     *
     * @param codeType 验证码类型
     * @param areaCode 国家代码
     * @param phone    手机号码
     * @param ip       用户IP地址
     * @return 响应结果
     */
    public RespBodyVo send(Integer codeType, String areaCode, String phone, String ip) {
        // 防止重复发送：检查是否存在未过期的验证码记录
        String sql = "SELECT 1 FROM sys_sms_code WHERE NOW() <= create_time + INTERVAL valid_seconds SECOND " +
                     "AND area_code=? AND phone=? AND tenant_id=0 AND deleted=0 LIMIT 1";
        boolean exists = Db.existsBySql(sql, areaCode, phone);
        if (exists) {
            return RespBodyVo.fail("请求过于频繁，请稍后再试。");
        }

        // 生成随机验证码
        int code = RandomUtils.nextInt(100000, 999999);

        // 获取短信配置信息
        SystemConfigService systemConfigService = Aop.get(SystemConfigService.class);
        TxSmsConfig loginSmsConfig = systemConfigService.getSmsConfig(codeType);

        // 发送短信
        TencentSmsUtils.sendSms(loginSmsConfig, areaCode, phone, String.valueOf(code));

        // 生成唯一ID并保存验证码记录
        long id = SnowflakeIdUtils.id();
        SysSmsCode sysSmsCode = new SysSmsCode();
        sysSmsCode.setId(id)
                  .setAreaCode(areaCode)
                  .setPhone(phone)
                  .setCode(String.valueOf(code))
                  .setIp(ip)
                  .setValidSeconds(Long.valueOf(loginSmsConfig.getValidSeconds()))
                  .setCodeType(codeType);

        sysSmsCode.set("platform", loginSmsConfig.getPlatform());
        boolean save = sysSmsCode.save();
        if (!save) {
            return RespBodyVo.fail("验证码保存失败，请稍后再试。");
        }

        return RespBodyVo.ok(Kv.by("id", id));
    }
}

import org.junit.Test;

import com.example.auth.app.config.EnoteMysqlDbConfig;
import com.example.auth.app.enums.SmsCodeType;
import nexus.io.jfinal.aop.Aop;
import nexus.io.model.body.RespBodyVo;
import nexus.io.tio.boot.tesing.TioBootTest;

public class TencentSmsServiceTest {

    @Test
    public void testSendSms() {
        TioBootTest.runWith(EnoteMysqlDbConfig.class);
        TencentSmsService smsService = Aop.get(TencentSmsService.class);
        RespBodyVo response1 = smsService.send(SmsCodeType.LOGIN.getType(), "86", "15836475191", "192.168.1.2");
        System.out.println(response1);

        // 尝试重复发送，预期失败
        RespBodyVo response2 = smsService.send(SmsCodeType.LOGIN.getType(), "86", "15836475191", "192.168.1.2");
        System.out.println(response2);
    }
}

package com.example.auth.app.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class SmsCodeSendVo {
    private Integer codeType; // 验证码类型: 1-注册, 2-登录, 3-更换手机号码, 4-重置登录密码
    private String areaCode;  // 国家或地区代码，如中国为 "86"
    private String phone;     // 手机号码
}

import com.example.auth.app.enums.PhoneType;
import com.example.auth.app.model.SmsCodeSendVo;
import com.example.auth.app.services.sms.TencentSmsService;
import com.example.auth.app.utils.RegexUtil;
import nexus.io.annotation.EnableCORS;
import nexus.io.annotation.RequestPath;
import nexus.io.jfinal.aop.Aop;
import nexus.io.model.body.RespBodyVo;
import nexus.io.tio.boot.http.TioRequestContext;
import nexus.io.tio.http.common.utils.HttpIpUtils;

@RequestPath("/sms")
@EnableCORS
public class SmsController {

    private TencentSmsService smsService = Aop.get(TencentSmsService.class);

    /**
     * 发送验证码接口
     *
     * @param vo SmsCodeSendVo 请求参数
     * @return 响应结果
     */
    public RespBodyVo send(SmsCodeSendVo vo) {
        Integer codeType = vo.getCodeType();
        String areaCode = vo.getAreaCode();
        String phone = vo.getPhone();

        // 参数校验
        if (codeType == null) {
            return RespBodyVo.fail("验证码类型不能为空");
        }
        if (areaCode == null || areaCode.isEmpty()) {
            return RespBodyVo.fail("国家代码不能为空");
        }
        if (phone == null || phone.isEmpty()) {
            return RespBodyVo.fail("手机号码不能为空");
        }

        // 手机号格式校验（针对大陆号码）
        PhoneType phoneType = PhoneType.getPhoneType(areaCode);
        if (phoneType == PhoneType.MAIN_LAND && !RegexUtil.isMobileSimple(phone)) {
            return RespBodyVo.fail("手机号码格式不正确");
        }

        // 获取真实IP
        String realIp = HttpIpUtils.getRealIp(TioRequestContext.getRequest());

        // 发送验证码
        return smsService.send(codeType, areaCode, phone, realIp);
    }
}

package com.example.auth.app.dao;

import com.example.auth.app.utils.UserIdUtils;
import nexus.io.db.activerecord.Db;
import nexus.io.db.activerecord.Row;

public class SysUserInfoDao {

    public static final String tableName = "sys_user_info";

    /**
     * 判断用户名是否存在
     *
     * @param username 用户名
     * @return 存在返回true，否则返回false
     */
    public boolean existsUsername(String username) {
        return Db.exists(tableName, "username", username);
    }

    /**
     * 通过手机号保存新用户信息
     *
     * @param areaCode 国家代码
     * @param phone    手机号码
     * @param username 用户名
     * @param nickName 昵称
     * @return 新用户的ID，保存失败返回null
     */
    public Long saveByPhone(String areaCode, String phone, String username, String nickName) {
        long userId = UserIdUtils.random();
        Row row = new Row();
        row.set("id", userId)
              .set("username", username)
              .set("area_code", areaCode)
              .set("phone", phone)
              .set("nick_name", nickName);
        boolean save = Db.save(tableName, row);
        return save ? userId : null;
    }
}

package com.example.auth.app.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class LoginVo {
    private Long id;         // 验证码ID
    private String areaCode; // 国家代码
    private String phone;    // 手机号码
    private Integer codeType;// 验证码类型
    private Integer code;    // 验证码
}

import com.example.auth.app.dao.SysUserInfoDao;
import com.example.auth.app.model.LoginVo;
import com.jfinal.kit.Kv;
import nexus.io.db.activerecord.Db;
import nexus.io.db.activerecord.Row;
import nexus.io.jfinal.aop.Aop;
import nexus.io.model.body.RespBodyVo;
import nexus.io.tio.utils.hutool.RandomUtils;

import cn.dev33.satoken.stp.StpUtil;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class AuthService {

    /**
     * 通过用户名和密码登录
     *
     * @param username 用户名
     * @param password 密码
     * @return 登录结果
     */
    public TableResult<Kv> doLogin(String username, String password) {
        String sql = "SELECT id FROM sys_user_info WHERE username=? AND password=?";
        Long userId = Db.queryLong(sql, username, password);
        if (userId != null && userId > 0) {
            Kv kv = doLogin(userId);
            return TableResult.ok(kv);
        } else {
            return TableResult.fail("用户名或密码不正确");
        }
    }

    /**
     * 执行登录操作
     *
     * @param userId 用户ID
     * @return 登录结果
     */
    public Kv doLogin(Long userId) {
        StpUtil.login(userId);
        String tokenValue = StpUtil.getTokenValue();
        long tokenTimeout = StpUtil.getTokenTimeout();
        Kv kv = new Kv();
        kv.set("token", tokenValue);
        kv.set("tokenTimeout", tokenTimeout);
        Row row = Db.findById("sys_user_info", userId);
        kv.set(row.toMap());
        return kv;
    }

    /**
     * 通过验证码进行登录或注册
     *
     * @param vo LoginVo 请求参数
     * @return 响应结果
     */
    public RespBodyVo loginByPhone(LoginVo vo) {
        Long id = vo.getId();
        Integer code = vo.getCode();
        String areaCode = vo.getAreaCode();
        String phone = vo.getPhone();
        Integer codeType = vo.getCodeType();

        // 登录注册只接受对应用途；不允许重置密码验证码用于登录。
        if (id == null || code == null || codeType == null || (codeType != 1 && codeType != 2)) {
            return RespBodyVo.fail("验证码参数无效。");
        }
        String sqlCode = "SELECT 1 FROM sys_sms_code WHERE id=? AND tenant_id=0 AND platform=? "
                + "AND area_code=? AND phone=? AND code=? AND code_type=? AND deleted=0 "
                + "AND TIMESTAMPDIFF(SECOND, create_time, NOW()) BETWEEN 0 AND valid_seconds LIMIT 1";
        if (!Db.existsBySql(sqlCode, id, "tencent", areaCode, phone, code, codeType)) {
            return RespBodyVo.fail("验证码无效或已过期。");
        }

        // 判断用户是否存在
        String sql = "SELECT id FROM sys_user_info WHERE area_code=? AND phone=? AND deleted=0";
        Long userId = Db.queryLong(sql, areaCode, phone);
        if (userId != null) {
            // 用户存在，执行登录
            Kv loginResult = this.doLogin(userId);
            return RespBodyVo.ok(loginResult);
        } else {
            // 用户不存在，自动注册新用户
            log.info("自动注册新用户:{}", phone);
            SysUserInfoDao sysUserInfoDao = Aop.get(SysUserInfoDao.class);
            userId = sysUserInfoDao.saveByPhone(areaCode, phone, phone, "User_" + RandomUtils.nextInt(1000, 9999));
            if (userId == null) {
                return RespBodyVo.fail("用户注册失败，请稍后再试。");
            }
            Kv loginResult = this.doLogin(userId);
            return RespBodyVo.ok(loginResult);
        }
    }
}

import com.example.auth.app.model.LoginVo;
import com.example.auth.app.services.auth.AuthService;
import nexus.io.jfinal.aop.Aop;
import nexus.io.model.body.RespBodyVo;
import nexus.io.annotation.EnableCORS;
import nexus.io.annotation.RequestPath;

@RequestPath("/auth")
@EnableCORS
public class AuthController {

    private AuthService authService = Aop.get(AuthService.class);

    /**
     * 通过验证码登录或注册
     *
     * @param vo LoginVo 请求参数
     * @return 响应结果
     */
    public RespBodyVo loginByPhone(LoginVo vo) {
        Long id = vo.getId();
        Integer code = vo.getCode();

        // 参数校验
        if (id == null) {
            return RespBodyVo.fail("验证码ID不能为空");
        }
        if (code == null) {
            return RespBodyVo.fail("验证码不能为空");
        }

        return authService.loginByPhone(vo);
    }
}