springboot实现JWT

最新推荐文章于 2024-07-14 17:37:12 发布
最新推荐文章于 2024-07-14 17:37:12 发布
阅读量275 收藏 1
点赞数
分类专栏： jwt 文章标签： jwt session spring
原文链接：https://blog.csdn.net/akiranicky/article/details/99307713
版权

pom.xml

 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- JWT依赖 -->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.7.0</version>
        </dependency>
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.4.0</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.28</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

编写JwtConfig

package com.hy.jwt_demo.config;


import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.Date;


/**
 * @author hy
 * @description:
 * @date 2020/09/07
 */
@ConfigurationProperties(prefix = "config.jwt")
@Component
public class JwtConfig {

    private String secret;
    private long expire;
    private String header;

    /**header
     * 生成token
     * @param subject
     * @return
     */
    public String createToken (String subject){
        Date nowDate = new Date();
        Date expireDate = new Date(nowDate.getTime() + expire * 1000);//过期时间

        return Jwts.builder()
                .setHeaderParam("typ", "JWT")
                .setSubject(subject)
                .setIssuedAt(nowDate)
                .setExpiration(expireDate)
                .signWith(SignatureAlgorithm.HS256, secret)
                .compact();
    }
    /**
     * 获取token中注册信息
     * @param token
     * @return
     */
    public Claims getTokenClaim (String token) {
        try {
            return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
        }catch (Exception e){
//            e.printStackTrace();
            return null;
        }
    }
    /**
     * 验证token是否过期失效
     * @param expirationTime
     * @return
     */
    public boolean isTokenExpired (Date expirationTime) {
        return expirationTime.before(new Date());
    }

    /**
     * 获取token失效时间
     * @param token
     * @return
     */
    public Date getExpirationDateFromToken(String token) {
        return getTokenClaim(token).getExpiration();
    }
    /**
     * 获取用户名从token中
     */
    public String getUsernameFromToken(String token) {
        return getTokenClaim(token).getSubject();
    }

    /**
     * 获取jwt发布时间
     */
    public Date getIssuedAtDateFromToken(String token) {
        return getTokenClaim(token).getIssuedAt();
    }

    // --------------------- getter & setter ---------------------

    public String getSecret() {
        return secret;
    }
    public void setSecret(String secret) {
        this.secret = secret;
    }
    public long getExpire() {
        return expire;
    }
    public void setExpire(long expire) {
        this.expire = expire;
    }
    public String getHeader() {
        return header;
    }
    public void setHeader(String header) {
        this.header = header;
    }
}

配置拦截器

package com.hy.jwt_demo.interceptor;


import com.hy.jwt_demo.config.JwtConfig;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.SignatureException;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @author hy
 * @description:
 * @date 2020/09/07
 */

@Component
public class TokenInterceptor extends HandlerInterceptorAdapter {

    @Resource
    private JwtConfig jwtConfig ;
    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws SignatureException {
        /** 地址过滤 */
        String uri = request.getRequestURI() ;
        if (uri.contains("/login")){
            return true ;
        }
        /** Token 验证 */
        String token = request.getHeader(jwtConfig.getHeader());
        if(StringUtils.isEmpty(token)){
            token = request.getParameter(jwtConfig.getHeader());
        }
        if(StringUtils.isEmpty(token)){
            throw new SignatureException(jwtConfig.getHeader()+ "不能为空");
        }

        Claims claims = null;
        try{
            claims = jwtConfig.getTokenClaim(token);
            if(claims == null || jwtConfig.isTokenExpired(claims.getExpiration())){
                throw new SignatureException(jwtConfig.getHeader() + "失效，请重新登录。");
            }
        }catch (Exception e){
            throw new SignatureException(jwtConfig.getHeader() + "失效，请重新登录。");
        }

        /** 设置 identityId 用户身份ID */
        request.setAttribute("identityId", claims.getSubject());
        return true;
    }
}

注册拦截器到SpringMvc

package com.hy.jwt_demo.config;



import com.hy.jwt_demo.interceptor.TokenInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import javax.annotation.Resource;
/**
 * @author hy
 * @description:
 * @date 2020/09/07
 */
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Resource
    private TokenInterceptor tokenInterceptor ;
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(tokenInterceptor).addPathPatterns("/**");
    }
}

统一异常处理类

package com.hy.jwt_demo.exception;

import com.hy.jwt_demo.config.ResultDto;
import com.hy.jwt_demo.config.ResultUtil;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.security.SignatureException;

