swagger◆jwt◆shiro◆redis

swagger◆jwt◆shiro◆redis

swagger◆jwt◆shiro◆redis

第一段：前言

最近在项目中想整合swagger◆jwt◆shiro◆redis过程中遇到诸多问题和困难,现重新写一个demo并记录解决步骤.存在的问题：

shiro默认的拦截跳转都是跳转url页面,而前后端分离后,后端并无权干涉页面跳转.

shiro默认的登录拦截校验机制是使用的session.

参考资料：SpringBoot结合JWT◆Shiro◆Redis实现token无状态登录授权

第二段：需求及相关说明

需求首次通过post请求进行登入；

登录成功后返回token；

服务端负责token生命周期的刷新

用户权限的校验；

Shiro ◆ JWT实现无状态鉴权机制

首先post用户名与密码到login进行登入,如果成功在请求头Header返回一个加密的Authorization,失败的话直接返回未登录,以后访问都带上这个Authorization即可.

鉴权流程主要是要重写shiro的入口过滤器BasicHttpAuthenticationFilter,在此基础上进行拦截、token验证授权等操作

关于AccessToken及RefreshToken概念说明

关于Redis中保存RefreshToken信息(做到JWT的可控性)

登录认证通过后返回AccessToken信息(在AccessToken中保存当前的时间戳和帐号),同时在Redis中设置一条以帐号为Key,Value为当前时间戳(登录时间)的RefreshToken,现在认证时必须AccessToken没失效以及Redis存在所对应的RefreshToken,且RefreshToken时间戳和AccessToken信息中时间戳一致才算认证通过,这样可以做到JWT的可控性,如果重新登录获取了新的AccessToken,旧的AccessToken就认证不了,因为Redis中所存放的的RefreshToken时间戳信息只会和最新的AccessToken信息中携带的时间戳一致,这样每个用户就只能使用最新的AccessToken认证.

Redis的RefreshToken也可以用来判断用户是否在线,如果删除Redis的某个RefreshToken,那这个RefreshToken所对应的AccessToken之后也无法通过认证了,就相当于控制了用户的登录,可以剔除用户

关于根据RefreshToken自动刷新AccessToken

同时前端进行获取替换,下次用新的AccessToken进行访问即可.

第三段：实现步骤

1.8
③③2
1.⑥0
2.9.2
③9.0




    org.springframework.boot
    spring-boot-starter-data-jdbc


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


    org.springframework.boot
    spring-boot-starter-test


    org.springframework.boot
    spring-boot-starter-logging



    com.auth0
    java-jwt
    ${jwt.version}




    com.baomidou
    mybatis-plus-boot-starter
    ${mybatis-plus.version}



    org.springframework.boot
    spring-boot-starter-data-redis




    org.projectlombok
    lombok




    org.apache.shiro
    shiro-spring
    ${shiro.version}




    io.springfox
    springfox-swagger2
    ${swagger.version}



    io.springfox
    springfox-swagger-ui
    ${swagger.version}


    mysql
    mysql-connector-java
    runtime

配置文件

server:
  port: 8081
jwt:
 #  AccessToken 过期时间单位分钟
 EXPIRE_TIME: 5
 # RefreshToken 过期时间单位分钟
 REFRESH_EXPIRE_TIME: 30
 # 密钥盐
 TOKEN_SECRET: 50eFa4d9W8ba4d*bb276f^11
swagger:
  enabled: true
spring:
  datasource:
username: root
password: maple1234
url: jdbc:mysql://12⑦0.0.1:3306/db2020?useSSL=falseuseUnicode=truecharacterEncoding=utf-8serverTimezone=GMT+8
driver-class-name: com.mysql.cj.jdbc.Driver
  redis:
host: 12⑦0.0.1
port: 6379
mybatis-plus:
  mapper-locations: classpath:com/maplexl/shiroJwtRedis/mapper/xml/*.xml
logging:
  level:
   com.maplexl: debug

@Configuration
@EnableSwagger2
public class SwaggerConfig {
//是否开启swagger,根据环境来选择
@Value(value = "${swagger.enabled}")
Boolean swaggerEnabled;

@Bean
public Docket api() {
    //全局参数
    Parameter token = new ParameterBuilder().name("token")
            .description("用户登陆令牌")
            .parameterType("header")
            .modelRef(new ModelRef("String"))
            //是否必须
            .required(false)
            .build();
    ArrayList parameters = new ArrayList<>();
    parameters.add(token);
    return new Docket(DocumentationType.SWAGGER_2)
            .globalOperationParameters(parameters)
            .apiInfo(apiInfo())
            .enable(swaggerEnabled)
            .groupName("api")
            .select()
            .apis(RequestHandlerSelectors.basePackage("com.maplexl.shiroJwtRedis.controller"))
            .paths(PathSelectors.any())
            .build();
}


private ApiInfo apiInfo() {
    return new ApiInfoBuilder()
            .title("jwt-shiro-redis")
            .description("api")
            // 作者信息
            .contact(new Contact("枫叶", "https://www.cnblogs.com/junlinsky/", "203051919@qq.com"))
            .version("1.0.0")
            .build();
}
}

主要实现token的签发、验证和数据解析.

@Slf4j
@SuppressWarnings("unused")
public class JwtUtil {

/**
 * token到期时间,毫秒为单位
 */
