springboot 配置 jjwt

最新推荐文章于 2024-10-09 21:43:08 发布
最新推荐文章于 2024-10-09 21:43:08 发布
阅读量1.7k 收藏 6
点赞数 1
分类专栏： spring auth 文章标签： token
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengxing_2/article/details/98946700
版权

JWT 全名 JSON WEB Token 主要作用为用户身份验证, 广泛应用与前后端分离项目当中.

    JWT 的优缺点 : https://www.jianshu.com/p/af8360b83a9f

 

一、pom.xml 引入jar文件

        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-api</artifactId>
            <version>0.10.7</version>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-impl</artifactId>
            <version>0.10.7</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-jackson</artifactId>
            <version>0.10.7</version>
            <scope>runtime</scope>
        </dependency>

二、添加jwt自定义字段 application.yml

# jwt 配置
custom:
  jwt:
    # header:凭证(校验的变量名)
    header: token
    # 有效期1天(单位:s)
    expire: 5184000
    # secret: 秘钥(普通字符串)
    secret: aHR0cHM6Ly9teS5vc2NoaW5hLm5ldC91LzM2ODE4Njg=
    # 签发者
    issuer: test-kou

三、添加加密解密方法


import io.jsonwebtoken.*;
import lombok.Data;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.DatatypeConverter;
import java.security.Key;
import java.util.Base64;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * JWT 工具类
 * <p>
 * jwt含有三部分：头部（header）、载荷（payload）、签证（signature）
 * (1)头部一般有两部分信息：声明类型、声明加密的算法（通常使用HMAC SHA256）
 * (2)载荷该部分一般存放一些有效的信息。jwt的标准定义包含五个字段：
 * - iss：该JWT的签发者
 * - sub: 该JWT所面向的用户
 * - aud: 接收该JWT的一方
 * - exp(expires): 什么时候过期，这里是一个Unix时间戳
 * - iat(issued at): 在什么时候签发的
 * (3)签证（signature） JWT最后一个部分。该部分是使用了HS256加密后的数据；包含三个部分
 *
 * @author kou
 */
@ConfigurationProperties(prefix = "custom.jwt")
@Data
@Component
public class JwtUtil {

    private static final Logger logger = LoggerFactory.getLogger(JwtUtil.class);

    // 秘钥
    private String secret;

    // 有效时间
    private Long expire;

    // 用户凭证
    private String header;

    // 签发者
    private String issuer;

    /**
     * 生成token签名
     *
     * @param subject
     * @return
     */
    public String generateToken(String subject) {

        final SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

        Date now = new Date();
        // 过期时间
        Date expireDate = new Date(now.getTime() + expire * 1000);

        //Create the Signature SecretKey
        final byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(Base64.getEncoder().encodeToString(getSecret().getBytes()));
        final Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName());

        final Map<String, Object> headerMap = new HashMap<>();
        headerMap.put("alg", "HS256");
        headerMap.put("typ", "JWT");

        //add JWT Parameters
        final JwtBuilder builder = Jwts.builder()
                .setHeaderParams(headerMap)
                .setSubject(subject)
                .setIssuedAt(now)
                .setExpiration(expireDate)
                .setIssuer(getIssuer())
                .signWith(signatureAlgorithm, signingKey);

        logger.info("JWT[" + builder.compact() + "]");
        return builder.compact();

    }

    /**
     * 解析token
     *
     * @param token token
     * @return
     */
    public Claims parseToken(String token) {

        Claims claims = null;
        try {
            final byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(Base64.getEncoder().encodeToString(getSecret().getBytes()));
            claims = Jwts.parser().setSigningKey(apiKeySecretBytes).parseClaimsJws(token).getBody();
            logger.info("Parse JWT token by: ID: {}, Subject: {}, Issuer: {}, Expiration: {}", claims.getId(), claims.getSubject(), claims.getIssuer(), claims.getExpiration());
        } catch (ExpiredJwtException | UnsupportedJwtException | MalformedJwtException | SignatureException
                | IllegalArgumentException e) {
            logger.info("Parse JWT errror " + e.getMessage());
            return null;
        }
        return claims;
    }

    /**
     * 判断token是否过期
     *
     * @param expiration
     * @return
     */
    public boolean isExpired(Date expiration) {

        return expiration.before(new Date());
    }

}

 

