Spring实现JWT简单实例

2021-11-17

Spring实现JWT简单实例，结合Spring Security。

JWT简介

JSON Web Token（缩写 JWT）是目前最流行的跨域认证解决方案。
Json web token（JWT）是为网络应用环境传递声明而执行的一种基于JSON的开发标准（RFC 7519），该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。
JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息。

JWT网络流程

浏览器发起登录请求，携带用户名和密码；
服务端验证身份，根据算法，将用户标识符打包生成 token；
服务器返回JWT信息给浏览器，JWT不包含敏感信息；
浏览器发起请求获取相关资源，携带 token数据发送到服务器；
服务器检测数据中的token，验明正身；
服务器允许该用户的资源请求；
该用户获取到后端返回的相关资源。

JWT数据结构

一个token分3部分，按顺序：头部（header)、载荷（payload)、签证（signature)。
token对象为一个很长的字符串，字符串之间通过”.”分隔符分为三个子串，各子串之间没有换行符，一般格式为：xxxxx.yyyyy.zzzzz 。
JWT的头部header承载两部分信息：声明类型，这里是jwt；声明加密的算法，通常直接使用 HMAC SHA256。
载荷payload 部分是一个 JSON 对象，用来存放实际需要传递的数据。JWT 规定了7个官方字段，供选用。 iss (issuer)：签发人； exp (expiration time)：过期时间； sub (subject)：主题； aud (audience)：受众； nbf (Not Before)：生效时间； iat (Issued At)：签发时间； jti (JWT ID)：编号。
签证signature 部分是对前两部分的签名，防止数据篡改。需要指定一个密钥（secret）。然后，使用 Header 里指定的签名算法（默认是 HMAC SHA256）生成签名。

JWT优缺点

JWT默认不加密，但可以加密。生成原始令牌后，可以使用改令牌再次对其进行加密。
当JWT未加密时，一些私密数据无法通过JWT传输。
JWT不仅可用于认证，还可用于信息交换。善用JWT有助于减少服务器请求数据库的次数。
JWT的最大缺点是服务器不保存会话状态，所以在使用期间不可能取消令牌或更改令牌的权限。也就是说，一旦JWT签发，在有效期内将会一直有效。
JWT本身包含认证信息，因此一旦信息泄露，任何人都可以获得令牌的所有权限。为了减少盗用，JWT的有效期不宜设置太长。对于某些重要操作，用户在使用时应该每次都进行进行身份验证。
为了减少盗用和窃取，JWT不建议使用HTTP协议来传输代码，而是使用加密的HTTPS协议进行传输。

引入依赖

// JSON对象处理依赖
// https://mvnrepository.com/artifact/com.alibaba/fastjson
implementation group: 'com.alibaba', name: 'fastjson', version: '1.2.78'

// https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-security
implementation group: 'org.springframework.boot', name: 'spring-boot-starter-security', version: '2.5.5'

// https://mvnrepository.com/artifact/io.jsonwebtoken/jjwt
implementation group: 'io.jsonwebtoken', name: 'jjwt', version: '0.9.1'

// entity 中 @Data 等lombok注解依赖
// https://mvnrepository.com/artifact/org.projectlombok/lombok
compileOnly group: 'org.projectlombok', name: 'lombok', version: '1.18.10'

Security配置类实现：WebSecurityConfig

import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

/**
 * Spring-Security 安全配置类
 * 配置基本的验证规则
 */
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    // 设置 HTTP 验证规则
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 关闭csrf验证
        http.csrf().disable()
                // 对请求进行认证
                .authorizeRequests()
                // 所有 / 的所有请求 都放行
                .antMatchers("/").permitAll()
                // 所有 /login 的POST请求 都放行
                // 使用 /login 过滤器时，失效；
                // 无 /login 过滤器时，放行，controller层处理token
                // .antMatchers(HttpMethod.POST, "/login").permitAll()
                // 权限检查，传入的字符串不自动增加任何前缀
                .antMatchers("/permission/**").hasAuthority("AUTH_WRITE")
                // 角色检查，传入的字符串自动增加 ROLE_ 前缀
                .antMatchers("/role/**").hasRole("ADMIN")
            	// 放行swagger
                .antMatchers("/swagger-ui.html").permitAll()
                .antMatchers("/webjars/**").permitAll()
                .antMatchers("/v2/**").permitAll()
                .antMatchers("/swagger-resources/**").permitAll()
                // 所有请求需要身份认证
                .anyRequest().authenticated()
                .and()
                // 添加一个过滤器 所有访问 /login 的请求交给 JWTLoginFilter 来处理
                .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());
    }
}

