基于SpringBoot2开发WebApi（六）JWT(json web token)集成

最新推荐文章于 2024-01-03 19:15:44 发布
最新推荐文章于 2024-01-03 19:15:44 发布
阅读量1.4k 收藏 2
点赞数
分类专栏： Java Spring Boot 文章标签： spring boot jwt token
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_17486399/article/details/117659948
版权

1.前言

1.1.JWT说明

JWT全程JSON Web Token，是一个开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于作为JSON对象在各方之间安全地传输信息。该信息可以被验证和信任，因为它是数字签名。

1.2.什么情况下需要用JWT

  • Authorization (授权) : 这是使用JWT的最常见场景。一旦用户登录，后续每个请求都将包含JWT，允许用户访问该令牌允许的路由、服务和资源。单点登录是现在广泛使用的JWT的一个特性，因为它的开销很小，并且可以轻松地跨域使用。
  • Information Exchange (信息交换) : 对于安全的在各方之间传输信息而言，JSON Web Token无疑是一种很好的方式。因为JWT可以被签名，例如，用公钥/私钥对，你可以确定发送人就是它们所说的那个人。另外，由于签名是使用头和有效负载计算的，您还可以验证内容没有被篡改。

1.3.JWT结构说明

JSON Web Token由三部分组成，它们之间用圆点(.)连接。这三部分分别是：

  • Header：JWT头
  • Payload：有效载荷
  • Signature：签名

结构是这样的：xxxxxx.yyyyyy.zzzzzz

例如：

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhdWQiOlsiMSIsImFkbWluIiwiMSJdLCJleHAiOjE2MjMwNzUyMzcsImlhdCI6MTYyMzA0NjQzN30.pT5NgZCkfN2WwQS8rp1Scifa07KbuvZbXO8y8596ACg

2.集成说明

2.1引入依赖

        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.4.0</version>
        </dependency>

2.2.定义Token工具类

TokenUtil
package com.xxxxxx.sim.utils;

import com.auth0.jwt.JWT;
import com.xxxxxx.sim.model.AdminUser;
import org.springframework.boot.autoconfigure.kafka.KafkaProperties;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.math.BigInteger;
import java.util.List;

/**
 * Token方法封装
 * @author xxxx
 * @date 20200428
 */
public class TokenUtil {
    /**
     * 获取Token里面的UserId
     * @return
     */
    public static String getTokenUserId() {
        // 从 http 请求头中取出 token
        String token = getRequest().getHeader("token");
        String userId = JWT.decode(token).getAudience().get(0);
        return userId;
    }

    /**
     * 获取Token里面的UserName
     * @return
     */
    public static String getTokenUseName(){
        // 从 http 请求头中取出 token
        String token = getRequest().getHeader("token");
        String userName = JWT.decode(token).getAudience().get(1);
        return userName;
    }
    /**
     * 获取request
     *
     * @return
     */
    public static HttpServletRequest getRequest() {
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder
                .getRequestAttributes();
        return requestAttributes == null ? null : requestAttributes.getRequest();
    }

}

2.3.定义注解

@CheckToken需要验证Token注解
package com.xxxxxx.sim.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 需要验证Token
 * @author xxxxxx
 * @date 20200428
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface CheckToken {
    boolean required() default true;
}

@PassToken跳过Token验证注解
package com.xxxxxx.sim.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


/**
 * 跳过验证
 * @author xxxxxx
 * @date 20200428
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface PassToken {
    boolean required() default true;
}

需要验证Token注解

2.4.定义Token拦截器

AuthenticationInterceptor
package com.xxxxxx.sim.utils;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.exceptions.JWTVerificationException;
import com.xxxxxx.sim.annotation.CheckToken;
import com.xxxxxx.sim.annotation.PassToken;
import com.xxxxxx.sim.model.AdminUser;
import com.xxxxxx.sim.service.AdminUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;
import java.math.BigInteger;


/**
 * Token拦截器
 * @author xxxxxx
 * @date 20200428
 */
