Shiro+JWT 前后端分离方案

理论的东西就不说了，网上一大堆教程。

因为我本身web应用做得比较多，所以本篇文章主要是结合SpringBoot来讲解。当然shiro也是支持standlon模式使用的(可以参考我的另一篇文章 自定义Realm)

使用SpringBoot，最优的依赖方案是shiro-spring-boot-starter

<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-spring-boot-starter</artifactId>
  <version>1.4.0</version>
</dependency>

SpringBoot集成Shiro的思路路径是 创建配置文件-->创建过滤器-->创建Realm 。（其实也不完全正确，这几个步骤得结合起来考虑）

首先，我们来创建配置文件

ShiroConfig

SecurityManager 是Shiro的核心组件，所以得首先创建它。

DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
securityManager.setRealm(shiroRealm);

注意：shiroRealm是我们通过Spring Autowired自动注入的，这里的shiroRealm也就是我们自定义的realm，后面会讲到–ShiroRealm。

@Autowired
private ShiroRealm shiroRealm;

因为我们是前后端分离项目，所以shiro的Session功能我们是用不到的，得把它关闭。下面代码的作用就是关闭subject session。

DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();

DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);

securityManager.setSubjectDAO(subjectDAO);

官方文档中有这么一段话介绍 securityManager.subjectDAO.sessionStorageEvaluator.sessionStorageEnabled = false

This will prevent Shiro from using a Subject’s session to store
that Subject’s state across requests/invocations/messages for all Subjects.
这将阻止Shiro使用Subject的会话存储Subject的请求/调用/消息中的状态。

Just be sure that you authenticate on every request
so Shiro will know who the Subject is for any given request/invocation/message.
一定要保证您对每个请求进行身份验证，以便于Shiro知道任何给定请求/调用/消息的subject是谁。

所以，前后端分离项目的关键是**每个请求都得交给shiro去验证身份，也就是说每个请求都会调用subject的login方法 **

继而每次请求都会调用自定义realm中的doGetAuthenticationInfo 方法。

---

创建SecurityManager 后，我们来创建过滤器Filter.

@Bean("shiroFilter")
public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
  ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
  shiroFilterFactoryBean.setSecurityManager(securityManager);

  // 拦截器
  Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
  filterChainDefinitionMap.put("/doc.html", "anon");
  filterChainDefinitionMap.put("/**/*.js", "anon");
  filterChainDefinitionMap.put("/**/*.css", "anon");
  filterChainDefinitionMap.put("/**/*.html", "anon");
  filterChainDefinitionMap.put("/**/*.svg", "anon");
  filterChainDefinitionMap.put("/**/*.pdf", "anon");
  filterChainDefinitionMap.put("/**/*.jpg", "anon");
  filterChainDefinitionMap.put("/**/*.png", "anon");
  filterChainDefinitionMap.put("/**/*.ico", "anon");

  // 添加自己的过滤器并且取名为jwt
  Map<String, Filter> filterMap = new HashMap<String, Filter>(1);
  filterMap.put("jwt", new JwtFilter());
  shiroFilterFactoryBean.setFilters(filterMap);

  // <!-- 过滤链定义，从上向下顺序执行，一般将/**放在最为下边
  filterChainDefinitionMap.put("/**", "jwt");

  shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
  return shiroFilterFactoryBean;
}

• anon–表示不进行拦截，是anonymous的缩写
• JwtFilter是我们自定义的Filter,稍候我们会创建。

---

Shiro可以通过@RequiresPermissions(value = {"sys:admin:get"}) 、@RequiresRoles 细粒度的控制资源访问权限，在Spring应用中，要想使用注解的方式控制权限。还得配置以下几个java bean。

@Bean
public static LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
  return new LifecycleBeanPostProcessor();
}

/**
     * 下面的代码是添加注解支持
     * @return
     */
@Bean
@DependsOn("lifecycleBeanPostProcessor")
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
  DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
  defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);

  /*defaultAdvisorAutoProxyCreator.setUsePrefix(true);
        defaultAdvisorAutoProxyCreator.setAdvisorBeanNamePrefix("_no_advisor");*/
  return defaultAdvisorAutoProxyCreator;
}

@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) {
  AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
  advisor.setSecurityManager(securityManager);
  return advisor;
}

---