四、添加拦截方法，拦截token处理，我这边使用的是filter拦截处理，根据自己需求自定


import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URLDecoder;
import java.net.URLEncoder;

/**
 * 如果请求中（请求头或者Cookie）中存在JWT，则：
 * 1、解析JWT并查找对应的用户信息，然后加入request attribute中
 * 2、更新Cookie时间、更新JWT失效时间放入Header
 * <p>
 * OncePerRequestFilter 一次请求只进入一次filter
 */
@Component
@Slf4j
public class JWTFilter extends OncePerRequestFilter {

    public static final String SECURITY_USER = "SECURITY_USER";

    // 设置不需要校验的路径
    private static final String[] NOT_CHECK_URL = {"/login", "/registered"};

    @Autowired
    private JwtUtil jwtUtil;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {

        // 判断是否需要对token处理
        if (!isNotCheck(request.getRequestURI())) {
            // 获取token
            String token = getToken(request);

            if (StringUtils.isBlank(token)) {
                log.info("请求无效，原因：{} 为空！", jwtUtil.getHeader());
                request.setAttribute("exceptionCode", SystemParameters.TOKEN_IS_NULL.getIndex());
                request.setAttribute("exceptionMessage", "请求无效，原因：" + jwtUtil.getHeader() + " 为空！");
                request.getRequestDispatcher("/exception/authentication").forward(request, response);
                // throw new AuthenticationException(SystemParameters.TOKEN_IS_NULL.getIndex(),  "请求无效，原因：" + jwtUtil.getHeader() + " 为空！");
                return;
            }

            Claims claims = jwtUtil.parseToken(token);

            // 判断签名信息
            if (null != claims && !claims.isEmpty() && !jwtUtil.isExpired(claims.getExpiration())) {
                // 获取签名用户信息
                String userId = claims.getSubject();
                //获取相应的用户信息，可以在过滤器中先行获取，也可以先保存用户ID，在需要时进行获取
                // User user = usersService.findById(Long.valueOf(userId));

                request.setAttribute(SECURITY_USER, userId);
                Cookie jwtCookie = new Cookie(jwtUtil.getHeader(), URLEncoder.encode(token, "UTF-8"));
                jwtCookie.setHttpOnly(true);
                jwtCookie.setPath("/");
                response.addCookie(jwtCookie);

                response.addHeader(jwtUtil.getHeader(), token);
            } else {
                log.info("{} 无效，请重新登录！", jwtUtil.getHeader());
                request.setAttribute("exceptionCode", SystemParameters.AUTHENTICATION_FAILED.getIndex());
                request.setAttribute("exceptionMessage", jwtUtil.getHeader() + " 无效，请重新登录！");
                request.getRequestDispatcher("/exception/authentication").forward(request, response);
                // throw new AuthenticationException(SystemParameters.AUTHENTICATION_FAILED.getIndex(), jwtUtil.getHeader() + " 无效，请重新登录！");
                return;
            }
        }

        filterChain.doFilter(request, response);
    }

    /**
     * 获取token
     *
     * @param request
     * @return 返回token
     */
    private String getToken(HttpServletRequest request) {

        //先从header中获取token
        String token = request.getHeader(jwtUtil.getHeader());

        //再从cookie中获取
        if (StringUtils.isBlank(token)) {
            try {
                Cookie[] cookies = request.getCookies();
                if (cookies != null) {
                    for (Cookie cookie : cookies) {
                        if (jwtUtil.getHeader().equals(cookie.getName())) {
                            token = URLDecoder.decode(cookie.getValue(), "UTF-8");
                        }
                    }
                }
            } catch (Exception e) {
                log.error("Can NOT get jwt from cookie -> Message: {}", e);
            }
        }

        return token;
    }

