经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Java » 查看文章
shiro，基于springboot，基于前后端分离，从登录认证到鉴权，从入门到放弃
来源：cnblogs　　作者：撸码识途　　时间：2018/11/8 9:56:33　　对本文有异议

这个demo是基于springboot项目的。

名词介绍：

Shiro
Shiro 主要分为 安全认证 和 接口授权 两个部分，其中的核心组件为 Subject、 SecurityManager、 Realms，公共部分 Shiro 都已经为我们封装好了，我们只需要按照一定的规则去编写响应的代码即可…

Subject 即表示主体，将用户的概念理解为当前操作的主体，因为它即可以是一个通过浏览器请求的用户，也可能是一个运行的程序，外部应用与 Subject 进行交互，记录当前操作用户。Subject 代表了当前用户的安全操作，SecurityManager 则管理所有用户的安全操作。

SecurityManager 即安全管理器，对所有的 Subject 进行安全管理，并通过它来提供安全管理的各种服务（认证、授权等）

Realm 充当了应用与数据安全间的 桥梁 或 连接器。当对用户执行认证（登录）和授权（访问控制）验证时，Shiro 会从应用配置的 Realm 中查找用户及其权限信息。

1.导入shiro依赖

  1.         <dependency>
  2.             <groupId>org.apache.shiro</groupId>
  3.             <artifactId>shiro-spring</artifactId>
  4.             <version>1.4.0</version>
  5.         </dependency>
  6. 　　　　
  7.         <dependency>
  8.             <groupId>org.crazycake</groupId>
  9.             <artifactId>shiro-redis</artifactId>
  10.             <version>2.8.24</version>
  11.         </dependency>
  1. shiro-redis为什么要导入这个包呢？将用户信息交给redis管理。