ShiroConfig完整配置文件如下：

@Slf4j
@Configuration
public class ShiroConfig {

    @Autowired
    private ShiroRealm shiroRealm;
    /**
     *
     * @return
     */
    @Bean("securityManager")
    public DefaultWebSecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(shiroRealm);

        /*
         * 关闭shiro自带的session，详情见文档
         * http://shiro.apache.org/session-management.html#SessionManagement-
         * StatelessApplications%28Sessionless%29
         */
        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();

        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);

        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
        securityManager.setSubjectDAO(subjectDAO);

        return securityManager;
    }


    @Bean("shiroFilter")
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);

        // 拦截器
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
        filterChainDefinitionMap.put("/doc.html", "anon");
        filterChainDefinitionMap.put("/**/*.js", "anon");
        filterChainDefinitionMap.put("/**/*.css", "anon");
        filterChainDefinitionMap.put("/**/*.html", "anon");
        filterChainDefinitionMap.put("/**/*.svg", "anon");
        filterChainDefinitionMap.put("/**/*.pdf", "anon");
        filterChainDefinitionMap.put("/**/*.jpg", "anon");
        filterChainDefinitionMap.put("/**/*.png", "anon");
        filterChainDefinitionMap.put("/**/*.ico", "anon");

        // 添加自己的过滤器并且取名为jwt
        Map<String, Filter> filterMap = new HashMap<String, Filter>(1);
        filterMap.put("jwt", new JwtFilter());
        shiroFilterFactoryBean.setFilters(filterMap);

        // <!-- 过滤链定义，从上向下顺序执行，一般将/**放在最为下边
        filterChainDefinitionMap.put("/**", "jwt");

        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactoryBean;
    }


    @Bean
    public static LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }

    /**
     * 下面的代码是添加注解支持
     * @return
     */
    @Bean
    @DependsOn("lifecycleBeanPostProcessor")
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);

        /*defaultAdvisorAutoProxyCreator.setUsePrefix(true);
        defaultAdvisorAutoProxyCreator.setAdvisorBeanNamePrefix("_no_advisor");*/
        return defaultAdvisorAutoProxyCreator;
    }

    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
        advisor.setSecurityManager(securityManager);
        return advisor;
    }
}

JwtFilter

在配置ShiroConfig时，我们提到需要配置自定义过滤器。过滤器的作用就是拦截指定的请求，比如我们在上面设置的是filterChainDefinitionMap.put("/**", "jwt"); 拦截所有请求（这里的所有指的是流入到当前过滤器的所有请求，如果是图片、字体等请求，则不会进入，因为在此之前已经被拦截了）

我们来看具体的实现吧：JwtFilter继承了BasicHttpAuthenticationFilter 类，我们只要重写几个关键的方法即可。

public class JwtFilter extends BasicHttpAuthenticationFilter {
    /**
     * 执行登录认证
     *
     * @param request
     * @param response
     * @param mappedValue
     * @return
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        try {
            executeLogin(request, response);
            return true;
        } catch (Exception e) {
            throw new AuthenticationException("Token失效，请重新登录", e);
        }
    }

    /**
     *
     */
    @Override
    protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String token = httpServletRequest.getHeader("X-Access-Token");

        JwtToken jwtToken = new JwtToken(token);
        // 提交给realm进行登入，如果错误他会抛出异常并被捕获
        // 普通应用中获取subject方式 subject = SecurityUtils.getSubject();
        // 然后登录 subject.login(token)
        //login方法最后会回调到ShiroRealm.doGetAuthenticationInfo
        getSubject(request, response).login(jwtToken);
        // 如果没有抛出异常则代表登入成功，返回true
        return true;
    }

    /**
     * 对跨域提供支持
     */
    @Override
    protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));
        httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
        httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));
        // 跨域时会首先发送一个option请求，这里我们给option请求直接返回正常状态
        if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
            httpServletResponse.setStatus(HttpStatus.OK.value());
            return false;
        }
        return super.preHandle(request, response);
    }
}

