Json Web Token

已于 2023-11-20 11:06:47 修改
阅读量57 收藏
点赞数
分类专栏： java 文章标签： json 前端 java spring boot
于 2023-11-20 10:57:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47746614/article/details/134502899
版权

jwt

JWT

Json Web Token

web应用中，能够携带用户信息，带有数字签名的JSON字符串。

通常简称为token。

使用JWT后的访问流程：

用户登录时，访问一个"验证服务"，生成一个特殊的字符串给客户端。

这个字符串中，保存了用户信息，还有数字签名。

用户下次登录时，再次访问这个"验证服务"，只需按签发时的签名规则解密，就能判断能否访问，同时也能获取保存在其中的信息。

这个特殊的字符串，就成为token，包含三部分，用.隔开：“头.负载.签名”

JWT头				   负载信息					数字签名
aaaaaaaaaaaaaaaaaaaaaaa.bbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccccc

优点

  • 无需保存在服务端，减少服务器压力
  • 结构简单，占用字节少，方便传输
  • 可以携带用户信息
  • JSON格式通用，可以跨语言

基本使用

导入依赖

<!-- JWT-->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>
<!--JDK1.8以上添加才能使用JWT-->
<dependency>
    <groupId>javax.xml.bind</groupId>
    <artifactId>jaxb-api</artifactId>
    <version>2.3.1</version>
</dependency>

创建jwt工具类

  • 生成token时的秘钥是一个BASE64编码的字符串，该字符串长度至少为4

    String secret=Base64.getEncoder().encodeToString("hqyj".getBytes());

    在util包下建立一个JwtUtil工具类，创建一个token令牌

package com.hqyj.erp_service.util;

import com.hqyj.erp_service.entity.SysUser;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.HashMap;

@Component
public class JwtUtil {

    //生成token时的密钥
    @Value("${secret}")
    String secret;

    /*
     * 创建token的方法
     * */
    public String createToken(SysUser sysUser) {
        //1.定义token的有效期。记录生成时间，设置到期时间
        //当前时间
        long now = System.currentTimeMillis();
        //有效时长1天,计算到期时间
        long exp = now + 1000 * 3600 * 24;
        //2.定义token的负载信息
        HashMap<String, Object> map = new HashMap<>();
        map.put("suId", sysUser.getSuId());
        map.put("suName", sysUser.getSuName());
        map.put("email", sysUser.getEmail());
        map.put("suRole", sysUser.getSuRole());

        //3.创建一个用于生成token的对象
        JwtBuilder builder = Jwts.builder();
        builder.setClaims(map)//设置负载信息
                .setIssuer("com.hqyj")//设置签发者
                .setIssuedAt(new Date())//设置签发时间
                .setExpiration(new Date(exp))//设置到期时间
                .signWith(SignatureAlgorithm.HS256, secret);//设置签名算法和数字签名
        //返回构建好的token字符串
        return builder.compact();
    }
}

修改controller的返回数据

在登陆成功后，调用创建token的方法，给前端返回一个token

@PostMapping("/login")
public ResultData login(SysUser sysUser) {
    sysUser.setSuPassword(DigestUtils.md5DigestAsHex(sysUser.getSuPassword().getBytes()));
    QueryWrapper<SysUser> wrapper = new QueryWrapper<>(sysUser);
    SysUser one = sysUserService.getOne(wrapper);
    if (one == null) {
        return ResultData.error(1, "用户名或密码错误");
    }
    return ResultData.ok(jwtUtil.createToken(one));
}

前端保存返回的token

在前端页面登录成功后，将返回的token保存到localStorage中。

localStorage是一种Web存储机制，可以在用户的浏览器端保存键值对。

不同域名有各自的localStorage，同一个域名下的localStorage是共享的，所以在同一个站点下可以在不同页面中共享数据。

localStrorage的存储空间大小为5MB左右。

前端解析token

  • 安装npm i jwt-decode
  • 导入import {jwtDecode} from ‘jwt-decode’
  • 使用jwtDecode(要解析的token)
const sysUser = reactive({
    suId: '',
    suName: '',
    email: '',
    suRole: ''
})

onMounted(() => {
    var token = localStorage.getItem("token");
    var res = jwtDecode(token);
    sysUser.suId = res.suId;
    sysUser.suName = res.suName;
    sysUser.email = res.email;
    sysUser.suRole = res.suRole;
})

