devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringBoot实现token认证（基于缓存）_springboot中token存储到hashmap中

作者：小蓝xlanll | 2024-04-05 21:42:02

赞

踩

springboot中token存储到hashmap中

一、序言

本博客基于SpringBoot，使用redis缓存实现token认证，来验证用户身份的合法性。

二、什么是token？

token意为令牌，为一个随机的字符串UUID生成，用来标记来访用户的身份，通过该token，可以得出是哪一个用户向我服务器访问资源。

三、验证流程

当用户登录成功之后，则向客户端发送token，用来标记该用户，以后每次用户向服务器访问时，则在请求头带上该token。服务器从请求头中获取token，拿到该token之后，向redis缓存查找是否存在此token，如存在，则返回给用户相应的资源，若不存在，则返回，不给与资源。

四、程序实现

1.引入Maven依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>1.5.21.RELEASE</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  11.     <groupId>com.chen</groupId>
  12.     <artifactId>cachetest</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>cachetest</name>
  15.     <description>Demo project for Spring Boot</description>
  16.  
  17.     <properties>
  18.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  19.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  20.         <java.version>1.8</java.version>
  21.     </properties>
  22.  
  23.     <dependencies>
  24.         <dependency>
  25.             <groupId>org.springframework.boot</groupId>
  26.             <artifactId>spring-boot-starter-jdbc</artifactId>
  27.         </dependency>
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-starter-web</artifactId>
  31.         </dependency>
  32.         <dependency>
  33.             <groupId>org.mybatis.spring.boot</groupId>
  34.             <artifactId>mybatis-spring-boot-starter</artifactId>
  35.             <version>2.0.1</version>
  36.         </dependency>
  37.         <dependency>
  38.             <groupId>org.springframework.boot</groupId>
  39.             <artifactId>spring-boot-starter-cache</artifactId>
  40.         </dependency>
  41.  
  42.         <dependency>
  43.             <groupId>mysql</groupId>
  44.             <artifactId>mysql-connector-java</artifactId>
  45.             <scope>runtime</scope>
  46.         </dependency>
  47.         <dependency>
  48.             <groupId>org.springframework.boot</groupId>
  49.             <artifactId>spring-boot-starter-test</artifactId>
  50.             <scope>test</scope>
  51.         </dependency>
  52.         <dependency>
  53.             <groupId>junit</groupId>
  54.             <artifactId>junit</artifactId>
  55.             <version>4.12</version>
  56.             <scope>test</scope>
  57.         </dependency>
  58.         <dependency>
  59.             <groupId>org.springframework.boot</groupId>
  60.             <artifactId>spring-boot-test</artifactId>
  61.             <version>2.1.6.RELEASE</version>
  62.             <scope>test</scope>
  63.         </dependency>
  64.         <!-- 配置使用redis启动器 -->
  65.         <dependency>
  66.             <groupId>org.springframework.boot</groupId>
  67.             <artifactId>spring-boot-starter-data-redis</artifactId>
  68.         </dependency>
  69.         <!--  集成lombok简化代码 -->
  70.         <dependency>
  71.         <groupId>org.projectlombok</groupId>
  72.         <artifactId>lombok</artifactId>
  73.         </dependency>
  74.         <!--将对象转为json字符串-->
  75.         <dependency>
  76.             <groupId>org.json</groupId>
  77.             <artifactId>json</artifactId>
  78.         </dependency>
  79.         <dependency>
  80.             <groupId>commons-io</groupId>
  81.             <artifactId>commons-io</artifactId>
  82.         </dependency>
  83.  
  84.     </dependencies>
  85.  
  86.     <build>
  87.         <plugins>
  88.             <plugin>
  89.                 <groupId>org.springframework.boot</groupId>
  90.                 <artifactId>spring-boot-maven-plugin</artifactId>
  91.             </plugin>
  92.         </plugins>
  93.     </build>
  94.  
  95. </project>

2.创建user表

3.编写application.properties

  1. #配置数据源
  2. spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false
  3. spring.datasource.username=root
  4. spring.datasource.password=123456
  5.  
  6. #开启驼峰命名
  7. mybatis.configuration.map-underscore-to-camel-case=true
  8.  
  9. #配置redis
  10. spring.redis.host=localhost
  11. spring.redis.port=6379
  12.  
  13. #打印SQL语句日志
  14. logging.level.com.chen.mapper=debug

