• JWT的使用

    一、参考流程

    jwt解析出来的可以放在请求头也可以放在ThreadLocal中，根据项目而定（本文以ThreadLocal为例）
    在这里插入图片描述

    二、详细解决

    1、引入依赖
    		<!--JWT-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    2、封装一些常用的工具类

    特别注意：jwt生成工具中，有jwt的key这些。可以理解成加密工具中的盐和key主要

    	 /**
     * jwt claims key
     */
    public final static String JWT_CLAIMS_KEY = "jwt_claims_key";
    /**
     * jwt secret key
     */
    public static final String JWT_SECRET_KEY = "create_site";

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 1、JWT生成和解析工具
    /***
 * JWT生成工具
 * @author xusj
 * 
    CreateDate 2022/8/17 15:44
 */    
@Slf4j
public class JwtTokenUtils {
    /**
     * 生成jwttoken
     */
    public static String generateJwtToken(Long userId, String userName, String userAccount, Long siteId) {
        AccToken accToken = new AccToken(userId, userName, userAccount, siteId);
        //超时时间设置为7天
        accToken.setExpireDateTime(new Date((new Date()).getTime() + 3600L * 24 * 300 * 1000));
        ObjectMapper mapper = new ObjectMapper();
        String ac;
        try {
            //转化为一个json
            ac = mapper.writeValueAsString(accToken);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
            throw new ServiceException(LoginEnum.LOGIN_JSON_FAIL);
        }
        Map<String, Object> claims = new HashMap<>();
        claims.put(LoginEnum.JWT_CLAIMS_KEY, ac);
        //调用jwt中的方法，生成一个JwtBuilder（jwt创建者）
        JwtBuilder builder = Jwts.builder();
        //使用对称加密生成jwt token
        builder.setClaims(claims).signWith(SignatureAlgorithm.HS512, LoginEnum.JWT_SECRET_KEY);
        return builder.compact();
    }