使用拦截器+token实现拦截未登录状态下的访问

创建一个拦截器类和拦截器配置类

拦截器类

/*
 * 自定义权限拦截器
 * 实现HandlerInterceptor接口
 * 重写preHandle方法
 * */
public class AuthInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        //该方法如果返回false,不能访问后续内容
        return false;
    }
}

拦截器配置类

/*
 * 拦截器配置类
 * 需要添加@Configuration注解，在项目启动时执行
 * 实现WebMvcConfigurer接口
 * 重写addInterceptors方法
 * 注入自定义的拦截器对象
 * */
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {

    /*
    * 将自定义的拦截器对象注入到Spring容器中
    * */
    @Bean
    public AuthInterceptor authInterceptor() {
        return new AuthInterceptor();
    }

    /*
     * 发方法用于设置拦截信息
     * */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //registry的addInterceptor方法，参数为一个拦截对象
        registry.addInterceptor(authInterceptor())
                .addPathPatterns("/**")//设置要拦截的请求  这里表示拦截一切请求
                .excludePathPatterns("/sysUser/login")//放行登录的请求
                .excludePathPatterns("/sysUser/mailLogin");
    }
}

至此，后端只能访问/sysUser/login和/sysUser/mailLogin模块，其余请求访问无结果

在jwt工具类中定义验证token的方法

/*
     * 验证token
     * 根据不同异常返回对应的情况
     * 如果没有任何异常，返回保存在token中的负载信息
     * */
public ResultData validateToken(String token) {
    Claims claims;
    try {
        claims = Jwts.parser()
            .setSigningKey(secret)
            .parseClaimsJws(token)
            .getBody();
    } catch (ExpiredJwtException e) {
        //token过期时抛出
        return ResultData.error(1,"token过期");
    } catch (SignatureException e) {
        //签名异常
        return ResultData.error(2,"签名异常");
    } catch (MalformedJwtException e) {
        //token异常
        return ResultData.error(3,"token有误");
    }catch (Exception e){
        return ResultData.error(4,"解析token异常");
    }
    return  ResultData.ok(claims);
}

在拦截器中调用验证token的方法，选择是否要放行

在intercepte包下创建AuthInterceptor类

/*
 * 自定义权限拦截器
 * 实现HandlerInterceptor接口
 * 重写preHandle方法
 * */
public class AuthInterceptor implements HandlerInterceptor {

    //创建用于对象和JSON互转的工具
    ObjectMapper jsonTool = new ObjectMapper();
    @Autowired
    private JwtUtil jwtUtil;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws IOException {
        String token = request.getHeader("token");
        //判断当前的请求是否属于本项目中的某个controller中的请求
        if (handler instanceof HandlerMethod) {
            //判断当前请求是否携带token
            if (!StringUtils.hasText(token)) {
                //如果没有携带token，返回一个ResultData对象
                //创建一个ResultData对象
                ResultData res = ResultData.error(-1, "请登录(token不存在)");
                //将ResultData对象转换为JSON字符串
                String resultJson = jsonTool.writeValueAsString(res);
                //将JSON字符串写到响应中
                response.getOutputStream().write(resultJson.getBytes("utf-8"));
                response.setContentType("application/json;charset=utf-8");
                return false;
            }
            //如果携带token，解析token
            ResultData resultData = jwtUtil.validateToken(token);
            if(resultData.getCode()!=0){
                //将ResultData对象转换为JSON字符串
                String resultJson = jsonTool.writeValueAsString(resultData);
                //将JSON字符串写到响应中
                response.getOutputStream().write(resultJson.getBytes("utf-8"));
                response.setContentType("application/json;charset=utf-8");
                return  false;
            }
        }
        //该方法如果返回false,不能访问后续内容
        return true;
    }
}

在Vue项目中，使用axios访问某个controller时，携带token

axios.get("路径",
          {
            params:{
                a:x
            },
            headers:{
                token:localStrorage.getItem("token")
            }
		  });

如果Vue项目中，所有的axios请求都需要携带头信息(headers)时，使用axios拦截器

在main.ts中

import axios from 'axios'

// 所有axios请求发送时，都会携带token
axios.interceptors.request.use(config => {
    config.headers.token = localStorage.getItem("token");
    return config;
})

