springboot集成sa-token来实现登录鉴权（一）

springboot集成sa-token来实现登录鉴权（一）

这篇文章，我们将学习怎样初步集成sa-token来实现基本的登录认证和权限校验，并初步看下底层的源码实现。

sa-token简介

sa-token是一个轻量级的登录鉴权框架，比之前的shiro和springsecurity都要轻量，一行代码就可以实现登录功能。具体文档可以看：sa-token官网。这里我们不再赘述。直接来看具体实现代码。

spirngboot集成sa-token代码实现

点击看项目源码

maven依赖

		
        <dependency>
            <groupId>cn.dev33groupId>
            <artifactId>sa-token-spring-boot-starterartifactId>
            <version>1.34.0version>
        dependency>

        
        <dependency>
            <groupId>cn.dev33groupId>
            <artifactId>sa-token-dao-redis-jacksonartifactId>
            <version>1.34.0version>
        dependency>

        
        <dependency>
            <groupId>org.apache.commonsgroupId>
            <artifactId>commons-pool2artifactId>
        dependency>

其中，如果是springboot3.x版本的话，上面的sa-token-spring-boot-starter依赖要换成sa-token-spring-boot3-starter

配置文件

@Configuration
public class SaTokenConfigure implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new SaInterceptor(handler -> {
            SaRouter.match("/**", StpUtil::checkLogin)
                    .notMatch(SaTokenConstant.excludePathPatterns);
            // 这里可以给每个接口地址的路径鉴权，当然，也可以用注解在每个接口上鉴权
        })).addPathPatterns(SaTokenConstant.allRouters)
                .excludePathPatterns(SaTokenConstant.excludePathPatterns);
    }

    @Bean
    @Primary
    public SaTokenConfig getSaTokenConfigPrimary(){
        SaTokenConfig config = new SaTokenConfig();
        // token名称
        config.setTokenName(SaTokenConstant.TOKEN_NAME);
        // token有效期，单位 秒，默认是30天
        config.setTimeout(30 * 24 * 60 * 60);
        // token无操作存活时间(指定时间内无操作就视为token过期) 单位：秒
        config.setActivityTimeout(SaTokenConstant.ACTIVITY_TIMEOUT);
        // 是否允许同一账号并发登录，true是允许多个同一账号一起登录，false时同一账号新登录的会挤掉旧登录的
        config.setIsConcurrent(false);
        // 在多人登录同一账号时，是否共用一个token
        config.setIsShare(true);
        // token风格
        config.setTokenStyle(TokenStyleEnum.SIMPLE_UUID.getTokenStyle());
        // 是否输出操作日志
        config.setIsLog(false);
        /*
         是否尝试从 cookie 里读取 Token，此值为 false 后，StpUtil.login(id) 登录时也不会再往前端注入Cookie，
         false时，可以返回给前端token，然后让前端在每次请求时header里携带返回的token，
         这样可以用于不能使用cookie的设备端，不在局限于web浏览器端
         */
        config.setIsReadCookie(false);
        return config;
    }
}

全局异常处理

/**
 * 全局异常处理
 */
@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {

    /**
     * 全局登录异常处理
     * @param exception 登录抛出的异常
     * @return 提示信息
     */
    @ExceptionHandler(NotLoginException.class)
    public BaseResult<Object> handlerNotLoginException(NotLoginException exception) {
        // 打印日志
        log.error(exception.getMessage(), exception);
        // 判断登录异常的场景，定制化返回提示
        String type = exception.getType();
        switch (type){
            case NotLoginException.INVALID_TOKEN:
            case NotLoginException.TOKEN_TIMEOUT:
                return BaseResult.fail(520, SaTokenConstant.TOKEN_OVERDUE);
            case NotLoginException.BE_REPLACED:
            case NotLoginException.KICK_OUT:
                return BaseResult.fail(520, SaTokenConstant.LOGIN_REPLACE);
            default:
                return BaseResult.fail(520, SaTokenConstant.NOT_TOKEN);
        }
    }

    /**
     * 全局权限校验异常处理
     * @param exception 权限校验异常
     * @return
     */
    @ExceptionHandler(NotPermissionException.class)
    public BaseResult<String> handlerNotPermissionException(NotPermissionException exception){
        // 打印日志
        log.error(exception.getMessage(), exception);
        return BaseResult.fail(520, SaTokenConstant.PERMISSION_ERROR);
    }
}

