jwt

JWT
2021-10-14 17:17:56
系统全面的讲解多种会话技术的特点，重点突出讲解jwt在应用原理，以项目实战演示如何使用jwt会话技术
收起
编程语言 c语言编程软件编程语言排行榜

JWT产生和验证Token

万次阅读 多人点赞 2019-07-31 19:15:33

header 部分主要是两部分内容，一个是 Token 的类型，另一个是使用的算法，比如下面类型就是 JWT，使用的算法是 HS256，就是SHA-256，和md5一样是不可逆的散列算法。 { "typ": "JWT", "alg": "HS256" } 上面...

#Token验证
　　最近了解下基于 Token 的身份验证，跟大伙分享下。很多大型网站也都在用，比如 Facebook，Twitter，Google+，Github 等等，比起传统的身份验证方法，Token 扩展性更强，也更安全点，非常适合用在 Web 应用或者移动应用上。Token 的中文有人翻译成 “令牌”，我觉得挺好，意思就是，你拿着这个令牌，才能过一些关卡。
##传统的Token验证
　　HTTP 是一种没有状态的协议，也就是它并不知道是谁是访问应用。这里我们把用户看成是客户端，客户端使用用户名还有密码通过了身份验证，不过下回这个客户端再发送请求时候，还得再验证一下。
　　解决的方法就是，当用户请求登录的时候，如果没有问题，我们在服务端生成一条记录，这个记录里可以说明一下登录的用户是谁，然后把这条记录的 ID 号发送给客户端，客户端收到以后把这个 ID 号存储在 Cookie 里，下次这个用户再向服务端发送请求的时候，可以带着这个 Cookie ，这样服务端会验证一个这个 Cookie 里的信息，看看能不能在服务端这里找到对应的记录，如果可以，说明用户已经通过了身份验证，就把用户请求的数据返回给客户端。
　　上面说的就是 Session，我们需要在服务端存储为登录的用户生成的 Session ，这些 Session 可能会存储在内存，磁盘，或者数据库里。我们可能需要在服务端定期的去清理过期的 Session 。
　　##基于 Token 的身份验证方法
　　使用基于 Token 的身份验证方法，在服务端不需要存储用户的登录记录。大概的流程是这样的：
客户端使用用户名跟密码请求登录
服务端收到请求，去验证用户名与密码
验证成功后，服务端会签发一个 Token，再把这个 Token 发送给客户端
客户端收到 Token 以后可以把它存储起来，比如放在 Cookie 里或者 Local Storage 里
客户端每次向服务端请求资源的时候需要带着服务端签发的 Token
服务端收到请求，然后去验证客户端请求里面带着的 Token，如果验证成功，就向客户端返回请求的数据
##JWT+HA256验证
实施 Token 验证的方法挺多的，还有一些标准方法，比如 JWT，读作：jot ，表示：JSON Web Tokens 。JWT 标准的 Token 有三个部分：
header
payload
signature
中间用点分隔开，并且都会使用 Base64 编码，所以真正的 Token 看起来像这样：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJuaW5naGFvLm5ldCIsImV4cCI6IjE0Mzg5NTU0NDUiLCJuYW1lIjoid2FuZ2hhbyIsImFkbWluIjp0cnVlfQ.SwyHTEx_RQppr97g4J5lKXtabJecpejuef8AqKYMAJc

###Header
header 部分主要是两部分内容，一个是 Token 的类型，另一个是使用的算法，比如下面类型就是 JWT，使用的算法是 HS256，就是SHA-256，和md5一样是不可逆的散列算法。

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

上面的内容要用 Base64 的形式编码一下，所以就变成这样：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9

###Payload
Payload 里面是 Token 的具体内容，这些内容里面有一些是标准字段，你也可以添加其它需要的内容。下面是标准字段：
iss：Issuer，发行者
sub：Subject，主题
aud：Audience，观众
exp：Expiration time，过期时间
nbf：Not before
iat：Issued at，发行时间
jti：JWT ID
比如下面这个 Payload ，用到了 iss 发行人，还有 exp 过期时间。另外还有两个自定义的字段，一个是 name ，还有一个是 admin 。

{ 
 "iss": "ninghao.net",
 "exp": "1438955445",
 "name": "wanghao",
 "admin": true
}

使用 Base64 编码以后就变成了这个样子：

eyJpc3MiOiJuaW5naGFvLm5ldCIsImV4cCI6IjE0Mzg5NTU0NDUiLCJuYW1lIjoid2FuZ2hhbyIsImFkbWluIjp0cnVlfQ

