springboot集成JWT 登录验证

已于 2024-03-03 15:17:56 修改
阅读量1.2k 收藏 1
点赞数
分类专栏： springboot 文章标签： spring boot java web安全
于 2022-09-02 15:30:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16430873/article/details/126661380
版权

前言

 嗯，给之前的日志功能界面加登录验证。

一、集成JWT

maven配置

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.sakyoka.test</groupId>
  <artifactId>springboot-websocket-log-test</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>springboot-websocket-log-test</name>
  <url>http://maven.apache.org</url>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.4.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<!-- springboot start -->
		<!-- web -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
			<!-- <exclusions> <exclusion> <groupId>org.springframework.boot</groupId> 
				<artifactId>spring-boot-starter-tomcat</artifactId> </exclusion> </exclusions> -->
		</dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        
		<!-- socket -->
		<dependency>
		  <groupId>org.springframework.boot</groupId>
		  <artifactId>spring-boot-starter-websocket</artifactId>
		</dependency>
		<!-- springboot end -->        
		
		<!-- utils start -->
		<!-- 日志 logging-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-logging</artifactId>
		</dependency>

		<!-- 热部署 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<optional>true</optional>
		</dependency>
		<!-- utlis end -->
		
		<dependency> 
		    <groupId>org.projectlombok</groupId> 
		    <artifactId>lombok</artifactId> 
		</dependency>

		<dependency>
		    <groupId>cn.hutool</groupId>
		    <artifactId>hutool-all</artifactId>
		    <version>4.1.19</version>
		</dependency>

		<dependency>
		    <groupId>org.apache.tomcat.embed</groupId>
		    <artifactId>tomcat-embed-jasper</artifactId>
		    <scope>provided</scope>
		</dependency>
		
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.8.1</version>
        </dependency>
        
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.7</version>
		</dependency>
		
		<dependency>
		    <groupId>com.alibaba</groupId>
		    <artifactId>fastjson</artifactId>
		    <version>1.2.47</version>
		</dependency>
	</dependencies>


   <build>
        <finalName>springboot-websocket-log-test</finalName>
        <resources>
            <resource>
                <directory>${basedir}/src/main/webapp</directory>
                <!--注意此次必须要放在此目录下才能被访问到-->
                <targetPath>META-INF/resources</targetPath>
                <includes>
                    <include>**/**</include>
                </includes>
            </resource>
            <resource>
                <directory>${basedir}/src/main/resources</directory>
                <includes>
                    <include>**/**</include>
                </includes>
            </resource>
        </resources>
    </build>
</project>

JwtTokenUtils 封装jwt生成token和校验token值，可以设置token有效时间，这里设置半个小时。

package com.sakyoka.test.utils;

import java.util.Date;
import java.util.UUID;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;

/**
 * 
 * 描述：jwt token生成、校验
 * @author sakyoka
 * @date 2022年8月31日 下午5:20:35
 */
public class JwtTokenUtils {
	
	private JwtTokenUtils(){}
	
	/**有效时长：默认半个小时*/
	private static Long EXPIRATION_DATE = 
			Long.valueOf(Properties.get("login.jwt.expiration_date", Long.valueOf(30 * 60 * 1000).toString()));
	
	/**token秘钥*/
	private static String TOKEN_SECRET = Properties.get("login.jwt.token_secret", "123");
	
	/**签发主体*/
	private static String TOKEN_USER = Properties.get("login.jwt.token_user", "sakyoka");

	/**
	 * 
	 * 描述：生成token字符串
	 * @author sakyoka
	 * @date 2022年8月31日 下午5:20:12
	 * @param userName
	 * @return String
	 */
	public static String tokenCreate(String userName){
		String token = JWT.create()
				.withJWTId(UUID.randomUUID().toString().replace("-", ""))
				.withIssuer(TOKEN_USER)
				.withClaim("username", userName)
				.withExpiresAt(new Date(System.currentTimeMillis() + EXPIRATION_DATE))
				.sign(Algorithm.HMAC256(TOKEN_SECRET));
		return token;
	}
	
	/**
	 * 
	 * 描述：token校验
	 * @author sakyoka
	 * @date 2022年8月31日 下午5:21:41
	 * @param token
	 * @return true有效，false无效
	 */
	public static boolean tokenValid(String token){

		try {
			DecodedJWT decodedJWT = getJwt(token);
			Claim userClaim = decodedJWT.getClaim("username");
			if (userClaim.isNull()){
				System.out.println("token get username is null");
				return false;
			}
			//String userName = userClaim.asString();
			Date expirationDate = decodedJWT.getExpiresAt();
			return System.currentTimeMillis() < expirationDate.getTime();
		} catch (Exception e) {
			e.getStackTrace();
			return false;
		}
	}
	