用户身份认证信息实体类实现：AccountCredentials

import lombok.AllArgsConstructor;

/**
 * 负责存储用户名密码
 */
//@Data
@AllArgsConstructor
public class AccountCredentials implements Serializable {

    private String username;

    private String password;

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

    public String getUsername() {
        return this.username;
    }

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

    public String getPassword() {
        return this.password;
    }
}

Response返回类实现

import com.alibaba.fastjson.JSONObject;

/**
 * response 返回类
 */
public class JSONResult {
    public static String fillResultString(Integer status, String message, String result) {
        JSONObject jsonObject = new JSONObject() {{
            put("status", status);
            put("message", message);
            put("data", result);
        }};
        return jsonObject.toString();
    }
}

登录拦截器实现：JWTLoginFilter

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;

import javax.servlet.FilterChain;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * 验证所有的 /login 请求
 * 支持请求方式：POST、GET
 */
public class JWTLoginFilter extends AbstractAuthenticationProcessingFilter {

    // 构造函数
    public JWTLoginFilter(String url, AuthenticationManager authManager) {
        // 拦截请求地址url
        super(new AntPathRequestMatcher(url));
        // 设置authManager
        setAuthenticationManager(authManager);
    }

    // 设置用户信息到UsernamePasswordAuthenticationToken
    @Override
    public Authentication attemptAuthentication(
            HttpServletRequest req, HttpServletResponse res)
            throws AuthenticationException, IOException {

        // JSON 反序列化成 AccountCredentials
        // 支持请求Headers：application/json
        AccountCredentials accountCredentials = new ObjectMapper().readValue(req.getInputStream(), AccountCredentials.class);

        // 返回一个验证令牌
        return getAuthenticationManager().authenticate(
                new UsernamePasswordAuthenticationToken(
                        accountCredentials.getUsername(),
                        accountCredentials.getPassword()
                )
        );
    }

    // 通过身份验证
    @Override
    protected void successfulAuthentication(
            HttpServletRequest req,
            HttpServletResponse res, FilterChain chain,
            Authentication auth) {

        // 调用JWT服务，生成JWT并返回前端
        TokenAuthenticationService.addAuthentication(res, auth);
    }

    // 不通过身份验证
    @Override
    protected void unsuccessfulAuthentication(
            HttpServletRequest request, HttpServletResponse response, AuthenticationException failed)
            throws IOException {

        // 身份验证失败的response数据
        response.setContentType("application/json");
        response.setStatus(HttpServletResponse.SC_OK);
        response.getOutputStream().println(JSONResult.fillResultString(500, "fail", "User verify failed! "));
    }
}

权限或角色信息实体类实现：GrantedAuthorityImpl

import lombok.Data;
import org.springframework.security.core.GrantedAuthority;

/**
 * 负责存储权限和角色
 */
@Data
public class GrantedAuthorityImpl implements GrantedAuthority {

    private String authority;

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

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

自定义验证类实现：CustomAuthenticationProvider

import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.GrantedAuthority;

import java.util.ArrayList;

/**
 * 自定义身份验证组件
 * 提供密码验证功能
 * 在实际使用时换成相应的验证逻辑
 */
public 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("111")) {

            // 设置权限和角色
            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("password error！ ");
        }
    }

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

JWT生成及验证类实现：TokenAuthenticationService

import com.alibaba.fastjson.JSONObject;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.util.StringUtils;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Date;
import java.util.List;

/**
 * JWT生成类 & 验证类
 */
public class TokenAuthenticationService {

    // JWT有效时间，单位：ms，1天
    static final long EXPIRATION_TIME = 864_00_000;
    // JWT密码
    static final String SECRET = "P@ssw02d";
    // Token前缀
    static final String TOKEN_PREFIX = "yegetaier";
    // 存放Token的Header Key
    static final String HEADER_STRING = "Authorization";