4.编写用户类User

  1. package com.chen.bean;
  2.  
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  6.  
  7. @Data
  8. @AllArgsConstructor
  9. @NoArgsConstructor
  10. public class User {
  11.     int id;
  12.     String username;
  13.     String password;
  14. }

5.编写Mapper

  1. package com.chen.mapper;
  2.  
  3.  
  4. import com.chen.bean.User;
  5. import org.apache.ibatis.annotations.Mapper;
  6. import org.apache.ibatis.annotations.Select;
  7.  
  8. @Mapper
  9. public interface UserMapper {
  10.  
  11.     @Select("SELECT * FROM `user` WHERE username=#{username} AND password=#{password}")
  12.     public User getUser(User user);
  13. }

6.编写Service

  1. package com.chen.service;
  2.  
  3. import com.chen.bean.User;
  4. import com.chen.mapper.UserMapper;
  5. import org.springframework.stereotype.Service;
  6.  
  7. import javax.annotation.Resource;
  8.  
  9.  
  10. @Service
  11. public class UserService {
  12.  
  13.     @Resource
  14.     private UserMapper userMapper;
  15.  
  16.     public User getUser(User user) {
  17.         User u = userMapper.getUser(user);
  18.         return u;
  19.     }
  20. }

7.编写Msg类，用来封装返回的信息

  1. package com.chen.util;
  2.  
  3. import java.util.HashMap;
  4. import java.util.Map;
  5.  
  6. public class Msg {
  7.  
  8.     // 状态码: 200-成功 400-失败 500-异常
  9.     private int status;
  10.     // 提示信息
  11.     private String message;
  12.  
  13.     // 用户返回给浏览器的数据
  14.     private Map<String, Object> data = new HashMap<String, Object>();
  15.  
  16.     public static Msg success() {
  17.         Msg result = new Msg();
  18.         result.setStatus(200);
  19.         result.setMessage("处理成功！");
  20.         return result;
  21.     }
  22.  
  23.     public static Msg fail() {
  24.         Msg result = new Msg();
  25.         result.setStatus(400);
  26.         result.setMessage("处理失败！");
  27.         return result;
  28.     }
  29.  
  30.     public static Msg error() {
  31.         Msg result = new Msg();
  32.         result.setStatus(500);
  33.         result.setMessage("未知异常！");
  34.         return result;
  35.     }
  36.  
  37.     public Msg add(String key, Object value) {
  38.         this.data.put(key, value);
  39.         return this;
  40.     }
  41.  
  42.     public int getStatus() {
  43.         return status;
  44.     }
  45.  
  46.     public void setStatus(int status) {
  47.         this.status = status;
  48.     }
  49.  
  50.     public String getMessage() {
  51.         return message;
  52.     }
  53.  
  54.     public void setMessage(String message) {
  55.         this.message = message;
  56.     }
  57.  
  58.     public Map<String, Object> getData() {
  59.         return data;
  60.     }
  61.  
  62.     public void setData(Map<String, Object> data) {
  63.         this.data = data;
  64.     }
  65. }

8.编写Controller

  1. package com.chen.controller;
  2.  
  3.  
  4. import com.chen.bean.User;
  5. import com.chen.service.UserService;
  6. import com.chen.util.Msg;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.data.redis.core.StringRedisTemplate;
  9. import org.springframework.stereotype.Controller;
  10. import org.springframework.web.bind.annotation.PostMapping;
  11. import org.springframework.web.bind.annotation.RestController;
  12.  
  13. import java.util.UUID;
  14. import java.util.concurrent.TimeUnit;
  15.  
  16. @RestController
  17. public class UserController {
  18.  
  19.     @Autowired
  20.     private StringRedisTemplate stringRedisTemplate;
  21.  
  22.     @Autowired
  23.     private UserService userService;
  24.  
  25.     @PostMapping("/login")
  26.     public Msg login(User user) {
  27.         User u = userService.getUser(user);
  28.         if (u != null) {
  29.             String token = UUID.randomUUID().toString().replaceAll("-", "");
  30.             stringRedisTemplate.opsForValue().set(token, String.valueOf(u.getId()), 3600, TimeUnit.SECONDS);//将用户的ID信息存入redis缓存，并设置一小时的过期时间
  31.             return Msg.success().add("token",token).add("info","登录成功");
  32.         }else {
  33.             return Msg.fail().add("info", "登录失败");
  34.         }
  35.     }
  36.  
  37.     @PostMapping("/other")
  38.     public Msg other() {
  39.         return Msg.success().add("info", "该接口是来测试的");
  40.     }
  41.  
  42. }

