作为后端开发人员，我正面临着功能测试的JWT令牌过期的异常（JWTExpiredException）🤯。我认为我们很多人在日常生活编码中面临同样的问题🤬。想要出现这个问题。然后这篇文章适合你。🤩

让’在代码中潜水而不会浪费你的时间。⌚您可以从下面的Git下载代码。✨

创建JWT令牌，没有过期的春天启动

首先让’s move to the application.properties. file

jwt..secret = dasjs.
jwt.expirationdateinms = 50000.
jwt.refreshexpirationdateinms = 9000000.
spring.datasource.url = jdbc：mysql：// localhost / bootjwt？createdatabaseifnotexist = true&autoReconnect=true&useSSL=false
spring.datasource.username = root.
spring.datasource.password =.
spring.jpa.hibernate.ddl-auto = create-drop

jwt..秘密 = Dasjs.

jwt..前任pirydateinms=50000

jwt..refreskexpirationDateinms.=9000000

春天.数据源.URL.=JDBC.:mysql.:// localhost / bootjwt？createdatabaseifnotexist = true&autoReconnect=true&useSSL=false

春天.数据源.用户名=根

春天.数据源.密码=

春天.JPA..冬眠.DDL.-汽车=创造-降低

我们正在使用简单的Spring Boot JWT Web令牌示例，正如您所看到的那样 jwt..expirationdateinms = 50000. 定义正常的令牌到期和 jwt..refreshexpirationdateinms = 9000000. 定义刷新令牌到期。

看更多:

使用懒惰的加载模块加快角度应用程序
懒惰的装载模块是角度10的一个特征，......

现在是时候使用我们的服务类（JWTUTIL）配置刷新令牌的时间

包裹 com.dasjs.springbootsecurity.config;

导入java.util.arrays;
导入java.util.collection;
导入java.util.date;
导入java.util.hashmap;
导入java.util.list;
导入java.util.map;

导入org.springframework.beans.factory.annotation.value;
导入org.springframework.security.authentication.badcredentialSexception;
导入org.springframework.security.authentication.usernamepasswordauthenticationToken;
导入org.springframework.security.core.grantedauthority;
导入org.springframework.security.core.authority.simplegrantedauthority;
导入org.springframework.security.core.userdetails.userdetails;
导入org.springframework.sterotype.service;

导入io.jsonwebtoken.claims;
导入io.jsonwebloken.expiredjwtexception;
导入io.jsonwebtoken.jws;
导入io.jsonwebtoken.jwts;
导入io.jsonwebtoken.malomfordjwtexception;
导入io.jsonwebtoken.signaturealgorithm;
导入io.jsonwebtoken.signatureexception;
导入io.jsonwebtoken.unsupportedjwtexception;

