热门搜索:
您现在的位置是：首页 > 文章详情

Shiro和SpringBoot简单集成

日期：2018-09-09点击：329

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（可选）精简代码

思路

  1. 使用Jwt Token实现无状态登录
    平时用户登录后，服务器将会把用户信息存储到Session里，在用户数量很大的时候，服务器负担会很大。而使用token方式登录，服务器不存储用户信息，而是将其加密后生成token发送给请求方，请求方在请求需要权限的资源时，将token带上，服务器解析token即可知道登录用户的信息。

  2. 服务器自动刷新token
    token需要刷新。对于活跃的用户，服务器自动完成刷新token；对于长期不活跃的用户，服务器通过配置的 token有效期 来检查，如果时间超过有效期的两倍，则认为该用户需要重新登录。

  3. 登录流程

    • 用户通过账号密码登录
      用户登录成功后，服务器将用户信息等集合起来做成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.com drop database if exists `rb_demo`; CREATE DATABASE rb_demo DEFAULT CHARACTER SET utf8 COLLATE 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 { @Autowired private UserRealm userRealm; /** * Shiro 安全管理器 */ @Bean public DefaultWebSecurityManager securityManager() { DefaultWebSecurityManager manager = new DefaultWebSecurityManager(); // 设置自定义的 SubjectFactory manager.setSubjectFactory(subjectFactory()); // 设置自定义的 SessionManager manager.setSessionManager(sessionManager()); // 禁用 Session ((DefaultSessionStorageEvaluator)((DefaultSubjectDAO)manager.getSubjectDAO()).getSessionStorageEvaluator()) .setSessionStorageEnabled(false); // 设置自定义的 Realm manager.setRealms(getRealms()); return manager; } /** * 设置过滤规则 */ @Bean public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) { ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean(); shiroFilterFactoryBean.setSecurityManager(securityManager); //自定义拦截器 参考 ShiroLoginFilter.java Map<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 */ @Bean public DefaultWebSubjectFactory subjectFactory(){ ASubjectFactory mySubjectFactory = new ASubjectFactory(); return mySubjectFactory; } /** * session管理器 * 禁用了 Session * sessionManager通过sessionValidationSchedulerEnabled禁用掉会话调度器， * @return */ @Bean public DefaultSessionManager sessionManager(){ DefaultSessionManager sessionManager = new DefaultSessionManager(); sessionManager.setSessionValidationSchedulerEnabled(false); return sessionManager; } /** * 配置自定义的 Realm * @return */ @Bean public 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 { @Override public 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 @Lazy private JwtUtil jwtUtil; @Override protected boolean isAccessAllowed(ServletRequest request,ServletResponse response, Object mappedValue) { // 判断请求是否是公共请求，通过请求的url判断 if(WebUtil.isPublicRequest((HttpServletRequest) request)){ return true; } return false;// 拒绝，统一交给 onAccessDenied 处理 } @Override protected 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));//返回json return false; } if(jwtToken.getIsFlushed()){//需要刷新token httpServletResponse.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{ @Autowired private UserService userService; @Value("${jwt.salt}") private String jwtSalt; private static final String DEFAULT_JWT_SALT = "asdfh2738yWsdjDfha";//默认的盐 /** * 授权处理 * 不使用 * @param principals * @return */ @Override protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) { return null; } /** * 身份认证 */ @Override protected 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 { @Override public boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) { //账号密码登录，则token应该是自定义的 AccountPasswordAuthenticationToken if(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;//用户在数据库中的id private String account; private String password; public UserAuthenticationToken(String account, String password){ this.account = account; this.password = password; } /** * 返回 account * @return */ @Override public Object getPrincipal() { return this.account; } /** * 返回 password * @return */ @Override public 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) { // 需要读取appKey if(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); } // 压缩，可选GZIP jwtBuilder.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){//不支持的token throw 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 token long 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倍有效期，此时应该刷新token time + period + period >= now){ // log.info("刷新token"); jwtToken.setToken(issueJWT(// 制作JWT Token CommonUtil.getRandomString(20),//令牌id claims.getSubject(),//用户id (issuer == null ? DEFAULT_ISSUER : issuer),//签发人 claims.get("roles", String.class),//访问角色,设置为null，不使用 claims.get("perms", String.class),//权限集合字符串，json period,//token有效时间*2 SignatureAlgorithm.HS512 )); jwtToken.setIsFlushed(true); }else{ log.error("未知错误 - Jwts.parser() 方法未对过期token抛出异常"); } // 设置其他字段 jwtToken.setId(claims.getSubject());//用户id jwtToken.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 签发人 @Autowired private JwtUtil jwtUtil; @Autowired private 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 Token String jwtToken = jwtUtil.issueJWT( CommonUtil.getRandomString(20),//令牌id，必须为整个系统唯一id token.getUserId() + "",//用户id (issuer == null ? JwtUtil.DEFAULT_ISSUER : issuer),//签发人，可随便定义 null,//访问角色 JSONArray.toJSONString(permissions),//用户权限集合，json格式 (period == null ? JwtUtil.DEFAULT_PERIOD : period),//token有效时间 SignatureAlgorithm.HS512//签名算法，我也不知道是啥来的 ); //token存入 response里的Header response.setHeader(WebConst.TOKEN,jwtToken); // 返回Message的json Message 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 Config aop: auto: true redis: host: 127.0.0.1 password: port: 6379 database: 0 datasource: url: jdbc:mysql://xxx.xx.xx.xxx:3306/rb_demo?useUnicode=true&characterEncoding=UTF-8 username: root password: driver-class-name: com.mysql.jdbc.Driver # Jwt Token相关配置 jwt: appKey: ds[W&dsfa:dfhu12a%W@ // app秘钥，随便定义即可 appId: 210293ajkw723o@7eh*db //appId，随便定义即可 period: 120000 # 有效期，单位ms issuer: Server-System # 签发者，用于制作 jwt token salt: salt-sdwbhx23i # 盐，随便定义即可, view UserRealm.doGetAuthenticationInfo() # Mybatis-Plus 配置，请参考官方文档 mybatis-plus: mapper-locations: classpath:/mapper/*Mapper.xml typeAliasesPackage: com.spz.demo.security.entity global-config: id-type: 2 field-strategy: 0 db-column-underline: true refresh-mapper: true configuration: map-underscore-to-camel-case: true cache-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才是真实ip int 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

原文链接：https://yq.aliyun.com/articles/643801
关注公众号

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。

持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

转载内容版权归作者及来源网站所有，本站原创内容转载请注明来源。

相关文章

    文章评论

    共有0条评论来说两句吧...

    文章二维码

    扫描即可查看该文章

    点击排行

    推荐阅读

    最新文章