springboot整合springsecurity从Hello World到源码解析（五）：springsecurity+jwt整合restful服务

cover

上一章我们详细介绍了springsecurity的基础结构，并且在第三章我们已经知道了springsecurity中的
基础配置，但是那是基于all in one模式的，前端页面和后端集成在一起，然而事实上现在越来越多的开发模式是前后端分离，后端提供的restful接口，那我们本章就来学习下
springsecurity+jwt整合restful服务。

springboot整合springsecurity系列文章：
springboot整合springsecurity从Hello World到源码解析（一）：hello world程序入门
springboot整合springsecurity从Hello World到源码解析（二）：springsecurity配置加载解析
springboot整合springsecurity从Hello World到源码解析（三）：基础配置详解
springboot整合springsecurity从Hello World到源码解析（四）：springsecurity基础架构解析
springboot整合springsecurity从Hello World到源码解析（五）：springsecurity+jwt整合restful服务

jwt

首先我们先了解下什么是jwt，jwt全称是json web tokens，它是基于RFC 7519开放标准用于双方安全展示信息的一种方式。通俗说就是是用于服务端和客户端相互交换信息的一种凭证。
这个凭证我们就叫token，在传统的认证模式中，我们普遍的做法是这样的：
用户登录-》服务端生成session-》写入sessionId到cookie-》浏览器携带该session访问服务端-》服务器基于该sessionId查找信息-》认证通过（找到了）
这种做法存在如下问题：

1. 服务端需一定资源保存session信息，用户多时资源消耗较大
2. 扩展性不好，当我们的服务端需要集群时，因session保存在服务端，此时无法定位session，造成登录失效（传统解决办法：iphash，session写入redis等）
3. 跨域问题，当我们访问A网站时，此时不想再登录就能够访问关联网站B。（传统解决办法：写入持久层，A，B同时访问）
   虽然上面面对的问题我们普遍都有解决办法，但是显然都不怎么 ”友好“，所以这个时候就有一种干脆的解决办法了，服务端不再保存session，这样就轻松解决了上面所有问题。
   服务端只颁发token，那么现在的流程变成了这样：
   用户登录-》服务端颁发token-》客户端保存token（放入cooken或者header）-》携带token访问服务端-》服务端验证token（通过）-》调用api-》获取信息
   那么既然是服务端颁发的token，那肯定要保证该token的安全（只有该服务端颁发的token才认），唯一（不能伪造），而jwt则是用来生成这个安全的token的。 jwt的组成如下：

• header（头），保存算法，类型
• payload（负载），用户的信息，如id，用户名等等

• signature（签名），将生成的token编码（加密）
  他们之间用 "."号隔开，例如：xxxxx.yyyyy.zzzzz

  
  
  

  token

整合rest服务

我们知道，在restful服务中，服务端不再直接生成页面了，而是只返回数据（json），客户端渲染，而我们前面的例子已经知道了springsecurity默认也是直接生成整个页面的，所以这里的关键
就成了我们需要自己定义返回数据形式了，主要是错误处理，那我们接下来就开始实践。

实践

pom

新建一个springboot项目，pom文件如下：

    
        spring-security-demos
        cn.jsbintask
        1.0.0
    
    4.0.0

    security-jwt-restful

    
        
            org.springframework.boot
            spring-boot-starter-freemarker
        
        
            org.springframework.boot
            spring-boot-starter-security
        
        
            org.springframework.boot
            spring-boot-starter-web
        

        
            org.projectlombok
            lombok
            true
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
        
            org.springframework.security
            spring-security-test
            test
        

        
            org.springframework.boot
            spring-boot-starter-data-jpa
        
        
            mysql
            mysql-connector-java
        

        
        
            io.jsonwebtoken
            jjwt
            0.9.1
        

    

数据源

定义数据源，application.yml文件以及sql脚本如下：

server:
  port: 8080

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    username: root
    password: jason
    url:  jdbc:mysql://localhost:3306/springsecurity_demos?useSSL=false

  jpa:
    show-sql: true
    hibernate:
      ddl-auto: update
    properties:
      hibernate:
        format_sql: true