登录相关接口

这里我们模拟下真实的登录场景：
用户在登录页一般会看到三个输入框，分别是：账号、密码和验证码图片。那么我们首先要在登录页面获取到验证码图片，并在登录接口中传入验证码并进行校验，那么后端就必须要存下返回给前端的验证码，那么我们需要先返回前端一个临时token，然后前端拿着这个临时token来请求获取验证码的接口，后端拿到这个临时token后，生成验证码，并将这个临时token作为缓存的key，验证码内容作为value存入缓存中。等到前端调用真正的登录接口时，需要传入 账号、密码、验证码和临时token，在这个接口中，我们通过临时token，去缓存中拿到验证码，和前端传入的验证码进行比对，然后再校验账号和密码。

controller层

@RestController
@Slf4j
public class LoginController {

    @Resource
    private VerifyImgUtil verifyImgUtil;

    @Resource
    private LoginService loginService;

    /**
     * 在获取验证码接口和登录接口前，先调用，获取一个临时token，用来作为验证码的key
     *
     * @return
     */
    @GetMapping("tempToken")
    public BaseResult<String> getTempToken(@RequestParam("tokenKey") String tokenKey) {
        log.info("开始获取临时token------>" + tokenKey);
        String token = SaTempUtil.createToken(tokenKey, 5 * 60);
        loginService.saveTempToken(token);
        return BaseResult.success(token, null);
    }

    /**
     * 获取图片验证码
     *
     * @param tempToken 获取到的临时token
     * @param response
     */
    @GetMapping("getVerifyImg")
    public BaseResult<String> getVerifyImg(@RequestParam("tempToken") String tempToken, HttpServletResponse response) throws IOException {
        log.info("开始获取图片验证码------>" + tempToken);
        if (!loginService.checkTempToken(tempToken)) {
            return BaseResult.fail(530, LoginConstant.TOKEN_EMPTY);
        }
        response.setContentType("image/jpeg");//设置相应类型,告诉浏览器输出的内容为图片
        response.setHeader("Pragma", "No-cache");//设置响应头信息，告诉浏览器不要缓存此内容
        response.setHeader("Cache-Control", "no-cache");
        response.setDateHeader("Expires", 0);
        OutputStream os = response.getOutputStream();
        verifyImgUtil.lineCaptcha(os, tempToken);
        try {
            os.flush();
        } finally {
            os.close();
        }
        return null;
    }

    /**
     * 模拟登录接口，真实场景中，可以先提供一个接口，返回一个临时token，
     * 然后再提供一个获取验证码的接口，里面需要传入刚才返回的临时token，生成验证码后，以临时token作为key，验证码作为value放入缓存，
     * 然后再来调用这个正式登录接口，里面需要传验证码和临时token以及用户的账号密码，先根据临时token从缓存中获取验证码来比对，
     * 然后再比对账号密码，比对成功后，删除缓存中对应临时token的验证码数据，并删除临时token
     *
     * @param dto 登录数据
     * @return
     */
    @PostMapping("/login")
    public BaseResult<String> login(@RequestBody LoginDto dto) {
        log.info("开始登录------>" + JSON.toJSONString(dto));
        BaseResult<String> result = loginService.checkLogin(dto);
        if (!result.isState()) {
            return result;
        }
        loginService.deleteTempToken(dto.getTempToken());// 校验成功后移除临时token
        // 登录
        StpUtil.login("10001");
        // 将用户的数据放入上下文session中
        StpUtil.getSession().set(LoginConstant.LOGIN_NAME, "admin");
        StpUtil.getSession().set(LoginConstant.REAL_NAME, "管理员");
        StpUtil.getSession().set(LoginConstant.USER_ID, "10001");
        return BaseResult.success(StpUtil.getTokenValue(), "登录成功");
    }

    /**
     * 注销登录接口
     */
    @PostMapping("logout")
    public void logout(){
        StpUtil.logout();
    }
}

service层

public interface LoginService {

    /**
     * 登录校验
     * @param dto
     * @return
     */
    BaseResult<String> checkLogin(LoginDto dto);

    /**
     * 存放临时token
     * @param tempToken 临时token
     */
    void saveTempToken(String tempToken);