/**
 * @author hy
 * @description:
 * @date 2020/09/07
 */
@RestControllerAdvice
public class PermissionHandler {
    @ExceptionHandler(value = { SignatureException.class })
    @ResponseBody
    public ResultDto<?> authorizationException(SignatureException e){
        return ResultUtil.error("1008",e.getMessage());
    }
    @ExceptionHandler(value = { RuntimeException.class })
    @ResponseBody
    public ResultDto<?> RuntimeException(RuntimeException e){
        return ResultUtil.error("1002",e.getMessage());
    }
}

编写测试接口

package com.hy.jwt_demo.controller;

import com.alibaba.fastjson.JSONObject;
import com.hy.jwt_demo.config.JwtConfig;
import com.hy.jwt_demo.config.ResultDto;
import com.hy.jwt_demo.config.ResultUtil;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

/**
 * @author hy
 * @description:
 * @date 2020/09/07
 */


@RestController
public class TokenController {

    @Resource
    private JwtConfig jwtConfig;

    /**
     * 用户登录接口
     *
     * @param userName
     * @param passWord
     * @return
     */
    @PostMapping("/login")
    public ResultDto<?> login(@RequestParam("userName") String userName,
                              @RequestParam("passWord") String passWord,HttpServletRequest request) {
        HttpSession session = request.getSession();
        Object userName1 = session.getAttribute("userName");
        JSONObject json = new JSONObject();
        String userId = null;
        /** 验证userName，passWord和数据库中是否一致，如不一致，直接return ResultTool.errer(); 【这里省略该步骤】*/

        // 这里模拟通过用户名和密码，从数据库查询userId
        // 这里把userId转为String类型，实际开发中如果subject需要存userId，则可以JwtConfig的createToken方法的参数设置为Long类型
        if ("zhangsan".equals(userName) && "123".equals(passWord)) {
            userId  =5 + "";
        }else {
            throw new RuntimeException("用户名或密码有误");
        }

        String token = jwtConfig.createToken(userId);
        if (!StringUtils.isEmpty(token)) {
            json.put("token", token);
        }
        return ResultUtil.success(json,"0000","success");
    }

    /**
     * 需要 Token 验证的接口
     */
    @PostMapping("/info")
    public ResultDto<?> info() {
        return ResultUtil.success("info","0000","success");
    }

    /**
     * 根据请求头的token获取userId
     *
     * @param request
     * @return
     */
    @GetMapping("/getUserInfo")
    public ResultDto<?> getUserInfo(HttpServletRequest request) {
        String usernameFromToken = jwtConfig.getUsernameFromToken(request.getHeader("token"));
        return ResultUtil.success(usernameFromToken,"0000","success");
    }

    /*
        为什么项目重启后，带着之前的token还可以访问到需要info等需要token验证的接口？
        答案：只要不过期，会一直存在，类似于redis
     */

}

用PostMan测试工具测试一下，访问登录接口，当对账号密码验证通过时，则返回一个token给客户端：

在这里插入图片描述

当直接去访问info接口时，会返回token为空的自定义异常：

在这里插入图片描述

当在请求头加上正确token时，则拦截器验证通过，可以正常访问到接口：

在这里插入图片描述

当在请求头加入一个错误token，则会返回token失效的自定义异常：

在这里插入图片描述

JWT总结

  1. 基于JSON，所以JWT是可以进行跨语言支持的，像JAVA，JavaScript，Node.JS，PHP等很多语言都可以使用。

  2. payload部分，需要时JWT可以存储一些其他业务逻辑所必要的非敏感信息。

  3. 体积小巧，便于传输；JWT的构成非常简单，字节占用很小，所以它是非常便于传输的。它不需要在服务端保存会话信息, 所以它易于应用的扩展。