2.shiro配置类

  1. package com.test.cbd.shiro;
  4. import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
  5. import org.apache.shiro.mgt.SecurityManager;
  6. import org.apache.shiro.session.mgt.SessionManager;
  7. import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
  8. import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
  9. import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
  10. import org.crazycake.shiro.RedisCacheManager;
  11. import org.crazycake.shiro.RedisManager;
  12. import org.crazycake.shiro.RedisSessionDAO;
  13. import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
  14. import org.springframework.beans.factory.annotation.Value;
  15. import org.springframework.context.annotation.Bean;
  16. import org.springframework.context.annotation.Configuration;
  17. import org.springframework.web.servlet.HandlerExceptionResolver;
  18. import java.util.LinkedHashMap;
  19. import java.util.Map;
  21. @Configuration
  22. public class ShiroConfig {
  24.     @Value("${spring.redis.shiro.host}")
  25.     private String host;
  26.     @Value("${spring.redis.shiro.port}")
  27.     private int port;
  28.     @Value("${spring.redis.shiro.timeout}")
  29.     private int timeout;
  30.     @Value("${spring.redis.shiro.password}")
  31.     private String password;
  33.     @Bean
  34.     public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
  35.         System.out.println("ShiroConfiguration.shirFilter()");
  36.         ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
  37.         shiroFilterFactoryBean.setSecurityManager(securityManager);
  39.         Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
  40.         //注意过滤器配置顺序 不能颠倒
  41.         //配置退出 过滤器,其中的具体的退出代码Shiro已经替我们实现了，登出后跳转配置的loginUrl
  42.         filterChainDefinitionMap.put("/logout", "logout");
  43.         // 配置不会被拦截的链接 顺序判断，在 ShiroConfiguration 中的 shiroFilter 处配置了 /ajaxLogin=anon，意味着可以不需要认证也可以访问
  44.         filterChainDefinitionMap.put("/static/**", "anon");
  45.         filterChainDefinitionMap.put("/*.html", "anon");
  46.         filterChainDefinitionMap.put("/ajaxLogin", "anon");
  47.         filterChainDefinitionMap.put("/login", "anon");
  48.         filterChainDefinitionMap.put("/**", "authc");
  49.         //配置shiro默认登录界面地址，前后端分离中登录界面跳转应由前端路由控制，后台仅返回json数据
  50.         shiroFilterFactoryBean.setLoginUrl("/unauth");
  51.         // 登录成功后要跳转的链接
  52. //        shiroFilterFactoryBean.setSuccessUrl("/index");
  53.         //未授权界面;
  54. //        shiroFilterFactoryBean.setUnauthorizedUrl("/403");
  55.         shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
  56.         return shiroFilterFactoryBean;
  57.     }
  59.     /**
  60.      * 凭证匹配器
  61.      * （由于我们的密码校验交给Shiro的SimpleAuthenticationInfo进行处理了
  62.      * ）
  63.      *
  64.      * @return
  65.      */
  66.     @Bean
  67.     public HashedCredentialsMatcher hashedCredentialsMatcher() {
  68.         HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
  69.         hashedCredentialsMatcher.setHashAlgorithmName("md5");//散列算法:这里使用MD5算法;
  70.         hashedCredentialsMatcher.setHashIterations(1024);//散列的次数，比如散列两次，相当于 md5(md5(""));
  71.         return hashedCredentialsMatcher;
  72.     }
  74.     @Bean
  75.     public MyShiroRealm myShiroRealm() {
  76.         MyShiroRealm myShiroRealm = new MyShiroRealm();
  77.         myShiroRealm.setCredentialsMatcher(hashedCredentialsMatcher());
  78.         return myShiroRealm;
  79.     }
  82.     @Bean
  83.     public SecurityManager securityManager() {
  84.         DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
  85.         securityManager.setRealm(myShiroRealm());
  86.         // 自定义session管理 使用redis
  87.         securityManager.setSessionManager(sessionManager());
  88.         // 自定义缓存实现 使用redis
  89.         securityManager.setCacheManager(cacheManager());
  90.         return securityManager;
  91.     }
  93.     //自定义sessionManager
  94.     @Bean
  95.     public SessionManager sessionManager() {
  96.         MySessionManager mySessionManager = new MySessionManager();
  97.         mySessionManager.setSessionDAO(redisSessionDAO());
  98.         return mySessionManager;
  99.     }
  101.     /**
  102.      * 配置shiro redisManager
  103.      * <p>
  104.      * 使用的是shiro-redis开源插件
  105.      *
  106.      * @return
  107.      */
  108.     public RedisManager redisManager() {
  109.         RedisManager redisManager = new RedisManager();
  110.         redisManager.setHost(host);
  111.         redisManager.setPort(port);
  112.         redisManager.setExpire(1800);// 配置缓存过期时间
  113.         redisManager.setTimeout(timeout);
  114.         redisManager.setPassword(password);
  115.         return redisManager;
  116.     }
  118.     /**
  119.      * cacheManager 缓存 redis实现
  120.      * <p>
  121.      * 使用的是shiro-redis开源插件
  122.      *
  123.      * @return
  124.      */
  125.     @Bean
  126.     public RedisCacheManager cacheManager() {
  127.         RedisCacheManager redisCacheManager = new RedisCacheManager();
  128.         redisCacheManager.setRedisManager(redisManager());
  129.         return redisCacheManager;
  130.     }
  132.     /**
  133.      * RedisSessionDAO shiro sessionDao层的实现 通过redis
  134.      * <p>
  135.      * 使用的是shiro-redis开源插件
  136.      */
  137.     @Bean
  138.     public RedisSessionDAO redisSessionDAO() {
  139.         RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
  140.         redisSessionDAO.setRedisManager(redisManager());
  141.         return redisSessionDAO;
  142.     }
  144.     /**
  145.      * 开启shiro aop注解支持.
  146.      * 使用代理方式;所以需要开启代码支持;
  147.      *
  148.      * @param securityManager
  149.      * @return
  150.      */
  151.     @Bean
  152.     public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
  153.         AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
  154.         authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
  155.         return authorizationAttributeSourceAdvisor;
  156.     }
  158.     /**
  159.      * 注册全局异常处理
  160.      * @return
  161.      */
  162.     @Bean(name = "exceptionHandler")
  163.     public HandlerExceptionResolver handlerExceptionResolver() {
  164.         return new MyExceptionHandler();
  165.     }
  167.     //自动创建代理，没有这个鉴权可能会出错
  168.     @Bean
  169.     public DefaultAdvisorAutoProxyCreator getDefaultAdvisorAutoProxyCreator() {
  170.         DefaultAdvisorAutoProxyCreator autoProxyCreator = new DefaultAdvisorAutoProxyCreator();
  171.         autoProxyCreator.setProxyTargetClass(true);
  172.         return autoProxyCreator;
  173.     }
  174. }

