SpringBoot+SpringSecurity+JWT整合

1.简介

SpringSecurity是spring的一个安全管理框架，相比另一个安全框架shiro，它提供了更丰富的功能，社区资源也比shiro丰富。

web应用主要用于认证和授权

认证：验证当前访问系统的是不是本系统用户，并且要确定具体是哪个用户

授权：经过认证完成过后判断当前用户是否具有某个权限操作具体资源

springsecurity的核心就是认证和授权，并且更快的整合soring应用

2.快速入门

2.1准备工作

首先搭建一个soringBoot工程

pom依赖

        org.springframework.boot        spring-boot-starter-parent        2.5.0                8        8        UTF-8                            org.springframework.boot            spring-boot-starter-web            

创建一个测试小例子

@RestControllerpublic class HelloController {    @GetMapping("/hello")    public String hello() {        return "hello security";    }}

访问http://localhost:8080/hello， 返回字符串hello security

2.2 引入spring security pom依赖

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

再次登录会需要输入用户名和密码，此时默认用户名为： user 密码为控制台输入的密码

Using generated security password: e493f2ae-cb1e-4802-b0a2-1e8da5d97068

3.认证

3.1 登录校验流程

3.2 原理讲解

根据入门案例，分析具体流程

3.2.1 SpringScurity完整流程

springsecurity底层实现是通过一系列的过滤器链完成登录验证和授权等功能，主要是使用到下面15个过滤器

调用流程

认证流程介绍

接口和类介绍：

UsernamePasswordAuthenticationFilter： 认证过滤器主要用于生成Authentication对象完成用户信息封装。

AuthenticationManager： 定义了认证Authentication的方法。

AbstractUserDetailsAuthenticationProvider：提供了authenticate()认证方法，并且在里面调用UserDetailsServiceloadUserByUsername查询用户信息。

UserDetailsService：获取用户信息的核心接口，里面定义了根据用户名查询用户信息，可以实现该接口覆盖默认的用户信息查询方法，完成自定义用户信息查询，返回一个UserDetails用户信息封装对象。

UserDetails： 主要封装用户相关信息，通过UserDetailsService获取用户信息返回UserDetails对象，然后将相关信息设置到Authentication对象中。

3.3 解决问题

3.3.1 思路分析

登录

1. 自定义登录接口

调用ProviderManager的认证方法，如果认证通过生成jwt并存入到redis

2. 自定义UserDetailsService

通过自定义的实现完成从数据库查询用户信息和权限信息并返回UserDetails对象

校验

3. 自定义jwt认证过滤器

获取生成jwt token，解析token获取userid，通过userid从redis中获取用户信息，存入到SecurityContextHolder中，方便后续其他过滤器通过SecurityContextHolder获取用户信息

3.3.2 jwt简介

1. 什么是 JSON Web Token？

JSON Web 令牌 （JWT） 是一种开放标准 （RFC 7519），它定义了一种紧凑且独立的方式，用于在各方之间以 JSON 对象的形式安全地传输信息。此信息可以验证和信任，因为它是经过数字签名的。JWT 可以使用密钥（使用 HMAC 算法）或使用 RSA 或 ECDSA 的公钥/私钥对进行签名。

尽管 JWT 可以加密以提供各方之间的保密性，但我们将专注于签名令牌。签名令牌可以验证其中包含的声明的完整性，而加密令牌则向其他方隐藏这些声明。当使用公钥/私钥对对令牌进行签名时，签名还证明只有持有私钥的一方才是签名的一方。

跨平台 跨语言 轻量级json 对象进行数据传输， 数字签名保证安全性

应用场景：

• 授权：这是使用 JWT 的最常见方案。用户登录后，每个后续请求都将包含 JWT，允许用户访问使用该令牌允许的路由、服务和资源。单点登录是当今广泛使用 JWT 的一项功能，因为它的开销很小，并且能够跨不同域轻松使用。

