SpringBoot整合JWT示例教程

最新推荐文章于 2024-08-13 22:37:59 发布
最新推荐文章于 2024-08-13 22:37:59 发布
阅读量879 收藏 21
点赞数 27
分类专栏： spring 文章标签： spring boot 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_Richard/article/details/140388565
版权

1. JWT简介

JSON Web Token (JWT) 是一种开放标准（RFC 7519），它定义了一种紧凑且自包含的方式，用于在各方之间作为 JSON 对象安全地传输信息。由于这些信息是经过数字签名的，因此可以被验证和信任。JWT 通常用于身份验证和信息交换场景，特别是在 Web 应用程序的认证和授权机制中。

组成
JWT 由三部分组成：Header、Payload 和 Signature。这三部分分别用点（.）分隔，形成一个字符串。

Header（头部）：
Header 通常由两部分组成：令牌的类型（JWT）和所使用的签名算法（例如，HMAC SHA256 或 RSA）。

{
  "alg": "HS256",
  "typ": "JWT"
}

这个 JSON 对象被 Base64Url 编码后，形成 JWT 的第一部分。
Payload（负载）：

  • Payload 包含声明（claims），声明是关于实体（通常是用户）和其他数据的声明。声明有三种类型：
  • Registered claims（注册声明）：预定义的声明，如 iss（发行者）、exp（过期时间）、sub（主题）、aud（受众）。
  • Public claims（公共声明）：可以自由定义的声明，但为了避免冲突，建议在 IANA JSON Web Token Claims 注册表中注册或使用 URI 作为声明名称的前缀。
  • Private claims（私有声明）：自定义的声明，用于共享信息，比如用户角色、权限等。
    例:
{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true
}

这个 JSON 对象也被 Base64Url 编码后，形成 JWT 的第二部分。
Base64编码方式是可逆的，也就是透过编码后发放的Token内容是可以被解析的。一般而言不建议在Payload放敏感讯息，比如使用者的密码。
Signature（签名）：
签名部分用于验证消息在传输过程中未被篡改。
首先，需要指定一个密钥，然后使用指定的签名算法对编码后的 Header 和 Payload 以及一个密钥进行签名。签名的过程实际上是对头部以及负载内容进行签名，防止内容被窜改。如果有人对头部以及负载的内容解码之后进行修改，再进行编码，最后加上之前的签名组合形成新的JWT的话，那么服务器端会判断出新的头部和负载形成的签名和JWT附带上的签名是不一样的。如果要对新的头部和负载进行签名，在不知道服务器加密时用的密钥的话，得出来的签名也是不一样的。

例子：

HMACSHA256(
  base64UrlEncode(header) + "." + base64UrlEncode(payload),
  secret
)

生成的签名也被 Base64Url 编码，形成 JWT 的第三部分。