前端页面在使用axios访问后，要对返回值做判断

if (res.data.code == 0) {
    state.count = res.data.count;
    state.tableData = res.data.list;
} else {
    ElMessage.error(res.data.msg);
    router.replace("/")
}

使用拦截器+自定义注解实现权限控制

创建一个自定义权限注解@Auth，设置roles属性值。

在需要权限控制的地方(某个controller或某个controller中的方法)上添加注解，同时设置roles注解属性，表示什么角色能访问。

在拦截器中把要请求的方法所在类获取后，判断是否包含自定义注解，如果有获取登录时的信息，判断注解中roles值是否和登录角色的roles匹配。

当前三种角色：

ADMIN 超级管理员，可以访问任何模块，并且修改其他用户的角色

USER 普通用户，可以访问任何模块

GUEST 游客，只能访问图表模块

自定义注解

在util包下创建Auth注解

/*
* 自定义注解
* 需要添加两个注解
* @Target表示该注解在哪里使用
* @Retention表示该注解的作用域
* */
@Target({ElementType.TYPE,ElementType.METHOD})//当前表示该注解可以用在类或方法上
@Retention(RetentionPolicy.RUNTIME)//表示运行期间注解都生效
public @interface Auth {

    //定义注解的属性，当前表示角色属性。默认为"GUEST"表示游客
    String roles() default "GUEST";
}

在需要控制权限的类或方法上添加自定义注解

@Auth(roles = "ADMIN,USER")
public class WarehouseController {
    
}

在拦截器中判断当前请求是否有权限

在intercepte包下创建AuthInterceptor类

//验证权限

//获取当前的请求操作对象
HandlerMethod handlerMethod = (HandlerMethod) handler;

//获取当前要请求的类
Class<?> beanType = handlerMethod.getBeanType();
//获取当前要请求的方法
Method method = handlerMethod.getMethod();

Auth annotation = null;

//判断要请求的类上是否有自定义注解
if (beanType.isAnnotationPresent(Auth.class)) {
    //获取指定的注解
    annotation = beanType.getAnnotation(Auth.class);
}
//判断要请求的方法上是否有自定义注解
else if (method.isAnnotationPresent(Auth.class)) {
    annotation = method.getAnnotation(Auth.class);
}
//获取注解的某个属性值
String roles = annotation.roles();
//获取当前登录的用户的角色,从已对token解析后的结果中获取
String suRole = ((Claims) resultData.getObj()).get("suRole").toString();
//判断用户的角色是否与注解指定的角色匹配
if (!roles.contains(suRole)) {
    //构造一个无权限的返回值
    ResultData res = ResultData.error(-2, "当前用户无权限");
    String resultJson = jsonTool.writeValueAsString(res);
    response.getOutputStream().write(resultJson.getBytes("utf-8"));
    response.setContentType("application/json;charset=utf-8");
    return false;
}

全部文件

创建token，验证token

在工具包（util）下创建的工具类（JwtUtil）

  • 生成token：创建token的方法（createToken）
    • 1.定义token的有效期。记录生成时间，设置到期时间
    • 2.定义token的负载信息
    • 3.创建一个用于生成token的对象
  • 验证token： 根据不同异常返回对应的情况；如果没有任何异常，返回保存在token中的负载信息（validateToken）
    • token过期时抛出：ExpiredJwtException e
    • 签名异常：SignatureException e
    • token异常：MalformedJwtException e
    • 解析token异常：Exception e
package com.hqyj.erp_service.util;

import com.hqyj.erp_service.entity.SysUser;
import io.jsonwebtoken.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.HashMap;

@Component
public class JwtUtil {

    //生成token时的密钥
    @Value("${secret}")
    String secret;
   // String secret=Base64.getEncoder().encodeToString("hqyj".getBytes());

    /*
     * 创建token的方法
     * */
    public String createToken(SysUser sysUser) {
        //1.定义token的有效期。记录生成时间，设置到期时间
        //当前时间
        long now = System.currentTimeMillis();
        //有效时长1天,计算到期时间
        long exp = now + 1000 * 3600 * 24;
        //2.定义token的负载信息
        HashMap<String, Object> map = new HashMap<>();
        map.put("suId", sysUser.getSuId());
        map.put("suName", sysUser.getSuName());
        map.put("email", sysUser.getEmail());
        map.put("suRole", sysUser.getSuRole());

        //3.创建一个用于生成token的对象
        JwtBuilder builder = Jwts.builder();
        builder.setClaims(map)//设置负载信息
            .setIssuer("com.hqyj")//设置签发者
            .setIssuedAt(new Date())//设置签发时间
            .setExpiration(new Date(exp))//设置到期时间
            .signWith(SignatureAlgorithm.HS256, secret);//设置签名算法和数字签名
        //返回构建好的token字符串
        return builder.compact();
    }