    /**
     * 删除临时token
     * @param tempToken 临时token
     */
    void deleteTempToken(String tempToken);

    /**
     * 校验临时token是否有效
     * @param tempToken 临时token
     * @return
     */
    boolean checkTempToken(String tempToken);
}

@Service
public class LoginServiceImpl implements LoginService {

    @Resource
    private RedisUtil redisUtil;

    private static final String tempTokenPre = "tempToken";

    @Override
    public BaseResult<String> checkLogin(LoginDto dto) {
        if (StringUtils.isBlank(dto.getTempToken())) {
            return BaseResult.fail(530, LoginConstant.TOKEN_EMPTY);
        }
        if (StringUtils.isBlank(dto.getVerifyCode())) {
            return BaseResult.fail(530, LoginConstant.VERIFY_CODE_EMPTY);
        }
        if (StringUtils.isBlank(dto.getLoginName())) {
            return BaseResult.fail(530, LoginConstant.LOGIN_NAME_EMPTY);
        }
        if (StringUtils.isBlank(dto.getPassword())) {
            return BaseResult.fail(530, LoginConstant.PASSWORD_EMPTY);
        }
        // 校验
        Object verifyCode = redisUtil.get(dto.getTempToken());
        if (verifyCode == null) {
            return BaseResult.fail(530, LoginConstant.VERIFY_OVERDUE);
        }
        if (!dto.getVerifyCode().equalsIgnoreCase(verifyCode.toString())) {
            return BaseResult.fail(530, LoginConstant.VERIFY_CODE_ERROR);
        }
        if (!"admin".equals(dto.getLoginName())) {
            return BaseResult.fail(530, LoginConstant.LOGIN_NAME_ERROR);
        }
        if (!"123".equals(dto.getPassword())) {
            return BaseResult.fail(530, LoginConstant.PASSWORD_ERROR);
        }
        // 校验成功后，移除redis
        redisUtil.delete(dto.getTempToken());
        return BaseResult.success(null, null);
    }

    @Override
    public void saveTempToken(String tempToken) {
        redisUtil.set(tempTokenPre + tempToken, "1", 300);
    }

    @Override
    public void deleteTempToken(String tempToken) {
        redisUtil.delete(tempTokenPre + tempToken);
    }

    @Override
    public boolean checkTempToken(String tempToken) {
        Object o = redisUtil.get(tempTokenPre + tempToken);
        return o != null;
    }
}

接口中的参数类

@Data
public class LoginDto implements Serializable {

    /**
     * 账号
     */
    private String loginName;

    /**
     * 密码
     */
    private String password;

    /**
     * 验证码
     */
    private String verifyCode;

    /**
     * 临时token，用来校验验证码
     */
    private String tempToken;
}

返回数据封装

@Data
public class BaseResult<T> implements Serializable {

    /**
     * 返回数据
     */
    private T data;

    /**
     * 提示信息
     */
    private String message;

    /**
     * 状态码
     */
    private int code;

    /**
     * 状态
     */
    private boolean state = true;

    public static <T> BaseResult<T> result(int code, String message, boolean state) {
        BaseResult<T> result = new BaseResult<>();
        result.setCode(code);
        result.setMessage(message);
        result.setState(state);
        return result;
    }

    /**
     * 返回信息
     *
     * @param code    状态码
     * @param message 信息
     * @param t       数据
     * @param      T
     * @return ResultVo
     */
    public static <T> BaseResult<T> result(int code, String message, T t, boolean state) {
        BaseResult<T> r = new BaseResult<>();
        r.setCode(code);
        r.setMessage(message);
        r.setData(t);
        r.setState(state);
        return r;
    }

    /**
     * 返回成功
     *
     * @param data data
     * @param   T
     * @return ResultVo
     */
    public static <T> BaseResult<T> success(T data, String message) {
        return result(HttpStatus.OK.value(), message, data, true);
    }

    /**
     * 返回失败
     *
     * @param code code
     * @param   T
     * @return ResultVo
     */
    public static <T> BaseResult<T> fail(int code, String message) {
        return result(code, message, null, false);
    }
}

全局变量类和枚举类

/**
 * 要排除登录校验的接口地址枚举类
 */