见哥敬礼
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【SpringBoot】45、SpringBoot中整合JWT实现Token验证（注解篇）
Asurplus
02-28 21万+
前言 上篇文章，我们已经在 SpringBoot 中整合了 JWT 并实现了 Token 验证，那我们在实际应用中就会发现，如果每个 视图层（controller）都手动验证 token，代码就会显得特别臃肿，本篇文章主要为了解决该问题。 如果对整合 JWT 还不熟悉的朋友，可以先看看我的这篇博客：【SpringBoot】四十四、SpringBoot中整合JWT实现Token验证 自定义注解 1、创建自定义注解 package com.asurplus.common.annotation; import
SpringBoot集成JWT生成token及校验方法过程解析
08-19
主要介绍了SpringBoot集成JWT生成token及校验方法过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Springboot 生成JWT
qq_50909707的博客
07-20 579
Springboot 生成JWT
Springboot与JWT
最新发布
游王子的博客
07-14 1090
JWT简称JSON Web Token，也就是通过JSON形式作为Web应用中的令牌，用于在各方之间安全地将信息作为JSON对象传输。在数据传输过程中还可以完成数据加密、签名等相关处理。
Springboot Jwt实现
Lazy_G的博客
01-27 531
JwtInterceptor import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.hf.manager.annotation.JwtToken; import com.hf.manager.commons.Constant; import com.hf.manager.entity.User; import com.hf.manager.service.UserService; import com.h
Spring Boot 实现 JWT
云胡
06-21 7715
Web 网站离不开用户认证，这边我们不用 ，而直接使用 。JWT 的背景知识可以看阮一峰老师的这篇文章: JSON Web Token 入门教程JWT 由三个部分组成：在 中添加 配置信息。 2.2 新建 JwtUtil 工具类 新建 目录，在 目录下新建 。将当前 注入到 容器中。，匹配 配置文件的前缀，然后将配置文件里面的数据加载到当前类。 2.3 用户登录创建 token 2.3 拦截器验证 token 如何自定义拦截器可以看我的这篇: Spring Boot 2 配置登录拦截。 三、参考资料
SpringBoot-JWT生成
m0_62785037的博客
09-20 313
SpringBoot-JWT生成详细说明和实战
基于springboot+jwt实现刷新token过程解析
08-19
基于SpringBoot+JWT实现刷新Token过程解析 标题解析 本文主要介绍了基于SpringBoot和JWT实现刷新Token的过程解析，旨在帮助读者更好地理解Token的刷新机制和实现方式。 描述解析 文中通过示例代码详细介绍了基于...
基于springboot实现JWT登录拦截及验证(超详细版)
Java程序员十六的博客
06-26 660
基于Springboot通过Jwt实现登录拦截及验证
springboot + jwt + websocket + 拦截
09-02
在IT行业中，Spring Boot、JWT（JSON Web Token）和WebSocket是三个非常重要的技术概念，而“拦截”通常指的是在系统中实现的一种中间件机制，用于处理请求或响应。结合提供的标题和描述，我们可以深入探讨这四个...
java jwt刷新_基于springboot+jwt实现刷新token过程解析
weixin_35448535的博客
02-27 2269
前一段时间讲过了springboot+jwt的整合，但是因为一些原因(个人比较懒)并没有更新关于token的刷新问题，今天跟别人闲聊，聊到了关于业务中token的刷新方式，所以在这里我把我知道的一些点记录一下，也希望能帮到一些有需要的朋友，同时也希望给我一些建议，话不多说，上代码！1：这种方式为在线刷新，比方说设定的token有效期为30min,那么每次访问资源时，都会在拦截器中去判断一下toke...
SPRINGBOOT+JWT
07-16
最新springboot+jwt校验案例，完整代码，下载即用，最新springboot+jwt校验案例，完整代码，下载即用，
springboot实现jwt
AYANBAO的博客
04-18 224
2.新建jwt生成的工具类。pom中新增以上依赖。
springboot-JWT
FA的博客
07-23 103
JWT原理 单点登录
Springboot：JWT
沉迷写代码的程序猿的博客
03-22 4144
文章目录Springboot：JWT一、JWT简介1、JWT的优势2、JWT的结构2.1、标头（Header）2.2、有效负荷（Payload）2.3、签名（Signature）二、SpringBoot整合JWT Springboot：JWT 一、JWT简介 JWT，是指JSON Web Token，也就指通过JSON形式作为Web应用中的令牌，用于在各方之间安全地将信息作为JSON对象传输。在数据传输过程中还可以完成数据加密、签名等相关处理。 1、JWT的优势 在JavaWeb阶段，经常使用ses
SpringBoot中使用JWT
cxzhq2002的杂记
11-04 1664
JWT是什么我就不说了，这里只说名SpringBoot中怎么用。 首先在pom中天际依赖 1 <dependency> 2 <groupId>org.bitbucket.b_c</groupId> 3 <artifactId>jose4j</artifactId> 4 <version>0.6.5</version> 5 </dependency> 这里我用
Spring Boot + jwt
weixin_63831348的博客
06-20 2074
Spring Boot + jwt
springboot+jwt
weixin_41945912的博客
04-08 177
1.pom <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.9.1</version> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值