    /**
     * 根据url判断是否需要校验，false需要校验
     *
     * @param url
     * @return 是否需要校验
     */
    private boolean isNotCheck(String url) {

        // 处理路径以"/" 结尾的"/"
        url = url.endsWith("/") ? url.substring(0, url.lastIndexOf("/")) : url;

        for (String path : NOT_CHECK_URL) {
            // 判断是否以 "/**" 结尾
            if (path.endsWith("/**")) {
                return url.startsWith(path.substring(0, path.lastIndexOf("/") + 1))
                        || url.equals(path.substring(0, path.lastIndexOf("/")));
            }

            // 判断url == path
            if (url.equals(path)) {
                return true;
            }
        }

        return false;
    }

}

 

五、配置过滤器


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 过滤器配置
 *
 * @author kou
 */
@Configuration
public class FilterConfig {

    @Autowired
    private JWTFilter jwtFilter;

    @Bean
    public FilterRegistrationBean registrationBean() {

        FilterRegistrationBean registration = new FilterRegistrationBean();
        // 设置过滤器
        registration.setFilter(jwtFilter);
        // 设置拦截路径
        registration.addUrlPatterns("/rest/*");
        // 设置过滤器名称
        registration.setName("JWTFilter");
        // 设置过滤器执行顺序
        registration.setOrder(1);

        return registration;
    }
}

六、添加异常处理类


/**
 * 认证异常类
 *
 * @author kou
 */
public class AuthenticationException extends RuntimeException {

    private static final long serialVersionUID = 1L;

    //自定义错误码
    private Integer code;

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    /**
     * Creates a new AuthenticationException.
     */
    public AuthenticationException() {
        super();
    }

    /**
     * Constructs a new AuthenticationException.
     *
     * @param message the reason for the exception
     */
    public AuthenticationException(String message) {
        super(message);
    }

    /**
     * Constructs a new AuthenticationException.
     *
     * @param cause the underlying Throwable that caused this exception to be thrown.
     */
    public AuthenticationException(Throwable cause) {
        super(cause);
    }

    /**
     * Constructs a new AuthenticationException.
     *
     * @param message the reason for the exception
     * @param cause   the underlying Throwable that caused this exception to be thrown.
     */
    public AuthenticationException(String message, Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new AuthenticationException.
     *
     * @param message the reason for the exception
     */
    public AuthenticationException(int code, String message) {
        super(message);
        this.code = code;
    }

    /**
     * Constructs a new AuthenticationException.
     *
     * @param cause the underlying Throwable that caused this exception to be thrown.
     */
    public AuthenticationException(int code, Throwable cause) {
        super(cause);
        this.code = code;
    }

    /**
     * Constructs a new AuthenticationException.
     *
     * @param message the reason for the exception
     * @param cause   the underlying Throwable that caused this exception to be thrown.
     */
    public AuthenticationException(int code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
    }

}

七、添加全局异常处理类


import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * 全局异常处理
 *
 * @author kou
 */
@ControllerAdvice
public class GlobalException {

    /**
     * 授权登录异常
     */
    @ResponseBody
    @ExceptionHandler(AuthenticationException.class)
    public BaseResult authenticationException(AuthenticationException e) {

        return new BaseResult(SystemParameters.FAIL.getIndex(), e.getMessage(), e.getCode());
    }

    @ExceptionHandler(Exception.class)
    @ResponseBody
    BaseResult exception(Exception e) {

        return new BaseResult(SystemParameters.FAIL.getIndex(), e.getMessage(), SystemParameters.ERROR.getIndex());
    }

}

注意：