###Signature
JWT 的最后一部分是 Signature ，这部分内容有三个部分，先是用 Base64 编码的 header.payload ，再用加密算法加密一下，加密的时候要放进去一个 Secret ，这个相当于是一个密码，这个密码秘密地存储在服务端。

var encodedString = base64UrlEncode(header) + "." + base64UrlEncode(payload); 
HMACSHA256(encodedString, 'secret');

处理完成以后看起来像这样：

SwyHTEx_RQppr97g4J5lKXtabJecpejuef8AqKYMAJc

最后这个在服务端生成并且要发送给客户端的 Token 看起来像这样：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJuaW5naGFvLm5ldCIsImV4cCI6IjE0Mzg5NTU0NDUiLCJuYW1lIjoid2FuZ2hhbyIsImFkbWluIjp0cnVlfQ.SwyHTEx_RQppr97g4J5lKXtabJecpejuef8AqKYMAJc

客户端收到这个 Token 以后把它存储下来，下会向服务端发送请求的时候就带着这个 Token 。服务端收到这个 Token ，然后进行验证，通过以后就会返回给客户端想要的资源。验证的过程就是
根据传过来的token再生成一下第三部分Signature，然后两个比对一下，一致就验证通过。

收起

展开全文

2021-06-20 .NET高级班 62-ASP.NET Core JWT的权限认证使用(工具版)
public void ConfigureServices(IServiceCollection services) { #region jwt校验 HS JWTTokenOptions tokenOptions = new JWTTokenOptions(); Configuration.
收起
shell

JWT 教程_1 SpringBoot与JWT整合

万次阅读 2021-01-02 16:01:45

SpringBoot与JWT整合2.1 JWT的结构：2.2 JWT的使用测试：1) java-jwt 版本2) jjwt 版本检验过期时间自定义claim2.3 SpringBoot与JWT整合： 1. 介绍 https://jwt.io/ Json web token (JWT), 是为了在网络应用环境...

https://gitee.com/fakerlove/spring-security
 

 文章目录
 1. 介绍
2. SpringBoot与JWT整合
2.1 JWT的结构：
2.2 JWT的使用测试：
1) java-jwt 版本
2) jjwt 版本
检验
过期时间
自定义claim
   
   
2.3 SpringBoot与JWT整合：
 

 
1. 介绍 
 
 https://jwt.io/ 
 
Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。 
2. SpringBoot与JWT整合 
2.1 JWT的结构： 
Header（头）：包含令牌的类型与使用的签名算法，它会使用Base64进行编码
{
	"alg": "HS265",
	"typ": "JWT"
}
 
Payload（有效负载）: 包含声明（有关用户实体和其他数据的声明），使用Base64进行编码
Base64是一种可逆的编码，因此不要在负载里存入敏感数据！
{
	"id": "1",
	"name": "BLU",
	"admin": true
}
 
Signature（签名）：使用编码后的header和payload以及一个指定密钥，然后使用header中指定的算法（HS265）进行签名.
签名的作用是保证JWT没有被篡改过
 
负载 
 
 iss: jwt 的签发者 
 sub: jwt 所面向的用户 
 aud：接受jwt 的一方 
 exp: jwt的过期时间，这个过期时间必须要大于签发时间 
 nbf：定义在什么时间之前，该jwt 不可用的 
 iat: jwt的签发时间 
 jti:jwt 的唯一身份识别，主要用来作为一次性token，从而回避重放攻击 
 
有很多公司在做jwt ,因为jwt 是标准，并不是实现，所以需要公司实现，比较有名的 
auth0,java-jwt,jjwt 
<!-- https://mvnrepository.com/artifact/io.jsonwebtoken/jjwt -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

 
<!-- https://mvnrepository.com/artifact/com.auth0/java-jwt -->
<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>3.12.0</version>
</dependency>

 
2.2 JWT的使用测试： 
1) java-jwt 版本 
依赖： 
<dependency>
	<groupId>com.auth0</groupId>
	<artifactId>java-jwt</artifactId>
	<version>3.4.0</version>
</dependency>
 
测试： 
@Test
void getToken() {

	//HashMap<String,Object> map = new HashMap<String, Object>();
	Calendar instance = Calendar.getInstance();
	instance.add(Calendar.SECOND, 60);
	String token = JWT.create()
			//.withHeader(map)
			//设置Payload
			.withClaim("userId", 10)
			.withClaim("username", "BLU")
			//设置token过期时间(60s)
			.withExpiresAt(instance.getTime())
			//设置签名
			.sign(Algorithm.HMAC256("!@#$%^&*"));
	System.out.println(token);

}
 
eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MDA3NDA2MTUsInVzZXJJZCI6MTAsInVzZXJuYW1lIjoiQkxVIn0.0re-tA4dQm4blGhn1DvpnUl7Lrz_EWXwn8LfRbWQXCU
 
@Test
void TokenVerify() {
	//创建验证对象
	JWTVerifier verifier = JWT.require(Algorithm.HMAC256("!@#$%^&*")).build();
	DecodedJWT verify = verifier.verify("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MDA3NDA2MTUsInVzZXJJZCI6MTAsInVzZXJuYW1lIjoiQkxVIn0.0re-tA4dQm4blGhn1DvpnUl7Lrz_EWXwn8LfRbWQXCU");
	System.out.println(verify.getClaim("userId").asInt());
	System.out.println(verify.getClaims().get("username").asString());
	System.out.println("过期时间："+verify.getExpiresAt());	
}
 
10
BLU
过期时间：Tue Sep 22 10:10:15 CST 2020
 
2) jjwt 版本 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.1</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo3</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo3</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>11</java.version>
    </properties>

    <dependencies>

        <!-- https://mvnrepository.com/artifact/io.jsonwebtoken/jjwt -->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

 
验证 
package com.example.demo3;

import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Date;

@SpringBootTest
class Demo3ApplicationTests {

    @Test
    void contextLoads() {
        JwtBuilder jwtBuilder= Jwts.builder()
                // 用户的id
                .setId("001")
                // 接受用户的角色信息
                .setSubject("Rose")
                // 签发时间
                .setIssuedAt(new Date())
                // 采用的算法
                .signWith(SignatureAlgorithm.HS256,"xxxx");

      String token=jwtBuilder.compact();
      System.out.println(token);
    }

}

 
结果 
eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiIwMDEiLCJzdWIiOiJSb3NlIiwiaWF0IjoxNjA5NTcxNzg1fQ.pqau27EgQhVtqamer2_8z-gBQeATGNveBuUAyVlSac4
 
检验 
    @Test
    public void verfity(){
        String token="eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiIwMDEiLCJzdWIiOiJSb3NlIiwiaWF0IjoxNjA5NTcxNzg1fQ.pqau27EgQhVtqamer2_8z-gBQeATGNveBuUAyVlSac4";
        Claims claims= Jwts.parser()
                .setSigningKey("xxxx")
                .parseClaimsJws(token)
                .getBody();
        System.out.println(claims.getId());
        System.out.println(claims.getSubject());
        System.out.println(claims.getIssuedAt());
    }

 
结果 
001
Rose
Sat Jan 02 15:16:25 CST 2021
 
过期时间 
    @Test
    void contextLoads() {
        JwtBuilder jwtBuilder= Jwts.builder()
                // 用户的id
                .setId("001")
                // 接受用户的角色信息
                .setSubject("Rose")
                // 签发时间
                .setIssuedAt(new Date())
                // 采用的算法
                .signWith(SignatureAlgorithm.HS256,"xxxx")
                .setExpiration(new Date(System.currentTimeMillis()+60*1000));

      String token=jwtBuilder.compact();
      System.out.println(token);
    }
 
 
自定义claim 
package com.example.demo3;

import io.jsonwebtoken.*;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Date;

@SpringBootTest
class Demo3ApplicationTests {

    @Test
    void contextLoads() {
        JwtBuilder jwtBuilder= Jwts.builder()
                // 用户的id
                .setId("001")
                // 接受用户的角色信息
                .setSubject("Rose")
                // 签发时间
                .setIssuedAt(new Date())
                // 采用的算法
                .signWith(SignatureAlgorithm.HS256,"xxxx")
               // .setExpiration(new Date(System.currentTimeMillis()+60*1000))
                .claim("name","joker")
                .claim("login","sadas");

      String token=jwtBuilder.compact();
      System.out.println(token);
    }

    @Test
    public void verfity(){
        String token="eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiIwMDEiLCJzdWIiOiJSb3NlIiwiaWF0IjoxNjA5NTcyODU4LCJuYW1lIjoiam9rZXIiLCJsb2dpbiI6InNhZGFzIn0.-Z2YMakhk6pKa27xyEFgGb5Jjm0ebMUEMpLSFA42c7A";
        Claims claims= Jwts.parser()
                .setSigningKey("xxxx")
                .parseClaimsJws(token)
                .getBody();
        System.out.println(claims.getId());
        System.out.println(claims.getSubject());
        System.out.println(claims.getIssuedAt());
        System.out.println(claims.get("name"));
        System.out.println(claims.get("login"));
    }

}

 
2.3 SpringBoot与JWT整合： 
依赖 
<dependencies>
	<dependency>
		<groupId>com.auth0</groupId>
		<artifactId>java-jwt</artifactId>
		<version>3.4.0</version>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
	<dependency>
		<groupId>org.mybatis.spring.boot</groupId>
		<artifactId>mybatis-spring-boot-starter</artifactId>
		<version>2.1.2</version>
	</dependency>
	<dependency>
		<groupId>org.projectlombok</groupId>
		<artifactId>lombok</artifactId>
	</dependency>
	<dependency>
		<groupId>com.alibaba</groupId>
		<artifactId>druid</artifactId>
		<version>1.1.22</version>
	</dependency>
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
	</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>
 