3.安全认证和权限验证的核心，自定义Realm 

  1. package com.test.cbd.shiro;
  4. import com.google.gson.JsonObject;
  5. import com.test.cbd.service.UserService;
  6. import com.test.cbd.vo.SysPermission;
  7. import com.test.cbd.vo.SysRole;
  8. import com.test.cbd.vo.UserInfo;
  9. import org.apache.commons.beanutils.BeanUtils;
  10. import org.apache.shiro.SecurityUtils;
  11. import org.apache.shiro.authc.*;
  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.session.Session;
  16. import org.apache.shiro.subject.PrincipalCollection;
  17. import org.apache.shiro.subject.Subject;
  18. import org.apache.shiro.util.ByteSource;
  19. import springfox.documentation.spring.web.json.Json;
  21. import javax.annotation.Resource;
  22. import java.util.HashSet;
  23. import java.util.Set;
  25.  
  26. public class MyShiroRealm extends AuthorizingRealm {
  27.     @Resource
  28.     private UserService userInfoService;
  30.     @Override
  31.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals){
  32. //        // 权限信息对象info,用来存放查出的用户的所有的角色（role）及权限（permission）
  33.         SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
  34.         Session session = SecurityUtils.getSubject().getSession();
  35.         UserInfo user = (UserInfo) session.getAttribute("USER_SESSION");
  36.         // 用户的角色集合
  37.         Set<String> roles = new HashSet<>();
  38.         roles.add(user.getRoleList().get(0).getRole());
  39.         authorizationInfo.setRoles(roles);
  40.         return authorizationInfo;
  41.     }
  43.     /*主要是用来进行身份认证的，也就是说验证用户输入的账号和密码是否正确。*/
  44.     @Override
  45.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token)
  46.             throws AuthenticationException {
  47. //        System.out.println("MyShiroRealm.doGetAuthenticationInfo()");
  48.         //获取用户的输入的账号.
  49.         String username = (String) token.getPrincipal();
  50. //        System.out.println(token.getCredentials());
  51.         //通过username从数据库中查找 User对象，如果找到，没找到.
  52.         //实际项目中，这里可以根据实际情况做缓存，如果不做，Shiro自己也是有时间间隔机制，2分钟内不会重复执行该方法
  53.         UserInfo userInfo = userInfoService.findByUsername(username);
  54.        // Subject subject = SecurityUtils.getSubject();
  55.         //Session session = subject.getSession();
  56.         //session.setAttribute("role",userInfo.getRoleList());
  57. //        System.out.println("----->>userInfo="+userInfo);
  58.         if (userInfo == null) {
  59.             return null;
  60.         }
  61.         if (userInfo.getState() == 1) { //账户冻结
  62.             throw new LockedAccountException();
  63.         }
  64.         String credentials = userInfo.getPassword();
  65.         System.out.println("credentials="+credentials);
  66.         ByteSource credentialsSalt = ByteSource.Util.bytes(username);
  67.         SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(
  68.                 userInfo.getUserName(), //用户名
  69.                 credentials, //密码
  70.                 credentialsSalt,
  71.                 getName()  //realm name
  72.         );
  73.         Session session = SecurityUtils.getSubject().getSession();
  74.         session.setAttribute("USER_SESSION", userInfo);
  75.         return authenticationInfo;
  76.     }
  78. }

4.全局异常处理器

  1. package com.test.cbd.shiro;
  4. import com.alibaba.fastjson.support.spring.FastJsonJsonView;
  5. import org.apache.shiro.authz.UnauthenticatedException;
  6. import org.apache.shiro.authz.UnauthorizedException;
  7. import org.springframework.web.servlet.HandlerExceptionResolver;
  8. import org.springframework.web.servlet.ModelAndView;
  9. import javax.servlet.http.HttpServletRequest;
  10. import javax.servlet.http.HttpServletResponse;
  11. import java.util.HashMap;
  12. import java.util.Map;
  14. /**
  15.  * Created by Administrator on 2017/12/11.
  16.  * 全局异常处理
  17.  */
  18. public class MyExceptionHandler implements HandlerExceptionResolver {
  20.     public ModelAndView resolveException(HttpServletRequest httpServletRequest, 
    　　　　　　　　　　　　HttpServletResponse httpServletResponse, Object o, Exception ex) {
  21.         ModelAndView mv = new ModelAndView();
  22.         FastJsonJsonView view = new FastJsonJsonView();
  23.         Map<String, Object> attributes = new HashMap<String, Object>();
  24.         if (ex instanceof UnauthenticatedException) {
  25.             attributes.put("code", "1000001");
  26.             attributes.put("msg", "token错误");
  27.         } else if (ex instanceof UnauthorizedException) {
  28.             attributes.put("code", "1000002");
  29.             attributes.put("msg", "用户无权限");
  30.         } else {
  31.             attributes.put("code", "1000003");
  32.             attributes.put("msg", ex.getMessage());
  33.         }
  35.         view.setAttributesMap(attributes);
  36.         mv.setView(view);
  37.         return mv;
  38.     }
  39. }