@Service
公共类Jwtutil {

	私人弦秘密; 
	私人int jwtextinms;
	私有int refreskexpirddateinms;

	@Value（“$ {jwt.secret}”）
	公共void setsecret（String Secret）{
		这个。分泌=秘密;
	}

	@Value（“$ {jwt.expirateddateinms}”）
	public void setjwtexpirdinms（int jwtextinmms）{
		this.jwtexpirationInms = jwtextimms;
	}
	
	@Value（“$ {jwt.refreshexpirddationdateinms}”）
	公共void setrefresexexpirddateinms（int refreskexpirddateinms）{ 
		this.refreskexpirationdateinms = refreskexpirationdateinms;
	}

	public string generatek（userdetails userdetails）{
		Map<String, Object>索赔=新的hashmap<>();

		Collection<？延伸给予授予授权>角色= userdetails.getauthorities（）;

		if (roles.contains(new 简单的身份奉献("ROLE_ADMIN"))) {
			索赔.put（“isadmin”，true）;
		}
		if (roles.contains(new 简单的身份奉献("ROLE_USER"))) {
			索赔（“keuser”，true）;
		}
		
		返回dogenerateken（索赔，userdetails.getUsername（））;
	}

	私有字符串Dogenerateken（地图<String, Object>索赔，字符串主题）{
		返回JWTS.Builder（）。SetClaims（索赔）.setsubject（主题）.setsissuedat（新日期（system.currenttimemillis（）））
				.setexpion（新日期（system.currenttimemillis（）+ jwtextiveinms））
				.signwith（signaturealgorithm.hs512，secret）.compact（）;

	}
	
	公共字符串dogeneraterefreshtoken（地图<String, Object>索赔，字符串主题）{

		返回JWTS.Builder（）。SetClaims（索赔）.setsubject（主题）.setsissuedat（新日期（system.currenttimemillis（）））
				.setexpion（新日期（system.currenttimemillis（）+ refreskexpirationdateinms））
				.signwith（signaturealgorithm.hs512，secret）.compact（）;

	}

	public boolean validateken（String authtoken）{
		try {
			Jws<Claims>索赔= jwts.parser（）。SetsigningKey（秘密）.parseclaimsjws（authtoken）;
			return true;
		catch（signaturexception | malormedjwtexception | Unsupportedjwtexception | IllegalArgumentException前）{
			抛出新的BadcredentialSexception（“Invalid_credentials”，EX）;
		catch（ExpiredJwtexception前）{
			throw ex;
		}
	}

	公共字符串getusernamefromtoken（String令牌）{
		索赔= jwts.parser（）。setsigningkey（秘密）.parseclaimsjws（令牌）.getbody（）;
		return索赔.getsubject（）;

	}

	public List<简单的身份奉献>getRolesFromToken（String令牌）{
		索赔= jwts.parser（）。setsigningkey（秘密）.parseclaimsjws（令牌）.getbody（）;

		List<简单的身份奉献> roles = null;

		boolean isadmin =索赔。重点（“Isadmin”，Boolean.class）;
		boolean iSuser =索赔。重点（“keuser”，boolean.class）; 

		if (isAdmin != null && isAdmin) {
			roles = Arrays.asList(new 简单的身份奉献("ROLE_ADMIN"));
		}

		if (isUser != null && isAdmin) {
			roles = Arrays.asList(new 简单的身份奉献("ROLE_USER"));
		}
		return roles;

	}

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

包裹 com.Dasjs..SpringBootsecurity..配置;

进口 java..利用者.阵列;

进口 java..利用者.收藏;

进口 java..利用者.日期;

进口 java..利用者.Hashmap.;

进口 java..利用者.列表;

进口 java..利用者.地图;

进口 org..Springframework..豆子.工厂.注解.价值;

进口 org..Springframework..安全.验证.BadcredentialSexception.;

进口 org..Springframework..安全.验证.用户namepasswordaeuthenticationToken.;

进口 org..Springframework..安全.核.GrantedAuthority.;

进口 org..Springframework..安全.核.权威.简单的身份奉献;

进口 org..Springframework..安全.核.用户details..用户details..;

进口 org..Springframework..刻板印象.服务;

进口 IO..jsonweptoken..索赔;

进口 IO..jsonweptoken..前任piredjwtexception.;

进口 IO..jsonweptoken..JWS.;

进口 IO..jsonweptoken..jwt.s.;

进口 IO..jsonweptoken..malformedjwtexception.;

进口 IO..jsonweptoken..signaturealgorithm.;

进口 IO..jsonweptoken..signatureexception.;

进口 IO..jsonweptoken..UNSUPPORTEDJWTException.;

@服务

民众班级 jwt.util. {

私人的细绳秘密;

私人的㈡ jwt.expordioninms.;

私人的㈡ refreskexpirationDateinms.;

@价值(“$ {jwt.secret}”)

民众空白索引(细绳秘密) {

这个.秘密 = 秘密;

}

@价值(“$ {jwt.expirationdateinms}”)

民众空白 setjwtextInms.(㈡ jwt.expordioninms.) {

这个.jwt.expordioninms. = jwt.expordioninms.;

}

@价值(“$ {jwt.refreshexpirddatedateinms}”)

民众空白 setRefreshexpirationDateinms.(㈡ refreskexpirationDateinms.) {

这个.refreskexpirationDateinms. = refreskexpirationDateinms.;

}

民众细绳 generateToken.(用户details.. 用户details.) {

地图<细绳, 目的> 索赔 = 新的 Hashmap.<>();

收藏<? 延伸 GrantedAuthority.> 角色 = 用户details..得到authorities.();

如果 (角色.包含(新的简单的身份奉献(“角色_admin”))) {

索赔.放(“isadmin”, 真的);

}

如果 (角色.包含(新的简单的身份奉献(“角色_user”))) {

索赔.放(“威尔”, 真的);

}

返回 dogenerateken.(索赔, 用户details..得到username.());

}

私人的细绳 dogenerateken.(地图<细绳, 目的> 索赔, 细绳主题) {

返回 jwt.s..建造者().机制(索赔).sitewject.(主题).setissuedat(新的日期(系统.Currenttimemillis.()))

.seteption.(新的日期(系统.Currenttimemillis.() + jwt.expordioninms.))

.sign(signaturealgorithm..HS512, 秘密).袖珍的();

}

民众细绳 dogeneraterefreshtoken.(地图<细绳, 目的> 索赔, 细绳主题) {

返回 jwt.s..建造者().机制(索赔).sitewject.(主题).setissuedat(新的日期(系统.Currenttimemillis.()))

.seteption.(新的日期(系统.Currenttimemillis.() + refreskexpirationDateinms.))

.sign(signaturealgorithm..HS512, 秘密).袖珍的();

}

民众布尔基 vignateToken.(细绳 authtoken.) {

尝试 {

JWS.<Claims> 索赔 = jwt.s..解析器().守则(秘密).Parseclaimsjws.(authtoken.);

返回真的;

} 抓住 (signatureexception. | malformedjwtexception. | UNSUPPORTEDJWTException | IllegalArgumentException. 前任) {

扔新的 BadcredentialSexception.(“无效证件”, 前任);

} 抓住 (前任piredjwtexception. 前任) {

扔前任;

}

民众细绳得到usernamefromtoken.(细绳令牌) {

索赔索赔 = jwt.s..解析器().守则(秘密).Parseclaimsjws.(令牌).塔();

返回索赔.得到s赞许();

}

民众列表<简单的身份奉献> 得到rolesfromtoken.(细绳令牌) {

索赔索赔 = jwt.s..解析器().守则(秘密).Parseclaimsjws.(令牌).塔();

列表<简单的身份奉献> 角色 = 无效的;

布尔基 Isadmin. = 索赔.得到(“isadmin”, 布尔基.班级);

布尔基伊斯兰人 = 索赔.得到(“威尔”, 布尔基.班级);

如果 (Isadmin. ！= 无效的 && Isadmin.) {

角色 = 阵列.亚文斯特(新的简单的身份奉献(“角色_admin”));

}

如果 (伊斯兰人！= 无效的 && Isadmin.) {

角色 = 阵列.亚文斯特(新的简单的身份奉献(“角色_user”));

}

返回角色;

}

现在我们必须为JWT身份验证实现过滤器。在此筛选器中命名 customjwtauthenticationfilter， 如果jwt令牌在测试期间过期，那么我们必须设置 isrefreshtoken. set to true.

看更多:

您是否知道关于角度9的这些隐藏的调试API？
调试是每个开发人员的一个很好的工具。和角度......

创建自定义授权过滤器

当令牌到期时，我们必须从中获得索赔 前任piredjwtexception. 并将其存放在 http.request。这些索赔将用于创建刷新JWT令牌。我们必须通过创建安全上下文 用户namepasswordaeuthenticationToken. with null values.

包裹 com.dasjs.springbootsecurity.config;

导入java.io.ioException;

导入javax.servlet.filterchain;
导入javax.servlet.servletException;
导入javax.servlet.http.httpservletRequest;
导入javax.servlet.http.httpservletresponse;

导入org.springframework.beans.factory.annotation.Autowired;
导入org.springframework.security.authentication.badcredentialSexception;
导入org.springframework.security.authentication.usernamepasswordauthenticationToken;
导入org.springframework.security.core.context.securityContextholder;
导入org.springframework.security.core.userdetails.user;
导入org.springframework.security.core.userdetails.userdetails;
导入org.springframework.sterotype.component;
导入org.springframework.util.stringutils;
导入org.springframework.web.filter.onceperrequestfilter;

导入io.jsonwebloken.expiredjwtexception;

@Component
公共类CustomJwtauthenticationFilter扩展了托架requestFilter {

	@Autowired
	私人jwtutil jwttokentul;

	@Override
	受保护的void dofilterinternal（httpservletrequest请求，httpservletresponse响应，filterchain链）
			抛出servletException，ioException {

		 try{
			// jwt令牌处于“持卡令牌”的形式。删除承载词和
			//只得到令牌
			string jwttoken = elptringjwtfromrequest（请求）;

			if（stryutils.hastext（jwttoken）&&jwttokentutil.validatekoken（jwttoken））{
				userdetails userdetails = new user（jwttokentutil.getusernamefromtoken（jwttoken），“”，
						jwttokentutil.getrolesfromtoken（jwttoken））;

				UsernamepasswordaeuthenticationToken usernamepasswordauthenticationToken = new usernamepasswordauthenticationToken（
						userdetails，null，userdetails.getauthorities（））;
				//在上下文中设置身份验证后，我们指定
				//当前用户已被身份验证。所以它通过了
				// Spring Security配置成功。
				SecurityContextholder.getContext（）。setauthentication（UsernamepasswordauthenticationToken）;
			} else {
				system.out.println（“无法设置安全上下文”）;
			}
		 catch（ExpiredJwtexception前）
		 {
			 字符串ISRefReshToken = Request.getheader（“ISRefReshToken”）;
				string requesturel = request.getrequesturl（）。ToString（）;
				//如果以下条件为真，则允许刷新令牌创建。
				if（isrefreshtoken！= null&&Isrefreshtoken.equals（“真实”）&&Requestul.Contains（“refreshtoken”））{
					allowforrefreshtoken（前，请求）;
				} else
					Request.setTribute（“例外”，EX）;
		 }
		 Catch（BadcredentialSexception前）
		 {
			 Request.setTribute（“例外”，EX）;
		 }
		Chain.Dofilter（请求，响应）;
	}
	
	私有void allowforrefreshtoken（expiredjwtexception ex，httpservletrequeest请求）{

		//创建具有空值的UsernamepasswordauthentationTokenToken。
		UsernamepasswordaeuthenticationToken usernamepasswordauthenticationToken = new usernamepasswordauthenticationToken（
				null, null, null);
		//在上下文中设置身份验证后，我们指定
		//当前用户已被身份验证。所以它通过了
		// Spring Security配置成功。
		SecurityContextholder.getContext（）。setauthentication（UsernamepasswordauthenticationToken）;
		//将索赔设置为使其在控制器中我们将使用它来创建
		// new JWT
		Request.setAttribute（“索赔”，ex.getClaims（））;

	}

	私有字符串extractjwtfromrequest（httpservletrequest请求）{
		String BearerToken = Request.getheader（“授权”）;
		if（stryutils.hastext（bearertoken）&&bearertoken.startswith（“持票人”））{
			返回bearertoken.substring（7，bearertoken.length（））;
		}
		return null;
	}

}

包裹 com.Dasjs..SpringBootsecurity..配置;

进口 java..IO..IoException.;

进口 java.x..servlet..滤波器;

进口 java.x..servlet..servlet.Exception.;

进口 java.x..servlet..http..http.servletrequest.;

进口 java.x..servlet..http..http.servletresponse.;

进口 org..Springframework..豆子.工厂.注解.自动利用;

进口 org..Springframework..安全.验证.BadcredentialSexception.;

进口 org..Springframework..安全.验证.用户namepasswordaeuthenticationToken.;

进口 org..Springframework..安全.核.语境.SecurityContextholder.;

进口 org..Springframework..安全.核.用户details..用户;

进口 org..Springframework..安全.核.用户details..用户details..;

进口 org..Springframework..刻板印象.零件;

进口 org..Springframework..利用者.stringutils.;

进口 org..Springframework..网页.筛选.丁雷德里特弗雷特;

进口 IO..jsonweptoken..前任piredjwtexception.;

@零件

民众班级 customjwtauthenticationFilter. 延伸丁雷德里特弗雷特 {

@Autowired.

私人的 jwt.util. jwt.tokentutil.;

@Override.

保护空白 dofilterinternal.(http.servletrequest. 要求, http.servletresponse. 回复, 滤波器链)

抛出 servlet.Exception., IoException. {

尝试{

// jwt令牌处于“持卡令牌”的形式。删除承载词和

// 得到 only the Token

细绳 jwt.token. = ExtractJwtfromRequest.(要求);

如果 (stringutils..黑衣(jwt.token.) && jwt.tokentutil..vignateToken.(jwt.token.)) {

用户details.. 用户details. = 新的用户(jwt.tokentutil..得到usernamefromtoken.(jwt.token.), “,

jwt.tokentutil..得到rolesfromtoken.(jwt.token.));

用户namepasswordaeuthenticationToken. 用户namepasswordaeuthenticationToken. = 新的用户namepasswordaeuthenticationToken.(

用户details., 无效的, 用户details..得到authorities.());

//在上下文中设置身份验证后，我们指定

//当前用户已被身份验证。所以它通过了

// Spring Security配置成功。

SecurityContextholder..得到Context.().setauthentication.(用户namepasswordaeuthenticationToken.);

} 别的 {

系统.出去.println.(“无法设置安全上下文”);

}

}抓住(前任piredjwtexception. 前任)

{

细绳 isrefreshtoken. = 要求.Getheader.(“isrefreshtoken”);

细绳 Requesturl. = 要求.得到Requesturl.().toString.();

//如果以下条件为真，则允许刷新令牌创建。

如果 (isrefreshtoken. ！= 无效的 && isrefreshtoken..等于(“真的”) && Requesturl..包含(“refrestoken”)) {

allowforrefreshtoken.(前任, 要求);

} 别的

要求.setAttribute.(“例外”, 前任);

}

抓住(BadcredentialSexception. 前任)

{

要求.setAttribute.(“例外”, 前任);

}

链.Dofilter.(要求, 回复);

}

私人的空白 allowforrefreshtoken.(前任piredjwtexception. 前任, http.servletrequest. 要求) {

//创建具有空值的UsernamepasswordauthentationTokenToken。

用户namepasswordaeuthenticationToken. 用户namepasswordaeuthenticationToken. = 新的用户namepasswordaeuthenticationToken.(

无效的, 无效的, 无效的);

//在上下文中设置身份验证后，我们指定

//当前用户已被身份验证。所以它通过了

// Spring Security配置成功。

SecurityContextholder..得到Context.().setauthentication.(用户namepasswordaeuthenticationToken.);

//将索赔设置为使其在控制器中我们将使用它来创建

//新的JWT.

要求.setAttribute.(“索赔”, 前任.得到Claims.());

}

私人的细绳 ExtractJwtfromRequest.(http.servletrequest. 要求) {

细绳 Bearertoken. = 要求.Getheader.(“授权”);

如果 (stringutils..黑衣(Bearertoken.) && Bearertoken..以。。开始(“持票人”)) {

返回 Bearertoken..划线(7, Bearertoken..长度());

}

返回无效的;

}

现在我们可以移动到身份验证控制器中的“创建刷新令牌”。

包裹 com.dasjs.springbootsecurity.controller;

导入java.util.hashmap;
导入java.util.map;
导入java.util.map.entry;

导入javax.servlet.http.httpservletRequest;

导入org.springframework.beans.factory.annotation.Autowired;
导入org.springframework.http.reponsentity;
导入org.springframework.security.authentication.身份验证管理员;
导入org.springframework.security.authentication.badcredentialSexception;
导入org.springframework.security.authentication.disabledException;
导入org.springframework.security.authentication.usernamepasswordauthenticationToken;
导入org.springframework.security.core.userdetails.userdetails;
导入org.springframework.web.bind.annotation.requestbody;
导入org.springframework.web.bind.annotation.requestmapping;
导入org.springframework.web.bind.annotation.requestmethod;
导入org.springframework.web.bind.annotation.restcontroller;

导入com.dasjs.springbootsecurity.config.customuserDetailsService;
导入com.dasjs.springbootsecurity.config.jwtutil;
导入com.dasjs.springbootsecurity.model.身份验证request.;
导入com.dasjs.springbootsecurity.model.authenticationResponse;
导入com.dasjs.springbootsecurity.model.userdto;

导入io.jsonwebtoken.impl.defaultClaims;

@RestController
公共类身份验证控制器{

	@Autowired
	私人身份验证管理员身份验证管理器;

	@Autowired
	privateUserDetailsService UserDetailSservice;

	@Autowired
	私人Jwtutil Jwtutil;

	@requestmapping（value =“/ authenticate”，方法= requestmethod.post）
	公共响应<?>CreateAuthenticationToken（@RequestBody身份验证request身份验证）
			throws Exception {
		try {
			身份验证管理员.Authenticate（新的USERNAMEPASSWORDAUTHENTINCETTOKEN（
					身份验证request..getUserName（），身份验证request.getPassword（）））））;
		catch（disabassedException e）{
			抛出新的异常（“user_disabled”，e）;
		}
		catch（badcredentialsexception e）{
			抛出新的例外（“Invalid_credentials”，E）;
		}
		
		userdetails userdetails = userdetailsservice.loadUserByUsername（身份验证request..getUserName（））;
		字符串令牌= jwtutil.generatekoken（userdetails）;
		return alynateTentity.ok（新的身份验证响应（令牌））;
	}
	
	@requestmapping（value =“/ register”，方法= requestmethod.post）
	公共响应<?>SaveUser（@RequestBody Userdto用户）抛出异常{
		return anderthentity.ok（userdetailsservice.save（user））;
	}
	
	@requestmapping（value =“/ freeheshtoken”，method = requestmethod.get）
	公共响应<?>RefreshToken（httpservletrequest请求）抛出异常{
		//从HttpRequest获得索赔
		defaultClaims索赔=（IO.JSONWEBTOKEN.IMPL.DEFAULTCLIMS）REQUEST.getAttribute（“索赔”）;

		Map<String, Object>预示= getMapfromiojsonWebliums（索赔）;
		字符串令牌= jwtutil.dogeneraterefresktoken（想要图，期望的map.get（“sub”）。ToString（））;
		return alynateTentity.ok（新的身份验证响应（令牌））;
	}

	public Map<String, Object>getmapfromiojsonwebthokclaims（DefaultClaims索赔）{
		Map<String, Object>预期图= new hashmap<String, Object>();
		for (Entry<String, Object>条目：索赔.entryset（））{
			预示.put（rest.getkey（），stry.getValue（））;
		}
		return expectedMap;
	}
}

包裹 com.Dasjs..SpringBootsecurity..控制器;

进口 java..利用者.Hashmap.;

进口 java..利用者.地图;

进口 java..利用者.地图.入口;

进口 java.x..servlet..http..http.servletrequest.;

进口 org..Springframework..豆子.工厂.注解.自动利用;

进口 org..Springframework..http..响应;

进口 org..Springframework..安全.验证.身份验证管理员;

进口 org..Springframework..安全.验证.BadcredentialSexception.;

进口 org..Springframework..安全.验证.isaisablexception.;

进口 org..Springframework..安全.验证.用户namepasswordaeuthenticationToken.;

进口 org..Springframework..安全.核.用户details..用户details..;

进口 org..Springframework..网页.捆绑.注解.请求人员;

进口 org..Springframework..网页.捆绑.注解.RequestMapping.;

进口 org..Springframework..网页.捆绑.注解.要求method.;

进口 org..Springframework..网页.捆绑.注解.restcontroller.;

进口 com.Dasjs..SpringBootsecurity..配置.customuserdetailsservice.;

进口 com.Dasjs..SpringBootsecurity..配置.jwt.util.;

进口 com.Dasjs..SpringBootsecurity..模型.身份验证request.;

进口 com.Dasjs..SpringBootsecurity..模型.身份验证响应;

进口 com.Dasjs..SpringBootsecurity..模型.用户dto.;

进口 IO..jsonweptoken..拆.DefaultClaims.;

@RestController.

民众班级身份验证控制器 {

@Autowired.

私人的身份验证管理员身份验证管理员;

@Autowired.

私人的 customuserdetailsservice. 用户details.service.;

@Autowired.

私人的 jwt.util. jwt.util.;

@requestmappping.(价值 = “/认证”, 方法 = 要求method..邮政)

民众响应<?> CreateAuthenticationToken.(@请求人员身份验证request. 身份验证request.)

抛出例外 {

尝试 {

身份验证管理员.认证(新的用户namepasswordaeuthenticationToken.(

身份验证request..得到username.(), 身份验证request..获取密码()));

} 抓住 (isaisablexception. e) {

扔新的例外(“user_disabled”, e);

}

抓住 (BadcredentialSexception. e) {

扔新的例外(“无效证件”, e);

}

用户details.. 用户details. = 用户details.service..loadUserByusername.(身份验证request..得到username.());

细绳令牌 = jwt.util..generateToken.(用户details.);

返回响应.好的 (新的身份验证响应(令牌));

}

@RequestMapping.(价值 = “/登记”, 方法 = 要求method..邮政)

民众响应<?> Saptuser.(@RequestBody. 用户dto. 用户) 抛出例外 {

返回响应.好的 (用户details.service..保存(用户));

}

@requestmappping.(价值 = “/ refreshtoken”, 方法 = 要求method..得到)

民众响应<?> 刷新(http.servletrequest. 要求) 抛出例外 {

//从HttpRequest获得索赔

DefaultClaims. 索赔 = (IO..jsonweptoken..拆.DefaultClaims.) 要求.得到Attribute.(“索赔”);

地图<细绳, 目的> 预示图 = 得到mapfromiojsonwebthenglaims.(索赔);

细绳令牌 = jwt.util..dogeneraterefreshtoken.(预示图, 预示图.得到(“亚”).toString.());

返回响应.好的 (新的身份验证响应(令牌));

}

民众地图<细绳, 目的> 得到mapfromiojsonwebthenglaims.(DefaultClaims. 索赔) {

地图<细绳, 目的> 预示图 = 新的 Hashmap.<细绳, 目的>();

为了 (入口<细绳, 目的> 入口 : 索赔.进入()) {

预示图.放(入口.GetKey.(), 入口.GetValue.());

}

返回预示图;

}

那’它。现在，您可以检查此示例的演示。

刷新令牌：创建JWT令牌，没有过期的春天启动示例

创建JWT令牌，没有过期的春天启动

首先让’s move to the application.properties. file

现在是时候使用我们的服务类（JWTUTIL）配置刷新令牌的时间

创建自定义授权过滤器

演示屏幕截图

注册用户

验证URL.

使用普通令牌访问管理部分

创建刷新令牌

下载源代码

创建JWT令牌，没有过期的春天启动

首先让’s move to the application.properties. file

现在是时候使用我们的服务类（JWTUTIL）配置刷新令牌的时间

创建自定义授权过滤器

演示屏幕截图

注册用户

验证URL.

使用普通令牌访问管理部分

创建刷新令牌

下载源代码

相关文章：