@Getter
public enum ExcludePathEnum {
    TEMP_TOKEN("/tempToken", "获取临时token的接口"),
    VERIFY_IMG("/getVerifyImg", "获取验证码图片的接口"),
    LOGIN("/login", "登录接口"),
    LOGOUT("/logout", "注销登录接口");

    private final String path;
    private final String remark;

    ExcludePathEnum(String path, String remark) {
        this.path = path;
        this.remark = remark;
    }
}

public class LoginConstant {
    public static final String TOKEN_EMPTY = "token不能为空！";
    public static final String LOGIN_NAME_EMPTY = "请输入账号！";
    public static final String PASSWORD_EMPTY = "请输入密码！";
    public static final String LOGIN_NAME_ERROR = "账号不存在！";
    public static final String PASSWORD_ERROR = "密码错误，请重新输入！";
    public static final String VERIFY_CODE_EMPTY = "验证码不能为空！";
    public static final String VERIFY_CODE_ERROR = "验证码错误，请重新输入！";
    public static final String VERIFY_OVERDUE = "验证码已过期，请重新登录！";

    public static final String LOGIN_NAME = "loginName";
    public static final String REAL_NAME = "userName";
    public static final String USER_ID = "userId";
}

public class SaTokenConstant {

    /**
     * token的字段名
     */
    public static final String TOKEN_NAME = "token";

    /**
     * token无操作存活时间(指定时间内无操作就视为token过期) 单位：秒
     */
    public static final long ACTIVITY_TIMEOUT = 24 * 60 * 60;

    public static final List<String> allRouters = Collections.singletonList("/**");

    public static final List<String> excludePathPatterns = Arrays.asList(
            "/test/**",
            "/file/upload/img/head/**",
            "/swagger-resources/**",
            "/webjars/**",
            "/v2/**",
            "/doc.html",
            "**/swagger-ui.html",
            "/swagger-ui.html/**",
            "/img/head/**",
            ExcludePathEnum.TEMP_TOKEN.getPath(),
            ExcludePathEnum.VERIFY_IMG.getPath(),
            ExcludePathEnum.LOGIN.getPath(),
            ExcludePathEnum.LOGOUT.getPath()
    );

    public static final String NOT_TOKEN = "您未登录，请登录！";

    public static final String TOKEN_OVERDUE = "登录已失效，请重新登录！";

    public static final String LOGIN_REPLACE = "您的账号已在别处登录！";

    public static final String PERMISSION_ERROR = "您没有权限！";
}

@Getter
public enum TokenStyleEnum {
    /**
     * 一般的uuid风格
     */
    UUID("uuid"),
    /**
     * uuid风格，只不过去掉了中划线
     */
    SIMPLE_UUID("simple-uuid"),
    /**
     * 随机32位字符串
     */
    RANDOM_32("random-32"),
    /**
     * 随机64位字符串
     */
    RANDOM_64("random-64"),
    /**
     * 随机128位字符串
     */
    RANDOM_128("random-128"),
    /**
     * tik风格，gr_SwoIN0MC1ewxHX_vfCW3BothWDZMMtx__
     */
    TIK("tik");

    private final String tokenStyle;

    TokenStyleEnum(String tokenStyle) {
        this.tokenStyle = tokenStyle;
    }
}

验证码图片工具类

这里的验证码图片生成用的是hultool包的工具类，需要先导入hultool包
maven：

		<dependency>
            <groupId>cn.hutoolgroupId>
            <artifactId>hutool-allartifactId>
            <version>5.8.15version>
        dependency>

封装的工具类：

@Component
public class VerifyImgUtil {

    @Resource
    private RedisUtil redisUtil;

    /**
     * 生成验证码的字符，去掉了0、1、I、O这样容易混淆的字符
     */
    public static final String VERIFY_CODES = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";

    /**
     * 生成线段干扰的验证码
     *
     * @param os        输出流
     * @param tempToken 临时token，作为验证码写入缓存的key
     */
    public void lineCaptcha(OutputStream os, String tempToken) {
        //定义图形验证码的长和宽
        LineCaptcha captcha = CaptchaUtil.createLineCaptcha(200, 100);
        // 自定义纯数字的验证码（随机4位字符，可重复）
        RandomGenerator randomGenerator = new RandomGenerator(VERIFY_CODES, 4);
        captcha.setGenerator(randomGenerator);
        putVerifyCode(tempToken, captcha.getCode());
        captcha.write(os);
    }

