使用JWT保护你的Spring Boot应用 - Spring Security实战

什么是JWT

Json web token (JWT)，是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519)。该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。

基于Session的登录认证

在传统的用户登录认证中，因为http是无状态的，所以都是采用session方式。用户登录成功，服务端会保证一个session，当然会给客户端一个sessionId，客户端会把sessionId保存在cookie中，每次请求都会携带这个sessionId。
cookie+session这种模式通常是保存在内存中，而且服务从单服务到多服务会面临的session共享问题，随着用户量的增多，开销就会越大。而JWT不是这样的，只需要服务端生成token，客户端保存这个token，每次请求携带这个token，服务端认证解析就可。

JWT

第一部分我们称它为头部header，第二部分我们称其为载荷payload，第三部分是签证signature。

header

• 声明类型，这里是JWT
• 声明加密的算法，本文中使用HmacSHA512

创建Spring Boot应用

本文用IntellJ IDEA快速创建了一个Spring Boot应用，过程这里不再赘述。我们看下整个项目的pom.xml文件中的依赖部分：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

所有Spring Boot相关的依赖都是以starter形式出现，这样你无需关心版本和相关的依赖，所以这样大大简化了开发过程。

创建一个Web应用

我们先创建一个可以返回JSON的Controller。修改程序的入口文件：

@SpringBootApplication
@RestController
@EnableAutoConfiguration
public class JwtApplication {

    // main函数，Spring Boot程序入口
    public static void main(String[] args) {
        SpringApplication.run(JwtApplication.class, args);
    }

    // 根目录映射 Get访问方式 直接返回一个字符串
    @RequestMapping("/")
    Map<String, String> hello() {
      // 返回map会变成JSON key value方式
      Map<String,String> map=new HashMap<String,String>();
      map.put("content", "Hello JWT");
      return map;
    }
}

这个入口类我们添加@RestController和@EnableAutoConfiguration两个注解。@RestController注解相当于@ResponseBody和@Controller合在一起的作用。

run整个项目。访问http://localhost:8080/就能看到这个JSON的输出

{
	"content": "Hello JWT"
}

为了显示统一的JSON返回，这里建立一个JSONResult类进行。修改pom.xml，加入fastjson相关依赖。

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.45</version>
</dependency>

然后在我们的代码中加入一个新的类，里面只有一个结果集处理方法，因为只是个Demo，所有这里都放在一个文件中。这个类只是让返回的JSON结果变为三部分：

• status - 返回状态码 0 代表正常返回，其他都是错误
• message - 一般显示错误信息
• result - 结果集

  class JSONResult{
      public static String fillResultString(Integer status, String message, Object result){
          JSONObject jsonObject = new JSONObject(){{
              put("status", status);
              put("message", message);
              put("result", result);
          }};
          return jsonObject.toString();
      }
  }

然后我们引入一个新的@RestController并返回一些简单的结果，后面我们将对这些内容进行访问控制，这里用到了上面的结果集处理类。这里多放两个方法，后面我们来测试权限和角色的验证用。

@RestController
class UserController {

	// 路由映射到/users
	@RequestMapping(value = "/users", produces="application/json;charset=UTF-8")
	public String usersList() {

		ArrayList<String> users =  new ArrayList<String>(){{
			add("wyb");
			add("tom");
			add("jerry");
		}};

		return JSONResult.fillResultString(0, "", users);
	}

	@RequestMapping(value = "/hello", produces="application/json;charset=UTF-8")
	public String hello() {
		ArrayList<String> users =  new ArrayList<String>(){{ add("hello"); }};
		return JSONResult.fillResultString(0, "", users);
	}

	@RequestMapping(value = "/world", produces="application/json;charset=UTF-8")
	public String world() {
		ArrayList<String> users =  new ArrayList<String>(){{ add("world"); }};
		return JSONResult.fillResultString(0, "", users);
	}
}

重新run这个文件，访问http://localhost:8080/users就看到了下面的结果:

{
  "result": [
    "wyb",
    "tom",
    "jerry"
  ],
  "message": "",
  "status": 0
}

使用JWT保护你的Spring Boot应用

开始介绍正题，这里我们会对/users进行访问控制，先通过申请一个JWT(JSON Web Token读jot)，然后通过这个访问/users，才能拿到数据。
JWT很大程度上还是个新技术，通过使用HMAC(Hash-based Message Authentication Code)计算信息摘要，也可以用RSA公私钥中的私钥进行签名。这个根据业务场景进行选择，想了解更多JWT，可点链接进一步学习。

添加Spring Security

在pom.xml添加security，让用户在/login进行登录并获取Token

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.7.0</version>
</dependency>

至此我们之前所有的路由都需要身份验证。我们将引入一个安全设置类WebSecurityConfig，这个类需要从WebSecurityConfigurerAdapter类继承。

