logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

spring boot2整合shiro安全框架实现前后端分离的JWT token登录验证

 忠波irlphwt1ng 2019-12-01

代码略多,粘贴一些关键的代码,完整demo当然必须放在GitHub上面啦,当然带SQL文件的,在项目里面

GitHub地址:  https://github.com/zhang-xiaoxiang/shiro-jwt

说明:由于初衷是解决自己项目的bug的,就找的网上的一面博客瞎搞了一个demo.然后报的错网上难以找到解决办法,后来自己解决了,就记录一下,所以不算教程,我看评论大伙说的修改密码后之前的token仍然有效,可以使用redis处理,或者其他业务逻辑代码处理一下,这个仅仅是一个demo,当然很多培训机构的源码也有一些demo,大家可以参考,这里主要是给需要的小伙伴一个思路或者遇到那个bug的解决方案

关于这个例子介绍:

1使用的是spring boot2作为环境基础

2数据库框架是mybatis plus(对mybatis熟悉就行,你顺便看一下mybatis plus逆向生成代码的魅力)

3包含全局异常的处理(报错getWriter() has already been called for this response),这个BUG是网上的访问量比较高的CSDN的博客案例留下的bug,为了解决这个bug才有我的这篇博客,所以记录一下

4shiro可以实现除了验证和授权之外的一些功能,这里主要展示验证,验证相当于登录,授权相当于登录后查看是否有权限,就想即使登录了支付宝,但是付款的时候还是需要验证支付宝密码一样,当然前后端未分离可以使用thymeleaf网页引擎,貌似黑马视频有,这里就只做个登录例子

5jwt这种方式是不太时尚的,正确的方式spring security oauth2实现认证授权,这里仅供参考,欢迎小伙伴提出宝贵意见,我都会尽快回复

6使用的是mysql8,pom和properties文件你改成现在用得多一点的5.7版本的写法就行了

7这里根据博友评论确实忘了用户修改密码token的处理,我相信这个大家应该会处理的(更新一下token就行了)

主要步骤:

首先是pom引入(主要的依赖,由于代码较大,而且我提供了Git地址,需要的直接从GitHub拉下来就行了,后面不做过多阐述)

  1.             <!--JWT java web token 权限验证-->
  2.         <dependency>
  3.             <groupId>com.auth0</groupId>
  4.             <artifactId>java-jwt</artifactId>
  5.             <version>3.4.0</version>
  6.         </dependency>
  7.             <!--shiro 权限框架-->
  8.         <dependency>
  9.             <groupId>org.apache.shiro</groupId>
  10.             <artifactId>shiro-spring</artifactId>
  11.             <version>1.4.0</version>
  12.         </dependency>

 

