欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Shiro+JWT 前后端分离方案

程序员文章站 2024-03-20 18:54:40
...

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,重写两个方法:doGetAuthorizationInfodoGetAuthenticationInfo

我们先来看登录验证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 tokencredentialSimpleAuthenticationInfocredential 进行比较,但是呢,你仔细观察一下就知道,我们传给SimpleAuthenticationInfocredential 其实就是 AuthenticationToken tokencredential,所以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())的第一个参数

valuedoGetAuthorizationInfo返回值,默认是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;
		}
	}
}