public class AuthenticationInterceptor implements HandlerInterceptor {
    @Autowired
    private AdminUserService adminUserService;
    @Override
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object object) throws Exception {
        // 从 http 请求头中取出 token
        String token = httpServletRequest.getHeader("token");
        // 如果不是映射到方法直接通过
        if(!(object instanceof HandlerMethod)){
            return true;
        }
        HandlerMethod handlerMethod=(HandlerMethod)object;
        Method method=handlerMethod.getMethod();
        //检查是否有PassToken注释，有则跳过认证
        if (method.isAnnotationPresent(PassToken.class)) {
            PassToken passToken = method.getAnnotation(PassToken.class);
            if (passToken.required()) {
                return true;
            }
        }
        //检查有没有需要用户权限的注解
        if (method.isAnnotationPresent(CheckToken.class)) {
            CheckToken checkToken = method.getAnnotation(CheckToken.class);
            if (checkToken.required()) {
                // 执行认证
                if (token == null) {
                    return false;
                }
                // 获取 token 中的 user id
                String userId;
                try {
                    userId = JWT.decode(token).getAudience().get(0);
                } catch (JWTDecodeException j) {
                    return false;
                }
                AdminUser user = adminUserService.queryAdminUserById(new BigInteger(userId));
                if (user == null) {
                    return false;
                }
                // 验证 token
                JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(user.getPassWord())).build();
                try {
                    jwtVerifier.verify(token);
                } catch (JWTVerificationException e) {
                    return false;
                }
                return true;
            }
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {

    }
    @Override
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
    }
}

2.5.初始化拦截器

package com.xxxxxx.sim.configuration;

import com.xxxxxx.sim.utils.AuthenticationInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.format.FormatterRegistry;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.validation.MessageCodesResolver;
import org.springframework.validation.Validator;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.HandlerMethodReturnValueHandler;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.config.annotation.*;

import java.util.List;

/**
 * 新建Token拦截器
 * @author xxxxxxx
 * @date 20200429
 */
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(authenticationInterceptor())
                .addPathPatterns("/**");
    }
    @Bean
    public AuthenticationInterceptor authenticationInterceptor() {
        return new AuthenticationInterceptor();
    }
    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> arg0) {
        // TODO Auto-generated method stub

    }
    @Override
    public void addCorsMappings(CorsRegistry arg0) {
        // TODO Auto-generated method stub

    }
    @Override
    public void addFormatters(FormatterRegistry arg0) {
        // TODO Auto-generated method stub

    }
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry arg0) {
        // TODO Auto-generated method stub

    }
    @Override
    public void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> arg0) {
        // TODO Auto-generated method stub

    }
    @Override
    public void addViewControllers(ViewControllerRegistry arg0) {
        // TODO Auto-generated method stub

    }
    @Override
    public void configureAsyncSupport(AsyncSupportConfigurer arg0) {
        // TODO Auto-generated method stub

    }
    @Override
    public void configureContentNegotiation(ContentNegotiationConfigurer arg0) {
        // TODO Auto-generated method stub

    }
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer arg0) {
        // TODO Auto-generated method stub

    }
    @Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> arg0) {
        // TODO Auto-generated method stub

    }
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> arg0) {
        // TODO Auto-generated method stub

    }
    @Override
    public void configurePathMatch(PathMatchConfigurer arg0) {
        // TODO Auto-generated method stub

    }
    @Override
    public void configureViewResolvers(ViewResolverRegistry arg0) {
        // TODO Auto-generated method stub

    }
    @Override
    public void extendHandlerExceptionResolvers(List<HandlerExceptionResolver> arg0) {
        // TODO Auto-generated method stub

    }
    @Override
    public void extendMessageConverters(List<HttpMessageConverter<?>> arg0) {
        // TODO Auto-generated method stub

    }
    @Override
    public MessageCodesResolver getMessageCodesResolver() {
        // TODO Auto-generated method stub
        return null;
    }
    @Override
    public Validator getValidator() {
        // TODO Auto-generated method stub
        return null;
    }
}

3.Token使用

3.1.定义token使用Service

package com.xxxxxx.sim.service;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.xxxxxx.sim.model.AdminUser;
import org.springframework.stereotype.Service;

import java.util.Date;

/**
 * 获取Token Service
 * @author xxxxxx
 */
@Service
public class TokenService {

    /**
     * 获取Token
     * @param user
     * @return
     */
    public String getToken(AdminUser user) {
        Date start = new Date();
        //8小时有效时间
        long currentTime = System.currentTimeMillis() + 8*60* 60 * 1000;
        Date end = new Date(currentTime);
        String token = "";

        token = JWT.create().withAudience(user.getId().toString()).withIssuedAt(start).withExpiresAt(end)
                .sign(Algorithm.HMAC256(user.getPassWord()));
        return token;
    }
}

3.2.登录Controller生成Token

package com.xxxxxx.sim.controller;

