亲宝软件园·资讯

展开

Springboot Shiro整合JWT Springboot实现Shiro整合JWT的代码实例

一个JavaBean 人气:0

写在前面

之前想尝试把JWT和Shiro结合到一起,但是在网上查了些博客,也没太有看懂,所以就自己重新研究了一下Shiro的工作机制,然后自己想了个(傻逼)办法把JWT和Shiro整合到一起了

另外接下来还会涉及到JWT相关的内容,我之前写过一篇博客,可以看这里:Springboot实现JWT认证

Shiro的Session机制

由于我的方法是改变了Shiro的默认的Session机制,所以这里先简单讲一下Shiro的机制,简单了解Shiro是怎么确定每次访问的是哪个用户的

Servlet的Session机制

Shiro在JavaWeb中使用到的就是默认的Servlet的Session机制,大致流程如下:

image-20200227163238464

1.用户首次发请求

2.服务器接收到请求之后,无论你有没有权限访问到资源,在返回响应的时候,服务器都会生成一个Session用来储存该用户的信息,然后生成SessionId作为对应的Key

3.服务器会在响应中,用jsessionId这个名字,把这个SessionId以Cookie的方式发给客户(就是Set-Cookie响应头)

4.由于已经设置了Cookie,下次访问的时候,服务器会自动识别到这个SessionId然后找到你上次对应的Session

Shiro带来的变化

而结合Shiro之后,上面的第二步和第三步会发生小变化:

2.—>服务器不但会创建Session,还会创建一个Subject对象(就是Shiro中用来代表当前用户的类),也用这个SessionId作为Key绑定

3.—>第二次接受到请求的时候,Shiro会从请求头中找到SessionId,然后去寻找对应的Subject然后绑定到当前上下文,这时候Shiro就能知道来访的是谁了

我的思路

由于这个是我自己想出来的,所以可能会存在一定的问题,还请大佬指点

主要思想是:用JWT Token来代替Shiro原本返回的Session

image-20200227151055913

工作流程:

代码实现

导入JWT相关包

导入java-jwt包:

这个包里实现了一系列jwt操作的api(包括上面讲到的怎么校验,怎么生成jwt等等)

如果你是Maven玩家:

pom.xml里写入

<!-- https://mvnrepository.com/artifact/com.auth0/java-jwt -->
<dependency>
  <groupId>com.auth0</groupId>
  <artifactId>java-jwt</artifactId>
  <version>3.8.3</version>
</dependency>

如果你是Gradle玩家:

build.gradle里写入

compile group: 'com.auth0', name: 'java-jwt', version: '3.8.3'

如果你是其他玩家:

maven中央仓库地址点这里

JWT工具类

JwtUtils,代码如下:

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;

import java.io.Serializable;
import java.util.Calendar;
import java.util.Date;

/**
 * @author Lehr
 * @create: 2020-02-04
 */
public class JwtUtils {

  /**
   签发对象:这个用户的id
   签发时间:现在
   有效时间:30分钟
   载荷内容:暂时设计为:这个人的名字,这个人的昵称
   加密密钥:这个人的id加上一串字符串
   */
  public static String createToken(String userId,String realName, String userName) {

    Calendar nowTime = Calendar.getInstance();
    nowTime.add(Calendar.MINUTE,30);
    Date expiresDate = nowTime.getTime();

    return JWT.create().withAudience(userId)  //签发对象
        .withIssuedAt(new Date())  //发行时间
        .withExpiresAt(expiresDate) //有效时间
        .withClaim("userName", userName)  //载荷,随便写几个都可以
        .withClaim("realName", realName)
        .sign(Algorithm.HMAC256(userId+"HelloLehr"));  //加密
  }