实现shiro的AuthenticationToken接口的类JwtToken
  1. //package com.example.shirojwt.jwt;
  3. import org.apache.shiro.authc.AuthenticationToken;
  5. /**
  6.  * JwtToken:实现shiro的AuthenticationToken接口的类JwtToken
  7.  *
  8.  * @author zhangxiaoxiang
  9.  * @date: 2019/07/12
  10.  */
  11. public class JwtToken implements AuthenticationToken{
  13.     private String token;
  15.     public JwtToken(String token) {
  16.         this.token = token;
  17.     }
  19.     @Override
  20.     public Object getPrincipal() {
  21.         return token;
  22.     }
  24.     @Override
  25.     public Object getCredentials() {
  26.         return token;
  27.     }
  28. }

 再写一个token的验证工具类

  1. //package com.example.shirojwt.util;
  3. import com.auth0.jwt.JWT;
  4. import com.auth0.jwt.JWTVerifier;
  5. import com.auth0.jwt.algorithms.Algorithm;
  6. import com.auth0.jwt.exceptions.JWTDecodeException;
  7. import com.auth0.jwt.interfaces.DecodedJWT;
  8. import lombok.extern.slf4j.Slf4j;
  10. import java.util.Date;
  12. /**
  13.  * JwtUtil:用来进行签名和效验Token
  14.  *
  15.  * @author zhangxiaoxiang
  16.  * @date: 2019/07/12
  17.  */
  18. @Slf4j
  19. public class JwtUtil {
  20.     /**
  21.      * JWT验证过期时间 EXPIRE_TIME 分钟
  22.      */
  23.     private static final long EXPIRE_TIME = 30 * 60 * 1000;
  25.     /**
  26.      * 校验token是否正确
  27.      *
  28.      * @param token  密钥
  29.      * @param secret 用户的密码
  30.      * @return 是否正确
  31.      */
  32.     public static boolean verify(String token, String username, String secret) {
  33.         try {
  34.             //根据密码生成JWT效验器
  35.             Algorithm algorithm = Algorithm.HMAC256(secret);
  36.             JWTVerifier verifier = JWT.require(algorithm)
  37.                     .withClaim("username", username)
  38.                     .build();
  39.             //效验TOKEN
  40.             DecodedJWT jwt = verifier.verify(token);
  41.             log.info("登录验证成功!");
  42.             return true;
  43.         } catch (Exception exception) {
  44.             log.error("JwtUtil登录验证失败!");
  46.             return false;
  47.         }
  48.     }
  50.     /**
  51.      * 获得token中的信息无需secret解密也能获得
  52.      *
  53.      * @return token中包含的用户名
  54.      */
  55.     public static String getUsername(String token) {
  56.         try {
  57.             DecodedJWT jwt = JWT.decode(token);
  58.             return jwt.getClaim("username").asString();
  59.         } catch (JWTDecodeException e) {
  60.             return null;
  61.         }
  62.     }
  64.     /**
  65.      * 生成token签名EXPIRE_TIME 分钟后过期
  66.      *
  67.      * @param username 用户名(电话号码)
  68.      * @param secret   用户的密码
  69.      * @return 加密的token
  70.      */
  71.     public static String sign(String username, String secret) {
  72.         Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
  73.         Algorithm algorithm = Algorithm.HMAC256(secret);
  74.         // 附带username信息
  75.         return JWT.create()
  76.                 .withClaim("username", username)
  77.                 .withExpiresAt(date)
  78.                 .sign(algorithm);
  80.     }
  82.     public static void main(String[] args) {
  83.         /**
  84.          * 测试生成一个token
  85.          */
  86.         String sign = sign("18888888888", "123456");
  87.        log.warn("测试生成一个token\n"+sign);
  88.     }
  89. }

写一个jwt过滤器来作为shiro的过滤器。

  1. //package com.example.shirojwt.filter;
  3. import com.alibaba.fastjson.JSONObject;
  4. import com.alibaba.fastjson.serializer.SerializerFeature;
  5. import com.example.shirojwt.jwt.JwtToken;
  6. import com.example.shirojwt.result.ResponseData;
  7. import com.example.shirojwt.result.ResponseDataUtil;
  8. import lombok.extern.slf4j.Slf4j;
  9. import org.apache.shiro.authc.AuthenticationException;
  10. import org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter;
  11. import org.springframework.http.HttpStatus;
  12. import org.springframework.stereotype.Component;
  13. import org.springframework.web.bind.annotation.RequestMethod;
  15. import javax.servlet.*;
  16. import javax.servlet.http.HttpServletRequest;
  17. import javax.servlet.http.HttpServletResponse;
  20. /**
  21.  * JwtFilter:jwt过滤器来作为shiro的过滤器
  22.  *
  23.  * @author zhangxiaoxiang
  24.  * @date: 2019/07/12
  25.  */
  26. @Slf4j
  27. @Component//这个注入与否影响不大
  28. public class JwtFilter extends BasicHttpAuthenticationFilter implements Filter {
  29.     /**
  30.      * 执行登录
  31.      * @param request
  32.      * @param response
  33.      * @return
  34.      * @throws Exception
  35.      */
  36.     @Override
  37.     protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
  38.         HttpServletRequest httpServletRequest = (HttpServletRequest) request;
  39.         String token = httpServletRequest.getHeader("Token");
  40.         JwtToken jwtToken = new JwtToken(token);
  41.         // 提交给realm进行登入，如果错误他会抛出异常并被捕获
  42.         try {
  43.             getSubject(request, response).login(jwtToken);
  44.             // 如果没有抛出异常则代表登入成功，返回true
  45.             return true;
  46.         } catch (AuthenticationException e) {
  47.             ResponseData responseData = ResponseDataUtil.authorizationFailed( "没有访问权限，原因是:" + e.getMessage());
  48.             //SerializerFeature.WriteMapNullValue为了null属性也输出json的键值对
  49.             Object o = JSONObject.toJSONString(responseData, SerializerFeature.WriteMapNullValue);
  50.             response.setCharacterEncoding("utf-8");
  51.             response.getWriter().print(o);
  52.             return false;
  53.         }
  55.     }
  57.     /**
  58.      * 执行登录认证
  59.      *
  60.      * @param request
  61.      * @param response
  62.      * @param mappedValue
  63.      * @return
  64.      */
  65.     @Override
  66.     protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
  67.         try {
  68.             return executeLogin(request, response);
  69.             // return true;有一篇博客这里直接返回true是不正确的,在这里我特别指出一下
  70.         } catch (Exception e) {
  71.             log.error("JwtFilter过滤验证失败!");
  72.             return false;
  73.         }
  74.     }
  77.     /**
  78.      * 对跨域提供支持
  79.      * @param request
  80.      * @param response
  81.      * @return
  82.      * @throws Exception
  83.      */
  84.     @Override
  85.     protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
  86.         HttpServletRequest httpServletRequest = (HttpServletRequest) request;
  87.         HttpServletResponse httpServletResponse = (HttpServletResponse) response;
  88.         httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));
  89.         httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
  90.         httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));
  91.         // 跨域时会首先发送一个option请求，这里我们给option请求直接返回正常状态
  92.         if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
  93.             httpServletResponse.setStatus(HttpStatus.OK.value());
  94.             return false;
  95.         }
  96.         return super.preHandle(request, response);
  97.     }
  98. }

