工具类

package com.wego.controller;

import cn.dev33.satoken.annotation.SaIgnore;
import cn.dev33.satoken.stp.StpUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.google.code.kaptcha.impl.DefaultKaptcha;
import com.wego.bean.ResultBean;
import com.wego.constant.CommonState;
import com.wego.constant.WeGoConstant;
import com.wego.converter.UserConverter;
import com.wego.dto.UserLoginDTO;
import com.wego.dto.UserRegisterDTO;
import com.wego.entity.User;
import com.wego.service.UserService;
import com.wego.toolkits.redis.util.JsonRedisUtil;
import com.wego.toolkits.validator.ValidatorUtil;
import com.wego.utils.JsonUtil;
import com.wego.utils.PasswordUtil;
import com.wego.utils.RandomUtil;
import com.wego.utils.RequestUtil;
import com.wego.utils.ResultBeanUtil;
import com.wego.vo.UserTokenVO;
import jakarta.annotation.Resource;
import jakarta.validation.constraints.NotBlank;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.time.LocalDateTime;
import java.util.Base64;
import javax.imageio.ImageIO;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

/**
 * 用户控制层
 *
 * @author hc 13264494458
 */
@RestController
@RequestMapping("/user")
public class UserController {
    @Resource
    private DefaultKaptcha defaultKaptcha;

    @Resource
    private UserService userService;

    @Resource
    private UserConverter userConverter;

    @Resource
    private JsonRedisUtil<String> jsonRedisUtil;

    @SaIgnore
    @PostMapping("/v1/login")
    public ResultBean<UserTokenVO> login(@RequestBody UserLoginDTO userLoginDTO) {
        //数据有效性校验
        ValidatorUtil.validateEntity(userLoginDTO);
        // TODO:判断校验码是否正确
        final QueryWrapper<User> queryWrapper = Wrappers.<User>query()
                .eq("account", userLoginDTO.getAccount())
                .eq("state", CommonState.POSITIVE);
        //根据账户查询用户
        final User user = userService.getOne(queryWrapper);
        if (user == null) {
            return ResultBeanUtil.<UserTokenVO>error().setMsg("账户不存在或账户被禁用");
        }
        final String encryptPassword = PasswordUtil.encrypt(userLoginDTO.getPassword(), user.getSalt());
        //比较密码
        if (encryptPassword.equals(user.getPassword())) {
            // 登录成功
            final UserTokenVO userTokenVO = userConverter.user2userTokenVO(user);

            // 将当前登录用户纳入sa-token管理
            StpUtil.login(JsonUtil.obj2String(userTokenVO));

            final String tokenValue = StpUtil.getTokenValue();
            return ResultBeanUtil.<UserTokenVO>success()
                    .setMsg("登录成功！")
                    .addData("token", tokenValue, "user", userTokenVO);
        }
        return ResultBeanUtil.<UserTokenVO>error().setMsg("登录失败！");
    }

    /**
     * 生成验证码
     * @throws IOException
     */
    @GetMapping("/v1/verifyCode")
    public ResultBean<String> getVerifyCode() throws IOException {
        // 生成文字验证码
        String verifyCode = defaultKaptcha.createText();

        final String ip = RequestUtil.getIp();
        //验证码放入Redis
        jsonRedisUtil.set(ip + "-verifyCode", verifyCode, WeGoConstant.VERIFY_CODE_TTL);

        // 生成图片验证码
        BufferedImage image = defaultKaptcha.createImage(verifyCode);
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ImageIO.write(image, "jpg", out);
        // 对字节组Base64编码
        return ResultBeanUtil.success(Base64.getEncoder().encodeToString(out.toByteArray()));
    }

    /**
     * 校验验证码
     * @param verifyCode
     * @return
     */
    @ResponseBody
    @GetMapping("/v1/checkVerifyCode")
    public ResultBean<String> checkVerifyCode(@NotBlank(message = "校验码不能为空") String verifyCode) {
        final String ip = RequestUtil.getIp();
        final String redisVerifyCode = jsonRedisUtil.get(ip + "-verifyCode");

        //用户没有登录，让用户登录
        if (redisVerifyCode == null) {
            return ResultBeanUtil.error("请刷新页面生成验证码后再次请求！");
        } else {
            //比较验证码忽略大小写
            if (redisVerifyCode.equalsIgnoreCase(verifyCode)) {
                return ResultBeanUtil.success("验证码正确！");
            } else {
                return ResultBeanUtil.error("请刷新页面生成验证码后再次请求！");
            }
        }
    }

}

测试代码

    /**
     * 注册逻辑
     * @param userRegisterDTO
     * @return
     */
    @PostMapping("/v1/register")
    public ResultBean<String> register(@RequestBody UserRegisterDTO userRegisterDTO) {
        ValidatorUtil.validateEntity(userRegisterDTO);
        //判断两个密码是否一致
        if (!userRegisterDTO.getPassword1().equals(userRegisterDTO.getPassword2())) {
            return ResultBeanUtil.error("两次密码不一致");
        }

        boolean res;
        //比较验证码是否正确
        final String ip = RequestUtil.getIp();
        final String veriyCode = jsonRedisUtil.get(ip + "-verifyCode");
        //用户没有登录，让用户登录
        if (veriyCode == null) {
            res = false;
        } else {
            //比较验证码忽略大小写
            res = veriyCode.equalsIgnoreCase(userRegisterDTO.getVerifyCode());
        }

        final String salt = RandomUtil.genString(5, 22);
        final String encryptPassword = PasswordUtil.encrypt(userRegisterDTO.getPassword1(), salt);
        final User user = User.builder()
                .account(userRegisterDTO.getAccount())
                .salt(salt)
                .password(encryptPassword)
                .state(CommonState.POSITIVE)
                .createTime(LocalDateTime.now())
                .updateTime(LocalDateTime.now())
                .build();
        res = res && userService.save(user);

        if (res) {
            return ResultBeanUtil.success("用户注册成功！");
        }

        return ResultBeanUtil.error("用户注册失败！");
    }

测试结果