     由于使用filter过滤器，springmvc 不能进行filter拦截异常，故通过请求转发来实现统一异常拦截

八、错误异常处理，用来处理filter转发出来的请求拦截异常，进而让springmvc统一处理异常

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;

/**
 * 错误控制器
 *
 * @author kou
 */
@RestController
public class ErrorController {

    @RequestMapping("/exception/authentication")
    public BaseResult authenticationException(HttpServletRequest request) {

        throw new AuthenticationException(Integer.valueOf(request.getAttribute("exceptionCode").toString()), request.getAttribute("exceptionMessage").toString());
    }
}

九、返回统一格式


public class BaseResult {

    // 结果状态码
    private int ret;
    // 结果说明
    private String msg;

    private int err;

    public BaseResult() {
    }

    public BaseResult(int ret, String msg, int err) {
        this.ret = ret;
        this.msg = msg;
        this.err = err;
    }

    public int getRet() {
        return ret;
    }

    public void setRet(int ret) {
        this.ret = ret;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public int getErr() {
        return err;
    }

    public void setErr(int err) {
        this.err = err;
    }

}

 

 

 

 

 

 

 

Springboot3: JWT认证支持
随风飘絮
10-20 2434
JSON Web Token (JWT)是一个开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于作为JSON对象在各方之间安全地传输信息。该信息可以被验证和信任，因为它是数字签名的。由三部分组成：1，头部（header）: token类型和签名算法, json2，数据（payload）: 存放实际需要传递的数据,json3，签名（Signature）：base64编码过的header数据+"."+base64编码过的payload数据，服务端密钥，从头部获取签名算法，进行加密获得。
JWT管理token授权
天天向上
08-14 891
jwt和传统session的区别？ 传统的session认证 1、用户向服务器发送用户名和密码。 2、服务器验证通过后，在当前对话（session）里面保存相关数据，比如用户角色、登录时间等等。 3、服务器向用户返回一个 session_id，写入用户的 Cookie。 4、用户随后的每一次请求，都会通过 Cookie，将 session_id 传回服务器。 5、服务器收到 sess...
手把手教你：在Spring Boot + Vue项目中实现JWT登录验证，打造高效安全的前后端分离系统
最新发布
小菜的博客
10-09 1421
手把手教你：在Spring Boot + Vue项目中实现JWT登录验证，打造高效安全的前后端分离系统
springboot3整合最新版jjwt（0.12.3）
m0_73376570的博客
01-31 4441
基于黑马的苍穹外卖，使用springboot3整合jjwt（0.12.3）
springboot jjwt
金溪的博客
11-01 1349
JJWT 全称Java Json Web Token。 而JWT是一种在两方之间传输信息的方法，在jwt的主体中编码的信息被称为claims。jwt的扩展形式是json，因此每个claim都是json对象中的一个键。 jwts增强了可验证性，接收都可以确定jwt没有通过验证签名来篡改。jwts可以加密签名成为jws，或加密成为jwe。 jwts生成的jwt的结果有三个部分的字符串，每个部分由...
Spring boot + jjwt
qq_42616672的博客
02-24 670
1. 引入依赖 <!--jwt--> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.9.0</version> </dependency> <!--阿里 FastJson依赖--> <depende
springboot使用jjwt
04-18
它简化了Spring应用程序的开发过程，提供了自动配置和约定优于配置的原则。而JWT（JSON Web Token）是一种用于身份验证和授权的开放标准，它可以在客户端和服务器之间全地传输信息。 在Spring Boot中使用JJWT（Java...
springboot 继承jjwt
09-14
在Spring Boot项目中继承jjwt，你可以按照以下步骤来配置和使用： 1. 首先，确保你已经添加了jjwt的依赖到你的项目中。可以在你的pom.xml文件中添加以下依赖： ```xml <groupId>io.jsonwebtoken <artifactId>...
springboot集成jjwt
03-30
<artifactId>jjwt <version>0.9.1 ``` 2. 创建 JWT 工具类 创建一个 JWT 工具类，用于生成和解析 JWT。 ``` @Component public class JwtUtils { private static final String SECRET_KEY = "your_secret_...
关于spring boot集成jjwt的示例
qq_51147454的博客
05-04 717
导入jjwt的maven坐标。# 写jjwt工具类。
实战指南：Spring Boot 3.x 与JJWT 0.9.x到0.12.5版本升级，使用HS256算法生成JWT
专注于深入研究多种编程语言，以实战为导向，逐步拓展开发技能，提升工程化编码和思维能力，展现无敌技术实力。
07-01 701
本实战指南旨在帮助开发者在Spring Boot 3.x应用中，从JJWT 0.9.x升级至0.12.5版本，有效地实现JWT生成并使用HS256算法进行加密。通过详细的示例和指导，您将了解如何应对升级带来的变化，并优化JWT在安全认证中的应用。
Springboot：JWT
沉迷写代码的程序猿的博客
03-22 4264
文章目录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
Spring Boot + jwt
weixin_63831348的博客
06-20 3338
Spring Boot + jwt
session与token
Uzizi的博客
07-30 480
基于session认证所显露的问题 Session: 每个用户经过我们的应用认证之后，我们的应用都要在服务端做一次记录，以方便用户下次请求的鉴别，通常而言session都是保存在内存中，而随着认证用户的增多，服务端的开销会明显增大。 扩展性: 用户认证之后，服务端做认证记录，如果认证的记录被保存在内存中的话，这意味着用户下次请求还必须要请求在这台服务器上,这样才能拿到授权的资源，这样在分布式的...
SpringBoot集成JWT
07-14 396
JWT（json web tokens）是目前比较流行的跨域认证解决方案；说通俗点就是比较流行的token生成和校验的方案。碰巧公司有个app的项目的token采用了jwt方案，因此记录下后端项目集成jwt的过程，方便后续查阅。一、jwt的简单介绍 jwt生成的token是一种无状态的token，服务端不需要对该token进行保存；它一般由客户端保存。客户端访问请求服务时，...
springboot中集成JWT
m0_47164142的博客
04-10 302
的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源。由三个部分组成：公共部分、私有部分、签名部分。最后由这三者组合进行。）是为了在网络应用环境间传递声明而执行的一种基于。
SpringBoot引入JWT
weixin_45131680的博客
01-13 685
随着技术的发展，分布式web应用的普及，通过session管理用户登录状态成本越来越高，因此慢慢发展成为token的方式做登录身份校验，然后通过token去取redis中的缓存的用户信息，随着之后jwt的出现，校验方式更加简单便捷化，无需通过redis缓存，而是直接根据token取出保存的用户信息，以及对token可用性校验，单点登录更为简单。
Spring Boot 实现 JWT
云胡
06-21 7803
Web 网站离不开用户认证，这边我们不用 ，而直接使用 。JWT 的背景知识可以看阮一峰老师的这篇文章: JSON Web Token 入门教程JWT 由三个部分组成：在 中添加 配置信息。 2.2 新建 JwtUtil 工具类 新建 目录，在 目录下新建 。将当前 注入到 容器中。，匹配 配置文件的前缀，然后将配置文件里面的数据加载到当前类。 2.3 用户登录创建 token 2.3 拦截器验证 token 如何自定义拦截器可以看我的这篇: Spring Boot 2 配置登录拦截。 三、参考资料
JWT
m0_46487331的博客
12-14 952
Author：Allen_Huang Version：1.0.0 一. JWT简介 什么是JWT？ JWT(JSON Web Token)是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准。 它将用户信息加密到token里，服务器不保存任何用户信息。服务器通过使用保存的密钥验证token的正确性，只要正确即通过验证；应用场景如用户登录。JWT详细讲解请见 github：https://github.com/jwtk/jjwt 为什么使用JWT？ 随着技术的发展，分布式web应用的普.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值