• isAccessAllowed：判断是否允许访问，内部调用executeLogin执行登录，executeLogin没有抛出异常，表示允许登录（相当于每次请求都会进行登录逻辑判断）
• executeLogin： 从请求头中拿出token,调用subject的login方法就行登录验证（这里封装了JwtToken,[稍候讲解](### JwtToken))
• preHandle： 跨越支持

---

JwtToken

JwtToken的实现很简单，但要注意两点：

• 必须实现AuthenticationToken接口
• 返回的Principal和Credentials是一样的，都是成员变量token

下面讲解自定义Realm时会提到这两点。

import org.apache.shiro.authc.AuthenticationToken;

public class JwtToken implements AuthenticationToken {

    private static final long serialVersionUID = 1L;
    private String token;

    public JwtToken(String token) {
        this.token = token;
    }

    @Override
    public Object getPrincipal() {
        return token;
    }

    @Override
    public Object getCredentials() {
        return token;
    }
}

ShiroRealm

自定义Realm需要继承AuthorizingRealm，重写两个方法：doGetAuthorizationInfo 和 doGetAuthenticationInfo

我们先来看登录验证doGetAuthenticationInfo：

@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
  //这里getPrincipal和getCredentials是一样的
  //因为我们在
  // JwtToken jwtToken = new JwtToken(token);
  // getSubject(request, response).login(jwtToken);
  // 提交的是JwtToken，jwtToken中Principal和Credentials都是token
  String credentials = (String) token.getCredentials();
  if (credentials == null) {
    log.info("————————身份认证失败——————————");
    throw new AuthenticationException("token为空!");
  }
  // 校验token有效性
  LoginUser loginUser = this.checkUserTokenIsEffect(credentials);
  //return SimpleAuthenticationInfo之后会进入到方法 assertCredentialsMatch(token, info);
  //该方法比较info中的Credential和token中的Credential，具体表现在
  //Object tokenHashedCredentials = hashProvidedCredentials(token, info);取出token中的Credential
  //Object accountCredentials = getCredentials(info);取出authenticationInfo中的Credential
  //equals(tokenHashedCredentials, accountCredentials);
  return new SimpleAuthenticationInfo(loginUser, credentials, getName());
}

重点讲解一下SimpleAuthenticationInfo：代码注释中已经说了，shiro内部会拿出AuthenticationToken token的credential 和 SimpleAuthenticationInfo的credential 进行比较，但是呢，你仔细观察一下就知道，我们传给SimpleAuthenticationInfo的credential 其实就是 AuthenticationToken token 的credential，所以shiro内部的验证逻辑对于我们这个示例来说，形同虚设。（因为一定会相等的嘛）

那真正的验证逻辑在哪实现的呢？没错，checkUserTokenIsEffect方法中，我们来看checkUserTokenIsEffect 实现：

public LoginUser checkUserTokenIsEffect(String token) throws AuthenticationException {
  // 解密获得username，用于和数据库进行对比
  String username = JwtUtil.getUsername(token);
  if (username == null) {
    throw new AuthenticationException("token非法无效!");
  }

  // 查询用户信息
  log.debug("———校验token是否有效————checkUserTokenIsEffect——————— "+ token);
  //TODO 查询数据库，根据username得到loginUser
  LoginUser loginUser = new LoginUser();//这里是模拟
  loginUser.setId("admin");
  loginUser.setUsername(username);
  loginUser.setStatus(1);
  loginUser.setPassword("123456");
  if (loginUser == null) {
    throw new AuthenticationException("用户不存在!");
  }
  // 判断用户状态
  if (loginUser.getStatus() != 1) {
    throw new AuthenticationException("账号已被锁定,请联系管理员!");
  }
  // 校验token是否超时失效 & 或者账号密码是否错误
  if (!jwtTokenRefresh(token, username, loginUser.getPassword())) {
    throw new AuthenticationException("Token失效，请重新登录!");
  }

  return loginUser;
}

在checkUserTokenIsEffect中，我们会去数据库查找有没有当前用户，以及用户名密码是否是正确的、token是否过期（jwt本身就能做到用户名密码校验）。

有一种场景：假如token的过期时间是2小时，用户在1小时59分时登录了某个页面，然后他停留了5~10分钟，在此期间，他可能写了一篇文章，但是当他保存文章时，token已经过期了，系统提示不能保存，用户得抓狂吧。

我们借助redis来解决这个问题，详情参见jwtTokenRefresh方法：