自定义Realm

  1. //package com.example.shirojwt.shiro;
  3. import com.example.shirojwt.entity.User;
  4. import com.example.shirojwt.jwt.JwtToken;
  5. import com.example.shirojwt.service.UserService;
  6. import com.example.shirojwt.util.JwtUtil;
  7. import lombok.extern.slf4j.Slf4j;
  8. import org.apache.shiro.authc.AuthenticationException;
  9. import org.apache.shiro.authc.AuthenticationInfo;
  10. import org.apache.shiro.authc.AuthenticationToken;
  11. import org.apache.shiro.authc.SimpleAuthenticationInfo;
  12. import org.apache.shiro.authz.AuthorizationInfo;
  13. import org.apache.shiro.authz.SimpleAuthorizationInfo;
  14. import org.apache.shiro.realm.AuthorizingRealm;
  15. import org.apache.shiro.subject.PrincipalCollection;
  16. import org.springframework.beans.factory.annotation.Autowired;
  17. import org.springframework.stereotype.Component;
  19. /**
  20.  * MyRealm:自定义一个授权
  21.  *
  22.  * @author zhangxiaoxiang
  23.  * @date: 2019/07/12
  24.  */
  26. @Component
  27. @Slf4j
  28. public class MyRealm extends AuthorizingRealm {
  30.     @Autowired
  31.     private UserService userService;
  33.     /**
  34.      * 必须重写此方法，不然Shiro会报错
  35.      * @param token
  36.      * @return
  37.      */
  38.     @Override
  39.     public boolean supports(AuthenticationToken token) {
  40.         return token instanceof JwtToken;
  41.     }
  43.     /**
  44.      * 只有当需要检测用户权限的时候才会调用此方法，例如checkRole,checkPermission之类的
  45.      * @param principals
  46.      * @return
  47.      */
  48.     @Override
  49.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
  50.         String username = JwtUtil.getUsername(principals.toString());
  51.         User user = userService.findByUserName(username);
  52.         SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
  53.         return simpleAuthorizationInfo;
  54.     }
  56.     /**
  57.      * 默认使用此方法进行用户名正确与否验证，错误抛出异常即可。
  58.      * @param auth
  59.      * @return
  60.      * @throws AuthenticationException
  61.      */
  62.     @Override
  63.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken auth) throws AuthenticationException {
  64.         String token = (String) auth.getCredentials();
  65.         // 解密获得username，用于和数据库进行对比
  66.         String username = null;
  67.         try {
  68.             //这里工具类没有处理空指针等异常这里处理一下(这里处理科学一些)
  69.             username = JwtUtil.getUsername(token);
  70.         } catch (Exception e) {
  71.             throw new AuthenticationException("heard的token拼写错误或者值为空");
  72.         }
  73.         if (username == null) {
  74.           log.error("token无效(空''或者null都不行!)");
  75.             throw new AuthenticationException("token无效");
  76.         }
  77.         User userBean = userService.findByUserName(username);
  78.         if (userBean == null) {
  79.             log.error("用户不存在!)");
  80.             throw new AuthenticationException("用户不存在!");
  81.         }
  82.         if (!JwtUtil.verify(token, username, userBean.getUserPassword())) {
  83.             log.error("用户名或密码错误(token无效或者与登录者不匹配)!)");
  84.             throw new AuthenticationException("用户名或密码错误(token无效或者与登录者不匹配)!");
  85.         }
  86.         return new SimpleAuthenticationInfo(token, token, "my_realm");
  87.     }
  88. }

 ShiroConfig核心配置

  1. //package com.example.shirojwt.config;
  4. import com.example.shirojwt.filter.JwtFilter;
  5. import com.example.shirojwt.shiro.MyRealm;
  6. import org.apache.shiro.mgt.DefaultSessionStorageEvaluator;
  7. import org.apache.shiro.mgt.DefaultSubjectDAO;
  8. import org.apache.shiro.mgt.SecurityManager;
  9. import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
  10. import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
  11. import org.springframework.context.annotation.Bean;
  12. import org.springframework.context.annotation.Configuration;
  14. import javax.servlet.Filter;
  15. import java.util.HashMap;
  16. import java.util.LinkedHashMap;
  17. import java.util.Map;
  19. /**
  20.  * ShiroConfig:shiro 配置类,配置哪些拦截,哪些不拦截,哪些授权等等各种配置都在这里
  21.  * 
  22.  * 很多都是老套路,按照这个套路配置就行了
  23.  *
  24.  * @author zhangxiaoxiang
  25.  * @date: 2019/07/12
  26.  */
  28. @Configuration
  29. public class ShiroConfig {
  30.     /**
  31.      * 注入安全过滤器
  32.      * @param securityManager
  33.      * @return
  34.      */
  35.     @Bean("shiroFilter")
  36.     public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
  37.         ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
  38.         shiroFilterFactoryBean.setSecurityManager(securityManager);
  39.         //拦截器
  40.         Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
  41.         // 配置不会被拦截的链接 顺序判断
  42.         filterChainDefinitionMap.put("/login/**", "anon");
  43.         filterChainDefinitionMap.put("/**.js", "anon");
  44.         filterChainDefinitionMap.put("/druid/**", "anon");
  45.         filterChainDefinitionMap.put("/swagger**/**", "anon");
  46.         filterChainDefinitionMap.put("/**/swagger**/**", "anon");
  47.         filterChainDefinitionMap.put("/webjars/**", "anon");
  48.         filterChainDefinitionMap.put("/v2/**", "anon");
  49.         // 添加自己的过滤器并且取名为jwt
  50.         Map<String, Filter> filterMap = new HashMap<String, Filter>(1);
  51.         filterMap.put("jwt", new JwtFilter());
  52.         shiroFilterFactoryBean.setFilters(filterMap);
  53.         //<!-- 过滤链定义，从上向下顺序执行，一般将/**放在最为下边
  54.         filterChainDefinitionMap.put("/**", "jwt");
  55.         //未授权界面;
  56.         shiroFilterFactoryBean.setUnauthorizedUrl("/403");
  57.         shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
  58.         return shiroFilterFactoryBean;
  59.     }
  61.     /**
  62.      * 注入安全管理器
  63.      * @param myRealm
  64.      * @return
  65.      */
  66.     @Bean("securityManager")
  67.     public SecurityManager securityManager(MyRealm myRealm) {
  68.         DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
  69.         securityManager.setRealm(myRealm);
  71.         /*
  72.          * 关闭shiro自带的session，详情见文档
  73.          * http://shiro./session-management.html#SessionManagement-StatelessApplications%28Sessionless%29
  74.          */
  75.         DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
  76.         DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
  77.         defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
  78.         subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
  79.         securityManager.setSubjectDAO(subjectDAO);
  80.         return securityManager;
  82.        }
  83. }

 大体核心代码已经完成,项目结构如图(点击图片放大后就清晰了)

 测试示例

比如模拟登录token(在JwtUtil生成一个)错误,或者token输入成token12,或者账号密码错误等等...

 比如输入使用生成的token(相当于用户登录后返回的token):登录显然不需要token,登录后后台返回token,只是这里为了演示一个需要token的接口,所以把登录接口也设置了需要token,科学的方法是比如查询用户详情这个接口就必须要token,所以postman传入的token模拟的是需要token的接口而存在的,返回的token是给前端带上访问用户订单,地址的那些需要token认证的接口

 

 当然在控制层也可以测试其他被限制访问的接口和放行的接口,以及各种异常的测试,这里不做过多赘述,感兴趣的看GitHub的demo

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： 忠波irlphwt1ng > 《shiro》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多