	/**
	 * 
	 * 描述：获取DecodedJWT
	 * @author sakyoka
	 * @date 2022年9月1日 上午10:01:33
	 * @param token
	 * @return DecodedJWT
	 */
	private static DecodedJWT getJwt(String token){
		JWTVerifier verifier = JWT.require(Algorithm.HMAC256(TOKEN_SECRET))
				.withIssuer(TOKEN_USER).build();
		DecodedJWT decodedJWT = verifier.verify(token);
		return decodedJWT;
	}
}

二、配置拦截器

自定义CommonInterceptor拦截器，实现HandlerInterceptor的接口，主要校验header或者url上的token是否为空，是否有效。无效设置401并且跳转到登录页面

package com.sakyoka.test.systemconfig.interceptor;

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

import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import com.sakyoka.test.utils.JwtTokenUtils;

import lombok.extern.log4j.Log4j;

/**
 * 
 * 描述：请求拦截器
 * @author sakyoka
 * @date 2022年9月2日 下午1:54:41
 */
@Component
@Log4j
public class CommonInterceptor implements HandlerInterceptor{
	
	private static final int UNAUTHORIZED = 401;

	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		
		//从header中获取token值
		String token = request.getHeader("token");
		token = StringUtils.isBlank(token) ? request.getParameter("token") : token;
		if (StringUtils.isBlank(token)){
			log.debug("header token is null");
			response.setStatus(UNAUTHORIZED);
			response.sendRedirect("/login");
			return false;
		}
		
		//判断token有效性
		boolean tokenValid = JwtTokenUtils.tokenValid(token);
		if (!tokenValid){
			log.debug("invalid token");
			response.sendRedirect("/login");
			response.setStatus(UNAUTHORIZED);
			return false;
		}
		
		return true;
	}

	@Override
	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			ModelAndView modelAndView) throws Exception {

	}

	@Override
	public void afterCompletion(HttpServletRequest request, 
			HttpServletResponse response, Object handler, Exception ex)throws Exception {

	}

}

注册CommonInterceptor拦截器，并且添加要拦截的地址

package com.sakyoka.test.systemconfig.web;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import com.sakyoka.test.systemconfig.interceptor.CommonInterceptor;

/**
 * 
 * 描述：web配置
 * @author sakyoka
 * @date 2022年9月2日 下午1:59:04
 */
@Configuration
public class WebConfig extends WebMvcConfigurerAdapter{

	@Autowired
	CommonInterceptor commonInterceptor;
		
	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		//拦截所有/log 开头接口
		registry.addInterceptor(commonInterceptor)
				.addPathPatterns("/log/**");
	}
}

三、编写登录方法、登录页面

登录类，使用本地文件+配置文件的数据测试登录账号，这里就不连接数据校验了

package com.sakyoka.test.login.controller;

import java.io.File;

import org.apache.catalina.servlet4preview.http.HttpServletRequest;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.sakyoka.test.systemconfig.exception.CommonException;
import com.sakyoka.test.systemconfig.result.ResultBean;
import com.sakyoka.test.utils.FileUtils;
import com.sakyoka.test.utils.JwtTokenUtils;
import com.sakyoka.test.utils.OsUtils;
import com.sakyoka.test.utils.Properties;

import lombok.extern.log4j.Log4j;


/**
 * 
 * 描述：登录控制层
 * @author sakyoka
 * @date 2022年9月2日 下午2:02:49
 */
@Log4j
@Controller
public class LoginController {

	/**用户存储文件*/
	private static String LOGIN_USERS_FILE;
	
	/**默认账号*/
	private static final String DEFAULT_USER_NAME = Properties.get("login.default.username");
	
	/**默认密码*/
	private static final String DEFAULT_PASSWORD = Properties.get("login.default.password");
	
	static{
		String rootPath = OsUtils.isWindow() ? "D:\\" : "/mnt/";
		String userPath = rootPath + File.separator + "users_data";
		LOGIN_USERS_FILE = userPath + File.separator + "users.json";
		FileUtils.ifNotExistsCreate(LOGIN_USERS_FILE);
	}

	/**
	 * 
	 * 描述：登录页面
	 * @author sakyoka
	 * @date 2022年8月31日 下午3:06:59
	 * @return ModelAndView
	 */
	@GetMapping("/login")
	public ModelAndView loginpage(){
		ModelAndView modelAndView = new ModelAndView();
		modelAndView.setViewName("/login/login");
		return modelAndView;
	}
	