基于JWT的认证流程：
在这里插入图片描述

  • 前端通过Web表单将自己的用户名和密码发送到后端的接口。该过程一般是HTTP的POST请求。建议的方式是通过SSL加密的传输(https协议)，从而避免敏感信息被嗅探；
  • 后端核对用户名和密码成功后，将用户的id等其他信息作为JWT Payload(负载)，将其与头部分别进行Base64编码拼接后签名，形成一个JWT(Token)；
  • 后端将JWT字符串作为登录成功的返回结果返回给前端。前端可以将返回的结果保存在localStorage（浏览器本地缓存）或cookie上，退出登录时前端删除保存的JWT即可；
  • 前端在每次请求时将JWT放入HTTP的Header中的Authorization位。(解决XSS和XSRF问题）HEADER
  • 后端检查是否存在，如存在验证JWT的有效性。例如，检查签名是否正确﹔检查Token是否过期等；
  • 验证通过后后端使用JWT中包含的用户信息进行其他逻辑操作，返回相应结果。

注：Base64编码方式是可逆的，也就是透过编码后发放的Token内容是可以被解析的。一般而言，不建议在有效载荷内放敏感讯息，比如使用者的密码。

2. 准备工作

环境：JDK8 + SpringBoot2.6.13

2.1 生成秘钥对

需要使用到jdk的keytool工具，在jdk安装目录的bin目录内，在cmd控制窗口执行JDK中keytool的命令：

keytool -genkeypair -alias test -keyalg RSA -keysize 2048 -validity 365 -keystore test.jks -storepass test123 -keypass test123 -dname "CN=Sakura, OU=xxb, O=ncu, L=nc, ST=JX, C=CN"

参数解释

  • genkeypair: 生成一个密钥对（包括公钥和私钥）。
  • alias test: 为生成的密钥对指定一个别名 test。别名是用来识别密钥条目的。
  • keyalg RSA: 指定密钥对的算法为 RSA。RSA 是一种常用的公钥加密算法。
  • keysize 2048: 指定密钥的大小为 2048 位。密钥越长，安全性越高，但性能开销也越大。
  • validity 365: 指定证书的有效期为 365 天。
  • keystore test.jks: 指定密钥库文件的名称为 test.jks。如果文件不存在，keytool 会创建一个新的文件。
  • storepass test123: 指定密钥库的密码为 test123。这是保护整个密钥库的密码。
  • keypass test123: 指定密钥的密码为 test123。这是保护单个密钥条目的密码。
  • dname “CN=Sakura, OU=xxb, O=ncu, L=nc, ST=JX, C=CN”: 指定证书的详细信息，依次为名字与姓氏，组织单位，城市，区县，国家代码，使用逗号分隔的格式。

执行完命令后，会警告：

JKS 密钥库使用专用格式。建议使用 keytool -importkeystore -srckeystore test.jks -destkeystore test.jks -deststoretype pkcs12迁移到行业标准格式 PKCS12。
执行下上述命令即可：

keytool -importkeystore -srckeystore test.jks -destkeystore test.jks -deststoretype pkcs12

最后，将生成的test.jks文件放到springboot的resources目录（即类路径下）。

2.2 SpringBoo项目配置

项目目录如下：
在这里插入图片描述
maven 依赖：

server:
  port: 9000  # 服务端口

# 自定义JWT配置
<dependencies>
        <!-- web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- 注解执行器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- validation -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- hutool -->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.11</version>
        </dependency>
        <!--加密-->
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-crypto</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-rsa</artifactId>
            <version>1.0.9.RELEASE</version>
        </dependency>
    </dependencies>

application.yml配置文件：

server:
  port: 9000  # 服务端口

# 自定义JWT配置
app:
  jwt:
    location: classpath:test.jks  # JWT密钥存放位置，classpath为resource文件夹
    alias: test  # 别名
    password: test123  # 密码
    tokenTTL: 30m  # Token有效期为30min

  auth:
    excludePaths: # 排除的路径，不需要认证的路径
      - /auth/login

JwtApplication .java

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@SpringBootApplication
@EnableConfigurationProperties
@ConfigurationPropertiesScan("com.jwt.demo.config")
public class JwtApplication {

    public static void main(String[] args) {
        SpringApplication.run(JwtApplication.class, args);
    }

}

AuthProperties.java

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import java.util.List;

@Data
@ConfigurationProperties(prefix = "app.auth")
public class AuthProperties {
    /***
     * 指定需要拦截的请求路径
     */
    private List<String> includePaths;

    /**
     * 指定需要放行的请求路径
     */
    private List<String> excludePaths;
}

JwtProperties .java

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.core.io.Resource;

import java.time.Duration;

@Data
@ConfigurationProperties(prefix = "app.jwt")
public class JwtProperties {
    private Resource location;
    private String password;
    private String alias;
    private Duration tokenTTL = Duration.ofMinutes(10);

}

SecurityConfig .java

import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.rsa.crypto.KeyStoreKeyFactory;

import java.security.KeyPair;

@Configuration
@EnableConfigurationProperties(JwtProperties.class)
public class SecurityConfig {

    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    /**
     * 根据配置文件读取jks文件的密钥对
     */
    @Bean
    public KeyPair keyPair(JwtProperties properties){
        // 获取秘钥工厂
        KeyStoreKeyFactory keyStoreKeyFactory =
                new KeyStoreKeyFactory(
                        properties.getLocation(),
                        properties.getPassword().toCharArray());
        //读取钥匙对
        return keyStoreKeyFactory.getKeyPair(
                properties.getAlias(),
                properties.getPassword().toCharArray());
    }
}

JwtTool .java

import cn.hutool.core.exceptions.ValidateException;
import cn.hutool.jwt.JWT;
import cn.hutool.jwt.JWTValidator;
import cn.hutool.jwt.signers.JWTSigner;
import cn.hutool.jwt.signers.JWTSignerUtil;
import com.jwt.demo.constants.UserConstants;
import com.jwt.demo.exception.UnauthorizedException;
import org.springframework.stereotype.Component;

import java.security.KeyPair;
import java.time.Duration;
import java.util.Date;

@Component
public class JwtTool {
    private final JWTSigner jwtSigner;

    public JwtTool(KeyPair keyPair) {
        this.jwtSigner = JWTSignerUtil.createSigner(UserConstants.ALGORITHM, keyPair);
    }

    /**
     * 创建 access-token
     *
     * @param userId 用户id
     * @param ttl    有效时间
     * @return access-token
     */
    public String createToken(Long userId, Duration ttl) {
        // 1.生成jws
        return JWT.create()
                .setPayload(UserConstants.PAY_LOAD, userId) // 设置载荷
                .setExpiresAt(new Date(System.currentTimeMillis() + ttl.toMillis()))    // 设置过期时间
                .setSigner(jwtSigner)
                .sign();
    }

    /**
     * 解析token
     *
     * @param token token
     * @return 解析刷新token得到的用户信息
     */
    public Long parseToken(String token) {
        // 1.校验token是否为空
        if (token == null) {
            throw new UnauthorizedException("未登录");
        }
        // 2.校验并解析jwt
        JWT jwt;
        try {
            jwt = JWT.of(token).setSigner(jwtSigner);
        } catch (Exception e) {
            throw new UnauthorizedException("无效的token", e);
        }
        // 2.校验jwt是否有效
        if (!jwt.verify()) {
            // 验证失败
            throw new UnauthorizedException("无效的token");
        }
        // 3.校验是否过期
        try {
            JWTValidator.of(jwt).validateDate();
        } catch (ValidateException e) {
            throw new UnauthorizedException("token已经过期");
        }
        // 4.数据格式校验
        Object userPayload = jwt.getPayload(UserConstants.PAY_LOAD);
        if (userPayload == null) {
            // 数据为空
            throw new UnauthorizedException("无效的token");
        }

        // 5.数据解析
        try {
            Long userId = Long.valueOf(userPayload.toString());

            return userId;
        } catch (RuntimeException e) {
            // 数据格式有误
            throw new UnauthorizedException("无效的token");
        }
    }
}

UserConstants .java

/**
 * 常量类
 *
 * @date 2024-07-12 11:27
 */
public interface UserConstants {
    /**
     * JWT 载荷字段
     */
    String PAY_LOAD = "user";

    /**
     * 加密算法RSA256
     */
    String ALGORITHM = "rs256";

    /**
     * token对应的请求头字段名称
     */
    String AUTHORAZATION = "authorization";
}

3. 登录拦截器

编写登录拦截器逻辑，并注入到Spring的拦截器链。
AuthInterceptor .java

import cn.hutool.core.text.AntPathMatcher;
import cn.hutool.core.util.StrUtil;
import com.jwt.demo.config.AuthProperties;
import com.jwt.demo.constants.UserConstants;
import com.jwt.demo.exception.UnauthorizedException;
import com.jwt.demo.utils.JwtTool;
import com.jwt.demo.utils.UserContext;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
@RequiredArgsConstructor
public class AuthInterceptor implements HandlerInterceptor {

    // 采用构造器注入的方式注入配置类
    private final AuthProperties authProperties;

    private final JwtTool jwtTool;

    private final AntPathMatcher antPathMatcher = new AntPathMatcher();


    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        // 判断是否需要进行登录拦截
        if (isExcludedPath(request.getRequestURI())) {
            // 若不需要登录拦截，则放行
            return true;
        }
        // 若需要登录拦截，则获取token
        String header = String.valueOf(request.getHeader(UserConstants.AUTHORAZATION));
        String token = null;
        // 判断token是否存在
        if (StrUtil.isNotBlank(header)) {
            token = header;
        }
        // 校验并解析token
        Long userId = null;
        try {
            userId = jwtTool.parseToken(token);
        } catch (UnauthorizedException e) {
            // 拦截该请求
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            response.setContentType("application/json;charset=UTF-8");
            response.getWriter().write("{\"error\": \"Unauthorized\", \"message\": \"" + e.getMessage() + "\"}");
            return false; // 返回false以阻止请求的进一步处理

        }
        // 传递用户信息，放置在ThreadLocal中
        UserContext.setUser(userId);
        // 放行该请求
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 清空ThreadLocal
        UserContext.removeUser();
    }

    /**
     * 判断是否需要进行登录拦截
     *
     * @param path 当前请求的路径
     * @return 是否是不需要登录拦截的路径
     */
    private boolean isExcludedPath(String path) {
        // 判断是否是不需要登录拦截的路径
        for (String excludePath : authProperties.getExcludePaths()) {
            // 选择antPathMatcher实现路径匹配
            if (antPathMatcher.match(excludePath, path)) {
                return true;
            }
        }
        return false;
    }
}