    /**
     * 生成圆圈干扰的验证码
     *
     * @param os        输出流
     * @param tempToken 临时token，作为验证码写入缓存的key
     */
    public void circleCaptcha(OutputStream os, String tempToken) {
        //定义图形验证码的长、宽、验证码字符数、干扰元素个数
        CircleCaptcha captcha = CaptchaUtil.createCircleCaptcha(200, 100, 4, 20);
        // 自定义纯数字的验证码（随机4位字符，可重复）
        RandomGenerator randomGenerator = new RandomGenerator(VERIFY_CODES, 4);
        captcha.setGenerator(randomGenerator);
        putVerifyCode(tempToken, captcha.getCode());
        captcha.write(os);
    }

    /**
     * 生成扭曲干扰的验证码
     *
     * @param os        输出流
     * @param tempToken 临时token，作为验证码写入缓存的key
     */
    public void shearCaptcha(OutputStream os, String tempToken) {
        //定义图形验证码的长、宽、验证码字符数、干扰线宽度
        ShearCaptcha captcha = CaptchaUtil.createShearCaptcha(200, 100, 4, 4);
        // 自定义纯数字的验证码（随机4位字符，可重复）
        RandomGenerator randomGenerator = new RandomGenerator(VERIFY_CODES, 4);
        captcha.setGenerator(randomGenerator);
        putVerifyCode(tempToken, captcha.getCode());
        captcha.write(os);
    }

    /**
     * 将验证码放到缓存里
     *
     * @param tempToken  临时token，作为验证码写入缓存的key
     * @param verifyCode 验证码
     */
    private void putVerifyCode(String tempToken, String verifyCode) {
        redisUtil.set(tempToken, verifyCode, 40);
    }
}

redis工具类

@Component
public class RedisUtil {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 获取符合要求的所有key
     * @param patternKey 指定要求的key
     * @return 获取符合要求的所有key集合
     */
    public Set<String> getAllKey(String patternKey){
        return redisTemplate.keys(patternKey);
    }

    /**
     * 清空所有的redis数据库
     */
    public void flushAll(){
        redisTemplate.getConnectionFactory().getConnection().flushAll();
    }

    /**
     * 清空当前数据库
     */
    public void flushDB(){
        redisTemplate.getConnectionFactory().getConnection().flushDb();
    }

    /**
     * 指定缓存的有效期
     * @param key 缓存key
     * @param time 有效时间，已秒为单位
     * @return
     */
    public Boolean expire(String key, long time){
        if (time > 0){
            return redisTemplate.expire(key, time, TimeUnit.SECONDS);
        }
        return true;
    }

    /**
     * 获取指定key的过期时间，返回0表示永久有效
     * @param key 缓存key
     * @return 过期时间
     */
    public Long getExpire(String key){
        return redisTemplate.getExpire(key);
    }

    /**
     * 判断指定的缓存key是否存在
     * @param key 缓存key
     * @return
     */
    public Boolean hasKey(String key){
        return redisTemplate.hasKey(key);
    }

    /**
     * 删除指定的key，可以传入一个String数组，批量删除
     * @param key 缓存key数组
     */
    public void delete(String... key){
        if (key == null || key.length < 1){
            return;
        }
        if (key.length == 1){
            redisTemplate.delete(key[0]);
        } else {
            redisTemplate.delete(Arrays.asList(key));
        }
    }