5.因为现在的项目大多都是前后端分离的，所以我们需要实现自己的session管理

  1. package com.test.cbd.shiro;
  3. import org.apache.shiro.web.servlet.ShiroHttpServletRequest;
  4. import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
  5. import org.apache.shiro.web.util.WebUtils;
  6. import org.springframework.util.StringUtils;
  7. import javax.servlet.ServletRequest;
  8. import javax.servlet.ServletResponse;
  9. import java.io.Serializable;
  11.  
  12. public class MySessionManager extends DefaultWebSessionManager {
  14.     private static final String TOKEN = "token";
  16.     private static final String REFERENCED_SESSION_ID_SOURCE = "Stateless request";
  18.     public MySessionManager() {
  19.         super();
  20.     }
  22.     @Override
  23.     protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
  24.         String id = WebUtils.toHttp(request).getHeader(TOKEN);
  25.         //如果请求头中有 token 则其值为sessionId
  26.         if (!StringUtils.isEmpty(id)) {
  27.             request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE, REFERENCED_SESSION_ID_SOURCE);
  28.             request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, id);
  29.             request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
  30.             return id;
  31.         } else {
  32.             //否则按默认规则从cookie取sessionId
  33.             return super.getSessionId(request, response);
  34.         }
  35.     }
  36. }

6.控制器

  1. package com.test.cbd.shiro;
  3. import com.alibaba.fastjson.JSONObject;
  4. import com.test.cbd.vo.UserInfo;
  5. import io.swagger.annotations.Api;
  6. import lombok.extern.slf4j.Slf4j;
  7. import org.apache.shiro.SecurityUtils;
  8. import org.apache.shiro.authc.AuthenticationException;
  9. import org.apache.shiro.authc.IncorrectCredentialsException;
  10. import org.apache.shiro.authc.LockedAccountException;
  11. import org.apache.shiro.authc.UsernamePasswordToken;
  12. import org.apache.shiro.authz.annotation.RequiresRoles;
  13. import org.apache.shiro.crypto.hash.SimpleHash;
  14. import org.apache.shiro.session.Session;
  15. import org.apache.shiro.subject.Subject;
  16. import org.apache.shiro.util.ByteSource;
  17. import org.springframework.web.bind.annotation.*;
  19. import javax.servlet.http.HttpServletRequest;
  20. import java.net.InetAddress;
  22. @Slf4j
  23. @Api(value="shiro测试",description="shiro测试")
  24. @RestController
  25. @RequestMapping("/")
  26. public class ShiroLoginController {
  28.     /**
  29.      * 登录测试
  30.      * @param userInfo
  31.      * @return
  32.      */
  33.     @RequestMapping(value = "/ajaxLogin", method = RequestMethod.POST)
  34.     @ResponseBody
  35.     public String ajaxLogin(UserInfo userInfo) {
  36.         JSONObject jsonObject = new JSONObject();
  37.         UsernamePasswordToken token = new UsernamePasswordToken(userInfo.getUserName(), userInfo.getPassword());
  38.         Subject subject = SecurityUtils.getSubject();
  39.         try {
  40.             subject.login(token);
  41.             jsonObject.put("token", subject.getSession().getId());
  42.             jsonObject.put("msg", "登录成功");
  43.         } catch (IncorrectCredentialsException e) {
  44.             jsonObject.put("msg", "密码错误");
  45.         } catch (LockedAccountException e) {
  46.             jsonObject.put("msg", "登录失败，该用户已被冻结");
  47.         } catch (AuthenticationException e) {
  48.             jsonObject.put("msg", "该用户不存在");
  49.         } catch (Exception e) {
  50.             e.printStackTrace();
  51.         }
  52.         return jsonObject.toString();
  53.     }
  55.     /**
  56.      * 鉴权测试
  57.      * @param userInfo
  58.      * @return
  59.      */
  60.     @RequestMapping(value = "/check", method = RequestMethod.GET)
  61.     @ResponseBody
  62.     @RequiresRoles("guest")
  63.     public String check() {
  64.         JSONObject jsonObject = new JSONObject();
  65.         jsonObject.put("msg", "鉴权测试");
  66.         return jsonObject.toString();
  67.     }
  68. }