9.配置启动类，使mapper生效

  1. package com.chen;
  2.  
  3. import org.mybatis.spring.annotation.MapperScan;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. import org.springframework.cache.annotation.EnableCaching;
  7.  
  8. @MapperScan("com.chen.mapper")
  9. @SpringBootApplication
  10. @EnableCaching
  11. public class CachetestApplication {
  12.  
  13.     public static void main(String[] args) {
  14.         SpringApplication.run(CachetestApplication.class, args);
  15.     }
  16.  
  17. }

10.设置拦截器，在进行接口访问前，先验证token的正确性

  1. package com.chen.interceptor;
  2.  
  3. import com.chen.util.Msg;
  4. import org.json.JSONObject;
  5. import org.slf4j.LoggerFactory;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.data.redis.core.StringRedisTemplate;
  8. import org.springframework.stereotype.Component;
  9. import org.springframework.web.servlet.HandlerInterceptor;
  10. import org.springframework.web.servlet.ModelAndView;
  11.  
  12. import javax.servlet.http.HttpServletRequest;
  13. import javax.servlet.http.HttpServletResponse;
  14. import java.io.IOException;
  15. import java.io.PrintWriter;
  16.  
  17. @Component
  18. public class ParamInterceptor implements HandlerInterceptor {
  19.  
  20.  
  21.     @Autowired
  22.     private StringRedisTemplate stringRedisTemplate;
  23.  
  24.     @Override
  25.     public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
  26.         String token = httpServletRequest.getHeader("token");
  27.         //token验证
  28.         if(token!=null){
  29.             String id = stringRedisTemplate.opsForValue().get(token);
  30.             if(id!=null){
  31.                 System.out.println("token验证成功");
  32.                 return true;
  33.             }else{
  34.                 System.out.println("token验证失败");
  35.                 returnJson(httpServletResponse);
  36.                 return false;
  37.             }
  38.         }else{
  39.             System.out.println("token验证失败");
  40.             returnJson(httpServletResponse);
  41.             return false;
  42.         }
  43.  
  44.     }
  45.  
  46.     private void returnJson(HttpServletResponse response){
  47.         PrintWriter writer = null;
  48.         response.setCharacterEncoding("UTF-8");
  49.         response.setContentType("application/json; charset=utf-8");
  50.         try {
  51.             writer = response.getWriter();
  52.             Msg msg = Msg.fail().add("info", "没有token或token无效");
  53.             JSONObject jsonObject = new JSONObject(msg);
  54.             writer.print(jsonObject);
  55.         } catch (IOException e){
  56.            e.printStackTrace();
  57.         } finally {
  58.             if(writer != null){
  59.                 writer.close();
  60.             }
  61.         }
  62.     }
  63.  
  64.  
  65.     @Override
  66.     public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
  67.  
  68.     }
  69.  
  70.     @Override
  71.     public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
  72.  
  73.     }
  74.  
  75. }

11.配置拦截器，使前一步设置的拦截器生效

  1. package com.chen.config;
  2.  
  3. import com.chen.interceptor.ParamInterceptor;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  7. import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
  8.  
  9. @Configuration
  10. public class InterceptorConfig extends WebMvcConfigurationSupport {
  11.  
  12.     @Autowired
  13.     private ParamInterceptor paramInterceptor;
  14.  
  15.     public void addInterceptors(InterceptorRegistry registry) {
  16.         //此处配置拦截路径
  17.         registry.addInterceptor(paramInterceptor).addPathPatterns("/**").excludePathPatterns("/login");
  18.     }
  19.  
  20. }

登录之后的结果：

 使用其他接口进行测试：

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/368070
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号