    /**
     * 解析jwtToken
     */
    public static AccToken parseToken(String jwtToken) {
        AccToken accToken = null;
        try {
            JwtParser parser = Jwts.parser();
            //如果解析失败，会抛出异常
            Jws<Claims> claimsJws = parser.setSigningKey(LoginEnum.JWT_SECRET_KEY).parseClaimsJws(jwtToken);
            Claims claims = claimsJws.getBody();
            String acJson = (String) claims.get(LoginEnum.JWT_CLAIMS_KEY);
            ObjectMapper mapper = new ObjectMapper();
            //TODO XUSJ 还原json
            accToken = mapper.readValue(acJson, AccToken.class);
        } catch (Exception e) {
            log.info("==========token解析失败===========");
            e.printStackTrace();
        }
        //如果acctoken==null,说明token是无效的
        return accToken;
    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 2、token参数封装工具实体类
    package com.xiangzheng.website.utils.token;

import java.util.Date;

/***
 * token
 *
 * @author xusj
 * 
    CreateDate 2022/8/17 15:48
 */    
public class AccToken {

    private Long userId;
    private String userName;
    private String userAccount;
    //jwttoken的超时时间
    private Date expireDateTime;
    private Long siteId;

    public Long getSiteId() {
        return siteId;
    }

    public void setSiteId(Long siteId) {
        this.siteId = siteId;
    }

    public AccToken() {
    }

    public AccToken(Long userId, String userName, String userAccount, Long siteId) {
        this.userId = userId;
        this.userName = userName;
        this.userAccount = userAccount;
        this.siteId = siteId;
    }

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserAccount() {
        return userAccount;
    }

    public void setUserAccount(String userAccount) {
        this.userAccount = userAccount;
    }

    public Date getExpireDateTime() {
        return expireDateTime;
    }

    public void setExpireDateTime(Date expireDateTime) {
        this.expireDateTime = expireDateTime;
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 3、ThreadLocal使用存放用户信息（非必须的，按照项目需求一些参数可以放在请求头中【通过网关】，让后面的都在请求头中去参数也行）
    package com.xiangzheng.website.utils.threadLocalUtils;


import com.xiangzheng.website.utils.token.AccToken;
import org.springframework.stereotype.Component;

/**
 * 持有用户信息，用于代替session对象
 * 使用ThreadLocal实现
 *
 * @author xusj
 * 
    CreateDate 2022/8/18 13:27
 */    
@Component
public class HostHolder {

    /**
     * ThreadLocal本质是以线程为key存储元素
     */
    private final ThreadLocal<AccToken> users = new ThreadLocal<>();

    public void setUser(AccToken user) {
        users.set(user);
    }

    public AccToken getUser() {
        return users.get();
    }

    public void clear() {
        users.remove();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    3、编写登录接口逻辑
    • 1、这里是伪代码，主要模拟登录验证之后，生成JWT的过程
      -前面还有登录验证的逻辑，登录成功才会生成JWTToken，返回给前端，并且设置缓存

    后端生成JWT注意点如下：

    • 1.1：放到缓存中
    • 1.2：token返给前端，前端放在请求头中
    // 前面还有登录验证的逻辑，登录成功才会生成JWTToken
// 生成JWT
        String jwtToken = JwtTokenUtils.generateJwtToken(user.getId(), user.getUserName(), user.getUserAccount(), loginDTO.getSiteId());
        // 封装返回登录成功返回
        UserInfoVO userInfoVO = new UserInfoVO();
        userInfoVO.setUserImg(user.getUserPhoto());
        userInfoVO.setUserName(user.getUserName());
        userInfoVO.setSiteId(loginDTO.getSiteId());
        userInfoVO.setUserAccount(user.getUserAccount());
        userInfoVO.setToken(jwtToken);
        try {
            redisCache.setCacheObject(key, jwtToken, 7, TimeUnit.DAYS);
        } catch (Exception e) {
            throw new ServiceException("缓存异常");
        }
        return userInfoVo;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    4、编写拦截器

    拦截器的目的：
    1、拦截请求头中的参数，解析并校验
    2、这里是将解析出来的参数放到ThreadLocal中；也可以通过网关放在请求头中
    3、如果使用ThreadLocal一定要请求结束之后清除
    4、之后要使用直接通过ThreadLoacl中使用就行了
    5、记得校验缓存中的token是否过期

    /**
 * 拦截器
 *
 * @author xusj
 * 
    CreateDate 2022/6/6 15:18
 */    
@Slf4j
public class AuthInterceptor implements HandlerInterceptor {
    @Resource
    private RedisCache redisService;
    @Resource
    private HostHolder hostHolder;


    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // 校验请求头
        log.info("请求拦截====>{}", request.getRequestURI());
        String accessToken = request.getHeader("Authorization");
        if (StringUtils.isEmpty(accessToken)) {
            throw new ServiceException(LoginEnum.AUTH_FAIL);
        }
        // 解析JWT，解析失败异常。获取请求头中的信息
        AccToken accToken = JwtTokenUtils.parseToken(accessToken);
        // 判断是否过期
        String accessTokenRedis = (String) redisService.getCacheObject(RedisConstants.USER_TOKEN_INFORMATION_AUTH + accToken.getUserId() + accToken.getUserAccount() + accToken.getSiteId());
        if (StringUtils.isEmpty(accessTokenRedis)) {
            throw new ServiceException(LoginEnum.LOGIN_EXPIRED);
        }
        // TODO XUSJ 放userId和siteId到请求头中，便于后面使用
        // 将token解码后的数据存入当前线程的ThreadLocalMap中
        hostHolder.setUser(accToken);
        log.info("=========当前threadLocal中的参数{}=========", JSON.toJSONString(accToken));
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 请求结束，将保存的信息清除
        hostHolder.clear();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

    三、总结

    1、这图比较官方，上面是我自己的图比较糙
    在这里插入图片描述
    2、ThreadLocal和请求头的选择按照项目觉得即可

    3、贴一下我在上面使用到的自己封装的Redis工具

    package com.xiangzheng.website.utils.redis;

import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @author xusj
 * 
    CreateDate 2022/6/6 18:59
 */    
@Component
@SuppressWarnings("all")
public class RedisCache {
    @Resource
    public RedisTemplate redisTemplate;

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key   缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key      缓存的键值
     * @param value    缓存的值
     * @param timeout  时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout) {
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @param unit    时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <T> T getCacheObject(final String key) {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }

    /**
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteObject(final String key) {
        return redisTemplate.delete(key);
    }

    /**
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     */
    public long deleteObject(final Collection collection) {
        return redisTemplate.delete(collection);
    }

    /**
     * 缓存List数据
     *
     * @param key      缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final List<T> dataList) {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key) {
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    /**
     * 缓存Set
     *
     * @param key     缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet) {
        BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
        Iterator<T> it = dataSet.iterator();
        while (it.hasNext()) {
            setOperation.add(it.next());
        }
        return setOperation;
    }

    /**
     * 获得缓存的set
     *
     * @param key
     * @return
     */
    public <T> Set<T> getCacheSet(final String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param dataMap
     */
    public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
        if (dataMap != null) {
            redisTemplate.opsForHash().putAll(key, dataMap);
        }
    }

    /**
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public <T> Map<String, T> getCacheMap(final String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 往Hash中存入数据
     *
     * @param key   Redis键
     * @param hKey  Hash键
     * @param value 值
     */
    public <T> void setCacheMapValue(final String key, final String hKey, final T value) {
        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getCacheMapValue(final String key, final String hKey) {
        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key, hKey);
    }

    /**
     * 获取多个Hash中的数据
     *
     * @param key   Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }

    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern) {
        return redisTemplate.keys(pattern);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
  • 相关阅读:
    仿真软件Proteus8.10 SP3 pro一键安装、汉化教程（附proteus8.10下载链接安装视频）
    算术运算符2（阁瑞钛伦特软件-九耶实训）
    Visual Studio Code Python – 2022年7月更新
    hive正则匹配总结
    TCP网络协议
    风哥PG-DBA培训15：PostgreSQL集群解决方案与流复制项目实战
    【iOS】Category、Extension和关联对象
    创建型设计模式之单例模式
    『FastTunnel』荣获GVP的开源内网穿透工具，动手搭建属于自己的内网穿透平台
    ESP32学习笔记（50）——搭建环境、编译烧写（Windows+Espressif-IDE）
  • 原文地址：https://blog.csdn.net/weixin_46643875/article/details/126486876