    // JWT生成方法
    public static void addAuthentication(HttpServletResponse response, Authentication auth) {

        // authorities 字符串处理，对象List 转换为 逗号分割字符串
        String authoritiesString = "";
        Object[] grantedAuthorities = auth.getAuthorities().toArray();
        for (Object grantedAuthority : grantedAuthorities) {
            authoritiesString += JSONObject.parseObject(JSONObject.toJSONString(grantedAuthority)).getString("authority") + ",";
        }
        // 去除 authorities 字符串结尾的逗号
        authoritiesString = authoritiesString.substring(0, authoritiesString.length() - 1);

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

        // 将 JWT 写入 body，返回前端
        try {
            response.setContentType("application/json");
            response.setStatus(HttpServletResponse.SC_OK);
            response.getOutputStream().println(JSONResult.fillResultString(200, "success", JWT));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // JWT验证方法
    public static Authentication getAuthentication(HttpServletRequest request) {
        // 获取用户token信息：token可能在请求头、请求参数、cookie中
        // 从请求头获取token
        String token = request.getHeader(HEADER_STRING);
        if (StringUtils.isEmpty(token)) {
            // 从请求参数获取token
            // 支持请求Headers：multipart/form-data
            token = request.getParameter(HEADER_STRING);
            if (StringUtils.isEmpty(token)) {
                // 从cookie获取token
                Cookie[] Cookies = request.getCookies();
                if (Cookies != null) {
                    for (Cookie cookie : Cookies) {
                        if (cookie.getName().compareTo(HEADER_STRING) == 0) {
                            token = cookie.getValue();
                            break;
                        }
                    }
                }
            }
        }

        // 从request中获取到有效token
        if (token != null) {
            // 解析 Token
            Claims claims = Jwts.parser()
                    // 验签
                    .setSigningKey(SECRET)
                    // 去掉 前缀
                    .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;
    }
}

其他请求验证类实现：JWTAuthenticationFilter

import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.filter.GenericFilterBean;

import javax.servlet.FilterChain;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

/**
 * JWT拦截器，验证login之外的请求
 */
public class JWTAuthenticationFilter extends GenericFilterBean {

    @Override
    public void doFilter(ServletRequest request,
                         ServletResponse response,
                         FilterChain filterChain)
            throws IOException {

        // 捕获JWT验证中异常
        try {
            // JWT验证
            Authentication authentication = TokenAuthenticationService
                    .getAuthentication((HttpServletRequest) request);

            // 设置JWT验证结果到Security
            SecurityContextHolder.getContext()
                    .setAuthentication(authentication);

            // 将请求转发给过滤器链的下一个对象，如果没有filter，就到请求的资源
            filterChain.doFilter(request, response);
            
        } catch (Exception exception) {
            // 身份验证失败的response数据
            response.setContentType("application/json");
            response.getOutputStream().println(JSONResult.fillResultString(500, "fail", "Token verify failed! "));
        }
    }
}

hello测试类实现：TestController

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;

@RestController
public class TestController {

    @PostMapping("/hello")
    public String hello(@RequestBody Map<String, Integer> data) {
        return JSONResult.fillResultString(200, "success", "Hello, " + data.get("index"));
    }
}

运行测试

登录
curl -H “Content-Type: application/json” -X POST -d ‘{“username”:”admin”,”password”:”111”}’ http://127.0.0.1:8080/login

权限
curl -H “Content-Type: application/json” -H “Authorization: yegetaier xxx.yyy.zzz” http://127.0.0.1:8080/permission

角色
curl -H “Content-Type: application/json” -H “Authorization: yegetaier xxx.yyy.zzz” http://127.0.0.1:8080/role

其他
curl -H “Content-Type: application/json” -H “Authorization: yegetaier xxx.yyy.zzz” -X POST -d ‘{“index”:111}’ http://127.0.0.1:8080/hello
return: {“data”:”Hello, 111”,”message”:”success”,”status”:200}

token：xxx.yyy.zzz
token前缀：yegetaier
token前缀与token拼接中，前缀与token之间的空格可要可不要。

Controller获取当前登录用户信息

登录成功后，认证信息载体Authentication的Principal字段存储了用户名信息。

实际场景中，Principal字段应该存储用户ID。

import org.springframework.web.bind.annotation.*;

import java.security.Principal;

@RestController
public class TestController {

    @GetMapping("/getUserFromPrincipal")
    public String getUserFromPrincipal(Principal principal) {
        return JSONResult.fillResultString(200, "success", principal.getName());
    }
}