    /**
     * String类型的添加缓存数据
     * @param key 缓存key
     * @param value 缓存value
     */
    public void set(String key, Object value){
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * String类型的添加缓存数据，并设置过期时间，单位为秒
     * @param key 缓存key
     * @param value 缓存value
     * @param time 过期时间
     */
    public void set(String key, Object value, long time){
        redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
    }

    /**
     * 获取指定key的缓存数据
     * @param key 缓存key
     * @return
     */
    public Object get(String key){
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 指定key的值递增
     * @param key 缓存key
     * @param delta 递增因子，即每次递增加几
     * @return
     */
    public Long incr(String key, long delta){
        if (delta < 0){
            throw new RuntimeException("递增因子要大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 指定key的值递减
     * @param key 缓存key
     * @param delta 递减因子，即每次递减减几
     * @return
     */
    public Long decr(String key, long delta){
        if (delta < 0){
            throw new RuntimeException("递减因子要大于0");
        }
        return redisTemplate.opsForValue().decrement(key, delta);
    }

    /**
     * 
Hash类型
     * 获取指定key的指定键值对的值
     * @param key 缓存key
     * @param hashKey hash类型的键值对的key
     * @return
     */
    public Object hget(String key, String hashKey){
        return redisTemplate.opsForHash().get(key, hashKey);
    }

    /**
     * 
Hash类型
     * 获取指定key的所有键值对的值
     * @param key 缓存key
     * @return
     */
    public Map<Object, Object> hmget(String key){
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 
Hash类型
     * 添加指定缓存key的多个键值对
     * @param key 缓存key
     * @param map 对应的多个键值对
     */
    public void hmset(String key, Map<Object, Object> map){
        redisTemplate.opsForHash().putAll(key, map);
    }

    /**
     * 
Hash类型
     * 添加指定缓存key的多个键值对，并设置过期时间，以秒为单位
     * @param key 缓存key
     * @param map 对应的多个键值对
     * @param time 过期时间
     */
    public void hmset(String key, Map<Object, Object> map, long time){
        redisTemplate.opsForHash().putAll(key, map);
        expire(key, time);
    }

    /**
     * 
Hash类型
     * 添加指定缓存key的一个键值对
     * @param key 换存key
     * @param hashKey 对应的键值对的key
     * @param value 对应的键值对的value
     */
    public void hSet(String key, String hashKey, Object value){
        redisTemplate.opsForHash().put(key, hashKey, value);
    }

    /**
     * 
Hash类型
     * 添加指定缓存key的一个键值对，并设置过期时间，以秒为单位
     * @param key 缓存key
     * @param hashKey 对应的键值对的key
     * @param value 对应的键值对的value
     * @param time 过期时间
     */
    public void hSet(String key, String hashKey, Object value, long time){
        hSet(key, hashKey, value);
        expire(key, time);
    }

    /**
     * 
Hash类型
     * 删除指定key的指定键值对
     * @param key 缓存key
     * @param hashKey 要删除的键值对的key
     */
    public void hDelete(String key, Object... hashKey){
        redisTemplate.opsForHash().delete(key, hashKey);
    }

    /**
     * 
Hash类型
     * 判断缓存中是否有指定key的指定键值对
     * @param key 缓存key
     * @param hashKey 对应键值对的key
     * @return
     */
    public Boolean hHashKey(String key, Object hashKey){
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }
    
    /**
     * 
Hash类型
     * 递增指定key的指定键值对的值，如果不存在，则会创建，并且返回新增后的值
     * @param key 缓存key
     * @param hashKey 指定键值对的key
     * @param delta 递增因子，即要加几
     * @return
     */
    public double hIncr(String key, String hashKey, long delta) {
        return redisTemplate.opsForHash().increment(key, hashKey, delta);
    }
    
    /**
     * 
Hash类型
     * 递减指定key的指定键值对的值，如果不存在，则会创建，并且返回新增后的值
     * @param key 缓存key
     * @param hashKey 指定键值对的key
     * @param delta 递减因子，即要减几
     * @return
     */
    public double hDecr(String key, String hashKey, long delta) {
        return redisTemplate.opsForHash().increment(key, hashKey, -delta);
    }

    //================================Set===========================

    /**
     * 
Set类型
     * 根据key获取Set中的所有值
     * @param key 缓存key
     * @return
     */
    public Set<Object> sGet(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 
Set类型
     * 查询指定的key中指定的value是否存在
     * @param key 缓存key
     * @param value Set中的指定元素
     * @return
     */
    public Boolean sHasKey(String key, Object value) {
        return redisTemplate.opsForSet().isMember(key, value);
    }

    /**
     * 
Set类型
     * 将缓存数据放入指定的key中
     * @param key 缓存key
     * @param values Set集合
     * @return
     */
    public Long sSet(String key, Object... values) {
        return redisTemplate.opsForSet().add(key, values);
    }

    /**
     * 
Set类型
     * 将缓存数据放入指定的key中，并设置过期时间，单位为秒
     * @param key 缓存key
     * @param time 过期时间
     * @param values 要放入缓存的数据
     * @return
     */
    public Long sSet(String key, long time, Object... values) {
        Long l = sSet(key, values);
        expire(key, time);
        return l;
    }

    /**
     * 
Set类型
     * 获取指定的key中Set的长度
     * @param key 缓存key
     * @return
     */
    public Long sGetSetLength(String key) {
        Long l = redisTemplate.opsForSet().size(key);
        return l == null ? 0 : l;
    }

    /**
     * 
Set类型
     * 移除指定的key中指定的value
     * @param key 缓存key
     * @param values 指定要移除的value
     * @return
     */
    public long sRemove(String key, Object... values) {
        Long l = redisTemplate.opsForSet().remove(key, values);
        return l == null ? 0 : l;
    }


    //==========================List=======================

    /**
     * 
List类型
     * 获取指定的key中的list集合内容，根据起始下标获取
     * @param key 缓存key
     * @param start 集合的开始下标，包含在内
     * @param end 集合的截止下标，也包含在内
     * @return
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 
List类型
     * 根据key获取list集合的长度
     * @param key 缓存key
     * @return
     */
    public long lGetLength(String key) {
        Long l = redisTemplate.opsForList().size(key);
        return l == null ? 0 : l;
    }

    /**
     * 
List类型
     * 获取指定key的指定下标的元素
     * @param key 缓存key
     * @param index 指定的list集合下标
     * @return
     */
    public Object lGetByIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 
List类型
     * 将值从左侧放入List类型的缓存中，头插法
     * @param key 缓存key
     * @param value 要放入缓存的值
     * @return
     */
    public void lSet(String key, Object value) {
        redisTemplate.opsForList().leftPush(key, value);
    }

    /**
     * 
List类型
     * 将值从右侧放入List类型的缓存中，尾插法
     * @param key 缓存key
     * @param value 要放入缓存的值
     */
    public void rSet(String key, Object value) {
        redisTemplate.opsForList().rightPush(key, value);
    }

    /**
     * 
List类型
     * 将值从左侧放入List类型的缓存中，头插法，并设置过期时间，单位为秒
     * @param key 缓存key
     * @param value 要放入缓存的值
     * @param time 过期时间
     * @return
     */
    public void lSet(String key, Object value, long time) {
        redisTemplate.opsForList().leftPush(key, value);
        expire(key, time);
    }

    /**
     * 
List类型
     * 将值从右侧放入List类型的缓存中，尾插法，并设置过期时间，单位为秒
     * @param key 缓存key
     * @param value 要放入缓存的值
     * @param time 过期时间
     */
    public void rSet(String key, Object value, long time) {
        redisTemplate.opsForList().rightPush(key, value);
        expire(key, time);
    }

    /**
     * 
List类型
     * 将list集合从左边放入缓存，头插法
     * @param key 缓存key
     * @param list 要放入缓存的集合
     */
    public void lSet(String key, List<Object> list) {
        redisTemplate.opsForList().leftPushAll(key, list);
    }

    /**
     * 
List类型
     * 将list集合从右边放入缓存，尾插法
     * @param key 缓存key
     * @param list 要放入缓存的集合
     */
    public void rSet(String key, List<Object> list) {
        redisTemplate.opsForList().rightPushAll(key, list);
    }

    /**
     * 
List类型
     * 将list集合从左边放入缓存，头插法，并设置过期时间，单位为秒
     * @param key 缓存key
     * @param list 要放入缓存的集合
     * @param time 过期时间
     */
    public void lSet(String key, List<Object> list, long time) {
        redisTemplate.opsForList().leftPushAll(key, list);
        expire(key, time);
    }

    /**
     * 
List类型
     * 将list集合从右边放入缓存，尾插法，并设置过期时间，单位为秒
     * @param key 缓存key
     * @param list 要放入缓存的集合
     * @param time 过期时间
     */
    public void rSet(String key, List<Object> list, long time) {
        redisTemplate.opsForList().rightPushAll(key, list);
        expire(key, time);
    }

    /**
     * 
List类型
     * 修改指定key的list集合中指定下标的值
     * @param key 缓存key
     * @param index 要修改的值的下标
     * @param value 修改的值
     */
    public void lUpdateIndex(String key, long index, Object value) {
        redisTemplate.opsForList().set(key, index, value);
    }

    /**
     * 
List类型
     * 
移除指定key的list集合中指定个数的指定值
     * 
若count = 0，则表示移除全部
     * 
若count > 0，则表示从List集合的左侧开始数
     * 
若count < 0，则表示从List集合的右侧开始数
     * @param key 缓存key
     * @param count 要移除的元素个数
     * @param value 要移除的值
     * @return
     */
    public Long lRemove(String key, long count, Object value) {
        Long l = redisTemplate.opsForList().remove(key, count, value);
        return l == null ? 0L : l;
    }


    //===============================ZSet=============================

    /**
     * 
ZSet类型
     * 添加ZSet类型的缓存，这是一个有序集合，是按照元素的scores的值由小到大排序的
     * @param key 缓存key
     * @param value 要添加的值
     * @param scores 值的scores,根据此值的大小来排序
     */
    public void zAdd(String key, String value, double scores) {
        redisTemplate.opsForZSet().add(key, value, scores);
    }

    /**
     * 
ZSet类型
     * 批量添加ZSet类型的缓存，将一个set集合添加的ZSet中
     * @param key 缓存key
     * @param values 要放入缓存的set集合
     */
    public void zAdd(String key, Set<ZSetOperations.TypedTuple<Object>> values) {
        redisTemplate.opsForZSet().add(key, values);
    }

    /**
     * 
ZSet类型
     * 移除指定key中ZSet集合中的一个或多个指定的元素
     * @param key 缓存key
     * @param values 要移除的元素
     * @return
     */
    public Long zRemove(String key, Object... values) {
        Long l = redisTemplate.opsForZSet().remove(key, values);
        return l == null ? 0L : l;
    }

    /**
     * 
ZSet类型
     * 增加指定key的ZSet集合中指定元素的scores，并返回增加后的scores值
     * @param key 缓存key
     * @param value 要增加scores的元素
     * @param delta 递增因子，即加几
     * @return 增加后的scores值
     */
    public Double zincr(String key, String value, double delta) {
        return redisTemplate.opsForZSet().incrementScore(key, value, delta);
    }

    /**
     * 
ZSet类型
     * 返回指定key中ZSet集合中指定元素的下标
     * @param key 缓存key
     * @param value 要获取下标的元素
     * @return 指定元素的下标
     */
    public Long zRank(String key, Object value) {
        return redisTemplate.opsForZSet().rank(key, value);
    }

    /**
     * 
ZSet类型
     * 获取指定key的ZSet集合中指定下标区间的元素，由小到大排序
     * @param key 缓存key
     * @param start 开始下标，包含在内
     * @param end 截止下标，也包含在内
     * @return 指定下标区间内的元素
     */
    public Set<Object> zRange(String key, long start, long end) {
        return redisTemplate.opsForZSet().range(key, start, end);
    }

    /**
     * 
ZSet类型
     * 获取指定key的ZSet集合中指定下标区间的元素，由大到小排序
     * @param key 缓存key
     * @param start 开始下标，包含在内
     * @param end 截止下标，也包含在内
     * @return 指定下标区间内的元素
     */
    public Set<Object> zReRange(String key, long start, long end) {
        return redisTemplate.opsForZSet().reverseRange(key, start, end);
    }

    /**
     * 
ZSet类型
     * 获取指定key的ZSet集合中指定下标区间的元素，并带上元素的scores
     * @param key 缓存key
     * @param start 开始下标，包含在内
     * @param end 截止下标，也包含在内
     * @return 指定下标区间内的元素
     */
    public Set<ZSetOperations.TypedTuple<Object>> zRangeWithScores(String key, long start, long end) {
        return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
    }

    /**
     * 
ZSet类型
     * 获取指定key的ZSet集合中指定scores的元素
     * @param key 缓存key
     * @param scores 值的scores,根据此值的大小来排序
     * @return
     */
    public Object zScores(String key, double scores) {
        return redisTemplate.opsForZSet().score(key, scores);
    }
}

测试演示

首先获取一个临时token

然后获取验证码图片

其次是真正的登录接口调用

这里获取到真正的token后，前端就要在之后的接口中将这个token放入header中，至于这个header的字段名叫什么，在
这里的配置文件中会配置，配置后，接口的登录校验就会从header中获取这个字段的值来进行登录校验

其他接口，调用的时候会校验是否登录

已经登录后的调用返回：

未登录的调用返回：