SpringBoot使用token简单鉴权

2024-05-27 01:33:06 99

本文内容纲要：

-1.简介

-2.具体实现

-2.1工程结构

-2.2代码实现

-3.测试

-4.扩展点

-5.源码

本文使用SpringBoot结合Redis进行简单的token鉴权。

1.简介

刚刚换了公司，所以最近有些忙碌，所以一直没有什么产出，最近朋友问我登录相关的，所以这里先写一篇简单使用token鉴权的文章，后续会补充一些高阶的，所以如果感觉这篇文章简单，可以直接绕行，言归正传，现在一般系统都进行了前后端分离，为了保证一定的安全性，现在很流行使用token来进行会话的验证，一般流程如下：

用户登录请求登录接口时，验证用户名密码等，验证成功会返回给前端一个token，这个token就是之后鉴权的唯一凭证。
后台可能将token存储在redis或者数据库中。
之后前端的请求，需要在header中携带token，后端取出token去redis或者数据库中进行验证，如果验证通过则放行，如果不通过则拒绝操作。

当然，如上的说法只是简单的实现，实质上还有很多需要优化的地方。

2.具体实现

2.1工程结构

本文工程结构如下：

其中：

config：用于配置拦截器
controller：这里只编写了LoginController（用于登录和注销）和TestController（用于测试未登录效果）
interceptor：编写拦截器代码
service：只写了操作redis的代码和登录相关的代码

2.2代码实现

本文使用redis存储token信息，用户只是创建了一个固定的用户，在pom中加入相关依赖，完整内容如下：

<?xmlversion="1.0"encoding="UTF-8"?>
<projectxmlns="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.0https://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.2.0.RELEASE</version>
		<relativePath/><!--lookupparentfromrepository-->
	</parent>
	<groupId>com.dalaoyang</groupId>
	<artifactId>springboot2_redis_login</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>springboot2_redis_login</name>
	<description>springboot2_redis_login</description>

	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<scope>runtime</scope>
			<optional>true</optional>
		</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>

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

</project>

配置文件中配置对应的redis信息，如下：

server.port=8888
##redis配置
spring.redis.host=localhost
spring.redis.port=6379

接下来编写redis相关操作，本文示例只需要使用到get，set和delete操作，都是简单的使用RedisTemplate，RedisService内容如下：

packagecom.dalaoyang.service;

importorg.springframework.data.redis.core.RedisTemplate;
importorg.springframework.data.redis.core.ValueOperations;
importorg.springframework.data.redis.serializer.RedisSerializer;
importorg.springframework.data.redis.serializer.StringRedisSerializer;
importorg.springframework.stereotype.Service;

importjavax.annotation.Resource;

@Service
publicclassRedisService{
@Resource
privateRedisTemplate<String,Object>redisTemplate;

publicvoidset(Stringkey,Objectvalue){
//更改在redis里面查看key编码问题
RedisSerializerredisSerializer=newStringRedisSerializer();
redisTemplate.setKeySerializer(redisSerializer);
ValueOperations<String,Object>vo=redisTemplate.opsForValue();
vo.set(key,value);
}

publicObjectget(Stringkey){
ValueOperations<String,Object>vo=redisTemplate.opsForValue();
returnvo.get(key);
}

publicBooleandelete(Stringkey){
returnredisTemplate.delete(key);
}
}

LoginService只是进行登录和注销操作，其中登录就是先判断用户名密码是否正确，如果正确，那么会生成一个字符串做为token（本文中使用uuid），并且做为返回值，密码错误则提示错误。注销实质就是删除redis中token的缓存，完整内容如下：

packagecom.dalaoyang.service;

importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.stereotype.Service;

importjavax.servlet.http.HttpServletRequest;
importjava.util.Objects;
importjava.util.UUID;

@Service
publicclassLoginService{

@Autowired
privateRedisServiceredisService;

publicStringlogin(Stringusername,Stringpassword){
if(Objects.equals("dalaoyang",username)&&
Objects.equals("123",password)){
Stringtoken=UUID.randomUUID().toString();
redisService.set(token,username);
return"用户："+username+"登录成功，token是："+token;
}else{
return"用户名或密码错误，登录失败！";
}
}

publicStringlogout(HttpServletRequestrequest){
Stringtoken=request.getHeader("token");
Booleandelete=redisService.delete(token);
if(!delete){
return"注销失败，请检查是否登录！";
}
return"注销成功！";
}
}

LoginController内容很简单，只是对LoginService的简单调用，如下：

packagecom.dalaoyang.controller;


