java jwt如何刷新过期时间

客户端

创新互联2013年开创至今，先为阜宁等服务建站，阜宁等地企业，进行企业商务咨询服务。为阜宁企业网站制作PC+手机+微官网三网同步一站式服务解决您的所有建站问题。

auth_header = JWT.encode({ user_id: 123, iat: Time.now.to_i, # 指定token发布时间 exp: Time.now.to_i + 2 # 指定token过期时间为2秒后，2秒时间足够一次HTTP请求，同时在一定程度确保上一次token过期，减少replay attack的概率；}, "my shared secret")

RestClient.get("", authorization: auth_header)

服务端

class ApiController ActionController::Base

attr_reader :current_user

before_action :set_current_user_from_jwt_token

def set_current_user_from_jwt_token

# Step 1:解码JWT，并获取User ID，这个时候不对Token签名进行检查

# the signature. Note JWT tokens are *not* encrypted, but signed.

payload = JWT.decode(request.authorization, nil, false) # Step 2: 检查该用户是否存在于数据库

@current_user = User.find(payload['user_id'])

# Step 3: 检查Token签名是否正确.

JWT.decode(request.authorization, current_user.api_secret)

# Step 4: 检查 "iat" 和"exp" 以确保这个Token是在2秒内创建的.

now = Time.now.to_i if payload['iat'] now || payload['exp'] now # 如果过期则返回401

end

rescue JWT::DecodeError

# 返回 401

endend

如何在Java 中创建和验证JWT

用户发起登录请求，服务端创建一个加密后的jwt信息，作为token返回值，在后续请求中jwt信息作为请求头，服务端正确解密后可获取到存储的用户信息，表示验证通过；解密失败说明token无效或者已过期。

加密后jwt信息如下所示，是由.分割的三部分组成，分别为Header、Payload、Signature。

eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiJqd3QiLCJpYXQiOjE0NzEyNzYyNTEsInN1YiI6IntcInVzZXJJZFwiOjEsXCJyb2xlSWRcIjoxfSIsImV4cCI6MTQ3MTMxOTQ1MX0.vW-pPSl5bU4dmORMa7UzPjBR0F6sqg3n3hQuKY8j35o

Header包含两部分信息，alg指加密类型，可选值为HS256、RSA等等，typ=JWT为固定值，表示token的类型。

{

"alg": "HS256",

"typ": "JWT"

}

Payload是指签名信息以及内容，一般包括iss (发行者), exp (过期时间), sub(用户信息), aud (接收者),以及其他信息，详细介绍请参考官网。

{

"sub": "1234567890",

"name": "John Doe",

"admin": true

}

Signature则为对Header、Payload的签名。

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

在jwt官网，可以看到有不同语言的实现版本，这里使用的是Java版的jjwt。话不多说，直接看代码，加解密都很简单：

/**

* 创建 jwt

* @param id

* @param subject

* @param ttlMillis

* @return

* @throws Exception

*/

public String createJWT(String id, String subject, long ttlMillis) throws Exception {

SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256 ;

long nowMillis = System. currentTimeMillis();

Date now = new Date( nowMillis);

SecretKey key = generalKey();

JwtBuilder builder = Jwts. builder()

.setId(id)

.setIssuedAt(now)

.setSubject(subject)

.signWith(signatureAlgorithm, key);

if (ttlMillis = 0){

long expMillis = nowMillis + ttlMillis;

Date exp = new Date( expMillis);

builder.setExpiration( exp);

}

return builder.compact();

}

/**

* 解密 jwt

* @param jwt

* @return

* @throws Exception

*/

public Claims parseJWT(String jwt) throws Exception{

SecretKey key = generalKey();

Claims claims = Jwts. parser()

.setSigningKey( key)

.parseClaimsJws( jwt).getBody();

return claims;

}

加解密的key是通过固定字符串转换而生成的；subject为用户信息的json字符串；ttlMillis是指token的有效期，时间较短，需要定时更新。

这里要介绍的token刷新方式，是在生成token的同时生成一个有效期较长的refreshToken，后续由客户端定时根据refreshToken来获取最新的token。浏览器与服务端之间建立sse(server send event)请求，来实现刷新。关于sse在前面博文中有介绍过，此处略过不提。

单点登录JWT与Spring Security OAuth

通过 JWT 配合 Spring Security OAuth2 使用的方式，可以避免 每次请求 都 远程调度 认证授权服务。 资源服务器 只需要从 授权服务器 验证一次，返回 JWT。返回的 JWT 包含了 用户 的所有信息，包括 权限信息 。

1. 什么是JWT

JSON Web Token（JWT）是一种开放的标准（RFC 7519），JWT 定义了一种 紧凑 且 自包含 的标准，旨在将各个主体的信息包装为 JSON 对象。 主体信息 是通过 数字签名 进行 加密 和 验证 的。经常使用 HMAC 算法或 RSA（ 公钥 / 私钥 的 非对称性加密 ）算法对 JWT 进行签名， 安全性很高 。

2. JWT的结构

JWT 的结构由三部分组成：Header（头）、Payload（有效负荷）和 Signature（签名）。因此 JWT 通常的格式是 xxxxx.yyyyy.zzzzz。

2.1. Header

Header 通常是由 两部分 组成：令牌的 类型 （即 JWT）和使用的 算法类型 ，如 HMAC、SHA256 和 RSA。例如:

将 Header 用 Base64 编码作为 JWT 的 第一部分 ，不建议在 JWT 的 Header 中放置 敏感信息 。

2.2. Payload

下面是 Payload 部分的一个示例：

将 Payload 用 Base64 编码作为 JWT 的 第二部分 ，不建议在 JWT 的 Payload 中放置 敏感信息 。

2.3. Signature

要创建签名部分，需要利用 秘钥 对 Base64 编码后的 Header 和 Payload 进行 加密 ，加密算法的公式如下：

签名 可以用于验证 消息 在 传递过程 中有没有被更改。对于使用 私钥签名 的 token，它还可以验证 JWT 的 发送方 是否为它所称的 发送方 。

3. JWT的工作方式

客户端 获取 JWT 后，对于以后的 每次请求 ，都不需要再通过 授权服务 来判断该请求的 用户 以及该 用户的权限 。在微服务系统中，可以利用 JWT 实现 单点登录 。认证流程图如下：

4. 案例工程结构

工程原理示意图如下:

5. 构建auth-service授权服务

UserServiceDetail.java

UserRepository.java

实体类 User 和上一篇文章的内容一样，需要实现 UserDetails 接口，实体类 Role 需要实现 GrantedAuthority 接口。

User.java

Role.java

jks 文件的生成需要使用 Java keytool 工具，保证 Java 环境变量没问题，输入命令如下：

其中，-alias 选项为 别名 ，-keyalg 为 加密算法 ，-keypass 和 -storepass 为 密码选项 ，-keystore 为 jks 的 文件名称 ，-validity 为配置 jks 文件 过期时间 （单位：天）。

生成的 jks 文件作为 私钥 ，只允许 授权服务 所持有，用作 加密生成 JWT。把生成的 jks 文件放到 auth-service 模块的 src/main/resource 目录下即可。

对于 user-service 这样的 资源服务 ，需要使用 jks 的 公钥 对 JWT 进行 解密 。获取 jks 文件的 公钥 的命令如下：

这个命令要求安装 openSSL 下载地址，然后手动把安装的 openssl.exe 所在目录配置到 环境变量 。

输入密码 fzp123 后，显示的信息很多，只需要提取 PUBLIC KEY，即如下所示：

新建一个 public.cert 文件，将上面的 公钥信息 复制到 public.cert 文件中并保存。并将文件放到 user-service 等 资源服务 的 src/main/resources 目录下。至此 auth-service 搭建完毕。

maven 在项目编译时，可能会将 jks 文件 编译 ，导致 jks 文件 乱码 ，最后不可用。需要在 pom.xml 文件中添加以下内容：

6. 构建user-service资源服务

注入 JwtTokenStore 类型的 Bean，同时初始化 JWT 转换器 JwtAccessTokenConverter，设置用于解密 JWT 的 公钥 。

配置 资源服务 的认证管理，除了 注册 和 登录 的接口之外，其他的接口都需要 认证 。

新建一个配置类 GlobalMethodSecurityConfig，通过 @EnableGlobalMethodSecurity 注解开启 方法级别 的 安全验证 。

拷贝 auth-service 模块的 User、Role 和 UserRepository 三个类到本模块。在 Service 层的 UserService 编写一个 插入用户 的方法，代码如下：

配置用于用户密码 加密 的工具类 BPwdEncoderUtil：

实现一个 用户注册 的 API 接口 /user/register，代码如下：

在 Service 层的 UserServiceDetail 中添加一个 login() 方法，代码如下：

AuthServiceClient 作为 Feign Client，通过向 auth-service 服务接口 /oauth/token 远程调用获取 JWT。在请求 /oauth/token 的 API 接口中，需要在 请求头 传入 Authorization 信息， 认证类型 ( grant_type )、用户名 ( username ) 和 密码 ( password )，代码如下：

其中，AuthServiceHystrix 为 AuthServiceClient 的 熔断器 ，代码如下：

JWT 包含了 access_token、token_type 和 refresh_token 等信息，代码如下：

UserLoginDTO 包含了一个 User 和一个 JWT 成员属性，用于返回数据的实体：

登录异常类 UserLoginException

全局异常处理 切面类 ExceptionHandle

在 Web 层的 UserController 类中新增一个登录的 API 接口 /user/login 如下：

依次启动 eureka-service，auth-service 和 user-service 三个服务。

7. 使用Postman测试

因为没有权限，访问被拒绝。在数据库手动添加 ROLE_ADMIN 权限，并与该用户关联。重新登录并获取 JWT，再次请求 /user/foo 接口。

在本案例中，用户通过 登录接口 来获取 授权服务 加密后的 JWT。用户成功获取 JWT 后，在以后每次访问 资源服务 的请求中，都需要携带上 JWT。 资源服务 通过 公钥解密 JWT， 解密成功 后可以获取 用户信息 和 权限信息 ，从而判断该 JWT 所对应的 用户 是谁，具有什么 权限 。

获取一次 Token，多次使用， 资源服务 不再每次访问 授权服务 该 Token 所对应的 用户信息 和用户的 权限信息 。

一旦 用户信息 或者 权限信息 发生了改变，Token 中存储的相关信息并 没有改变 ，需要 重新登录 获取新的 Token。就算重新获取了 Token，如果原来的 Token 没有过期，仍然是可以使用的。一种改进方式是在登录成功后，将获取的 Token 缓存 在 网关上 。如果用户的 权限更改 ，将 网关 上缓存的 Token 删除 。当请求经过 网关 ，判断请求的 Token 在 缓存 中是否存在，如果缓存中不存在该 Token，则提示用户 重新登录 。

SpringBoot整合JWT实现登录认证

1、JWT的构成

- 头部(header):描述该JWT的最基本的信息，如类型以及签名所用的算法。

- 负载(payload):存放有效信息的地方。

- 签证(signature):base64加密后的header、base64加密后的payload和密钥secret加密后组成。

2、整合JWT

2.1 引入JWT依赖

com.auth0

java-jwt

3.18.3

2.2 编写JWTUtils工具类

package com.stock.utils;

import com.auth0.jwt.JWT;

import com.auth0.jwt.JWTCreator;

import com.auth0.jwt.JWTVerifier;

import com.auth0.jwt.algorithms.Algorithm;

import com.auth0.jwt.interfaces.DecodedJWT;

import com.auth0.jwt.interfaces.Verification;

import java.util.Calendar;

import java.util.Map;

public class JWTUtils {

private static final String SING="@#$%^*";

// 生成token

public static String getToken(Map map){

Calendar instance = Calendar.getInstance();

instance.add(Calendar.MINUTE,30);

//创建jwt builder

JWTCreator.Builder builder = JWT.create();

//payload

builder.withExpiresAt(instance.getTime());

map.forEach((k,v)-{

builder.withClaim(k,v);

});

//设置签名

String token = builder.sign(Algorithm.HMAC256(SING));

return token;

}

//验证令牌

public static void verifyToken(String token){

JWTVerifier require = JWT.require(Algorithm.HMAC256(SING)).build();

require.verify(token);

}

//获取token信息

public static DecodedJWT getTokenInfo(String token){

DecodedJWT verify = JWT.require(Algorithm.HMAC256(SING)).build().verify(token);

return verify;

}

}

2.3 编写拦截器

public class JWTInterceptor implements HandlerInterceptor {

@Override

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

if (HttpMethod.OPTIONS.toString().equals(request.getMethod())) {

System.out.println("OPTIONS请求，放行");

return true;

}

HashMap map = new HashMap();

String token = request.getHeader("token");

try {

JWTUtils.verifyToken(token);

return true;

}catch (SignatureVerificationException e){

map.put("msg","无效签名!");

}catch (TokenExpiredException e){

map.put("msg","token过期!");

}catch (AlgorithmMismatchException e){

map.put("msg","token加密算法不一致");

}catch (Exception e){

map.put("msg","无效签名!");

}

map.put("state",404);

map.put("path","/login");

//将map转化为字符串返回给前端

String result = new ObjectMapper().writeValueAsString(map);

response.setContentType("application/json;charset=UTF-8");

response.getWriter().println(result);

return false;

}

}

注意：

1、token存放在请求的header中；

2、在前后端分离的项目中，发送的GET/POST请求实则为两次请求。第一次请求为OPTIONS请求，第二次请求才是GET/POST请求；在OPTIONS请求中，不会携带请求头的参数，会导致在拦截器上获取请求头为空，自定义的拦截器拦截成功。第一次请求不能通过，就不能获取第二次的请求。所以需要在拦截器中加上如下代码来判断是否为OPTIONS请求，对于OPTIONS请求直接放过。

if (HttpMethod.OPTIONS.toString().equals(request.getMethod())) {

System.out.println("OPTIONS请求，放行");

return true;

}

2.4 配置拦截器

package com.stock.config;

import com.stock.Interceptors.JWTInterceptor;

import org.springframework.context.annotation.Configuration;

import org.springframework.web.servlet.config.annotation.InterceptorRegistry;

import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration

public class IntercepterConfg implements WebMvcConfigurer {

@Override

public void addInterceptors(InterceptorRegistry registry) {

registry.addInterceptor(new JWTInterceptor())

.addPathPatterns("/**")

.excludePathPatterns("/login");

}

}

2.5 编写Controller

package com.stock.controller;

import com.stock.entity.User;

import com.stock.result.Result;

import com.stock.service.UserService;

import com.stock.utils.JWTUtils;

import com.stock.utils.ResultUtils;

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.RequestBody;

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

import java.util.HashMap;

@RestController

public class LoginController {

private UserService userService;

@Autowired

public LoginController(UserService userService) {

this.userService = userService;

}

@PostMapping("/login")

public Result register(User user){

HashMap map = new HashMap();

map.put("username",user.getUserName());

String token = JWTUtils.getToken(map);

HashMap data = new HashMap();

data.put("token",token);

return ResultUtils.getresult(200,"登录成功!",data);

}

@GetMapping("/main")

public Result tomain(){

return ResultUtils.getresult(200,"访问成功",null);

}

}

2.6使用Postman测试

- 未登录前访问127.0.0.1:8888/main

- 先登录再访问127.0.0.1:8888/main

网页题目：jwtjava代码 java 代码大全
文章出自：http://lswzjz.com/article/dojoiee.html