@Configuration
@EnableWebSecurity
class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    // 设置 HTTP 验证规则
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 关闭csrf验证
        http.csrf().disable()
                // 对请求进行认证
                .authorizeRequests()
                // 所有 / 的所有请求 都放行
                .antMatchers("/").permitAll()
                // 所有 /login 的POST请求 都放行
                .antMatchers(HttpMethod.POST, "/login").permitAll()
                // 权限检查
                .antMatchers("/hello").hasAuthority("AUTH_WRITE")
                // 角色检查
                .antMatchers("/world").hasRole("ADMIN")
                // 所有请求需要身份认证
                .anyRequest().authenticated()
            .and()
                // 添加一个过滤器 所有访问 /login 的请求交给 JWTLoginFilter 来处理 这个类处理所有的JWT相关内容
                .addFilterBefore(new JWTLoginFilter("/login", authenticationManager()),
                        UsernamePasswordAuthenticationFilter.class)
                // 添加一个过滤器验证其他请求的Token是否合法
                .addFilterBefore(new JWTAuthenticationFilter(),
                        UsernamePasswordAuthenticationFilter.class);
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 使用自定义身份验证组件
        auth.authenticationProvider(new CustomAuthenticationProvider());

    }
}

先放两个基本类，一个负责存储用户名密码，另一个是一个权限类型，负责存储权限和角色。

class AccountCredentials {

    private String username;
    private String password;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

class GrantedAuthorityImpl implements GrantedAuthority{
    private String authority;

    public GrantedAuthorityImpl(String authority) {
        this.authority = authority;
    }

    public void setAuthority(String authority) {
        this.authority = authority;
    }

    @Override
    public String getAuthority() {
        return this.authority;
    }
}

在上面的安全设置类中，我们设置所有人都能访问/和POST方式访问/login，其他的任何路由都需要进行认证。然后将所有访问/login的请求，都交给JWTLoginFilter过滤器来处理。稍后我们会创建这个过滤器和其他这里需要的JWTAuthenticationFilter和CustomAuthenticationProvider两个类。

先建立一个JWT生成和验签的类

class TokenAuthenticationService {
    static final long EXPIRATIONTIME = 432_000_000;     // 5天
    static final String SECRET = "P@ssw02d";            // JWT密码
    static final String TOKEN_PREFIX = "Token";        // Token前缀
    static final String HEADER_STRING = "Authorization";// 存放Token的Header Key

  // JWT生成方法
    static void addAuthentication(HttpServletResponse response, String username) {

    // 生成JWT
        String JWT = Jwts.builder()
                // 保存权限（角色）
                .claim("authorities", "ROLE_ADMIN,AUTH_WRITE")
                // 用户名写入标题
                .setSubject(username)
                // 有效期设置
                        .setExpiration(new Date(System.currentTimeMillis() + EXPIRATIONTIME))
                // 签名设置
                        .signWith(SignatureAlgorithm.HS512, SECRET)
                        .compact();

        // 将 JWT 写入 body
        try {
            response.setContentType("application/json");
            response.setStatus(HttpServletResponse.SC_OK);
            response.getOutputStream().println(JSONResult.fillResultString(0, "", JWT));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

  // JWT验证方法
    static Authentication getAuthentication(HttpServletRequest request) {
        // 从Header中拿到token
        String token = request.getHeader(HEADER_STRING);

        if (token != null) {
            // 解析 Token
            Claims claims = Jwts.parser()
                    // 验签
                    .setSigningKey(SECRET)
                    // 去掉 Bearer
                    .parseClaimsJws(token.replace(TOKEN_PREFIX, ""))
                    .getBody();

            // 拿用户名
            String user = claims.getSubject();

            // 得到 权限（角色）
            List<GrantedAuthority> authorities =  AuthorityUtils.commaSeparatedStringToAuthorityList((String) claims.get("authorities"));

            // 返回验证令牌
            return user != null ?
                    new UsernamePasswordAuthenticationToken(user, null, authorities) :
                    null;
        }
        return null;
    }
}

这个类就两个static方法，一个负责生成JWT，一个负责认证JWT最后生成验证令牌。

下面来看自定义验证组件，这里简单写了，这个类就是提供密码验证功能，在实际使用时换成自己相应的验证逻辑，从数据库中取出、比对、赋予用户相应权限。

// 自定义身份认证验证组件
class CustomAuthenticationProvider implements AuthenticationProvider {

    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        // 获取认证的用户名 & 密码
        String name = authentication.getName();
        String password = authentication.getCredentials().toString();

        // 认证逻辑
        if (name.equals("admin") && password.equals("123456")) {

            // 这里设置权限和角色
            ArrayList<GrantedAuthority> authorities = new ArrayList<>();
            authorities.add( new GrantedAuthorityImpl("ROLE_ADMIN") );
            authorities.add( new GrantedAuthorityImpl("AUTH_WRITE") );
            // 生成令牌
            Authentication auth = new UsernamePasswordAuthenticationToken(name, password, authorities);
            return auth;
        }else {
            throw new BadCredentialsException("密码错误~");
        }
    }

    // 是否可以提供输入类型的认证服务
    @Override
    public boolean supports(Class<?> authentication) {
        return authentication.equals(UsernamePasswordAuthenticationToken.class);
    }
}

下面实现JWTLoginFilter 这个Filter比较简单，除了构造函数需要重写三个方法。

• attemptAuthentication - 登录时需要验证时候调用
• successfulAuthentication - 验证成功后调用
• unsuccessfulAuthentication - 验证失败后调用，这里直接灌入500错误返回，由于同一JSON返回，HTTP就都返回200了