/**
     * JWTToken刷新生命周期 （实现： 用户在线操作不掉线功能）
     * 1、登录成功后将用户的JWT生成的Token作为k、v存储到cache缓存里面(这时候k、v值一样)，缓存有效期设置为Jwt有效时间的2倍
     * 2、当该用户再次请求时，通过JWTFilter层层校验之后会进入到doGetAuthenticationInfo进行身份验证
     * 3、当该用户这次请求jwt生成的token值已经超时，但该token对应cache中的k还是存在，则表示该用户一直在操作只是JWT的token失效了，程序会给token对应的k映射的v值重新生成JWTToken并覆盖v值，该缓存生命周期重新计算
     * 4、当该用户这次请求jwt在生成的token值已经超时，并在cache中不存在对应的k，则表示该用户账户空闲超时，返回用户信息已失效，请重新登录。
     * 注意： 前端请求Header中设置Authorization保持不变，校验有效性以缓存中的token为准。
     *       用户过期时间 = Jwt有效时间 * 2。
     * @param token
     * @param userName
     * @param passWord
     * @return
     */
public boolean jwtTokenRefresh(String token, String userName, String passWord){
  String cacheToken = String.valueOf(redisUtil.get(CommonConstant.PREFIX_USER_TOKEN + token));
  if (StringUtils.isNotEmpty(cacheToken)) {
    // 校验token有效性
    if (!JwtUtil.verify(cacheToken, userName, passWord)) {
      String newAuthorization = JwtUtil.sign(userName, passWord);
      // 设置超时时间
      redisUtil.set(CommonConstant.PREFIX_USER_TOKEN + token, newAuthorization);
      redisUtil.expire(CommonConstant.PREFIX_USER_TOKEN + token, JwtUtil.EXPIRE_TIME *2 / 1000);
      log.info("——————————用户在线操作，更新token保证不掉线—————————jwtTokenRefresh——————— "+ token);
    }
    return true;
  }
  return false;
}

JwtUtil、redisUtil请参见附注

---

登录验证过后，我们来看权限验证：doGetAuthorizationInfo

@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
  log.info("===============Shiro权限认证开始============ [ roles、permissions]==========");
  String username = null;
  if (principals != null) {
    //这里为什么可以强转成LoginUser呢？
    //因为在登录验证时，我们new SimpleAuthenticationInfo传入的第一个参数就是LoginUser
    LoginUser sysUser = (LoginUser) principals.getPrimaryPrincipal();
    username = sysUser.getUsername();
  }

  SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();

  // 设置用户拥有的角色集合，比如“admin,test”
  //sysUserService.getUserRolesSet(username);从数据库中获取到用户所拥有的角色信息
  Set<String> roleSet = new HashSet<>();
  roleSet.add("admin");//模拟
  roleSet.add("visit");
  info.setRoles(roleSet);

  // 设置用户拥有的权限集合，比如“sys:role:add,sys:user:add”
  //sysUserService.getUserPermissionsSet(username);从数据库获取到用户的权限信息
  Set<String> permissionSet = new HashSet<>();
  permissionSet.add("sys:role:add");
  permissionSet.add("sys:user:add");
  info.addStringPermissions(permissionSet);
  log.info("===============Shiro权限认证成功==============");

  return info;
}

说明： info.setRoles(roleSet) 和 info.addStringPermissions(permissionSet)中的角色和权限应该从数据库中获取，我这边为了方便，就模拟了。

什么情况下才会进入doGetAuthorizationInfo方法呢？

答：当某个有@RequiresPermissions或者其他权限注解的方法被调用的时候，都会触发doGetAuthorizationInfo方法的调用。

如果角色权限信息每次调用都得从数据库中获取，对数据库来说压力还真的不小。所以shiro提供了缓存接口来缓存SimpleAuthorizationInfo 权限信息。

Shiro-Redis

Shiro自带支持memcache和memorycache，为了使用redis-cache，得引进一个第三方库.

<!-- shiro-redis -->
<dependency>
  <groupId>org.crazycake</groupId>
  <artifactId>shiro-redis</artifactId>
  <version>3.1.0</version>
  <exclusions>
    <exclusion>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-core</artifactId>
    </exclusion>
    <exclusion>
      <artifactId>guava</artifactId>
      <groupId>com.google.guava</groupId>
    </exclusion>
  </exclusions>
</dependency>

给SecurityManager注入redisCacheManager

