Shiro和SpringBoot简单集成

Shiro是一种简单的安全框架，可以用来处理系统的登录和权限问题。
本篇记录一下Spring Boot和Shiro集成，并使用Jwt Token进行无状态登录的简单例子。
参考Demo地址，此Demo适合用于SpringBoot小型项目的快速开发。

环境

SpringBoot 版本 1.5.15.RELEASE
不建议使用2.x版本的Springboot，与1.x相比很多地方代码有所改动，很麻烦。
Shiro 版本 1.4.0
IntelliJ IDEA
jjwt 版本 0.9.0
lombok（可选）精简代码

思路

使用Jwt Token实现无状态登录
平时用户登录后，服务器将会把用户信息存储到Session里，在用户数量很大的时候，服务器负担会很大。而使用token方式登录，服务器不存储用户信息，而是将其加密后生成token发送给请求方，请求方在请求需要权限的资源时，将token带上，服务器解析token即可知道登录用户的信息。
服务器自动刷新token
token需要刷新。对于活跃的用户，服务器自动完成刷新token；对于长期不活跃的用户，服务器通过配置的 token有效期 来检查，如果时间超过有效期的两倍，则认为该用户需要重新登录。
登录流程
- 用户通过账号密码登录
  用户登录成功后，服务器将用户信息等集合起来做成Jwt Token（字符串），然后将其放入Response里的header，并发送请求成功的json给请求方。
  请求方接收到请求成功的json信息后，从header中拿出jwt token存储起来。
- 用户请求需要验证的资源
  请求方将token放入request的header，并发送请求。
  服务器收到请求，检查request里的token，首先验证token合法性，不合法返回token不合法的json给请求方。
  如果token合法，则检查token是否过期：
  如果token签发时间到现在，已经超过了有效期，却没有超过有效期的两倍，则服务器自动生成新token，将其放入response的header，请求方接收到response后，可以检查header里是否有token，有则更新一下token预备下次请求。
  如果token从签发时间到现在，已经超过有效期的两倍，则用户需要重新登录。

集成步骤

注意

@Slf4j(topic = "xxx")注解是lombok集成的日志模块，可不使用，参考：日志处理方案

数据库建表

思路：
系统里有多个角色，每个角色对于多个权限。每个权限都是一个请求url，验证权限时，后台拿到用户信息后即可知道该用户的角色，而后去数据库查询该角色所拥有的权限集合，在其中查找是否存在当前请求url，存在说明用户有访问该url的权限，否则没有权限