import com.xxxxxx.sim.base.Result;
import com.xxxxxx.sim.base.ResultEnum;
import com.xxxxxx.sim.base.ResultGenerator;
import com.xxxxxx.sim.model.AdminUser;
import com.xxxxxx.sim.service.AdminUserService;
import com.xxxxxx.sim.service.TokenService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse;

/**
 * @author xxxxxx
 */
@Api(tags = "登录")
@RestController
public class LoginController {
    @Autowired
    private AdminUserService adminUserService;
    @Autowired
    private TokenService tokenService;

    @ApiOperation(value = "登陆", notes = "登陆")
    @ApiResponses({
            @ApiResponse(code = 200,message = "成功",response = AdminUser.class),
    })
    @RequestMapping(value = "/login" ,method = RequestMethod.GET)
    public Result<Object> login(@RequestParam String userName, @RequestParam String password, HttpServletResponse response){
        AdminUser adminUser=adminUserService.queryAdminUserListByUserName(userName);
        if(adminUser!=null)
        {
            if(adminUser.getPassWord().equals(password))
            {
                String token = tokenService.getToken(adminUser);
                Cookie cookie = new Cookie("token", token);
                cookie.setPath("/");
                response.addCookie(cookie);
                //将token返回前端
                adminUser.setUserToken(token);
                //将密码置空,不返回给前端
                adminUser.setPassWord("");
                return ResultGenerator.success(adminUser);
            }else
            {
                return ResultGenerator.failure(ResultEnum.PASSWORD_ERROR);
            }
        }else
        {
            return ResultGenerator.failure(ResultEnum.USER_NOT_EXISTS);
        }
    }
}

3.3.接口需要验证Token

    @CheckToken
    @ApiOperation(value = "用户列表查询", notes = "用户列表查询")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "key",value = "查询条件"),
            @ApiImplicitParam(name = "pageNum",value = "当前页",required = true),
            @ApiImplicitParam(name = "pageSize",value = "每页显示条数",required = true),
            @ApiImplicitParam(name = "roleId",value = "角色id",required = true)
    })
    @ApiResponses({
            @ApiResponse(code = 200,message = "成功",response = AdminUser.class),
    })
    @PostMapping(value = "queryAdminUserList")
    public Result<Object> queryAdminUserList(String key, int pageNum, int pageSize,BigInteger roleId){
        try {
            //判空
            if(roleId.longValue() <= 0){
                return ResultGenerator.failure(ResultEnum.Param_Error) ;
            }
            PageResult pageUserList = adminUserService.queryAdminUserList(key,pageNum,pageSize,roleId);
            return ResultGenerator.success("成功",pageUserList);
        } catch (Exception e) {
            e.printStackTrace();
            return ResultGenerator.error("失败:" + e.getMessage());
        }
    }

在接口方法上加上@CheckToken注解即可

4.最后再Swagger2上增加token传入的说明

package com.xxxxxx.sim.configuration;


import com.xxxxxx.sim.base.ResultEnum;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.bind.annotation.RequestMethod;
import springfox.documentation.builders.*;
import springfox.documentation.schema.ModelRef;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Parameter;
import springfox.documentation.service.ResponseMessage;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * <p>Swagger2配置类</p>
 * @author xxxxxx
 * @date 20200429
 */
@Configuration
@EnableSwagger2
public class SwaggerConfig {
    /**
     * 创建API应用
     * apiInfo() 增加API相关信息
     * 通过select()函数返回一个ApiSelectorBuilder实例,用来控制哪些接口暴露给Swagger来展现，
     * 本例采用指定扫描的包路径来定义指定要建立API的目录。
     *
     * @return
     */
    @Bean
    public Docket createRestApi() {
        //添加全局响应状态码
        List<ResponseMessage> responseMessageList = new ArrayList<>();
        Arrays.stream(ResultEnum.values()).forEach(errorEnums -> {
            responseMessageList.add(
                    new ResponseMessageBuilder().code(errorEnums.getCode()).message(errorEnums.getMessage()).responseModel(
                            new ModelRef(errorEnums.getMessage())).build()
            );
        });

        ParameterBuilder aParameterBuilder = new ParameterBuilder();
        aParameterBuilder.name("token").description("token验证信息").modelRef(new ModelRef("String")).parameterType("header").build();
        List<Parameter> aParameters = new ArrayList<Parameter>();
        aParameters.add(aParameterBuilder.build());

        return new Docket(DocumentationType.SWAGGER_2)
                // 添加全局响应状态码
                .globalResponseMessage(RequestMethod.GET, responseMessageList)
                .globalResponseMessage(RequestMethod.POST, responseMessageList)
                .globalResponseMessage(RequestMethod.PUT, responseMessageList)
                .globalResponseMessage(RequestMethod.DELETE, responseMessageList)

                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.jointcontrols.sim.controller"))
                .paths(PathSelectors.any())
                .build()
                .useDefaultResponseMessages(false)
                .globalOperationParameters(aParameters);



    }