@Bean("securityManager")
public DefaultWebSecurityManager securityManager() {
  DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
  ...
    省略其他
    ...
    //自定义缓存实现,使用redis
    //缓存的是doGetAuthorizationInfo(PrincipalCollection principals)过程
    //key是Principal对象--即new SimpleAuthenticationInfo(loginUser, credentials, getName())的第一个参数
    //value是doGetAuthorizationInfo返回值，默认是SimpleAuthenticationInfo
    securityManager.setCacheManager(redisCacheManager());
  return securityManager;
}

缓存的是doGetAuthorizationInfo(PrincipalCollection principals)过程。

key是Principal对象–即new SimpleAuthenticationInfo(loginUser, credentials, getName())的第一个参数

value是doGetAuthorizationInfo返回值，默认是SimpleAuthenticationInfo

实现RedisCacheManager：

@Value("${spring.redis.port}")
private String port;

@Value("${spring.redis.host}")
private String host;

@Value("${spring.redis.password}")
private String redisPassword;


public org.crazycake.shiro.RedisCacheManager redisCacheManager() {
  log.info("===============(1)创建缓存管理器RedisCacheManager");
  org.crazycake.shiro.RedisCacheManager redisCacheManager = new RedisCacheManager();
  redisCacheManager.setRedisManager(redisManager());
  //redis中针对不同用户缓存(此处的id需要对应user实体中的id字段,用于唯一标识)
  redisCacheManager.setPrincipalIdFieldName("id");
  //用户权限信息缓存时间
  redisCacheManager.setExpire(200000);
  return redisCacheManager;
}


@Bean
public RedisManager redisManager() {
  log.info("===============(2)创建RedisManager,连接Redis..URL= " + host + ":" + port);
  RedisManager redisManager = new RedisManager();
  redisManager.setHost(host);
  redisManager.setPort(Integer.valueOf(port));
  redisManager.setTimeout(0);
  if (!StringUtils.isEmpty(redisPassword)) {
    redisManager.setPassword(redisPassword);
  }
  return redisManager;
}

附注

JwtUtil

JwtUtil类需要引入依赖

<!--JWT-->
<dependency>
  <groupId>com.auth0</groupId>
  <artifactId>java-jwt</artifactId>
  <version>3.7.0</version>
</dependency>

//JwtUtil.java
/**
 * @Author Scott
 * @Date 2018-07-12 14:23
 * @Desc JWT工具类
 **/
public class JwtUtil {

	// Token过期时间30分钟（用户登录过期时间是此时间的两倍，以token在reids缓存时间为准）
	public static final long EXPIRE_TIME = 30 * 60 * 1000;

	/**
	 * 校验token是否正确
	 *
	 * @param token  **
	 * @param secret 用户的密码
	 * @return 是否正确
	 */
	public static boolean verify(String token, String username, String secret) {
		try {
			// 根据密码生成JWT效验器
			Algorithm algorithm = Algorithm.HMAC256(secret);
			JWTVerifier verifier = JWT.require(algorithm).withClaim("username", username).build();
			// 效验TOKEN
			DecodedJWT jwt = verifier.verify(token);
			return true;
		} catch (Exception exception) {
			return false;
		}
	}

	/**
	 * 获得token中的信息无需secret解密也能获得
	 *
	 * @return token中包含的用户名
	 */
	public static String getUsername(String token) {
		try {
			DecodedJWT jwt = JWT.decode(token);
			return jwt.getClaim("username").asString();
		} catch (JWTDecodeException e) {
			return null;
		}
	}

	/**
	 * 生成签名,5min后过期
	 *
	 * @param username 用户名
	 * @param secret   用户的密码
	 * @return 加密的token
	 */
	public static String sign(String username, String secret) {
		Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
		Algorithm algorithm = Algorithm.HMAC256(secret);
		// 附带username信息
		return JWT.create().withClaim("username", username).withExpiresAt(date).sign(algorithm);

	}

	/**
	 * 根据request中的token获取用户账号
	 * 
	 * @param request
	 * @return
	 */
	public static String getUserNameByToken(HttpServletRequest request){
		String accessToken = request.getHeader("X-Access-Token");
		String username = getUsername(accessToken);
		if (StringUtils.isEmpty(username)) {
			throw new HeartBeatException("未获取到用户");
		}
		return username;
	}
	