配置 
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/jwt?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=123456

mybatis.type-aliases-package=com.blu.entity
mybatis.mapper-locations=classpath:mapper/*.xml

logging.level.com.blu.dao=debug
 
数据库user表：
 
实体类： 
package com.blu.entity;

import lombok.Data;
import lombok.experimental.Accessors;

@Data
@Accessors(chain=true)
public class User {
	private String id;
	private String name;
	private String password;
}
 
UserDao： 
package com.blu.dao;

import org.apache.ibatis.annotations.Mapper;
import com.blu.entity.User;

@Mapper
public interface UserDao {
	User login(User user);
}
 
UserMapper： 
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.blu.dao.UserDao">
	<select id="login" parameterType="User" resultType="User">
		select * from user where name= #{name} and password= #{password}
	</select>
</mapper>
 
UserService： 
package com.blu.service;

import com.blu.entity.User;

public interface UserService {
	User login(User user);
}
 
UserServiceImpl： 
package com.blu.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.blu.dao.UserDao;
import com.blu.entity.User;
import com.blu.service.UserService;

@Service
public class UserServiceImpl implements UserService {
	
	@Autowired
	private UserDao userDao;

	@Override
	public User login(User user) {
		User userDB = userDao.login(user);
		if(userDB!=null) {
			return userDB;
		}
		throw new RuntimeException("认证失败！");
	}
	
}
 
JWT的工具类封装： 
package com.blu.utils;

import java.util.Calendar;
import java.util.Map;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;

public class JWTUtils {
	
	private static final String SIGN= "!@#$%^&*123456789";
	
	
	/**
	 * 生成Token
	 */
	public static String getToken(Map<String,String> map) {
		Calendar instance = Calendar.getInstance();
		instance.add(Calendar.DATE, 7);
		//创建JWTBuilder
		JWTCreator.Builder builder = JWT.create();
		//设置payload
		map.forEach((k,v)->{
			builder.withClaim(k, v);
		});
		//设置过期时间和签名，生成token
		String token = builder.withExpiresAt(instance.getTime())
			.sign(Algorithm.HMAC256(SIGN));
		return token;
	}
	
	/**
	 * 验证token
	 */
	public static void TokenVerify(String token) {
		JWT.require(Algorithm.HMAC256(SIGN)).build().verify(token);
	}
	
	/**
	 * 获取token信息 
	 */
	public static DecodedJWT getTokenInfo(String token) {
		DecodedJWT verify = JWT.require(Algorithm.HMAC256(SIGN)).build().verify(token);
		return verify;
	}

}
 
JWTInterceptor 拦截器 
package com.blu.interceptors;

import java.util.HashMap;
import java.util.Map;

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

import org.springframework.web.servlet.HandlerInterceptor;

import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.blu.utils.JWTUtils;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JWTInterceptor implements HandlerInterceptor {
	
	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		//获取请求头中的token
		String token = request.getHeader("token");
		Map<String,Object> map = new HashMap<String, Object>();
		try {
			JWTUtils.TokenVerify(token);
			//放行请求
			return true;
		} catch (SignatureVerificationException e) {
			map.put("msg", "无效签名");
			e.printStackTrace();
		} catch (TokenExpiredException e) {
			map.put("msg", "token已过期");
			e.printStackTrace();
		} catch (AlgorithmMismatchException e) {
			map.put("msg", "算法不一致");
			e.printStackTrace();
		} catch (Exception e) {
			map.put("msg", "token无效");
			e.printStackTrace();
		}
		map.put("state",false);
		//使用jackson将map转为json
		String json = new ObjectMapper().writeValueAsString(map);
		response.setContentType("application/json;charset=UTF-8");
		response.getWriter().print(json);
		return false;
	}

}
 
InterceptorConfig 配置类 
package com.blu.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import com.blu.interceptors.JWTInterceptor;

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {

	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		registry.addInterceptor(new JWTInterceptor())
				.addPathPatterns("/**")
				.excludePathPatterns("/user/login");
	}
	
}
 
UserController 
package com.blu.controller;