    /**
     * 创建该API的基本信息（这些基本信息会展现在文档页面中）
     * 访问地址：http://项目实际地址/swagger-ui.html
     *
     * @return
     */
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("SIM Manager APIs")
                .description("SIM卡管理接口文档")
                .termsOfServiceUrl("http://www.baidu.com")
                .version("1.0.0")
                .build();
    }
}

 

大鱼>
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JAVA开发第一个Springboot WebApi项目
技术分享博客，工作经验，技能学习分享（多做一些不会的，会有意向不到的收获，IT高手不可能永远只做会的）
03-06 1121
JAVA开发第一个Springboot WebApi项目
ASP.NET WebAPI Token JWT Bearer 认证失败和成功返回自定义数据 Json
04-17
asp.net WebAPI Token Oauth2.0授权自定义返回结果(包括登录正确返回，登录失败返回)。 详细参考：https://blog.csdn.net/u013546115/article/details/105580532
php实现JWT(json web token)鉴权实例详解
01-03
JWT是什么 JWT是json web token缩写。它将用户信息加密到token里，服务器不保存任何用户信息。服务器通过使用保存的密钥验证token的正确性，只要正确即通过验证。基于token的身份验证可以替代传统的cookie+session身份验证方法。 JWT由三个部分组成：header.payload.signature 以下示例以JWT官网为例 header部分： { alg: HS256, typ: JWT } 对应base64UrlEncode编码为：eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9 说明：该字段为jso
12_基于JWT的Web API身份验证
10-31
12_基于JWT的Web API身份验证Json Web Token(jwt)是一种不错的身份验证及授权方案，简单的说就是调用端调用api时，附带上一个由api端颁发的token，以此来验证调用者的授权信息。
springboot-react-jwt：JSON Web令牌React Spring Boot示例
02-05
JSON Web令牌/ React / Spring Boot示例 这是一个示例项目，其中使用JSON Web令牌保护Spring REST API。 Java和React的可用示例很少，并且有一些陷阱。 因此，我决定进行概念验证，创建一个独立的项目。 一切都在此存储库中发布。 JSON Web令牌 JSON Web令牌（JWT）是一个开放标准（RFC 7519），它定义了一种紧凑且自包含的方式，用于在各方之间安全地将信息作为JSON对象传输。 由于此信息是经过数字签名的，因此可以被验证和信任。 可以使用秘密（使用HMAC算法）或使用RSA [1]的公用/专用密钥对对JWT进行签名。 什么时候
ASP.NET Core Web API之Token验证
06-26
ASP.NET Core Web API采用Token进行身份验证。 主要技术：ASP.NET Core Web API , JWT , Json web token 包括获取Token，Token验证，生成Token等内容 具体可参考个人文章【ASP.NET Core Web API之Token验证】
SpringBoot零基础实现WebApi服务(1)项目构建
10-22 514
快速导航 IntelliJ IDEA 中的Spring Initializr快速构建SpringBoot工程 编写一个Hello SpringBoot程序 [运行程序] 三种方式启动项目 [more] 项目属性配置 [项目属性配置] application.properties文件设置配置 ...
使用SpringBoot快速构建Web API
unber的博客
12-07 1135
Dubbo 框架现在在国内的中小企业当中已经成为 Java 生态下服务化的事实标准，出现这种状态的原因很多，比如 Dubbo 框架设计优秀、文档和资料丰富、配置灵活、特性丰富等，但最主要的，我认为是 Java 开发人员对速度这一因素的痴迷。
基于SpringBoot2开发WebApi（一）创建一个简单的SpringBoot项目
谁念西风独自凉
05-20 3337
1.背景 最近需要做一个物联网卡的管理平台，由于之前开发人员多是基于.NET WebAPI的方式，为了迎合技术主流趋势，所以准备采用SpringBoot2.x+MySQL(MyBatis)框架，同时可以对工程师进行练兵。 2.开发工具及环境 开发工具采用的是IntelliJIDEA，目前主库的Java编程语言开发的集成环境。我这边使用的是IntelliJ IDEA 2019.3 开发环境基于Java 11 3.创建一个简单WEBAPI 3.1创建一个SpringBoot项目 我这里采用的.
Springboot快速搭建Web API项目
weixin_42562567的博客
08-31 931
SpringBoot最常见得用途就是web api项目。本文介绍使用自动配置功能，通过最简洁的pom依赖，快速搭建一个示例项目。实现的功能为：接收http请求并返回json格式的数据。
spring boot+JWT实现前后端分离快速开发
月七
12-13 379
spring boot+JWT实现前后端分离快速开发 直接步入正题 首先看pom.xml，主要是spring boot的依赖包以及jwt的依赖包。 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.or...
一个基于SpringBoot的种子项目用于快速构建纯JSONAPIRESTfulAPI项目。
08-07
一个基于Spring Boot的种子项目，用于快速构建纯JSON API、RESTful API项目。
spring-boot中文参考指南
11-29
Spring Boot中文参考指南 pdf
Maven SpringBoot简单案例 接口 web
10-12
SpringBoot 框架 demo 适合初学者 学习，零配置。maven 工具搭建。
SpringBoot - 集成Auth0 JWT
Maggieq8324的博客
08-19 3571
目录前言 说说JWT，先说下互联网服务常见的两种用户认证方式：session认证与Token认证 session认证 传统的Session认证的大体流程可以表示为用户提供用户名和密码登录后由服务器存储一份用户登录信息并传递给浏览器保存为Cookie，并在下次请求中根据Cookie来识别用户，但这种方式缺陷明显： - Session都是保存在内存中，随着认证用户的增多，服务端的开销明显增大 - 保存在内存中的Session限制了分布式的应用 - Cookie容易被截获伪造
springboot banner.txt 在线制作
狼魂之力
10-22 1874
https://www.cnblogs.com/bdjsdl/p/13439469.html 另外 有几个网站也是在线制作 banner的 http://patorjk.com/software/taag/ https://www.bootschool.net/ascii http://www.network-science.de/ascii/ https://www.degraeve.com/img2txt.php 佛祖保佑 永无bug _ooOoo_
初识JWT（JSON Web Token）
satoshiCC的博客
05-07 92
什么是JWT？ ：JSON Web Token (JWT)是一个开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于作为JSON对象在各方之间安全地传输信息。该信息可以被验证和信任，因为它是数字签名的 优点： 1 因为json的通用性，所以JWT是可以进行跨语言支持的，像JAVA,JavaScript,NodeJS,PHP等很多语言都可以使用。 2 因为有了payload部分，所以JWT可以在自身存储一些其他业务逻辑所必要的非敏感信息。 3 便于传输，jwt的构成非常简单，字节占用很小
使用jwt在后端进行鉴权
最新发布
qq_53483403的博客
01-03 341
在用户登录后，后台给前台发送一个凭证（token），前台请求的时候需要带上这个凭证（token），才可以访问接口，如果没有凭证或者凭证跟后台创建的不一致，则说明该用户不合法。
spring-boot+swagger实现WebApi文档
weixin_30521161的博客
03-25 131
1、引用依赖包 <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>2.5.0</version> </dependency ...
web api core jwt 刷新令牌
05-01
Web API Core JWT是使用JSON Web令牌认证机制的一个框架。JWT是一种标准的令牌格式，它允许交互方通过令牌在两个系统之间进行身份验证和授权。JWT由三部分组成：头部、有效载荷和签名，并通过Base 64编码进行编码和解码。 令牌一般会有一个失效时间，为了防止在失效时间内令牌失效，需要使用令牌刷新机制，即使用旧的令牌获取新的令牌。在Web API Core JWT中，使用Refresh Token来实现令牌刷新机制。 Refresh Token是一个长期有效的令牌，用于获取新的访问令牌。当访问令牌过期时，客户端可以使用Refresh Token向服务器请求新的访问令牌。如果Refresh Token还未失效，服务器会对其进行验证，并生成新的访问令牌。如果Refresh Token已经失效，客户端则需要重新进行身份验证获取新的令牌。 Web API Core JWT也提供了许多选项来配置Refresh Token的行为，例如Refresh Token的有效期、Refresh Token的存储位置等。在使用Refresh Token的过程中，需要注意Refresh Token的安全性，避免被恶意使用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大鱼>

一分也是爱

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值