• 信息交换：JSON Web 令牌是在各方之间安全传输信息的好方法。由于 JWT 可以签名（例如，使用公钥/私钥对），因此您可以确定发件人是他们所说的人。此外，由于签名是使用标头和有效负载计算的，因此您还可以验证内容是否未被篡改

2. JSON Web Token令牌结构

JSON Web 令牌由三部分组成，中间用 . 分割

页眉

有效荷载

签名

JWT通常如： xxxxx.yyyyy.zzzzz 组成

3. 结构详解

页眉 headers 需要Base64进行编码

页面主要包含令牌类型(令牌类型目前只有一种 JWT)和签名算法例如HMAC SHA256 RSA

例如：

{"alg" : "SHA256","typ" : "JWT"}

有效荷载 payload 需要Base64进行编码

荷载主要包含声明，声明分为已注册声明、公共声明、专用声明

已注册声明： 由JWT提前帮我们预定义好的例如iss（发行人），exp（到期时间），sub（主题），aud（受众）等。

公共声明： 这些可以由使用 JWT 的人随意定义。但为了避免冲突，它们应该在 IANA JSON Web 令牌注册表中定义，或者定义为包含抗冲突命名空间的 URI。

专用声明： 这个由用户自定义可以是一个json字符串用户可以将实体信息转换后放入专用声明中，

注意：这些声明中不要包含任何敏感信息

例如

{  "sub": "1234567890",  "name": "John Doe",  "admin": true}

签名

要创建签名部分，首先需要Base64编码页眉和有效荷载json数据，然后通过页面中指定的算法以及密钥进行算法加密获取签名的结果。

密钥：是用户自定义的一系列字符串作为私钥，不能提供给其他系统

4. 签名示例

// 头部信息{  "alg": "HS256",  "typ": "JWT"}// 有效荷载{  "sub": "1234567890",  "name": "John Doe",  "iat": 1516239022}// 通过指定算法签名HMACSHA256(  base64UrlEncode(header) + "." +  base64UrlEncode(payload),  your-256-bit-secret)// 签名后的结果eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

3.3.3 java中使用jwt

public class JwtTest {    // 生成jwt    @Test    public void contextLoads() {        HashMap headers = new HashMap();        Calendar instance = Calendar.getInstance();        instance.add(Calendar.SECOND, 200);        String token = JWT.create().withHeader(headers) //headers                .withClaim("userid", "21")                .withClaim("username", "wangm") //payload                .withExpiresAt(instance.getTime())                .sign(Algorithm.HMAC256("1231312sdasddsas"));// 密钥        System.out.println(token);    }    // 验证jwt 可以获取页眉数据和有效荷载数据    @Test    public void checkToken() {        JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256("1231312sdasddsas")).build();        DecodedJWT decodedJWT = jwtVerifier.verify("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2NzI0OTMxMTAsInVzZXJpZCI6IjIxIiwidXNlcm5hbWUiOiJ3YW5nbSJ9.DNmrAFgRnWdcAtBK6nkwNPV-GSsrKyO_TyoIeB0YqzI");        String userid = decodedJWT.getClaim("userid").asString();        System.out.println(userid);    }}

jwt封装工具类

@Componentpublic class JwtUtils {    private static String secretKey;    @Value("${JWT.secretKey}")    public void secretKey(String secretKey) {        JwtUtils.secretKey =  secretKey;    }        public static String generateToken(Map map, Integer expDay) {        Calendar instance = Calendar.getInstance();        instance.add(Calendar.SECOND, 1);        JWTCreator.Builder builder = JWT.create();        map.forEach((k, v) ->{            builder.withClaim(k, v);        });        builder.withExpiresAt(instance.getTime());        // 生成token        return builder.sign(Algorithm.HMAC256(secretKey));    }        public static void verifyToken(String token) {        // 验证token        JWT.require(Algorithm.HMAC256(secretKey)).build().verify(token);    }        public static DecodedJWT getTokenInfo(String token) {        DecodedJWT decodedJWT = JWT.require(Algorithm.HMAC256(secretKey)).build().verify(token);        return decodedJWT;    }}com.jack.study.security.entity.LoginUser [Username=admin, Password=[PROTECTED], Enabled=true, AccountNonExpired=true, credentialsNonExpired=true, AccountNonLocked=true, Granted Authorities=[admin]]

jwt整合springboot 整合拦截器统一令牌验证

// 整合拦截器实现统一token 验证public class JwtInterceptor implements HandlerInterceptor {    @Override    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {        String token = request.getHeader("token");        Map map = new HashMap<>();        if (StrUtil.isEmpty(token)) {            map.put("status", "514");            map.put("message", "token为空");            String s = new ObjectMapper().writeValueAsString(map);            response.setContentType("application/json;charset=UTF-8");            response.setCharacterEncoding("UTF-8");            response.getWriter().write(s);            return false;        }        // jwt异常处理        try{            JwtUtils.verifyToken(token);            return true;        }catch (SignatureVerificationException e1) {            map.put("status", "510");            map.put("message", "签名异常");        }catch (TokenExpiredException e2) {            map.put("status", "511");            map.put("message", "token已过期");        }catch (AlgorithmMismatchException e3) {            map.put("status", "512");            map.put("message", "加密算法异常");        }catch (JWTDecodeException e4) {            map.put("status", "513");            map.put("message", "token解密异常");        }catch (Exception e) {            map.put("status", "500");            map.put("message", "系统异常");        }        String s = new ObjectMapper().writeValueAsString(map);        response.setContentType("application/json;charset=UTF-8");        response.setCharacterEncoding("UTF-8");        response.getWriter().write(s);        return false;    }}

3.3.4 准备工作

1. 创建一个maven 工程 添加相关依赖

pom.xml