import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.blu.entity.User;
import com.blu.service.UserService;
import com.blu.utils.JWTUtils;

import lombok.extern.slf4j.Slf4j;

@RestController
@Slf4j
public class UserController {
	
	@Autowired
	private UserService userService;
	
	@GetMapping("/user/login")
	public Map<String,Object> login(User user){
		log.info("用户名：[{}]",user.getName());
		log.info("密码：[{}]",user.getPassword());
		Map<String,Object> map = new HashMap<String, Object>();
		try {
			User userDB = userService.login(user);
			Map<String,String> payload = new HashMap<String, String>();
			payload.put("id", userDB.getId());
			payload.put("name", userDB.getName());
			String token = JWTUtils.getToken(payload);
			map.put("state",true);
			map.put("msg","认证成功");
			map.put("token", token);
		} catch (Exception e) {
			map.put("state",false);
			map.put("msg",e.getMessage());
		}
		return map;
	}
	
	@PostMapping("/user/test")
	public Map<String,Object> test(HttpServletRequest request){
		
		String token = request.getHeader("token");
		DecodedJWT tokenInfo = JWTUtils.getTokenInfo(token);
		log.info("用户id：[{}]",tokenInfo.getClaim("id").asString());
		log.info("用户名：[{}]",tokenInfo.getClaim("name").asString());
		Map<String,Object> map = new HashMap<String, Object>();
		map.put("state", true);
		map.put("msg","请求成功");
		return map;
	}
	
}
 
测试 
登录获取token：
 
 测试错误的token：
 
 测试正确的token：

收起

展开全文

shiro

签发JWT,验证JWT,解析JWT字符串
2021-07-06 17:11:17
签发JWT,验证JWT,解析JWT字符串
收起
jwt-源码
2021-04-01 12:27:42
jwt
收起
JWT-源码
2021-03-21 03:11:23
JWT
收起
JavaScript
JWT教程_3 oauth和JWT 整合
万次阅读 2021-01-02 16:04:03
4. oauth和JWT 整合编写jwt 类 package com.example.demo3.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.spring...
收起
shiro
SpringBoot整合JWT
万次阅读 多人点赞 2019-08-12 17:03:55
JWT简介 1. 什么是JWT？ JWT(JSONWeb Token)是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准。它将用户信息加密到token里，服务器不保存任何用户信息。服务器通过使用保存的密钥验证token的正确...
收起
SpringBoot token 会话管理 Session
jwt:实施JWT-源码
2021-03-26 20:26:43
jwt:实施JWT
收起
Go
JWT 实战教程_jwt_源码
2021-10-01 00:11:16
jwt是什么，如何在springboot中整合jwt
收起
【SpringBoot】四十四、SpringBoot中整合JWT实现Token验证（整合篇）
千次阅读 多人点赞 2021-02-28 10:43:42
什么是JWT？ Json web token (JWT)，是为了在网络应用环境间传递声明而执行的一种基于 JSON 的开放标准（(RFC 7519)，该 token 被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT 的声明一般被...
收起
springboot java token
【SpringBoot】四十五、SpringBoot中整合JWT实现Token验证（注解篇）
万次阅读 多人点赞 2021-02-28 11:15:48
上篇文章，我们已经在 SpringBoot 中整合了 JWT 并实现了 Token 验证，那我们在实际应用中就会发现，如果每个视图层（controller）都手动验证 token，代码就会显得特别臃肿，本篇文章主要为了解决该问题。...
收起
springboot java token 自定义注解

jwt

文章目录

介绍

JWT的验证过程

实例

Jwt

1. JWT是什么

2. JWT的工作原理

JWT的验证

JWT令牌刷新思路

Vue使用 JWT做用户认证案例

java后端代码

vue中

传统开发对资源的访问限制利用session完成图解

JWT产生和验证Token

2021-06-20 .NET高级班 62-ASP.NET Core JWT的权限认证使用(工具版)

JWT 教程_1 SpringBoot与JWT整合

文章目录

1. 介绍

2. SpringBoot与JWT整合

2.1 JWT的结构：

2.2 JWT的使用测试：

1) java-jwt 版本

2) jjwt 版本

检验

过期时间

自定义claim

2.3 SpringBoot与JWT整合：

签发JWT,验证JWT,解析JWT字符串

jwt-源码

JWT-源码

JWT教程_3 oauth和JWT 整合

SpringBoot整合JWT

jwt:实施JWT-源码

JWT 实战教程_jwt_源码

【SpringBoot】四十四、SpringBoot中整合JWT实现Token验证（整合篇）

【SpringBoot】四十五、SpringBoot中整合JWT实现Token验证（注解篇）

jwt