常用注解
@RequiresGuest 代表无需认证即可访问，同理的就是 /path=anon

@RequiresAuthentication 需要认证，只要登录成功后就允许你操作

@RequiresPermissions 需要特定的权限，没有则抛出 AuthorizationException

@RequiresRoles 需要特定的橘色，没有则抛出 AuthorizationException


7.以上就是shiro登陆和鉴权的主要配置和类，下面补充一下其他信息。

①application.properties中shiro-redis相关配置：

  1. spring.redis.shiro.host=127.0.0.1
  2. spring.redis.shiro.port=6379
  3. spring.redis.shiro.timeout=5000
  4. spring.redis.shiro.password=123456

②因为数据是模拟的，所以在登陆认证的时候，并没有通过数据库查用户信息，可以通过以下方式模拟加密后的密码：

  1.     /**
  2.      * 生成测试用的md5加密的密码
  3.      * @param args
  4.      */
  5.     public static void main(String[] args) {
  6.         String hashAlgorithmName = "md5";
  7.         String credentials = "123456";//密码
  8.         int hashIterations = 1024;
  9.         ByteSource credentialsSalt = ByteSource.Util.bytes("root");//账号
  10.         String  obj = new SimpleHash(hashAlgorithmName, credentials, credentialsSalt, hashIterations).toHex();
  11.         System.out.println(obj);
  12.     }

上面obj的结果是b1ba853525d0f30afe59d2d005aad96c

③登陆认证的findByUsername方法，模拟到数据库查询用户信息，实际是自己构造的数据，偷偷懒。

  1.     public UserInfo findByUsername(String userName){
  2.         SysRole admin = SysRole.builder().role("admin").build();
  3.         List<SysPermission> list=new ArrayList<SysPermission>();
  4.         SysPermission sysPermission=new SysPermission("read");
  5.         SysPermission sysPermission1=new SysPermission("write");
  6.         list.add(sysPermission);
  7.         list.add(sysPermission1);
  8.         admin.setPermissions(list);
  9.         UserInfo root = UserInfo.builder().userName("root").password("b1ba853525d0f30afe59d2d005aad96c").credentialsSalt("123").state(0).build();
  10.         List<SysRole> roleList=new ArrayList<SysRole>();
  11.         roleList.add(admin);
  12.         root.setRoleList(roleList);
  13.         return root;
  14.     }

8.结果演示

输入正确的账号密码时，返回信息如下：

 

 故意输错密码时，返回信息如下：

 

鉴权时，如果该用户没有角色：

完！

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Java热门文章

  • 【IDEA】Application context not configured for this file
  • [IDEA] chapter_reader - idea看小说插件 idea阅读插件 idea摸鱼插件
  • thrift常见异常及原因分析
  • Java 调用 PaddleDetection 模型
  • JVM 详解，大白话带你认识 JVM
  • spring-boot-2.0.3不一样系列之番外篇 - @Configuration、Condition与@Conditional
  • Java Comparator.comparing比较导致空指针异常的解决
  • Java使用EasyExcel进行单元格合并的问题详解
  • 死磕 java集合之ArrayBlockingQueue源码分析
  • Java基础之集合Set详解

    • Java推荐文章

  • 面试场景题：一次关于线程池使用场景的讨论。
  • 前端黑科技：使用 JavaScript 实现网页扫码功能
  • 聊一聊 Netty 数据搬运工 ByteBuf 体系的设计与实现
  • 简单设计一个JAVA并行处理工具类
  • 【杂谈】JPA乐观锁改悲观锁遇到的一些问题与思考
  • 认识netty的基本组件
  • Jenkins如何使用CrumbIssuer防御CSRF攻击
  • 如何平稳地从nacos迁移到r-nacos？
  • 线程池遇到父子任务，有大坑，要注意！
  • Java JVM——12. 垃圾回收理论概述

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号