    4.0.0    com.jack.study    spring-security-token    1.0-SNAPSHOT            org.springframework.boot        spring-boot-starter-parent        2.5.0                8        8        UTF-8                            org.springframework.boot            spring-boot-starter-web                            org.springframework.boot            spring-boot-starter-test                                    org.springframework.boot            spring-boot-starter-security                                    org.springframework.boot            spring-boot-starter-data-redis                                    io.jsonwebtoken            jjwt            0.9.0                                    com.alibaba            fastjson            1.2.83                                    com.github.xiaoymin            swagger-bootstrap-ui            1.9.6                            io.springfox            springfox-swagger2            2.9.2                                                io.swagger                    swagger-models                                                        io.swagger            swagger-models            1.5.21                            cn.hutool            hutool-all            5.6.2                            org.projectlombok            lombok            true                            mysql            mysql-connector-java                            com.baomidou            mybatis-plus-boot-starter            3.4.3            

2. 创建启动类 并配置相关扫描

@SpringBootApplication(scanBasePackages = {"com.jack.study"}) // 组件扫描路径@MapperScan(basePackages = {"com.jack.study.*.mapper"}) // mapper文件扫描public class SecurityTokenApplication {    public static void main(String[] args) {        SpringApplication.run(SecurityTokenApplication.class, args);    }}

3. 定义yml配置

server:  port: 8080spring:#数据库连接配置  datasource:    driver-class-name: com.mysql.cj.jdbc.Driver    url: jdbc:mysql://localhost:3306/security-jwt?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC    username: root    password: 123456    #redis 连接配置  redis:    host: localhost    port: 6379    password: 123456mybatis-plus:#mapper xml扫描配置  mapper-locations: classpath:/mapper    //请求成功    SUCCESS(200,"成功"),    PARAM_IS_INVALID(1001,"参数为空"),    OK(200, "操作成功"),    FAIL(500, "操作失败"),    NO_AUTH(403, "没有权限"),    NO_PAGE(404, "未找到页面"),    TOKEN_OVERDUE(400, "Token超期");    //参数校检    private Integer code;    private String message;    ResultCode(Integer code,String message){        this.code = code;        this.message = message;    }    public Integer code(){        return this.code;    }    public String message(){        return this.message;    }}// 响应结果实体@Datapublic class Result implements Serializable {        private Integer code;        private String message;        private Object data;    public Result(){    }    //自定义错误代码和错误信息    public Result(Integer code, String message, Object data) {        this.code = code;        this.message = message;        this.data = data;    }    //根据枚举固定错误代码获取    public Result(ResultCode resultCode, Object data){        this.code = resultCode.code();        this.message = resultCode.message();        this.data = data;    }        public static Result success(){        Result result = new Result();        result.setCode(ResultCode.SUCCESS.code());        result.setMessage(ResultCode.SUCCESS.message());        return result;    }        public static Result success(Object data){        Result result = new Result();        result.setCode(ResultCode.SUCCESS.code());        result.setMessage(ResultCode.SUCCESS.message());        result.setData(data);        return result;    }        public static Result failure(ResultCode resultCode){        Result result = new Result();        result.setCode(resultCode.code());        result.setMessage(resultCode.message());        return result;    }        public static Result failure(Integer code, String message){        Result result = new Result();        result.setCode(code);        result.setMessage(message);        return result;    }        public static Result failure(ResultCode resultCode,Object data){        Result result = new Result();        result.setCode(resultCode.code());        result.setMessage(resultCode.message());        result.setData(data);        return result;    }        public static Result custom(Integer code, String message, Object data){        Result result = new Result();        result.setCode(code);        result.setMessage(message);        result.setData(data);        return result;    }}

异常封装统一处理

认证异常工具类

public class AuthExceptionUtil {    public static Result getErrMsgByExceptionType(AuthenticationException e) {        if (e instanceof LockedException) {            return Result.failure(1100, "账户被锁定，请联系管理员!");        } else if (e instanceof CredentialsExpiredException) {            return Result.failure(1105,"用户名或者密码输入错误!");        }else if (e instanceof InsufficientAuthenticationException) {            return Result.failure(403,"权限不足请登录!");        } else if (e instanceof AccountExpiredException) {            return Result.failure(1101, "账户过期，请联系管理员!");        } else if (e instanceof DisabledException) {            return Result.failure(1102, ("账户被禁用，请联系管理员!"));        } else if (e instanceof BadCredentialsException) {            return Result.failure(1105, "用户名或者密码输入错误!");        }else if (e instanceof AuthenticationServiceException) {            return Result.failure(1106, "认证失败，请重试!");        }        return Result.failure(1200, e.getMessage());    }    public static Result getErrMsgByExceptionType(AccessDeniedException e) {        if (e instanceof CsrfException) {            return Result.failure(-1001, "非法访问跨域请求异常!");        } else if (e instanceof org.springframework.security.web.csrf.CsrfException) {            return Result.failure(-1002,"非法访问跨域请求异常!");        } else if (e instanceof AuthorizationServiceException) {            return Result.failure(1101, "认证服务异常请重试!");        }else if (e instanceof AccessDeniedException) {            return Result.failure(4003, "权限不足不允许访问!");        }        return Result.failure(1200, e.getMessage());    }}

认证业务异常封装

public class BusinessException extends AuthenticationException {    public BusinessException(String msg, Throwable cause) {        super(msg, cause);    }    public BusinessException(String msg) {        super(msg);    }}

统一异常处理，根据自定义异常分别处理错误信息

@RestControllerAdvicepublic class GlobalExceptionHandler {// 根据实际自定义的异常统一处理    @ExceptionHandler(value = BusinessException.class)    public Result operationError(BusinessException e) {        return Result.failure(ResultCode.FAIL, e.getMessage());    }}

redisConfig 配置类

@Configurationpublic class RedisConfig {    public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory) {        RedisTemplate template = new RedisTemplate<>();        template.setConnectionFactory(connectionFactory);        FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);        // 使用StringRedisSerializer来序列化和反序列化redis的key值        template.setKeySerializer(new StringRedisSerializer());        template.setValueSerializer(serializer);        // Hash的key也采用StringRedisSerializer的序列化方式        template.setHashKeySerializer(new StringRedisSerializer());        template.setHashValueSerializer(serializer);        template.afterPropertiesSet();        return template;    }}

fastjoson 序列化

public class FastJsonRedisSerializer implements RedisSerializer {    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");    private Class clazz;    static    {        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);    }    public FastJsonRedisSerializer(Class clazz)    {        super();        this.clazz = clazz;    }    public byte[] serialize(T t) throws SerializationException    {        if (t == null)        {            return new byte[0];        }        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);    }    public T deserialize(byte[] bytes) throws SerializationException    {        if (bytes == null || bytes.length <= 0)        {            return null;        }        String str = new String(bytes, DEFAULT_CHARSET);        return JSON.parseObject(str, clazz);    }    protected JavaType getJavaType(Class clazz)    {        return TypeFactory.defaultInstance().constructType(clazz);    }}

redis 工具类封装

@Component@Order(-1)public final class RedisUtil {    @Autowired    private RedisTemplate redisTemplate;        public boolean expire(String key, long time) {        try {            if (time > 0) {                redisTemplate.expire(key, time, TimeUnit.SECONDS);            }            return true;        } catch (Exception e) {            e.printStackTrace();            return false;        }    }        public long getExpire(String key) {        return redisTemplate.getExpire(key, TimeUnit.SECONDS);    }        public boolean hasKey(String key) {        try {            return redisTemplate.hasKey(key);        } catch (Exception e) {            e.printStackTrace();            return false;        }    }        @SuppressWarnings("unchecked")    public void del(String... key) {        if (key != null && key.length > 0) {            if (key.length == 1) {                redisTemplate.delete(key[0]);            } else {                redisTemplate.delete(CollectionUtils.arrayToList(key));            }        }    }    // ============================String=============================        public Object get(String key) {        return key == null ? null : redisTemplate.opsForValue().get(key);    }        public boolean set(String key, Object value) {        try {            redisTemplate.opsForValue().set(key, value);            return true;        } catch (Exception e) {            e.printStackTrace();            return false;        }    }        public boolean set(String key, Object value, long time) {        try {            if (time > 0) {                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);            } else {                set(key, value);            }            return true;        } catch (Exception e) {            e.printStackTrace();            return false;        }    }        public long incr(String key, long delta) {        if (delta < 0) {            throw new RuntimeException("递增因子必须大于0");        }        return redisTemplate.opsForValue().increment(key, delta);    }        public long decr(String key, long delta) {        if (delta < 0) {            throw new RuntimeException("递减因子必须大于0");        }        return redisTemplate.opsForValue().increment(key, -delta);    }    // ================================Map=================================        public Object hget(String key, String item) {        return redisTemplate.opsForHash().get(key, item);    }        public Map hmget(String key) {        return redisTemplate.opsForHash().entries(key);    }        public boolean hmset(String key, Map map) {        try {            redisTemplate.opsForHash().putAll(key, map);            return true;        } catch (Exception e) {            e.printStackTrace();            return false;        }    }        public boolean hmset(String key, Map map, long time) {        try {            redisTemplate.opsForHash().putAll(key, map);            if (time > 0) {                expire(key, time);            }            return true;        } catch (Exception e) {            e.printStackTrace();            return false;        }    }        public boolean hset(String key, String item, Object value) {        try {            redisTemplate.opsForHash().put(key, item, value);            return true;        } catch (Exception e) {            e.printStackTrace();            return false;        }    }        public boolean hset(String key, String item, Object value, long time) {        try {            redisTemplate.opsForHash().put(key, item, value);            if (time > 0) {                expire(key, time);            }            return true;        } catch (Exception e) {            e.printStackTrace();            return false;        }    }        public void hdel(String key, Object... item) {        redisTemplate.opsForHash().delete(key, item);    }        public boolean hHasKey(String key, String item) {        return redisTemplate.opsForHash().hasKey(key, item);    }        public double hincr(String key, String item, double by) {        return redisTemplate.opsForHash().increment(key, item, by);    }        public double hdecr(String key, String item, double by) {        return redisTemplate.opsForHash().increment(key, item, -by);    }    // ============================set=============================        public Set