	/**
	 * 
	 * 描述：登录方法
	 * @author sakyoka
	 * @date 2022年8月31日 下午3:08:15
	 * @return ResultBean
	 */
	@PostMapping("/login")
	@ResponseBody
	public ResultBean login(HttpServletRequest request){
		
		String username = request.getParameter("username");
		if (StringUtils.isBlank(username)){
			return ResultBean.badRequest("username is blank", null);
		}
		
		String password = request.getParameter("password");
		if (StringUtils.isBlank(password)){
			return ResultBean.badRequest("password is blank", null);
		}
		
		String token = JwtTokenUtils.tokenCreate(username);
		//校验账号密码，有数据库当然读取数据库，这里直接读取本地文件
		//校验通过生成token
		String userContect = FileUtils.read(LOGIN_USERS_FILE);
		if (StringUtils.isNotBlank(userContect)){
			JSONObject jsonObject = JSON.parseObject(userContect);
			if (!jsonObject.containsKey(username)){
				if (this.checkDefaultUser(username, password)){
					return ResultBean.ok(token);
				}
			}
			String _password = jsonObject.getJSONObject(username).getString("password");
			if (password.equals(_password)){
				return ResultBean.ok(token);
			}
		}else{
			if (this.checkDefaultUser(username, password)){
				return ResultBean.ok(token);
			}
		}
		return ResultBean.builder()
				.code(ResultBean.UNAUTHORIZED)
				.msg("校验失败")
				.build();
	}
	
	/**
	 * 
	 * 描述：检查默认账号
	 * @author sakyoka
	 * @date 2022年8月31日 下午6:16:17
	 * @param username
	 * @param password
	 * @return true通过，false不通过
	 */
	private boolean checkDefaultUser(String username, String password){
		
		if (StringUtils.isBlank(DEFAULT_USER_NAME)) {
			log.warn("没有设置默认账号，请在配置文件设置login.default.username、login.default.password");
			throw new CommonException("没有设置默认账号，请在配置文件设置login.default.username、login.default.password");
		}
		
		if (DEFAULT_USER_NAME.equals(username)){
			if (DEFAULT_PASSWORD.equals(password)){
				return true;
			}else{
				throw new CommonException("password incorrect");
			}
		}
		
		throw new CommonException("not match account");
	}
	
	/**
	 * 
	 * 描述：登出方法
	 * @author sakyoka
	 * @date 2022年8月31日 下午3:08:22
	 * @param token
	 * @return ResultBean
	 */
	@PostMapping("/loginout")
	@ResponseBody
	public ResultBean loginout(HttpServletRequest request){
		//配合redis?
		return ResultBean.ok("");
	}
}