MvcConfig .java

import com.jwt.demo.interceptor.AuthInterceptor;
import lombok.RequiredArgsConstructor;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.DispatcherServlet;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * MVC配置
 *
 * @author: hong.jian
 * @date 2024-03-02 20:02
 */
@Configuration
@ConditionalOnClass(DispatcherServlet.class)
@RequiredArgsConstructor
public class MvcConfig implements WebMvcConfigurer {
    private final AuthInterceptor authInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 将自定义的拦截器进行注册
        registry.addInterceptor(authInterceptor);
    }
}

编写控制器AuthController
AuthController.java

import com.jwt.demo.config.JwtProperties;
import com.jwt.demo.domain.dto.LoginFormDTO;
import com.jwt.demo.domain.po.User;
import com.jwt.demo.domain.vo.UserLoginVO;
import com.jwt.demo.utils.JwtTool;
import com.jwt.demo.utils.UserContext;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author: hong.jian
 * @date 2024-07-12 10:36
 */
@RestController
@RequiredArgsConstructor
@Slf4j
@RequestMapping("/auth")
public class AuthController {

    private final JwtTool jwtTool;
    private final JwtProperties jwtProperties;

    /**
     * 用户登录后生成token
     *
     * @param loginDTO 登录表单
     * @return 含token的用户信息
     */
    @PostMapping("/login")
    public UserLoginVO login( LoginFormDTO loginDTO) {
        // 1.获取表单信息(省略)
        String username = loginDTO.getUsername();
        String password = loginDTO.getPassword();
        // 2. 登录逻辑校验（需要对接DB，这里使用静态数据模拟）
        User user = User.builder()
                .id(111L)
                .username("Sakura")
                .build();
        // 3.生成TOKEN
        String token = jwtTool.createToken(user.getId(), jwtProperties.getTokenTTL());
        // 4.封装VO返回
        UserLoginVO vo = UserLoginVO.builder().userId(user.getId()) // 用户id
                .username(user.getUsername())   // 用户名
                .token(token)   // token
                .build();
        log.info("UserLoginVO:{}", vo);
        return vo;
    }