importcom.dalaoyang.service.LoginService;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.web.bind.annotation.GetMapping;
importorg.springframework.web.bind.annotation.RequestMapping;
importorg.springframework.web.bind.annotation.RestController;

importjavax.servlet.http.HttpServletRequest;

@RestController
@RequestMapping("/login")
publicclassLoginController{

@Autowired
privateLoginServiceloginService;

@GetMapping({"/",""})
publicStringlogin(Stringusername,Stringpassword){
returnloginService.login(username,password);
}

@GetMapping("/logout")
publicStringlogout(HttpServletRequestrequest){
returnloginService.logout(request);
}
}

TestController中只是写了一个简单返回字符串的接口，如下：

packagecom.dalaoyang.controller;

importorg.springframework.web.bind.annotation.GetMapping;
importorg.springframework.web.bind.annotation.RequestMapping;
importorg.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
publicclassTestController{

@GetMapping({"/",""})
publicStringdosomething(){
return"dosomething";
}
}

接下来是拦截器，拦截器中需要取出header中的token，然后去redis中进行判断，如果存在，则允许操作，则返回提示信息，内容如下：

packagecom.dalaoyang.interceptor;

importcom.dalaoyang.service.RedisService;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.util.StringUtils;
importorg.springframework.web.servlet.HandlerInterceptor;
importorg.springframework.web.servlet.ModelAndView;

importjavax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;
importjava.util.Objects;

publicclassAuthInterceptorimplementsHandlerInterceptor{

@Autowired
privateRedisServiceredisService;

@Override
publicbooleanpreHandle(HttpServletRequestrequest,HttpServletResponseresponse,Objecthandler)throwsException{
response.setCharacterEncoding("UTF-8");
response.setContentType("text/html;charset=utf-8");
Stringtoken=request.getHeader("token");
if(StringUtils.isEmpty(token)){
response.getWriter().print("用户未登录，请登录后操作！");
returnfalse;
}
ObjectloginStatus=redisService.get(token);
if(Objects.isNull(loginStatus)){
response.getWriter().print("token错误，请查看！");
returnfalse;
}
returntrue;
}

@Override
publicvoidpostHandle(HttpServletRequestrequest,HttpServletResponseresponse,Objecthandler,ModelAndViewmodelAndView)throwsException{

}

@Override
publicvoidafterCompletion(HttpServletRequestrequest,HttpServletResponseresponse,Objecthandler,Exceptionex)throwsException{

}
}

最后配置一下拦截器，由于拦截器中使用了RedisService，所以这里需要使用如下方式注入拦截器，内容如下：

packagecom.dalaoyang.config;

importcom.dalaoyang.interceptor.AuthInterceptor;
importorg.springframework.context.annotation.Bean;
importorg.springframework.context.annotation.Configuration;
importorg.springframework.web.servlet.config.annotation.InterceptorRegistry;
importorg.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
publicclassAuthConfigimplementsWebMvcConfigurer{

@Bean
publicAuthInterceptorinitAuthInterceptor(){
returnnewAuthInterceptor();
}

@Override
publicvoidaddInterceptors(InterceptorRegistryregistry){
registry.addInterceptor(initAuthInterceptor()).addPathPatterns("/test/**").excludePathPatterns("/login/**");
}

}

内容到这里就已经完成了。

3.测试

可以使用如下步骤进行简单测试：

首先在浏览器访问：http://localhost:8888/test，可以看到提示

用户未登录，请登录后操作！

在使用错误密码浏览器访问：http://localhost:8888/login?username=dalaoyang&password=1，看到提示

用户名或密码错误，登录失败！

在浏览器使用用户名密码访问：http://localhost:8888/login?username=dalaoyang&password=123，看到提示

用户：dalaoyang登录成功，token是：02fdd2bd-1669-48b9-b51b-1e724f97688f

使用http工具，如postman等，将token放入header中，请求：http://localhost:8888/test，看到提示，请求成功。

dosomething

4.扩展点

本文只是简单对token使用做了一个样例，并不适用于生产环境，有很多地方是可以扩展的，比如：

本文redis值存储的只是username，而且并没有利用，实际情况可以存储用户信息等。
可以扩展使用jwt进行token管理。
可以放行几个固定的token用作内部接口调用等。
注意token的生成规则，不要有规律让别人利用。

5.源码

源码地址：https://gitee.com/dalaoyang/springboot_learn/tree/master/springboot2_redis_login

本文内容总结：1.简介，2.具体实现，2.1工程结构，2.2代码实现，3.测试，4.扩展点，5.源码，

原文链接：https://www.cnblogs.com/dalaoyang/p/11783225.html