登录页面，返回token成功之后，携带token去访问其他页面接口(/log/** 下的接口和页面，因为拦截器只配置了这个路径)

<%@ page contentType="text/html; charset=UTF-8" %>
<!DOCTYPE html>
<html>
<head> 
    <title>login page</title>
	<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
	<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
	<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
	<meta name="renderer" content="webkit">
    <jsp:include page="/WEB-INF/views/common/commonstatic.jsp" flush="true" />
</head>
<body>
    <div id="fisrt-div" style="width: 100%; height: 100%; text-align: center; padding: 10%;">
        <div id="loginDiv" style="width: 800px; height: 400px; margin: auto; text-align: center; border: 1px solid #eee; border-radius: 5px; background-color: white; padding: 90px;">
            <div style="height: 20%; font-weight: bolder; font-size: 21px; font-family: NSimSun;">login</div>
            <div style="height: 70%;">
		        <table border="0px" style="margin: auto;">
		            <tbody>
			            <tr style="height: 40px;">
			                <td class="first-cols"><font color="red">*</font>账号：</td>
			                <td><input type="text" name="username" id="username" class="param-field input-class form-control" 
			                           valids="notBlank" fieldDesc="账号名称"/></td>
			            </tr>
				        <tr style="height: 40px;">
			                <td class="first-cols"><font color="red">*</font>密码：</td>
			                <td><input type="password" name="password" id="password" class="param-field input-class form-control" 
			                           valids="notBlank" fieldDesc="密码"/></td>
			            </tr>
		            </tbody>
		            <tfoot>
			            <tr>
			                <td colspan="2" style="text-align: center;">
			                    <button class="btn btn-primary" onclick="login();" style="margin-top: 10px;">登录</button>
			                    <button class="btn btn-default" onclick="reset();" style="margin-top: 10px;">重置</button>
			                </td>
			            </tr>
		            </tfoot>
		        </table>
            </div>
        </div>
    </div>
</body>
<script type="text/javascript" src="${root}/common/ParamObjectUtils.js"></script>
<script type="text/javascript" src="${root}/common/ValidUtils.js"></script>
<script type="text/javascript" src="${root}/common/URLBuilder.js"></script>
<script>
function login(){
	//password 加密？
	var loginUrl = root + "/login";
	var validResult = ParamObjectUtils.valid();
	if (validResult.result === false){
		AlertMessgaeUtils.alert({id:'tip', title:'提示', content: validResult.msg});
		return ;
	}
	var paramObject = validResult.data
	$.ajax({
	    url: loginUrl,
	    type: "post",
	    data: paramObject,
	    success: function(res) {
	    	if (res.code == 200){
	    		var token = res.data;
	    		localStorage.setItem("token", token);
	    		location.href = root + "/log/logconsole?token=" + token;
	    	}else{
	    		AlertMessgaeUtils.alert({id:'tip', title:'提示', content: "return msg：" + res.msg});
	    	}
	    },
	    error: function(xhr, ts, et){
	    	var status = xhr.status;
	    	var msg = '';
	    	switch (status){
	    	    case 400: msg = '请求参数存在错误'; break;
	    	    case 401: msg = '请求地址没有权限'; break;
	    	    case 403: msg = '请求地址没有权限'; break;
	    	    case 404: msg = '未知请求地址'; break;
	    	    case 500: msg = '内部服务器处理异常'; break;
	    	    default: msg = '请求失败'; break;
	    	}
		    AlertMessgaeUtils.alert({id:'tip', title:'提示', content: 'msg:' + msg});
	    }
	});	
}
</script>
</html>

ok,可以测试了。

四、测试

访问地址http://127.0.0.1:9000/log/logconsole，立刻被拦截转跳到登录页面

 用配置文件配置的账号密码登录

 进来了。

如果把地址上的token删除，立刻又回到登录页面。

总结

1、测试过程可以发现，登出方法没有实现，确实没有实现。由于jwt产生的token是没有状态

的，设置不了过期没有做。当然，登出还是可以做的，只要做一个黑名单存储起来，单机本地缓存可以，集群用redis。

2、是不是发现，没有token的续期，每过30分钟就得重新登录。这个是有方案的，配合refresh_token。后面做例子补上，这次就简单的token校验。

3、如果有网关springboot  gateway的话，拦截校验当然放在网关统一校验，校验通过把账号添加到请求地址上。

附件

springboot+jwt登录认证+实时日志显示-Java文档类资源-CSDN下载

sakyoka
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Maven下的JWT配置
u011478348的博客
01-31 9676
SSM下的JWT配置 1.简介 随着互联网的不断发展，技术的迭代也非常之快。我们的用户认证也从刚开始的用户名密码转变到基于cookie的session认证，然而到了今天，这种认证已经不能满足与我们的业务需求了（分布式，微服务）。我们采用了另外一种认证方式：基于token的认证。 一、与cookie相比较的优势： 1、支持跨域访问，将token置于请求头中，而cookie是不支持跨域访问的； 2、...
springboot+jwt(com.auth0)
xuanyan_的博客
07-24 2894
springboot+jwt(com.auth0) 1、pom.xml 1 <dependency> 2 <groupId>com.auth0</groupId> 3 <artifactId>java-jwt</artifactId> 4 <version>3.7.0</version> 5 </dependency> 2、Jw
SpringBoot第一次使用auth0的JWT
世 间 尤 物，不 敢 妄 取
03-02 3749
依赖 <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.4.0</version> </dependency> 工具类（含包） package ...
auth0的java-jwt_Spring boot + JWT 实现安全验证 ---auth0.jwt
weixin_31936393的博客
02-28 1548
auth0的jwt 实现安全验证： 使用自定义参数 和时间戳生成token。验证token时验证自定义参数。auth0.jwt 验证token时会自动验证时间戳是否过期，如果过期，会抛出异常TokenExpiredException1.引入依赖com.auth0java-jwt3.10.32.生成token和验证token的工具类import java.util.Date;import org.s...
使用Auth0的安全无密码身份验证
代码教主
06-19 2141
在本文中，您将学习如何使用Auth0服务设置无密码身份验证。 Auth0允许您外包应用程序的身份验证功能。 什么是Auth0？ Auth0是一种身份验证即服务工具，可轻松实现您的应用或网站与身份验证相关的功能的实现。 如果您已经构建了一个应用程序并且只想将身份验证和授权功能外包，则应考虑使用Auth0之类的服务。 让我快速总结一下Auth0提供的功能： 单点登录 多因素认证...
auth0 封装 JwtUtils
qq_52425315的博客
11-28 254
auth0 封装 JwtUtils
springboot集成jwt
01-25
**SpringBoot集成JWT详解** SpringBoot是一个轻量级的Java框架，它简化了Spring应用程序的创建和部署。JWT（Json Web Token）则是一种用于在各方之间安全地传输信息的开放标准，广泛应用于身份验证和授权场景。在...
SpringBoot集成JWT生成token及校验方法过程解析
08-19
SpringBoot集成JWT生成token及校验方法过程解析 本文主要介绍了SpringBoot集成JWT生成token及校验方法的过程解析，通过示例代码详细介绍了JWT token的生成和校验过程，为读者提供了详细的Reference和学习价值。 一...
SpringBoot集成JWT实现token验证源码.zip
12-20
SpringBoot集成JWT实现token验证源码.zip SpringBoot集成JWT实现token验证源码.zip SpringBoot集成JWT实现token验证源码.zip 【备注】 主要针对计算机相关专业的正在做毕设的学生和需要项目实战的Java学习者。 也可...
SpringBoot集成JWT实现token验证的流程
10-15
标题中的“SpringBoot集成JWT实现token验证的流程”是指在SpringBoot应用中使用JWT（Json Web Token）技术来实现用户身份验证的过程。JWT是一种开放标准（RFC 7519），它定义了一种紧凑的、自包含的方式来安全地在各...
auth0-java:Auth0平台的Java客户端库
04-06
Auth0 Java 平台的Java客户端库。 下载 通过Maven获取Auth0 Java： < dependency> < groupId>com.auth0</ groupId> < artifactId>auth0</ artifactId> < version>1.28.1</ version> </ dependency> 或Gradle： implementation ' com.auth0:auth0:1.28.1 ' 安卓 auth0.android库中的Auth0身份验证API和用户管理API可用于Android。 检查了解更多信息。 验证API 该实现基于 。 通过从提供应用程序详细信息来创建AuthAPI实例。 阅读有关降低资源使用量的。 AuthAPI auth = new AuthAPI ( " {YOUR_DOMAIN
SpringBoot集成JWT快速入门Demo
最新发布
04-10
编译器版本：IntelliJ IDEA 2020.3.2 x64 JDK版本：java 1.8.0_111 SpringBoot集成JWT快速入门Demo，演示jwt生成与验证等功能，可以通过swaggler或者Postman进行测试。
springboot实现jwt登录验证
qq_46440190的博客
12-30 1267
1、导入依赖 <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.18.2</version> </dependency> <dependency>
SpringBoot整合JWT
南风的博客
01-20 787
SpringBoot整合JWT 概述 有关jwt的的详细概述请参考阮一峰博客入门教程：https://www.ruanyifeng.com/blog/2018/07/json_web_token-tutorial.html 整合 导包–采用 java-jwt jar包 <!-- jwt --> <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</a
【记录】JWT令牌的使用（两步即可）
weixin_54345825的博客
09-10 1224
【记录】JWT令牌的使用
【SpringBoot】整合JWT实现登录验证
03-06 332
随着技术的发展，分布式web应用的普及，通过session管理用户登录状态成本越来越高，因此慢慢发展成为token的方式做登录身份校验，然后通过token去取redis中的缓存的用户信息，随着之后jwt的出现，校验方式更加简单便捷化，无需通过redis缓存，而是直接根据token取出保存的用户信息，以及对token可用性校验，单点登录更为简单。这里还有一个在线的的JWT生成器pom依赖-- jwt支持 -->二、核心代码文件// 过期时间5分钟/*** 生成签名,5min后过期。
java基于springboot+jwt实现用户登录功能
qq_58493322的博客
06-07 767
总之，使用Spring Boot框架和JWT技术实现用户登录功能可以提高应用程序的安全性和可靠性，同时也可以提高用户体验和功能性。
Springboot整合JWT实现用户token登录验证
skyxya的博客
02-10 1732
使用token验证比传统session更加安全、快捷，也能够很好的处理后端服务器集群带来的用户登录session传递难题，token主要存放于用户端浏览器，在每次请求时携带在请求头中，后端可以通过唯一的签名密钥来检测token是否合法，从而实现登录验证的功能
SpringBoot集成JWT实现Token登录验证
我爱写代码 我爱写代码 我爱写代码
05-04 991
SpringBoot集成JWT实现Token登录验证
springboot集成jwt实现登录
09-07
对于Spring Boot集成JWT实现登录的步骤，可以按照以下几个步骤进行操作： 1. 添加依赖：在`pom.xml`文件中添加以下依赖，以引入JWT相关的库： ```xml <groupId>io.jsonwebtoken <artifactId>jjwt-api <version>...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值