  JWTLoginFilter extends AbstractAuthenticationProcessingFilter {

      public JWTLoginFilter(String url, AuthenticationManager authManager) {
          super(new AntPathRequestMatcher(url));
          setAuthenticationManager(authManager);
      }
  
      @Override
      public Authentication attemptAuthentication(
              HttpServletRequest req, HttpServletResponse res)
              throws AuthenticationException, IOException, ServletException {
  
          // JSON反序列化成 AccountCredentials
          AccountCredentials creds = new ObjectMapper().readValue(req.getInputStream(), AccountCredentials.class);
  
          // 返回一个验证令牌
          return getAuthenticationManager().authenticate(
                  new UsernamePasswordAuthenticationToken(
                          creds.getUsername(),
                          creds.getPassword()
                  )
          );
      }
  
      @Override
      protected void successfulAuthentication(
              HttpServletRequest req,
              HttpServletResponse res, FilterChain chain,
              Authentication auth) throws IOException, ServletException {
  
          TokenAuthenticationService.addAuthentication(res, auth.getName());
      }
  
  
      @Override
      protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed) throws IOException, ServletException {
  
          response.setContentType("application/json");
          response.setStatus(HttpServletResponse.SC_OK);
          response.getOutputStream().println(JSONResult.fillResultString(500, "Internal Server Error!!!", ""));
      }
  }

再完成最后一个类JWTAuthenticationFilter，这也是个拦截器，它拦截所有需要JWT的请求，然后调用TokenAuthenticationService类的静态方法去做JWT验证。

class JWTAuthenticationFilter extends GenericFilterBean {

    @Override
    public void doFilter(ServletRequest request,
                         ServletResponse response,
                         FilterChain filterChain)
            throws IOException, ServletException {
        Authentication authentication = TokenAuthenticationService
                .getAuthentication((HttpServletRequest)request);

        SecurityContextHolder.getContext()
                .setAuthentication(authentication);
        filterChain.doFilter(request,response);
    }
}

代码就写完了，整个Spring Security结合JWT基本就差不多了，下面我们来测试下，并说下整体流程。
开始测试，先运行整个项目，这里介绍下过程：

• 先程序启动 - main函数
• 注册验证组件 - WebSecurityConfig 类 configure(AuthenticationManagerBuilder auth)方法，这里我们注册了自定义验证组件
• 设置验证规则 - WebSecurityConfig 类 configure(HttpSecurity http)方法，这里设置了各种路由访问规则
• 初始化过滤组件 - JWTLoginFilter 和 JWTAuthenticationFilter 类会初始化
  首先测试获取Token，这里使用Postman来测试。

这里我们得到了相关的JWT，反Base64之后,就是下面的内容，标准JWT。

{"alg":"HS512"}{"authorities":"ROLE_ADMIN,AUTH_WRITE","sub":"admin","exp":1527506613}
ŸkÞیsBèÅ)}§[Ê­;EISªi¤3×Þîbĉç‹åMÙ¬Á\lç±ÎWÍt«‘ÃâA~üÀ€

整个过程如下：

• 拿到传入JSON，解析用户名密码 - JWTLoginFilter 类 attemptAuthentication 方法
• 自定义身份认证验证组件，进行身份认证 - CustomAuthenticationProvider 类 authenticate 方法
• 验证成功 - JWTLoginFilter 类 successfulAuthentication 方法
• 生成JWT - TokenAuthenticationService 类 addAuthentication 方法

再测试一个访问资源的：

说明我们的Token生效可以正常访问。其他的结果您可以自己去测试。再回到处理流程：

• 接到请求进行拦截 - JWTAuthenticationFilter 中的方法
• 验证JWT - TokenAuthenticationService 类 getAuthentication 方法
• 访问Controller

本文主要介绍了如何用Spring Security结合JWT保护你的Spring Boot应用。主要流程就结束了，希望能对你有帮助，代码会放到Github上。

本文代码

GitHub代码

参考资源

1. securing-spring-boot-with-jwts
2. jwt