	/**
	  *  从session中获取变量
	 * @param key
	 * @return
	 */
	public static String getSessionData(String key) {
		//${myVar}%
		//得到${} 后面的值
		String moshi = "";
		if(key.indexOf("}")!=-1){
			 moshi = key.substring(key.indexOf("}")+1);
		}
		String returnValue = null;
		if (key.contains("#{")) {
			key = key.substring(2,key.indexOf("}"));
		}
		if (StringUtils.isNotEmpty(key)) {
			HttpSession session = SpringContextUtils.getHttpServletRequest().getSession();
			returnValue = (String) session.getAttribute(key);
		}
		//结果加上${} 后面的值
		if(returnValue!=null){returnValue = returnValue + moshi;}
		return returnValue;
	}
	

	public static void main(String[] args) throws Exception{
		 /*String token = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE1NjUzMzY1MTMsInVzZXJuYW1lIjoiYWRtaW4ifQ.xjhud_tWCNYBOg_aRlMgOdlZoWFFKB_givNElHNw3X0";
		 System.out.println(JwtUtil.getUsername(token));*/

		String token = JwtUtil.sign("admin", "123456");
		System.out.println(token);
	}
}

---

RedisUtil

RedisUtil需要引入依赖：

<!-- Redis -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

# application.yml
spring:
  redis:
      host: 127.0.0.1
      port: 6379
      password:
      database: 0
      lettuce:
        shutdown-timeout: 200ms
        pool:
          max-active: 7
          max-idle: 7
          min-idle: 2
          max-wait: -1ms
          required: true

//RedisConfig
@Configuration
@EnableCaching // 开启缓存支持
public class RedisConfig{

	@Autowired
	private Environment env;

	@Bean
	public LettuceConnectionFactory redisConnectionFactory() {
		RedisStandaloneConfiguration redisConf = new RedisStandaloneConfiguration();
		redisConf.setHostName(env.getProperty("spring.redis.host"));
		redisConf.setPort(Integer.parseInt(env.getProperty("spring.redis.port")));
		redisConf.setPassword(RedisPassword.of(env.getProperty("spring.redis.password")));
		return new LettuceConnectionFactory(redisConf);
	}
	/**
	 * RedisTemplate配置
	 *
	 * @param lettuceConnectionFactory
	 * @return
	 */
	@Bean
	public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
		// 配置redisTemplate
		RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
		redisTemplate.setConnectionFactory(lettuceConnectionFactory);

		// 设置序列化
		Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
		ObjectMapper om = new ObjectMapper();
		om.setVisibility(PropertyAccessor.ALL, Visibility.ANY);
		om.enableDefaultTyping(DefaultTyping.NON_FINAL);
		jackson2JsonRedisSerializer.setObjectMapper(om);
		// value序列化
		redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);

		RedisSerializer<?> stringSerializer = new StringRedisSerializer();
		// key序列化
		redisTemplate.setKeySerializer(stringSerializer);
		// Hash key序列化
		redisTemplate.setHashKeySerializer(stringSerializer);
		// Hash value序列化
		redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
		redisTemplate.afterPropertiesSet();
		return redisTemplate;
	}

	@Bean
	public RedisCacheConfiguration cacheConfiguration() {
		RedisCacheConfiguration cacheConfig = RedisCacheConfiguration.defaultCacheConfig()
				.entryTtl(Duration.ofHours(60))
				.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
				.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
				.disableCachingNullValues();
		return cacheConfig;
	}

	@Bean
	public RedisCacheManager cacheManager() {
		RedisCacheManager rcm = RedisCacheManager.builder(redisConnectionFactory())
				.cacheDefaults(cacheConfiguration())
				.transactionAware()
				.build();
		return rcm;
	}
}

//RedisUtil.java
package com.soyuan.bigdata.heartbeat.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * redis 工具类
 * @Author Scott
 *
 */
@Component
public class RedisUtil {

	@Autowired
	private RedisTemplate<String, Object> redisTemplate;