    /*
     * 验证token
     * 根据不同异常返回对应的情况
     * 如果没有任何异常，返回保存在token中的负载信息
     * */
    public ResultData validateToken(String token) {
        Claims claims;
        try {
            claims = Jwts.parser()
                .setSigningKey(secret)
                .parseClaimsJws(token)
                .getBody();
        } catch (ExpiredJwtException e) {
            //token过期时抛出
            return ResultData.error(1,"token过期");
        } catch (SignatureException e) {
            //签名异常
            return ResultData.error(2,"签名异常");
        } catch (MalformedJwtException e) {
            //token异常
            return ResultData.error(3,"token有误");
        }catch (Exception e){
            return ResultData.error(4,"解析token异常");
        }
        return  ResultData.ok(claims);
    }

}

拦截器配置类

  • 需要添加@Configuration注解，在项目启动时执行
  • 实现WebMvcConfigurer接口
  • 注入自定义的拦截器对象：将自定义的拦截器对象注入到Spring容器中
  • 重写addInterceptors方法：用于设置拦截信息
package com.hqyj.erp_service.config;

import com.hqyj.erp_service.intercepte.AuthInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/*
 * 拦截器配置类
 * 需要添加@Configuration注解，在项目启动时执行
 * 实现WebMvcConfigurer接口
 * 重写addInterceptors方法
 * 注入自定义的拦截器对象
 * */
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {

    /*
    * 将自定义的拦截器对象注入到Spring容器中
    * */
    @Bean
    public AuthInterceptor authInterceptor() {
        return new AuthInterceptor();
    }

    /*
     * 发方法用于设置拦截信息
     * */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //registry的addInterceptor方法，参数为一个拦截对象
        registry.addInterceptor(authInterceptor())
                .addPathPatterns("/**")//设置要拦截的请求  这里表示拦截一切请求
                .excludePathPatterns("/sysUser/login")//放行登录的请求
                .excludePathPatterns("/sysUser/mailLogin");
    }
}

自定义注解，权限控制

在工具包（util）下自定义注解（Auth）：用于权限控制

  • @Target表示该注解在哪里使用
  • @Retention表示该注解的作用域
  • 定义注解的属性，当前表示角色属性。默认为"GUEST"表示游客
package com.hqyj.erp_service.util;

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

/*
* 自定义注解
* 需要添加两个注解
* @Target表示该注解在哪里使用
* @Retention表示该注解的作用域
* */
@Target({ElementType.TYPE,ElementType.METHOD})//当前表示该注解可以用在类或方法上
@Retention(RetentionPolicy.RUNTIME)//表示运行期间注解都生效
public @interface Auth {

    //定义注解的属性，当前表示角色属性。默认为"GUEST"表示游客
    String roles() default "GUEST";
}

自定义权限拦截器

在包（intercepte）下创建一个类（AuthInterceptor）：自定义权限拦截器

  • 实现HandlerInterceptor接口

  • 重写preHandle方法

  • 验证权限

package com.hqyj.erp_service.intercepte;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.hqyj.erp_service.util.Auth;
import com.hqyj.erp_service.util.JwtUtil;
import com.hqyj.erp_service.util.ResultData;
import io.jsonwebtoken.Claims;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.Method;

/*
 * 自定义权限拦截器
 * 实现HandlerInterceptor接口
 * 重写preHandle方法
 * */
public class AuthInterceptor implements HandlerInterceptor {