  /**
   * 检验合法性,其中secret参数就应该传入的是用户的id
   * @param token
   * @throws TokenUnavailable
   */
  public static void verifyToken(String token, String secret) throws TokenUnavailable {
    DecodedJWT jwt = null;
    try {
      JWTVerifier verifier = JWT.require(Algorithm.HMAC256(secret+"HelloLehr")).build();
      jwt = verifier.verify(token);
    } catch (Exception e) {
      //效验失败
      //这里抛出的异常是我自定义的一个异常,你也可以写成别的
      throw new TokenUnavailable();
    }
  }

  /**
  * 获取签发对象
  */
  public static String getAudience(String token) throws TokenUnavailable {
    String audience = null;
    try {
      audience = JWT.decode(token).getAudience().get(0);
    } catch (JWTDecodeException j) {
      //这里是token解析失败
      throw new TokenUnavailable();
    }
    return audience;
  }


  /**
  * 通过载荷名字获取载荷的值
  */
  public static Claim getClaimByName(String token, String name){
    return JWT.decode(token).getClaim(name);
  }
}

一点小说明:

关于jwt生成时的加密和验证方法:

jwt的验证其实就是验证jwt最后那一部分(签名部分)。这里在指定签名的加密方式的时候,还传入了一个字符串来加密,所以验证的时候不但需要知道加密算法,还需要获得这个字符串才能成功解密,提高了安全性。我这里用的是id来,比较简单,如果你想更安全一点,可以把用户密码作为这个加密字符串,这样就算是这段业务代码泄露了,也不会引发太大的安全问题(毕竟我的id是谁都知道的,这样令牌就可以被伪造,但是如果换成密码,只要数据库没事那就没人知道)

关于获得载荷的方法:

可能有人会觉得奇怪,为什么不需要解密不需要verify就能够获取到载荷里的内容呢?原因是,本来载荷就只是用Base64处理了,就没有加密性,所以能直接获取到它的值,但是至于可不可以相信这个值的真实性,就是要看能不能通过验证了,因为最后的签名部分是和前面头部和载荷的内容有关联的,所以一旦签名验证过了,那就说明前面的载荷是没有被改过的。

Controller层

 登录逻辑

  /**
   * 用户登录
   * @param userName
   * @param password
   * @param req
   * @return
   * @throws Exception
   */
  @SneakyThrows
  @PostMapping(value = "/login")
  public AccountVO login(String userName, String password, HttpServletRequest req){
    //尝试登录
    Subject subject = SecurityUtils.getSubject();
    try {
      subject.login(new UsernamePasswordToken(userName, password));
    } catch (Exception e) {
      throw new LoginFailed();
    }
    AccountVO account = accountService.getAccountByUserName(userName);
    String id = account.getId();
    //生成jwtToken
    String jwtToken = JwtUtils.createToken(id, account.getRealName(),account.getUserName(), subject.getSession().getId().toString());
    //设置好token,后来会在全局处理的时候放入响应里
    req.setAttribute("token", jwtToken);
    return account;
  }

主要是:在登录成功之后把这个Subject的SessionId放入JWT然后生成token:

String jwtToken = JwtUtils.createToken(id,account.getRealName(),account.getUserName(),subject.getSession().getId().toString());

以后我们就可以通过解析JWT来获取SessionId了,而不是每次把SessionId作为Cookie返回

退出逻辑

首先,由于JWT令牌本身就会失效,所以如果JWT令牌失效,也就相当与退出了

然后我们还可以同样实现Shiro中传统的手动登出:

public String logout(HttpServletRequest req) {
    SecurityUtils.getSubject().logout();
    return "用戶已经安全登出";
  }

这样的话Realm中的用户状态就变成未认证了,就算JWT没过期也需要重新登录了

自定义SessionManager

先上代码:

package com.imlehr.internship.shiroJwt;

import com.imlehr.internship.exception.TokenUnavailable;
import lombok.SneakyThrows;
import org.apache.shiro.session.mgt.SessionKey;
import org.apache.shiro.web.servlet.ShiroHttpServletRequest;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.apache.shiro.web.util.WebUtils;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.Serializable;
import java.util.UUID;