	/**
	 * 指定缓存失效时间
	 * 
	 * @param key  键
	 * @param time 时间(秒)
	 * @return
	 */
	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;
		}
	}

	/**
	 * 根据key 获取过期时间
	 * 
	 * @param key 键 不能为null
	 * @return 时间(秒) 返回0代表为永久有效
	 */
	public long getExpire(String key) {
		return redisTemplate.getExpire(key, TimeUnit.SECONDS);
	}

	/**
	 * 判断key是否存在
	 * 
	 * @param key 键
	 * @return true 存在 false不存在
	 */
	public boolean hasKey(String key) {
		try {
			return redisTemplate.hasKey(key);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 删除缓存
	 * 
	 * @param key 可以传一个值 或多个
	 */
	@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=============================
	/**
	 * 普通缓存获取
	 * 
	 * @param key 键
	 * @return 值
	 */
	public Object get(String key) {
		return key == null ? null : redisTemplate.opsForValue().get(key);
	}

	/**
	 * 普通缓存放入
	 * 
	 * @param key   键
	 * @param value 值
	 * @return true成功 false失败
	 */
	public boolean set(String key, Object value) {
		try {
			redisTemplate.opsForValue().set(key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}

	}

	/**
	 * 普通缓存放入并设置时间
	 * 
	 * @param key   键
	 * @param value 值
	 * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
	 * @return true成功 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;
		}
	}

	/**
	 * 递增
	 * 
	 * @param key 键
	 * @param by  要增加几(大于0)
	 * @return
	 */
	public long incr(String key, long delta) {
		if (delta < 0) {
			throw new RuntimeException("递增因子必须大于0");
		}
		return redisTemplate.opsForValue().increment(key, delta);
	}

	/**
	 * 递减
	 * 
	 * @param key 键
	 * @param by  要减少几(小于0)
	 * @return
	 */
	public long decr(String key, long delta) {
		if (delta < 0) {
			throw new RuntimeException("递减因子必须大于0");
		}
		return redisTemplate.opsForValue().increment(key, -delta);
	}

	// ================================Map=================================
	/**
	 * HashGet
	 * 
	 * @param key  键 不能为null
	 * @param item 项 不能为null
	 * @return 值
	 */
	public Object hget(String key, String item) {
		return redisTemplate.opsForHash().get(key, item);
	}

	/**
	 * 获取hashKey对应的所有键值
	 * 
	 * @param key 键
	 * @return 对应的多个键值
	 */
	public Map<Object, Object> hmget(String key) {
		return redisTemplate.opsForHash().entries(key);
	}

	/**
	 * HashSet
	 * 
	 * @param key 键
	 * @param map 对应多个键值
	 * @return true 成功 false 失败
	 */
	public boolean hmset(String key, Map<String, Object> map) {
		try {
			redisTemplate.opsForHash().putAll(key, map);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * HashSet 并设置时间
	 * 
	 * @param key  键
	 * @param map  对应多个键值
	 * @param time 时间(秒)
	 * @return true成功 false失败
	 */
	public boolean hmset(String key, Map<String, Object> map, long time) {
		try {
			redisTemplate.opsForHash().putAll(key, map);
			if (time > 0) {
				expire(key, time);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 向一张hash表中放入数据,如果不存在将创建
	 * 
	 * @param key   键
	 * @param item  项
	 * @param value 值
	 * @return true 成功 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;
		}
	}

	/**
	 * 向一张hash表中放入数据,如果不存在将创建
	 * 
	 * @param key   键
	 * @param item  项
	 * @param value 值
	 * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
	 * @return true 成功 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;
		}
	}

	/**
	 * 删除hash表中的值
	 * 
	 * @param key  键 不能为null
	 * @param item 项 可以使多个 不能为null
	 */
	public void hdel(String key, Object... item) {
		redisTemplate.opsForHash().delete(key, item);
	}

	/**
	 * 判断hash表中是否有该项的值
	 * 
	 * @param key  键 不能为null
	 * @param item 项 不能为null
	 * @return true 存在 false不存在
	 */
	public boolean hHasKey(String key, String item) {
		return redisTemplate.opsForHash().hasKey(key, item);
	}

	/**
	 * hash递增 如果不存在,就会创建一个 并把新增后的值返回
	 * 
	 * @param key  键
	 * @param item 项
	 * @param by   要增加几(大于0)
	 * @return
	 */
	public double hincr(String key, String item, double by) {
		return redisTemplate.opsForHash().increment(key, item, by);
	}

	/**
	 * hash递减
	 * 
	 * @param key  键
	 * @param item 项
	 * @param by   要减少记(小于0)
	 * @return
	 */
	public double hdecr(String key, String item, double by) {
		return redisTemplate.opsForHash().increment(key, item, -by);
	}

	// ============================set=============================
	/**
	 * 根据key获取Set中的所有值
	 * 
	 * @param key 键
	 * @return
	 */
	public Set<Object> sGet(String key) {
		try {
			return redisTemplate.opsForSet().members(key);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 根据value从一个set中查询,是否存在
	 * 
	 * @param key   键
	 * @param value 值
	 * @return true 存在 false不存在
	 */
	public boolean sHasKey(String key, Object value) {
		try {
			return redisTemplate.opsForSet().isMember(key, value);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将数据放入set缓存
	 * 
	 * @param key    键
	 * @param values 值 可以是多个
	 * @return 成功个数
	 */
	public long sSet(String key, Object... values) {
		try {
			return redisTemplate.opsForSet().add(key, values);
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 将set数据放入缓存
	 * 
	 * @param key    键
	 * @param time   时间(秒)
	 * @param values 值 可以是多个
	 * @return 成功个数
	 */
	public long sSetAndTime(String key, long time, Object... values) {
		try {
			Long count = redisTemplate.opsForSet().add(key, values);
			if (time > 0) {
				expire(key, time);
			}
			return count;
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 获取set缓存的长度
	 * 
	 * @param key 键
	 * @return
	 */
	public long sGetSetSize(String key) {
		try {
			return redisTemplate.opsForSet().size(key);
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 移除值为value的
	 * 
	 * @param key    键
	 * @param values 值 可以是多个
	 * @return 移除的个数
	 */
	public long setRemove(String key, Object... values) {
		try {
			Long count = redisTemplate.opsForSet().remove(key, values);
			return count;
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}
	// ===============================list=================================

	/**
	 * 获取list缓存的内容
	 * 
	 * @param key   键
	 * @param start 开始
	 * @param end   结束 0 到 -1代表所有值
	 * @return
	 */
	public List<Object> lGet(String key, long start, long end) {
		try {
			return redisTemplate.opsForList().range(key, start, end);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 获取list缓存的长度
	 * 
	 * @param key 键
	 * @return
	 */
	public long lGetListSize(String key) {
		try {
			return redisTemplate.opsForList().size(key);
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}

	/**
	 * 通过索引 获取list中的值
	 * 
	 * @param key   键
	 * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
	 * @return
	 */
	public Object lGetIndex(String key, long index) {
		try {
			return redisTemplate.opsForList().index(key, index);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 将list放入缓存
	 * 
	 * @param key   键
	 * @param value 值
	 * @param time  时间(秒)
	 * @return
	 */
	public boolean lSet(String key, Object value) {
		try {
			redisTemplate.opsForList().rightPush(key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将list放入缓存
	 * 
	 * @param key   键
	 * @param value 值
	 * @param time  时间(秒)
	 * @return
	 */
	public boolean lSet(String key, Object value, long time) {
		try {
			redisTemplate.opsForList().rightPush(key, value);
			if (time > 0) {
				expire(key, time);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将list放入缓存
	 * 
	 * @param key   键
	 * @param value 值
	 * @param time  时间(秒)
	 * @return
	 */
	public boolean lSet(String key, List<Object> value) {
		try {
			redisTemplate.opsForList().rightPushAll(key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将list放入缓存
	 * 
	 * @param key   键
	 * @param value 值
	 * @param time  时间(秒)
	 * @return
	 */
	public boolean lSet(String key, List<Object> value, long time) {
		try {
			redisTemplate.opsForList().rightPushAll(key, value);
			if (time > 0) {
				expire(key, time);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 根据索引修改list中的某条数据
	 * 
	 * @param key   键
	 * @param index 索引
	 * @param value 值
	 * @return
	 */
	public boolean lUpdateIndex(String key, long index, Object value) {
		try {
			redisTemplate.opsForList().set(key, index, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 移除N个值为value
	 * 
	 * @param key   键
	 * @param count 移除多少个
	 * @param value 值
	 * @return 移除的个数
	 */
	public long lRemove(String key, long count, Object value) {
		try {
			Long remove = redisTemplate.opsForList().remove(key, count, value);
			return remove;
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}
}