    /**
     * 用户登录后生成token
     * 测试接口
     */
    @GetMapping("/test")
    public void test() {
        // 直接从ThreadLocal获取用户信息
        log.info("userId:{}", UserContext.getUser());
    }

}

4. 测试

控制台日志：

2024-07-12 21:29:51.329  INFO 25212 --- [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 9000 (http) with context path ''
2024-07-12 21:29:51.335  INFO 25212 --- [  restartedMain] com.jwt.demo.JwtApplication              : Started JwtApplication in 2.352 seconds (JVM running for 3.21)
2024-07-12 21:29:51.710  INFO 25212 --- [nio-9000-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2024-07-12 21:29:51.710  INFO 25212 --- [nio-9000-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2024-07-12 21:29:51.711  INFO 25212 --- [nio-9000-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 1 ms
2024-07-12 21:29:58.489  INFO 25212 --- [nio-9000-exec-9] com.jwt.demo.controller.AuthController   : UserLoginVO:UserLoginVO(token=eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJ1c2VyIjoxMTEsImV4cCI6MTcyMDc5Mjc5OH0.KjmVdTh1RYUOZ_okycZJoj86qkfqlRuSPrwmjMNYS2uS0IwzM1Ab2D4m53F6z4x2zZxEt4aReC-Rnb_HpAx1uj0-unxAlsbe5mW9ok1GhtWp7EuW0k1rgQRA0nx6DUPwUmxhOXIyM9tdJsN0Sae5KQ5mimKORtB6n-VhIDo-cKqdTvtwKUVSbSiCHoQRryUBI2333TjdwkrYg2o-Fdwt80LkHxWOwoGelqmThDlvIvY-Nfkb0-EFIq1IlA027QBN3-TJdohy_3ATWWXOS1h4zuNzTzeN_ML4BZI-SWa2EajQl1eBpgYWZttWTcduV2WGDhsH-zsafC2IvW9tpz6b3A, userId=111, username=Sakura)
2024-07-12 21:30:49.347  INFO 25212 --- [io-9000-exec-10] com.jwt.demo.controller.AuthController   : userId:111

在这里插入图片描述
登录后请求需要带上token
在这里插入图片描述

Mr_Richard
关注
专栏目录
SpringBoot整合JWT
weixin_45782384的博客
12-29 140
新建一个SpringBoot项目 导入 Maven 坐标 <!--引入 jwt--> <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.4.0</version> </dependency> 配置application.properties文件 server.po
如何在springboot项目中使用JWT
weixin_51496936的博客
06-27 4359
开发初期，我试图用session来保存暂时需要保存或者暂时生成的数据，例如保存用户的账号密码记住用户登录的状态、保存各行政区的预约号球数量、保存用户当天取消预约次数等。但是使用session应用于前后端分离项目存在一定的弊端，例如由于session是存在与服务器的物理内存中，所以在分布式系统中，这种方式将会失效、因为session认证本质基于cookie，由于基于Cookie，而cookie无法跨域，所以session的认证也无法跨域，对单点登录不适用。该信息可以被验证和信任，因为它是数字签名的。
Spring Boot整合JWT
10-16
一个学习Spring Boot整合JWT的demo，使用的IDE是idea。
SpringBoot使用JWT详解
最新发布
qq_41765777的博客
08-13 848
son web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准.该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。
深入SpringBoot：JWT的集成与使用
Hello World
04-05 2576
JSON Web Token（JWT）是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519)，它定义了一种紧凑且自包含的方式，用于在各方之间以JSON对象安全传输信息。这些信息可以通过数字签名进行验证和信任。可以使用秘密（使用HMAC算法）或使用RSA的公钥/私钥对对JWT进行签名。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，该token也可直接被用于认证，也可被加密。是目前最流行的跨域认证解决方案。
Spring Boot + jwt
weixin_63831348的博客
06-20 2421
Spring Boot + jwt
springboot中整合JWT
weixin_60376559的博客
01-31 1739
springboot使用jwt
xmljava系统源码-JWT-DEMO:SpringBoot整合JWT完成权限验证功能示例
06-06
SpringBoot整合JWT完成权限验证功能示例 JWT官网：  JWT(Java版)的github地址: 什么是JWT Json Web Token（JWT）：JSON网络令牌，是为了在网络应用环境间传递声明而制定的一种基于JSON的开放标准（(RFC 7519)。JWT...
springboot整合jwt整合knife4j.zip
01-22
整合JWT到Spring Boot的第一步是添加jjwt和Spring Security依赖。在pom.xml中，加入以下依赖： ```xml <groupId>io.jsonwebtoken <artifactId>jjwt <version>0.9.1 <groupId>org.springframework.boot ...
spring-boot系列，使用JWT实现登录认证、完整的前后台交互的系统设计案例
03-09
spring-boo框架，基于JWT、redis鉴权设计，使用restful风格设计开发，前台使用layui、bootstrap等
springboot整合jwt示例下载
11-28
要实现Spring Boot整合JWT，你可以在网上搜索并下载一个示例项目，或者在官方文档中找到相关示例代码。在这个示例项目中，你可以学习到如何配置Spring Boot应用以支持JWT认证，如何定义JWT的生成和解析规则，以及...
springboot整合jwt实现单点登录
qq_35872777的博客
07-06 7929
jwt的结构：
springboot整合JWT
hand2020的博客
05-28 460
springboot整合JWT一、JWT介绍1.JWT的格式2.怎样使用token？3.流程图二、java代码实现1.maven依赖2.配置application.properties3.启动类4.实现代码JwtControllerCreatTokenJwtFilter测试效果1.浏览器发送请求获取token2.将token放入请求头中请求 一、JWT介绍 JSON Web token简称JWT， 是用于对应用程序上的用户进行身份验证的标记。也就是说, 使用 JWTS 的应用程序不再需要保存有关其用户的 c
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值