public static long EXPIRE_TIME;
/**
 * RefreshToken到期时间为,秒为单位
 */
public static long REFRESH_EXPIRE_TIME;
/**
 * 密钥盐
 */
private static String TOKEN_SECRET;

/**
 * 设置token过期时间及密钥盐
 *
 * @param expireTime        客户端token过期时间
 * @param refreshExpireTime 服务器token过期时间
 * @param tokenSecret       token加密使用的盐值
 */
public static void setProperties(long expireTime, long refreshExpireTime, String tokenSecret) {
    JwtUtil.EXPIRE_TIME = expireTime;
    JwtUtil.REFRESH_EXPIRE_TIME = refreshExpireTime;
    JwtUtil.TOKEN_SECRET = tokenSecret;
}

/**
 * 校验token是否正确
 *
 * @param token 密钥
 * @return 是否正确
 */
public static boolean verify(String token) {
    //创建token验证器
    JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(TOKEN_SECRET)).build();
    DecodedJWT decodedjwt = jwtVerifier.verify(token);
    log.info("认证通过");
    log.info("userId: [{}]", decodedjwt.getClaim("userId").asLong());
    log.info("过期时间：      [{}]", decodedjwt.getExpiresAt());
    return true;
}

/**
 * 获得token中的信息
 *
 * @return token中包含的用户id
 */
public static long getUserId(String token) {
    try {
        DecodedJWT jwt = JWT.decode(token);
        return jwt.getClaim("userId").asLong();
    } catch (JWTDecodeException e) {
        return -1L;
    }
}

/**
 * 获取currentTime
 * @param token 密钥
 * @return currentTime
 */
public static Long getCurrentTime(String token){
    try{
        DecodedJWT decodedjwt =JWT.decode(token);
        return decodedjwt .getClaim("currentTime").asLong();
    }catch (JWTCreationException e){
        return null;
    }
}
/**
 * 根据request中的token获取currentTime
 *
 * @param request request
 * @return CurrentTime
 */
public static Long getCurrentTime(HttpServletRequest request) {
    String accessToken = request.getHeader("token");
    Long currentTime = getCurrentTime(accessToken);
    if (currentTime == null) {
        throw new RuntimeException("未获取到currentTime");
    }
    return currentTime;
}

/**
 * 生成签名,5min后过期
 *
 * @param userId 用户名
 * @return 加密的token
 */
public static String sign(Long userId, Long currentTime) {
    String token = null;
    try {
        Date expireAt = new Date(currentTime ◆ EXPIRE_TIME);
        token = JWT.create()
                //存放数据
                .withClaim("userId", userId)
                .withClaim("currentTime", currentTime)
                //过期时间
                .withExpiresAt(expireAt)
                .sign(Algorithm.HMAC256(TOKEN_SECRET));
    } catch (RuntimeException e) {
        e.printStackTrace();
    }
    return token;
}


/**
 * 根据request中的token获取账号
 *
 * @param request request
 * @return 用户的账号
 */
public static Long getUserId(HttpServletRequest request) {
    String accessToken = request.getHeader("token");
    return getUserId(accessToken);
}
}

上面的工具类在使用前需需要设置EXPIRE_TIME、TOKEN_SECRET和REFRESH_EXPIRE_TIME

配置类

@Configuration
public class JwtUtilConfig {
@Value("${jwt.EXPIRE_TIME}")
private Long expireTime;
@Value("${jwt.REFRESH_EXPIRE_TIME}")
private Long refreshExpireTime;
@Value("${jwt.TOKEN_SECRET}")
private String tokenSecret;

@PostConstruct
public void init() {
    JwtUtil.setProperties(expireTime * 1000 * 60, refreshExpireTime * 60, tokenSecret);
}
}

RedisConfig

@Configuration
public class RedisConfig {
@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory factory) {

    RedisTemplate template = new RedisTemplate<>();
    // 配置连接工厂
    template.setConnectionFactory(factory);

    //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
    Jackson2JsonRedisSerializer