【20200220】SpringBoot 使用Token鉴权 - 图1

1.简介

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

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

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

2.具体实现

2.1工程结构

本文工程结构如下：
【20200220】SpringBoot 使用Token鉴权 - 图2
其中：

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

    2.2代码实现

    本文使用redis存储令牌信息，用户只是创建了一个固定的用户，在pom中加入相关依赖，完整内容如下：
    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 https://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>2.2.0.RELEASE</version>
    9.       <relativePath/> <!-- lookup parent from repository -->
    10.   </parent>
    11.   <groupId>com.dalaoyang</groupId>
    12.   <artifactId>springboot2_redis_login</artifactId>
    13.   <version>0.0.1-SNAPSHOT</version>
    14.   <name>springboot2_redis_login</name>
    15.   <description>springboot2_redis_login</description>
    16.   <properties>
    17.       <java.version>1.8</java.version>
    18.   </properties>
    19.   <dependencies>
    20.       <dependency>
    21.           <groupId>org.springframework.boot</groupId>
    22.           <artifactId>spring-boot-starter-data-redis</artifactId>
    23.       </dependency>
    24.       <dependency>
    25.           <groupId>org.springframework.boot</groupId>
    26.           <artifactId>spring-boot-starter-web</artifactId>
    27.       </dependency>
    28.       <dependency>
    29.           <groupId>org.springframework.boot</groupId>
    30.           <artifactId>spring-boot-devtools</artifactId>
    31.           <scope>runtime</scope>
    32.           <optional>true</optional>
    33.       </dependency>
    34.       <dependency>
    35.           <groupId>org.springframework.boot</groupId>
    36.           <artifactId>spring-boot-starter-test</artifactId>
    37.           <scope>test</scope>
    38.           <exclusions>
    39.               <exclusion>
    40.                   <groupId>org.junit.vintage</groupId>
    41.                   <artifactId>junit-vintage-engine</artifactId>
    42.               </exclusion>
    43.           </exclusions>
    44.       </dependency>
    45.   </dependencies>
    46.   <build>
    47.       <plugins>
    48.           <plugin>
    49.               <groupId>org.springframework.boot</groupId>
    50.               <artifactId>spring-boot-maven-plugin</artifactId>
    51.           </plugin>
    52.       </plugins>
    53.   </build>
    54. </project>
    55. 复制代码
    配置文件中配置对应的redis信息，如下：
    1. server.port=8888
    2. ##redis配置
    3. spring.redis.host=localhost
    4. spring.redis.port=6379
    5. 复制代码
    接下来编写redis相关操作，此处示例只需要使用到获取，设置和删除操作，都是简单的使用RedisTemplate，RedisService内容如下：
    1. package com.dalaoyang.service;
    2. import org.springframework.data.redis.core.RedisTemplate;
    3. import org.springframework.data.redis.core.ValueOperations;
    4. import org.springframework.data.redis.serializer.RedisSerializer;
    5. import org.springframework.data.redis.serializer.StringRedisSerializer;
    6. import org.springframework.stereotype.Service;
    7. import javax.annotation.Resource;
    8. @Service
    9. public class RedisService {
    10.   @Resource
    11.   private RedisTemplate<String,Object> redisTemplate;
    12.   public void set(String key, Object value) {
    13.       //更改在redis里面查看key编码问题
    14.       RedisSerializer redisSerializer =new StringRedisSerializer();
    15.       redisTemplate.setKeySerializer(redisSerializer);
    16.       ValueOperations<String,Object> vo = redisTemplate.opsForValue();
    17.       vo.set(key, value);
    18.   }
    19.   public Object get(String key) {
    20.       ValueOperations<String,Object> vo = redisTemplate.opsForValue();
    21.       return vo.get(key);
    22.   }
    23.   public Boolean delete(String key) {
    24.       return redisTemplate.delete(key);
    25.   }
    26. }
    27. 复制代码
    LoginService只是进行登录和初始化操作，其中登录就是先判断用户名密码是否正确，如果正确，那么会生成一个字符串做为令牌（此处中使用uuid），并且做为返回值，密码错误则提示错误。恢复实质就是删除redis中令牌的缓存，完整内容如下：
    1. package com.dalaoyang.service;
    2. import org.springframework.beans.factory.annotation.Autowired;
    3. import org.springframework.stereotype.Service;
    4. import javax.servlet.http.HttpServletRequest;
    5. import java.util.Objects;
    6. import java.util.UUID;
    7. @Service
    8. public class LoginService {
    9.   @Autowired
    10.   private RedisService redisService;
    11.   public String login(String username, String password) {
    12.       if (Objects.equals("dalaoyang", username) &&
    13.               Objects.equals("123", password)) {
    14.           String token = UUID.randomUUID().toString();
    15.           redisService.set(token, username);
    16.           return "用户：" + username + "登录成功，token是：" + token;
    17.       } else {
    18.           return "用户名或密码错误，登录失败！";
    19.       }
    20.   }
    21.   public String logout(HttpServletRequest request) {
    22.       String token = request.getHeader("token");
    23.       Boolean delete = redisService.delete(token);
    24.       if (!delete) {
    25.           return "注销失败，请检查是否登录！";
    26.       }
    27.       return "注销成功！";
    28.   }
    29. }
    30. 复制代码
    LoginController内容很简单，只是对LoginService的简单调用，如下：
    1. package com.dalaoyang.controller;
    2. import com.dalaoyang.service.LoginService;
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.web.bind.annotation.GetMapping;
    5. import org.springframework.web.bind.annotation.RequestMapping;
    6. import org.springframework.web.bind.annotation.RestController;
    7. import javax.servlet.http.HttpServletRequest;
    8. @RestController
    9. @RequestMapping("/login")
    10. public class LoginController {
    11.   @Autowired
    12.   private LoginService loginService;
    13.   @GetMapping({"/", ""})
    14.   public String login(String username, String password) {
    15.       return loginService.login(username, password);
    16.   }
    17.   @GetMapping("/logout")
    18.   public String logout(HttpServletRequest request) {
    19.       return loginService.logout(request);
    20.   }
    21. }
    22. 复制代码
    TestController中只是写了一个简单的返回字符串的接口，如下：
    1. package com.dalaoyang.controller;
    2. import org.springframework.web.bind.annotation.GetMapping;
    3. import org.springframework.web.bind.annotation.RequestMapping;
    4. import org.springframework.web.bind.annotation.RestController;
    5. @RestController
    6. @RequestMapping("/test")
    7. public class TestController {
    8.   @GetMapping({"/", ""})
    9.   public String dosomething() {
    10.       return "dosomething";
    11.   }
    12. }
    13. 复制代码
    接下来是拦截器，拦截器中需要收回header中的令牌，然后去redis中进行判断，如果存在，则允许操作，则返回提示信息，内容如下：
    1. package com.dalaoyang.interceptor;
    2. import com.dalaoyang.service.RedisService;
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.util.StringUtils;
    5. import org.springframework.web.servlet.HandlerInterceptor;
    6. import org.springframework.web.servlet.ModelAndView;
    7. import javax.servlet.http.HttpServletRequest;
    8. import javax.servlet.http.HttpServletResponse;
    9. import java.util.Objects;
    10. public class AuthInterceptor implements HandlerInterceptor {
    11.   @Autowired
    12.   private RedisService redisService;
    13.   @Override
    14.   public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    15.       response.setCharacterEncoding("UTF-8");
    16.       response.setContentType("text/html;charset=utf-8");
    17.       String token = request.getHeader("token");
    18.       if (StringUtils.isEmpty(token)) {
    19.           response.getWriter().print("用户未登录，请登录后操作！");
    20.           return false;
    21.       }
    22.       Object loginStatus = redisService.get(token);
    23.       if( Objects.isNull(loginStatus)){
    24.           response.getWriter().print("token错误，请查看！");
    25.           return false;
    26.       }
    27.       return true;
    28.   }
    29.   @Override
    30.   public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    31.   }
    32.   @Override
    33.   public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    34.   }
    35. }
    36. 复制代码
    最后配置一下拦截器，由于拦截器中使用了RedisService，所以这里需要使用如下方式注入拦截器，内容如下：
    1. package com.dalaoyang.config;
    2. import com.dalaoyang.interceptor.AuthInterceptor;
    3. import org.springframework.context.annotation.Bean;
    4. import org.springframework.context.annotation.Configuration;
    5. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    6. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    7. @Configuration
    8. public class AuthConfig implements WebMvcConfigurer {
    9.   @Bean
    10.   public AuthInterceptor initAuthInterceptor(){
    11.       return new AuthInterceptor();
    12.   }
    13.   @Override
    14.   public void addInterceptors(InterceptorRegistry registry) {
    15.       registry.addInterceptor(initAuthInterceptor()).addPathPatterns("/test/**").excludePathPatterns("/login/**");
    16.   }
    17. }
    18. 复制代码
    内容到这里就已经完成了。

    3.测试

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

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

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

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

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

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

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

  4. 使用http工具，如postman等，将令牌加入header中，请求：http：// localhost：8888 / test，看到提示，请求成功。

    做点什么

4.扩展点

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

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