/**
 * @author Lehr
 * @create: 2020-02-10
 */
public class CustomSessionManager extends DefaultWebSessionManager {


  //这里我为了省事用了lombok的标签
  @SneakyThrows
  @Override
  protected Serializable getSessionId(ServletRequest request, ServletResponse response) {

    String token = WebUtils.toHttp(request).getHeader("token");
    System.out.println("会话管理器得到的token是:" + token);
    if (token == null || token.length()<1) {
      return UUID.randomUUID().toString();
    }

    //在这里验证一下jwt了,虽然我知道这样不好
    String userId = JwtUtils.getAudience(token);
    JwtUtils.verifyToken(token, userId);
    String sessionId = JwtUtils.getClaimByName(token, "sessionId").asString();

    if (sessionId == null) {
      return new TokenUnavailable();
    }

    
    request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE, "header");
    request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, token);
    request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
    request.setAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED, isSessionIdUrlRewritingEnabled());

    return sessionId;
  }


}

之前的Session的获取,就是在DefaultWebSessionManager里实现的,所以我们现在只需要重写这个类,把我们如何获取Session的逻辑写进去就好了

这里说两个方法:

getSessionId(SessionKey key)

这个方法是在DefaultWebSessionManager的,这里并没有重写,我们上面重写的是后面第二个同名方法,只是想在这里谈谈,读者可以直接跳过这段也不影响

源码逻辑

在Shiro想要获取SessionId的时候,首先会调用的就是这个方法,而不是那个传入httpRequest的方法

在DefaultWebSessionManager中,他是这样做的

@Override
public Serializable getSessionId(SessionKey key) {
  Serializable id = super.getSessionId(key);
  if (id == null && WebUtils.isWeb(key)) {
    ServletRequest request = WebUtils.getRequest(key);
    ServletResponse response = WebUtils.getResponse(key);
    //调用第二个同名方法
    id = getSessionId(request, response);
  }
  return id;
}

这里需要注意的是,这个方法会在整个验证过程中多次被反复调用,而在服务器接受到用户请求的时候,只会调用一次的方法是下面这个,也就是我们重写的这个

getSessionId(ServletRequest request, ServletResponse response)

这个才是真正涉及到服务器接受到请求的时候获取Session逻辑,从用户的请求报文中获取SessionId

所以我们要重写的就是这一步

原版中的逻辑是:从Cookie里找到sessionId的值

我们只需要把逻辑该为:从Header中找出JWT(也就是从请求头的'token'头中找),然后解析JWT,获取到我们存放在其中的SessionId属性即可

ShiroConfiguration

我们只需要把自己写的SessionManager配置进去就好了

首先配好:

public DefaultWebSessionManager sessionManager()
{
  CustomSessionManager customSessionManager = new CustomSessionManager();
  return customSessionManager;
}

然后放入SecurityManager

public SecurityManager securityManager(MyRealm myRealm) {
  
  DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
  securityManager.setRealm(myRealm);
  
  return securityManager;
}

完成🎉

测试

登录

image-20200227161124575

我们获取到了JWT,JWT里面就带有SessionId

后续请求不带token

image-20200227161223110

显然,没过认证,我们看下后台:

image-20200227161319858

因为不能获得token所以无法得到该用户对应的sessionId,所以被授权拦截了

后面那个JSESSIONID是因为没得到sessionId新生成的,所以对应了一个没有登录的用户,自然就会被拒绝

只有带上之前的token,shiro才会认为我们是之前那个已经登录过的用户

后续请求带token

image-20200227161551066

后台:

image-20200227161616008

成功!

另外,因为JWT本身就适合RESTful API服务,所以,如果把Shiro和Redis整合起来做成分布式的,那么效果会更好

加载全部内容

相关教程
猜你喜欢
用户评论