-- Sql
-- Mysql Version 5.7
-- author 1802226517@qq.comdrop database if exists `rb_demo`;
CREATE DATABASE rb_demoDEFAULT CHARACTER SET utf8COLLATE utf8_general_ci;
USE rb_demo;-- ------------------------------ 用户部分 ------------------------------DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (`id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '主键',`account` VARCHAR(50) NOT NULL COMMENT '账号，唯一',`password` VARCHAR(100) NOT NULL COMMENT '密码',`name` VARCHAR(100) DEFAULT '默认用户名' COMMENT '昵称',`role_id` BIGINT UNSIGNED NOT NULL COMMENT '所属角色id',`status` TINYINT UNSIGNED NOT NULL COMMENT '是否启用',`is_deleted` TINYINT UNSIGNED NOT NULL COMMENT '是否删除',`version` BIGINT UNSIGNED NOT NULL COMMENT '版本',`gmt_create` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',`gmt_modified` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',PRIMARY KEY (`id`),KEY `idx_id` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户表';DROP TABLE IF EXISTS `role`;
CREATE TABLE `role` (`id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '主键',`name` VARCHAR(200) NOT NULL COMMENT '角色名称',`version` BIGINT UNSIGNED NOT NULL COMMENT '版本',PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='角色表';DROP TABLE IF EXISTS `permission`;
CREATE TABLE `permission` (`id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '主键',`role_id` BIGINT UNSIGNED NOT NULL COMMENT '所属角色id',`name` VARCHAR(200) NOT NULL COMMENT '权限名称',`url` VARCHAR(200) NOT NULL COMMENT '匹配url',`version` BIGINT UNSIGNED NOT NULL COMMENT '版本',PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='权限表';

建立Springboot项目

组件选择 web、redis和lombok，Springboot版本选择 1.5.15.RELEASE
连接数据库参考：Mybatis-Plus

编写Shiro配置类

ShiroConfig.java 这个配置类主要配置了Shiro拦截器、自定义的Realm和禁用了Session。
禁用Session方法参考代码注释。
为什么要禁用？因为我们采用Jwt Token方式完成登录验证，不需要存用户信息到Session。

package com.spz.demo.security.shiro.config;import com.spz.demo.security.shiro.filter.ShiroLoginFilter;
import com.spz.demo.security.shiro.matcher.PasswordCredentialsMatcher;
import com.spz.demo.security.shiro.realm.UserRealm;
import com.spz.demo.security.shiro.token.UserAuthenticationToken;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.mgt.DefaultSessionStorageEvaluator;
import org.apache.shiro.mgt.DefaultSubjectDAO;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.session.mgt.DefaultSessionManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.mgt.DefaultWebSubjectFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.servlet.Filter;
import java.util.*;/*** Shiro 配置* 禁用 Shiro Session 步骤：*      1. SubjectContext 在创建的时候，需要关闭 session 的创建，这个由 DefaultWebSubjectFactory.createSubject 管理。*          参考自定义类：ASubjectFactory.java*      2. 禁用使用 Sessions 作为存储策略的实现，这个由 securityManager 的 subjectDao.sessionStorageEvaluator 管理*      3. 禁用掉会话调度器，这个由 sessionManager 管理*/
@Slf4j(topic = "SYSTEM_LOG")
@Configuration
public class ShiroConfig {@Autowiredprivate UserRealm userRealm;/*** Shiro 安全管理器*/@Beanpublic DefaultWebSecurityManager securityManager() {DefaultWebSecurityManager manager = new DefaultWebSecurityManager();// 设置自定义的 SubjectFactorymanager.setSubjectFactory(subjectFactory());// 设置自定义的 SessionManagermanager.setSessionManager(sessionManager());// 禁用 Session((DefaultSessionStorageEvaluator)((DefaultSubjectDAO)manager.getSubjectDAO()).getSessionStorageEvaluator()).setSessionStorageEnabled(false);// 设置自定义的 Realmmanager.setRealms(getRealms());return manager;}/*** 设置过滤规则*/@Beanpublic ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();shiroFilterFactoryBean.setSecurityManager(securityManager);//自定义拦截器 参考 ShiroLoginFilter.javaMap<String, Filter> filtersMap = new LinkedHashMap<String, Filter>();filtersMap.put("shiroLoginFilter", new ShiroLoginFilter());//登录验证拦截器shiroFilterFactoryBean.setFilters(filtersMap);// 所有请求给这个拦截器处理Map<String,String> filterChainDefinitionMap = new LinkedHashMap<String,String>();filterChainDefinitionMap.put("/**", "shiroLoginFilter");shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);return shiroFilterFactoryBean;}/*** 自定义的 subjectFactory* 禁用了 Session* @return*/@Beanpublic DefaultWebSubjectFactory subjectFactory(){ASubjectFactory mySubjectFactory = new ASubjectFactory();return mySubjectFactory;}/*** session管理器* 禁用了 Session* sessionManager通过sessionValidationSchedulerEnabled禁用掉会话调度器，* @return*/@Beanpublic DefaultSessionManager sessionManager(){DefaultSessionManager sessionManager = new DefaultSessionManager();sessionManager.setSessionValidationSchedulerEnabled(false);return sessionManager;}/*** 配置自定义的 Realm* @return*/@Beanpublic Collection<Realm> getRealms(){Collection<Realm> realms = new ArrayList<>();// 配置自定义 UserRealm// 由于UserRealm里使用了自动注入，所以这里需要注入Realm而不是new新建userRealm.setAuthenticationTokenClass(UserAuthenticationToken.class);userRealm.setCredentialsMatcher(new PasswordCredentialsMatcher());//使用自定义的密码匹配器realms.add(userRealm);return realms;}
}

ASubjectFactory.java 和ShiroConfig配套使用，用于禁用Session。

package com.spz.demo.security.shiro.config;import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.mgt.DefaultSessionStorageEvaluator;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.subject.SubjectContext;
import org.apache.shiro.web.mgt.DefaultWebSubjectFactory;/*** 自定义的 SubjectFactory* 禁用Session* 对于无状态的TOKEN不创建session 这里都不使用session*/
public class ASubjectFactory extends DefaultWebSubjectFactory {@Overridepublic Subject createSubject(SubjectContext context) {context.setSessionCreationEnabled(Boolean.FALSE);return super.createSubject(context);}
}

编写自定义Shiro拦截器

ShiroLoginFilter.java

Message类是包装返回给请求方的类，需要将Message实例转为json输出到Response输出流，参考：[SpringMVC] Web层返回值包装JSON
WebUtil.isPublicRequest()方法判断请求是否为公共请求
建议将不需要验证权限的请求设置一个前缀，比如/public/，这样，isPublicRequest方法就可以检查请求url里是否有/public，有则说明是公共请求，直接放行。
所有请求(公共请求除外)都给* onAccessDenied*方法处理
在onAccessDenied方法里，通过检查请求url的方式来得知当前请求是什么类型的请求。
如果是登录请求，则直接放行，因为登录逻辑放在了controller层方法。
如果是其他请求，则需要验证登录和权限。
检查用户是否具备权限
将请求url和permission表里的url进行匹配，如果存在匹配，则说明有权限。

package com.spz.demo.security.shiro.filter;import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.spz.demo.security.bean.Message;
import com.spz.demo.security.common.MessageCode;
import com.spz.demo.security.common.RequestMappingConst;
import com.spz.demo.security.common.WebConst;
import com.spz.demo.security.entity.Role;
import com.spz.demo.security.exception.custom.RoleException;
import com.spz.demo.security.util.CommonUtil;
import com.spz.demo.security.util.JwtUtil;
import com.spz.demo.security.util.WebUtil;
import com.spz.demo.security.vo.JwtToken;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.web.filter.AccessControlFilter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;/*** 重写shiro拦截器* 所有请求由此拦截器拦截*/
@Slf4j(topic = "USER_LOG")
@Component
public class ShiroLoginFilter extends AccessControlFilter {//由于项目启动时，Shiro加载比其他bean快，所以这里需要加入Lazy注解，在使用时再加载。否则会出现jwtUtil为null的情况@Autowired@Lazyprivate JwtUtil jwtUtil;@Overrideprotected boolean isAccessAllowed(ServletRequest request,ServletResponse response, Object mappedValue) {// 判断请求是否是公共请求，通过请求的url判断if(WebUtil.isPublicRequest((HttpServletRequest) request)){return true;}return false;//  拒绝，统一交给 onAccessDenied 处理}@Overrideprotected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {HttpServletRequest httpServletRequest = (HttpServletRequest)request;HttpServletResponse httpServletResponse = (HttpServletResponse) response;// ========== 判断是否是登录请求，是就放行，登录处理放在了controller层 ==========if(WebUtil.isLoginRequest(httpServletRequest)){return true;}// ========== 其他请求，都需要验证 ==========//验证是否登录（检查json token）if(CommonUtil.isBlank(httpServletRequest.getHeader(WebConst.TOKEN))){// 返回JSON给请求方WebUtil.writeStringToResponse(httpServletResponse,JSON.toJSONString(new Message().setErrorMessage("[" + WebConst.TOKEN +  "] 不能为空，请将token存入header")));return false;}String token = httpServletRequest.getHeader(WebConst.TOKEN);JwtToken jwtToken;try {jwtToken = jwtUtil.parseJwt(token);}catch (RoleException re){//出现异常，说明验证失败Message message = new Message();if(re.getMessage().equals(RoleException.MSG_TOKEN_ERROR)){//token错误异常message.setMessage(MessageCode.TOKEN_ERROR,RoleException.MSG_TOKEN_ERROR);}else{//token过期异常message.setMessage(MessageCode.TOKEN_OVERDUE,RoleException.MSG_TOKEN_OVERDUE);}WebUtil.writeStringToResponse((HttpServletResponse) response,JSON.toJSONString(message));//返回jsonreturn false;}if(jwtToken.getIsFlushed()){//需要刷新tokenhttpServletResponse.setHeader(WebConst.TOKEN,jwtToken.getToken());// 更新response}// 检查用户是否具备权限if(!jwtToken.hasUrl(((HttpServletRequest) request).getRequestURI())){WebUtil.writeStringToResponse((HttpServletResponse) response,JSON.toJSONString(new Message().setPermissionDeniedMessage("没有权限")));return false;}else{//登录验证通过return true;}}
}

编写自定义的 Realm 类

Realm类用来给shiro注入认证信息和授权信息，我们需要自定义。
@Value("${jwt.salt}")是从application.yml中读取配置

package com.spz.demo.security.shiro.realm;import com.spz.demo.security.common.DatabaseConst;
import com.spz.demo.security.entity.User;
import com.spz.demo.security.service.UserService;
import com.spz.demo.security.shiro.token.UserAuthenticationToken;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;@Slf4j(topic = "USER_LOG")
@Component("userRealm")
public class UserRealm extends AuthorizingRealm{@Autowiredprivate UserService userService;@Value("${jwt.salt}")private String jwtSalt;private static final String DEFAULT_JWT_SALT = "asdfh2738yWsdjDfha";//默认的盐/*** 授权处理* 不使用* @param principals* @return*/@Overrideprotected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {return null;}/*** 身份认证*/@Overrideprotected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {// 获取用户String account = (String) authenticationToken.getPrincipal();//这里的user里只有账号和未加密的密码User user = userService.getUserByAccount(account,DatabaseConst.STATUS_ENABLE,DatabaseConst.IS_DETETED_NO);if (user  == null) {return null;}else{//这里这样做是因为我需要在web层可以拿到userID((UserAuthenticationToken)authenticationToken).setUserId(user.getId());//赋值userId}return new SimpleAuthenticationInfo(user,user.getPassword().toCharArray(),ByteSource.Util.bytes((jwtSalt == null ? DEFAULT_JWT_SALT: jwtSalt)),//盐getName());}
}

编写自定义的 Matcher 类

AuthenticatingRealm使用CredentialsMatcher进行密码匹配，我们需要自定义

package com.spz.demo.security.shiro.matcher;import com.spz.demo.security.entity.User;
import com.spz.demo.security.shiro.token.UserAuthenticationToken;
import com.spz.demo.security.util.CommonUtil;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.credential.CredentialsMatcher;/*** 改写原有的密码匹配器* 用于账号密码登录时的账密匹配*/
public class PasswordCredentialsMatcher implements CredentialsMatcher {@Overridepublic boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) {//账号密码登录，则token应该是自定义的 AccountPasswordAuthenticationTokenif(token instanceof UserAuthenticationToken){//这里检查账号和密码是否匹配//token是登录接口那里获取的，info是通过account获取到数据里的信息//密码需要进行md5处理，因为数据库存储的密码为密文if(info.getPrincipals().getPrimaryPrincipal() instanceof User){User user = (User)info.getPrincipals().getPrimaryPrincipal();if(token.getPrincipal().equals(user.getAccount()) &&CommonUtil.md5((String) token.getCredentials()).equals(user.getPassword())){return true;}}}return false;}
}

编写自定义的AuthenticationToken类

package com.spz.demo.security.shiro.token;import com.spz.demo.security.entity.User;
import lombok.Data;
import org.apache.shiro.authc.AuthenticationToken;/*** 用于登录* 登录时给此类的account和password(明文)赋值* 然后在UserRealm里将查询到的userId赋值给此类里的userId。controller层需要id*/
@Data
public class UserAuthenticationToken implements AuthenticationToken {private Long userId;//用户在数据库中的idprivate String account;private String password;public UserAuthenticationToken(String account, String password){this.account = account;this.password = password;}/*** 返回 account* @return*/@Overridepublic Object getPrincipal() {return this.account;}/*** 返回 password* @return*/@Overridepublic Object getCredentials() {return this.password;}
}

编写Jwt Token工具类

package com.spz.demo.security.util;import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.spz.demo.security.exception.custom.RoleException;
import com.spz.demo.security.vo.JwtToken;
import io.jsonwebtoken.*;
import io.jsonwebtoken.impl.DefaultHeader;
import io.jsonwebtoken.impl.DefaultJwsHeader;
import io.jsonwebtoken.impl.TextCodec;
import io.jsonwebtoken.impl.compression.DefaultCompressionCodecResolver;
import io.jsonwebtoken.lang.Assert;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import sun.java2d.pipe.AlphaPaintPipe;import javax.swing.event.CaretListener;
import javax.xml.bind.DatatypeConverter;
import java.io.IOException;
import java.util.*;/*** jwt 工具类** @author zp*/
@Slf4j(topic = "SYSTEM_LOG")
@Component
public class JwtUtil {@Value("${jwt.appKey}")private String appKey;//app key，用于加密@Value("${jwt.period}")private Long period;//token有效时间@Value(("${jwt.issuer}"))private String issuer;//jwt token 签发人public static final long DEFAULT_PERIOD = 60*60*1000;//token默认有效时间，1小时public static final String DEFAULT_APPKEY = "defaultAppKey";//默认appkey，配置文件里读不到appKey时用此值public static final String DEFAULT_ISSUER = "Server-System-2333";//默认签发人private static final ObjectMapper MAPPER = new ObjectMapper();private static  CompressionCodecResolver codecResolver = new DefaultCompressionCodecResolver();/*** 签发 JWT Token Token* @param id 令牌ID* @param subject subject 用户ID* @param issuer 签发人，自定义* @param roles 角色* @param permissions 权限集合，建议传入权限集合的json字符串* @param period 有效时间(ms)*               1. 在 当前时间-签发时间>有效时间 时携带token访问接口，会重新刷新token*                  在 当前时间-签发时间>有效时间*2 时，则需要重新登录。*               2. 这样可以分离长时间不活跃的用户和活跃用户*                  活跃用户感受不到token的刷新*                  不活跃用户需要登录才可以重新获取token* @param algorithm 加密算法* @return*/public String issueJWT(String id,String subject,String issuer,String roles,String permissions,Long period,SignatureAlgorithm algorithm) {// 需要读取appKeyif(appKey == null || appKey.equals("")){log.error("appKey无法读取：" + appKey);appKey = DEFAULT_APPKEY;}byte[] secreKeyBytes = DatatypeConverter.parseBase64Binary(appKey);// 秘钥JwtBuilder jwtBuilder = Jwts.builder();if (!StringUtils.isEmpty(id)) {jwtBuilder.setId(id);}if (!StringUtils.isEmpty(subject)) {jwtBuilder.setSubject(subject);}if (!StringUtils.isEmpty(issuer)) {jwtBuilder.setIssuer(issuer);}// 设置签发时间Date now = new Date();jwtBuilder.setIssuedAt(now);// 设置到期时间if (null != period) {jwtBuilder.setExpiration(new Date(now.getTime() + period + period)//签发时间+有效期*2);}if (!StringUtils.isEmpty(roles)) {jwtBuilder.claim("roles",roles);}if (!StringUtils.isEmpty(permissions)) {jwtBuilder.claim("perms",permissions);}// 压缩，可选GZIPjwtBuilder.compressWith(CompressionCodecs.DEFLATE);// 加密设置jwtBuilder.signWith(algorithm,secreKeyBytes);return jwtBuilder.compact();}/*** 验签JWT** @param jwt json web token* @return 如果验证通过，且刷新了token，则设置 JwtToken.isFlushed 为true*/public JwtToken parseJwt(String jwt) throws RoleException {if(appKey == null || appKey.equals("")){log.error("appKey无法读取：" + appKey);appKey = DEFAULT_APPKEY;}// 检查 jwt token 合法性Claims claims;try{claims = Jwts.parser().setSigningKey(DatatypeConverter.parseBase64Binary(appKey)).parseClaimsJws(jwt).getBody();}catch (ExpiredJwtException ex){//token过期异常 token已经失效需要重新登录throw new RoleException(RoleException.MSG_TOKEN_OVERDUE);}catch (SignatureException | UnsupportedJwtException | MalformedJwtException | IllegalArgumentException e){//不支持的tokenthrow new RoleException(RoleException.MSG_TOKEN_ERROR);}catch (Exception e){log.error("验证token时出现未知错误: " + CommonUtil.getDetailExceptionMsg(e));throw new RoleException(RoleException.MSG_UNKNOWN_ERROR);}JwtToken jwtToken = new JwtToken();// 检查是否需要刷新 jwt tokenlong time = claims.getIssuedAt().getTime();//token签发时间long now = new Date().getTime();//当前时间period = (period == null ? JwtUtil.DEFAULT_PERIOD : period);if(time + period >= now){//还在有效期内，不需要刷新token
//            log.info("不需要刷新token");jwtToken.setToken(jwt);jwtToken.setIsFlushed(false);}else if(time + period < now &&//超过有效期，但未超过2倍有效期，此时应该刷新tokentime + period + period >= now){
//            log.info("刷新token");jwtToken.setToken(issueJWT(// 制作JWT TokenCommonUtil.getRandomString(20),//令牌idclaims.getSubject(),//用户id(issuer == null ? DEFAULT_ISSUER : issuer),//签发人claims.get("roles", String.class),//访问角色,设置为null，不使用claims.get("perms", String.class),//权限集合字符串，jsonperiod,//token有效时间*2SignatureAlgorithm.HS512));jwtToken.setIsFlushed(true);}else{log.error("未知错误 - Jwts.parser() 方法未对过期token抛出异常");}// 设置其他字段jwtToken.setId(claims.getSubject());//用户idjwtToken.setPermissions(JSONObject.parseObject(claims.get("perms", String.class),List.class));//用户权限集合,json转为list集合return jwtToken;}/* ** @Description* @Param [val] 从json数据中读取格式化map* @Return java.util.Map<java.lang.String,java.lang.Object>*/@SuppressWarnings("unchecked")public static Map<String, Object> readValue(String val) {try {return MAPPER.readValue(val, Map.class);} catch (IOException e) {throw new MalformedJwtException("Unable to read JSON value: " + val, e);}}
}

controller登录验证

package com.spz.demo.security.controller;import com.alibaba.fastjson.JSONArray;
import com.spz.demo.security.bean.Message;
import com.spz.demo.security.common.MessageKeyConst;
import com.spz.demo.security.common.RedisConst;
import com.spz.demo.security.common.RequestMappingConst;
import com.spz.demo.security.common.WebConst;
import com.spz.demo.security.entity.Permission;
import com.spz.demo.security.entity.User;
import com.spz.demo.security.service.UserService;
import com.spz.demo.security.shiro.token.UserAuthenticationToken;
import com.spz.demo.security.util.CommonUtil;
import com.spz.demo.security.util.JwtUtil;
import com.spz.demo.security.util.RedisUtil;
import com.spz.demo.security.util.WebUtil;
import com.spz.demo.security.vo.JwtToken;
import io.jsonwebtoken.SignatureAlgorithm;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.subject.Subject;
import org.hibernate.validator.constraints.NotEmpty;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;@Slf4j(topic = "USER_LOG")
@RestController
public class UserController {@Value("${jwt.period}")private Long period;//token有效时间（毫秒）@Value(("${jwt.issuer}"))private String issuer;//jwt token 签发人@Autowiredprivate JwtUtil jwtUtil;@Autowiredprivate UserService userService;/*** 用户登录* 验证码校验和请求参数校验功能已去除，完整版参考Demo* @return*/@PostMapping(value = RequestMappingConst.LOGIN)public Message login(String account,String password,HttpServletRequest request,HttpServletResponse response)throws Exception{// 使用 Shiro 进行登录Subject subject = SecurityUtils.getSubject();UserAuthenticationToken token = new UserAuthenticationToken(account,password);subject.login(token);// 登录成功后，获取userid，查询该用户拥有的权限List<String> permissions =  userService.getUserPermissions(token.getUserId());// 制作JWT TokenString jwtToken = jwtUtil.issueJWT(CommonUtil.getRandomString(20),//令牌id，必须为整个系统唯一idtoken.getUserId() + "",//用户id(issuer == null ? JwtUtil.DEFAULT_ISSUER : issuer),//签发人，可随便定义null,//访问角色JSONArray.toJSONString(permissions),//用户权限集合，json格式(period == null ? JwtUtil.DEFAULT_PERIOD : period),//token有效时间SignatureAlgorithm.HS512//签名算法，我也不知道是啥来的);//token存入 response里的Headerresponse.setHeader(WebConst.TOKEN,jwtToken);// 返回Message的jsonMessage message = new Message().setSuccessMessage("登录成功，token已存入header");message.getData().put("account",account);message.getData().put(MessageKeyConst.LOGIN_TIME,new Date().getTime());log.info("用户登录成功 ip=" + WebUtil.getIpAdrress(request));return message;}
}

POM文件参考

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.spz.demo</groupId><artifactId>security</artifactId><version>0.0.1-SNAPSHOT</version><packaging>jar</packaging><name>security</name><description>登录和权限demo，适用于小项目</description><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>1.5.15.RELEASE</version><relativePath/> <!-- lookup parent from repository --></parent><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding><java.version>1.8</java.version><fastjson.version>1.2.38</fastjson.version><mybatisplus.version>2.2.0</mybatisplus.version></properties><dependencies><!--json--><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>${fastjson.version}</version></dependency><!-- Mybatis Plus --><dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-boot-starter</artifactId><version>${mybatisplus.version}</version></dependency><!-- Mybatis 代码生成器（模板引擎） --><dependency><groupId>org.apache.velocity</groupId><artifactId>velocity</artifactId><version>1.7</version></dependency><dependency><groupId>org.freemarker</groupId><artifactId>freemarker</artifactId><version>2.3.28</version></dependency><!-- redis --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><!-- Kaptcha验证码框架 --><dependency><groupId>com.github.axet</groupId><artifactId>kaptcha</artifactId><version>0.0.9</version></dependency><!-- apache --><dependency><groupId>commons-codec</groupId><artifactId>commons-codec</artifactId><version>1.11</version></dependency><!-- json 用于web层包装请求返回--><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId><version>2.7.4</version></dependency><!-- lombok 精简代码用 --><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.0</version><scope>provided</scope></dependency><!-- Jwt --><dependency><groupId>io.jsonwebtoken</groupId><artifactId>jjwt</artifactId><version>0.9.0</version></dependency><!-- shiro --><dependency><groupId>org.apache.shiro</groupId><artifactId>shiro-spring-boot-starter</artifactId><version>1.4.0</version></dependency><!-- Mysql --><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.47</version></dependency><!-- AOP --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>

application.yml参考

spring:# AOP Configaop:auto: trueredis:host: 127.0.0.1password:port: 6379database: 0datasource:url: jdbc:mysql://xxx.xx.xx.xxx:3306/rb_demo?useUnicode=true&characterEncoding=UTF-8username: rootpassword:driver-class-name: com.mysql.jdbc.Driver# Jwt Token相关配置
jwt:appKey: ds[W&dsfa:dfhu12a%W@ // app秘钥，随便定义即可appId: 210293ajkw723o@7eh*db //appId，随便定义即可period: 120000 # 有效期，单位msissuer: Server-System # 签发者，用于制作 jwt tokensalt: salt-sdwbhx23i # 盐，随便定义即可,  view UserRealm.doGetAuthenticationInfo()# Mybatis-Plus 配置，请参考官方文档
mybatis-plus:mapper-locations: classpath:/mapper/*Mapper.xmltypeAliasesPackage: com.spz.demo.security.entityglobal-config:id-type: 2field-strategy: 0db-column-underline: truerefresh-mapper: trueconfiguration:map-underscore-to-camel-case: truecache-enabled: true

工具类参考

通用工具类

package com.spz.demo.security.util;import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;import java.security.MessageDigest;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;/* ** @Author tomsun28* @Description 高频方法工具类* @Date 14:08 2018/3/12*/
@Slf4j(topic = "SYSTEM_LOG")
public class CommonUtil {/*** 获取指定位数的随机数* @param length* @return*/public static String getRandomString(int length) {String base = "abcdefghijklmnopqrstuvwxyz0123456789";Random random = new Random();StringBuilder sb = new StringBuilder();for (int i = 0; i < length; i++) {int number = random.nextInt(base.length());sb.append(base.charAt(number));}return sb.toString();}/*** MD5加密* @param content* @return*/public static String md5(String content) {// 用于加密的字符char[] md5String = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};try {// 使用平台默认的字符集将md5String编码为byte序列,并将结果存储到一个新的byte数组中byte[] byteInput = content.getBytes();// 信息摘要是安全的单向哈希函数,它接收任意大小的数据,并输出固定长度的哈希值MessageDigest mdInst = MessageDigest.getInstance("MD5");// MessageDigest对象通过使用update方法处理数据,使用指定的byte数组更新摘要mdInst.update(byteInput);//摘要更新后通过调用digest() 执行哈希计算,获得密文byte[] md = mdInst.digest();//把密文转换成16进制的字符串形式int j = md.length;char[] str = new char[j*2];int k = 0;for (int i=0;i<j;i++) {byte byte0 = md[i];str[k++] = md5String[byte0 >>> 4 & 0xf];str[k++] = md5String[byte0 & 0xf];}// 返回加密后的字符串return new String(str);}catch (Exception e) {log.error("加密出现错误：" + e.toString());return null;}}/*** 分割字符串进SET*/@SuppressWarnings("unchecked")public static Set<String> split(String str) {Set<String> set = new HashSet<>();if (StringUtils.isEmpty(str))return set;set.addAll(CollectionUtils.arrayToList(str.split(",")));return set;}/*** 检查字符串是否为空* @param str* @return*/public static boolean isBlank(String str){return (str == null || str.equals("") ? true : false);}
}

Web请求工具类

package com.spz.demo.security.util;import com.spz.demo.security.common.RedisConst;
import com.spz.demo.security.common.RequestMappingConst;
import org.apache.commons.lang.StringUtils;import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;public class WebUtil {/*** 检查url是否需要登录验证* @param url* @return false 不需要登录即可访问*         true  需要登录才可以访问*/public static boolean needLogin(String url){if(url.indexOf(RequestMappingConst.V_CODE) >= 0 || //验证码url.indexOf(RequestMappingConst.LOGIN) >= 0){//登录return false;}return true;}/*** 获取Ip地址* @param request* @return*/public static String getIpAdrress(HttpServletRequest request) {String Xip = request.getHeader("X-Real-IP");String XFor = request.getHeader("X-Forwarded-For");if (StringUtils.isNotEmpty(XFor) && !"unKnown".equalsIgnoreCase(XFor)) {//多次反向代理后会有多个ip值，第一个ip才是真实ipint index = XFor.indexOf(",");if (index != -1) {return XFor.substring(0,index);} else {return XFor;}}XFor = Xip;if (StringUtils.isNotEmpty(XFor) && !"unKnown".equalsIgnoreCase(XFor)) {return XFor;}if (StringUtils.isBlank(XFor) || "unknown".equalsIgnoreCase(XFor)) {XFor = request.getHeader("Proxy-Client-IP");}if (StringUtils.isBlank(XFor) || "unknown".equalsIgnoreCase(XFor)) {XFor = request.getHeader("WL-Proxy-Client-IP");}if (StringUtils.isBlank(XFor) || "unknown".equalsIgnoreCase(XFor)) {XFor = request.getHeader("HTTP_CLIENT_IP");}if (StringUtils.isBlank(XFor) || "unknown".equalsIgnoreCase(XFor)) {XFor = request.getHeader("HTTP_X_FORWARDED_FOR");}if (StringUtils.isBlank(XFor) || "unknown".equalsIgnoreCase(XFor)) {XFor = request.getRemoteAddr();}return XFor;}/*** 检查请求是否为登录请求* @param request* @return*/public static boolean isLoginRequest(HttpServletRequest request) {if(request.getRequestURI().indexOf(RequestMappingConst.LOGIN) >= 0){return true;}return false;}/*** 检查请求是否为注销请求* @param request* @return*/public static boolean isLogoutRequest(HttpServletRequest request) {if(request.getRequestURI().indexOf(RequestMappingConst.LOGOUT) >= 0){return true;}return false;}/*** 检查请求是否为公共请求* @param request* @return*/public static boolean isPublicRequest(HttpServletRequest request) {if(request.getRequestURI().indexOf(RequestMappingConst.BASIC_URL_PUBLIC) >= 0){return true;}return false;}/*** 输出json字符串到 HttpServletResponse* @param response* @param str : 字符串*/public static void writeJSONToResponse(HttpServletResponse response, String str){PrintWriter jsonOut = null;response.setContentType("application/json;charset=UTF-8");try {jsonOut = response.getWriter();jsonOut.write(str);}catch (Exception e){e.printStackTrace();}finally{if(jsonOut != null){jsonOut.close();}}}
}

参考文章

签发的用户认证token超时刷新策略
shiro实现手机验证码登录
SpringBoot 集成无状态的 Shiro