logging:
  level:
    org.springframework.*: debug

sql脚本如下，本例我们了简单，密码使用明文：

CREATE DATABASE springsecurity_demos;
USE springsecurity_demos;


SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for role
-- ----------------------------
DROP TABLE IF EXISTS `role`;
CREATE TABLE `role`  (
                       `id` int(11) NOT NULL AUTO_INCREMENT,
                       `role_name` varchar(16) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
                       `description` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
                       PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of role
-- ----------------------------
INSERT INTO `role` VALUES (1, 'user', 'this is a user role.');
INSERT INTO `role` VALUES (2, 'admin', 'this is a admin role.');

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
                       `id` int(11) NOT NULL AUTO_INCREMENT,
                       `username` varchar(16) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
                       `password` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
                       `age` int(11) NULL DEFAULT NULL,
                       `address` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
                       `role_id` int(11) NOT NULL,
                       PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES (1, 'jsbintask', '123456', 22, 'China, Wuhan', 1);

SET FOREIGN_KEY_CHECKS = 1;

接着定义实体类domain，repository等，参考之前的博客，值得注意的是，此处我们的AuthUser稍有不同：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class AuthUser implements UserDetails {
    private String username;
    private String password;
    private List roles;

    @Override
    public Collection getAuthorities() {
        return roles.isEmpty() ? Collections.EMPTY_LIST :
                // ROLE_ 是springsecurity对于角色的默认前缀，如果不加，验证会失败
                (roles.parallelStream().map(role -> new SimpleGrantedAuthority("ROLE_" + role.getRoleName())).collect(Collectors.toList()));
    }

    @Override
    public String getPassword() {
        return password;
    }

    @Override
    public String getUsername() {
        return username;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

配置securityConfig

我们和前面章节一样，定义一个SecurityConfig类，继承WebSecurityConfigurerAdapter：

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
}

接下来就是开始详细配置了，前面我们学习基础配置的时候已经知道，配置的重点是自定义
UserDetailsService，并且我们通过源码的方式知道了是UsernamePasswordAuthenticationFilter帮我们认证了用户，并且生成了页面，转发等等。
但是！在本例中，因为我们是整合restful服务，返回的都是json数据，所以我们不再需要这些。而既然要返回json数据，那我们先定义好一个通用的数据类，ResultVO：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class ResultVO {
    // code请自己定义，例如  10成功，20需要登陆  30无权限等等
    private Integer code;
    private String msg;
    private T data;
}

而既然我们的服务端是生成jwt，那现在登录的接口就成了生成jwt了，我们首先编写JwtUtil工具类：

public class JwtUtil {
    private static final String secret = "[email protected]";

    public static String generateToken(String username, List roles) {
        Map claims = new HashMap<>();
        claims.put("roles", roles.parallelStream().map(Role::getRoleName).collect(Collectors.joining(",")));

        return Jwts.builder()
                .setClaims(claims)
                .setSubject(username)
                //创建时间
                .setIssuedAt(new Date())
                //过期时间，我们设置为 五分钟
                .setExpiration(new Date(System.currentTimeMillis() + 5 * 60 * 1000))
                //签名，通过密钥保证安全性
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }

    public static AuthUser parseToken(String token) {
        Claims claims = Jwts.parser()
                .setSigningKey(secret)
                .parseClaimsJws(token)
                .getBody();
        String username = claims.getSubject();
        String roles = (String) claims.get("roles");

        //因为生成的时候没有放入密码，所以不需要密码
        return new AuthUser(username, null, Arrays.stream(roles.split(",")).map(name -> {
            Role role = new Role();
            role.setRoleName(name);
            return role;
        }).collect(Collectors.toList()));
    }
}

编写生成token的controller，UserController：

@RestController
public class UserController {
    @Resource
    private UserRepository userRepository;
    @Resource
    private RoleRepository roleRepository;

    @GetMapping("/token")
    public ResultVO login(String username, String password) {
        User user = userRepository.findByUsername(username);

        if (user == null || !user.getPassword().equals(password)) {
            ResultVO