    //创建用于对象和JSON互转的工具
    ObjectMapper jsonTool = new ObjectMapper();
    @Autowired
    private JwtUtil jwtUtil;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws IOException {
        //System.out.println(request.getRequestURI());
        //handler表示处理当前请求对象，可以通过判断该对象
        //System.out.println(handler);
        String token = request.getHeader("token");
        //判断当前的请求是否属于本项目中的某个controller中的请求
        if (handler instanceof HandlerMethod) {
            //判断当前请求是否携带token
            if (!StringUtils.hasText(token)) {
                //如果没有携带token，返回一个ResultData对象
                //创建一个ResultData对象
                ResultData res = ResultData.error(-1, "请登录(token不存在)");
                //将ResultData对象转换为JSON字符串
                String resultJson = jsonTool.writeValueAsString(res);
                //将JSON字符串写到响应中
                response.getOutputStream().write(resultJson.getBytes("utf-8"));
                response.setContentType("application/json;charset=utf-8");
                return false;
            }
            //如果携带token，解析token
            ResultData resultData = jwtUtil.validateToken(token);
            if (resultData.getCode() != 0) {
                //将ResultData对象转换为JSON字符串
                String resultJson = jsonTool.writeValueAsString(resultData);
                //将JSON字符串写到响应中
                response.getOutputStream().write(resultJson.getBytes("utf-8"));
                response.setContentType("application/json;charset=utf-8");
                return false;
            }
            //验证权限

            //获取当前的请求操作对象
            HandlerMethod handlerMethod = (HandlerMethod) handler;

            //获取当前要请求的类
            Class<?> beanType = handlerMethod.getBeanType();
            //获取当前要请求的方法
            Method method = handlerMethod.getMethod();

            Auth annotation = null;

            //判断要请求的类上是否有自定义注解
            if (beanType.isAnnotationPresent(Auth.class)) {
                //获取指定的注解
                annotation = beanType.getAnnotation(Auth.class);
            }
            //判断要请求的方法上是否有自定义注解
            else if (method.isAnnotationPresent(Auth.class)) {
                annotation = method.getAnnotation(Auth.class);
            }
            //获取注解的某个属性值
            String roles = annotation.roles();
            //获取当前登录的用户的角色,从已对token解析后的结果中获取
            String suRole = ((Claims) resultData.getObj()).get("suRole").toString();
            //判断用户的角色是否与注解指定的角色匹配
            if (!roles.contains(suRole)) {
                //构造一个无权限的返回值
                ResultData res = ResultData.error(-2, "当前用户无权限");
                String resultJson = jsonTool.writeValueAsString(res);
                response.getOutputStream().write(resultJson.getBytes("utf-8"));
                response.setContentType("application/json;charset=utf-8");
                return false;
            }
        }
        //该方法如果返回false,不能访问后续内容
        return true;
    }
}
qq_47746614
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JSON Web Token
m0_54355172的博客
11-28 6811
JWT
JSON Web Token原理深入理解
氷的博客
03-25 491
JWT全称Json Web Token，翻译为JSON格式的网络令牌，很多时候又简称为Token(JWT是Token的一种实现方式)。它要解决的问题，就是为多种终端设备，提供统一的、安全的令牌格式。因此，JWT只是一个令牌格式而已，你可以把它存储到Cookie，也可以存储到localstorage，没有任何限制！同样的，对于传输，你可以使用任何传输方式来传输JWT，一般来说，我们会使用HTTP请求头(Authorization)来传输它。比如，当登录成功后，服务器可以给客户端响应一个JWT。
JWT技术--JSON Web Token
热门推荐
qq_25046827的博客
04-07 1万+
一、JWT简介 JSON Web Token (JWT)是一个开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于作为JSON对象在各方之间安全地传输信息。该信息可以被验证和信任，因为它是数字签名的。 使用方式：服务端根据规范生成一个令牌（token），并且发放给客户端（保存在客户端）。此时客户端请求服务端的时候就可以携带者令牌，以令牌来证明自己的身份信息。 作用：类似session保持登录状态的办法，通过token来代表用户身份。 Authorization (授权) : 这是使用J
CTFHUB--JSON Web Token
qq_49422880的博客
06-07 1789
基础知识 链接: 官方解释.   什么是JWT Json Web Token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（RFC 7519。 该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景，是目前最流行的跨域认证解决方案。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。 JWT 的原理 服务器认
JWT（Json Web Token）详解
Vinjcent
09-09 1330
JSON Web Token （JWT）is an open standard（）that defines a compact and self-contained way for securely transmitting information between parties as a JSON object.This information can be verified and trusted because it is digitally signed. JWTs can be signed us
JWT（JSON Web Token）
weixin_63541561的博客
03-27 1069
是一种开放标准，用于在网络上安全传输信息的简洁、自包含的方式。它通常被用于身份验证和授权机制。JWT 由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）。总结来说，使用 JWT 相较于传统的基于会话的认证机制，可以减少服务器存储开销和管理复杂性，实现跨域支持和水平扩展，并且更适应无状态和微服务架构。前端：存储在浏览器的。
Json web token（JWT）攻防
网安君的博客
05-09 914
JWT介绍 JSON Web Tokens，是一种基于JSON的、用于在网络上声明某种主张的令牌（token）。JWT通常由三部分组成: 头信息（header）, 消息体（payload）和签名（signature）。它是一种用于双方之间传递安全信息的表述性声明规范。JWT作为一个开放的标准（RFC 7519），定义了一种简洁的、自包含的方法，从而使通信双方实现以JSON对象的形式安全的传递信息。 “令牌使用私人秘密或公钥/私钥进行签名。例如，服务器可以生成具有“以管理员身份登录”声明的令牌并将其提供给客
ctfhub JSON Web Token
CN天狼
04-01 2240
ctfhub JSON Web Token
JWT(JSON Web Token )详解及实例
深圳市多克创新科技有限公司
10-31 5648
JSON Web Token (JWT)详解
JSON Web Token （前端与后端对话密钥生成文件）
06-28
token 生成文件，用于前后端数据传输时发送的密钥（暗语）。 直接解压后引用该文件即可 -- 后端在收到第一次请求的时候调用 私有的（p开头的） -- 前端发来密钥的时候调用 公用的进行判断是否正确 你也可以自己...
单点登录中的JSON WEB TOKEN的使用方法C#版
03-21
Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。本实例还原了整个的使用流程。建议...
详解JSON Web Token 入门教程
10-18
主要介绍了详解JSON Web Token 入门教程，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
JWT(json web token)包
01-22
JWT(json web token)是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准。 JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源。比如用在用户登录上...
Json web token
05-10
JSON Web Token（JWT）是一种开放的标准（RFC 7519），定义了一种紧凑的、自包含的方式来安全地在各方之间传输信息作为一个JSON对象。这个信息可以被验证和信任，因为它是数字签名的。JWT被广泛用于认证和授权场景，...
微信小程序安装vant组件库和使用
qq_61132537的博客
07-23 638
van-button type="primary">主要按钮</van-button>
本地部署SearXNG
m0_62458145的博客
07-23 482
当您安装 SearXNG 时，默认的输出格式是 HTML 格式。请将以下行添加到 settings.yml 文件中。如前面的示例所示，settings.yml 文件位于 ${PWD}/searxng/settings.yml。SearXNG 是一个免费的互联网元搜索引擎，整合了各种搜索服务的结果。用户不会被跟踪，也不会被分析。中填写访问地址，例如：http://x.x.x.x:8080，如果你想通过其他方式安装 SearXNG，请参考。3. 在 Dify 中集成 SearXNG。
HTTP请求入参类型解读
最新发布
Bekind2010的专栏
07-24 1054
在HTTP请求中，请求头用于指示资源的MIME类型，即请求体的媒体类型。它告诉服务器实际发送的数据类型是什么，以便服务器能够正确地解析和处理这些数据。可以有多种值，每种值都对应着不同的媒体类型。以下是一些常见的?enctypeenctypeform-datatext/plaintext/plaintext/htmltext/htmltext/xmltext/xmltext/xml每种都对应着不同的数据格式和用途，选择合适的对于确保数据被正确解析和处理至关重要。
Gson使用TypeAdapterFactory和TypeAdapter实现Json中的Key统一修改
Zorro的博客
07-23 229
【代码】Gson使用TypeAdapterFactory和TypeAdapter实现Json中的Key统一修改。
json web token
05-16
JSON Web Token (JWT) 是一种用于在网络上安全地传输信息的开放标准。它是一种基于 JSON 格式的轻量级身份验证和授权机制，通常用于在客户端和服务器之间传递身份信息。JWT 包含了一些被称为声明的信息，这些声明可以用于验证身份和授权访问特定资源。JWT 通常包含三个部分：头部、载荷和签名。头部包含了令牌的元数据，载荷包含了用户身份信息，签名则用于验证令牌的真实性。JWT 通常与 OAuth2 和 OpenID Connect 等身份认证和授权协议一起使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值