【TGAM-springboot入门练手项目】采用jwt+shiro实现权限管理（二）

Bertha 。 2022-10-25 11:28 14阅读 0赞

# TGAM-springboot入门练手项目 #

> 此项目是个人参与工作室的一个项目，分为硬件、IOS、WEB、后端、数据分析等几大部分，具有实际商用价值。而我虽然只是在其中打杂，写的后端也不够好，但是我会努力地将这系列文章写清楚、详细，若有什么疑问，欢迎QQ：674619459和我交流。另外你的点赞、收藏便是对我最大的鼓励！！  
> GITHUB：https://github.com/lyf712/TGAM-SpringBoot-Vue-Demo>  
> 简单介绍：https://blog.csdn.net/qq\_44654974/article/details/112990344

**开发篇**  
\-----基础篇  
springboot基本使用  
篇1 Springboot学习入门之基本框架搭建和相应准备工作

springboot实现基本功能  
篇2 Springboot整合mybatis实现简单登录功能  
篇3 Springboot调用阿里云SDK短信服务  
篇4 Springboot+mybatis实现简单地增删改查-用户管理  
篇5 Springboot结合Redis实现数据分控制位上传  
篇6 Springboot 定时任务做超时检验

springboot实现安全管理  
[篇7 采用jwt+shiro实现权限管理（一）][7 _jwt_shiro]  
篇8 采用jwt+shiro实现权限管理（二）  
篇9 采用对称和非对称算法进行数据加密传输

\-----提升篇  
篇1 websocket进行长连接传输数据  
篇2 NGINX+tomcat集群  
篇3 初识多线程并发编程  
篇4 初识netty

**部署篇**  
  
篇1 springboot部署阿里云Tomcat  
篇2 springboot+Vue部署阿里云Tomcat并使用NGINX反向代理  
[篇3 springboot+Vue部署阿里云Tomcat并使用NGINX反向代理][3 springboot_Vue_Tomcat_NGINX]

--------------------

### 文章目录 ###

*  TGAM-springboot入门练手项目
 *  前言
 *  一、shiro是什么？
 *   *  1.为什么需要shiro？
     *  2.大致使用流程
 *  二、JWT使用步骤
 *   *  1.引入依赖
     *  2.创建相应的表
     *  3.编写MyRealm
     *  3.配置shiro以及拦截器
     *  4.测试使用
 *  总结

--------------------

# 前言 #

参考文章：  
[shiro官网，整体认知shiro][shiro_shiro]  
[realm注入原理][realm]  
[关于shiro开启realm缓存][shiro_realm]  
[UserNameToken安全性][UserNameToken]  
[深入理解token][token]

[shiro的表的创建][shiro]

学习大致总结

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NjU0OTc0_size_16_color_FFFFFF_t_70_pic_center]

--------------------

# 一、shiro是什么？ #

> Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。

## 1.为什么需要shiro？ ##

(1)易于使用

> 应用程序安全性可能非常令人困惑和沮丧，并被视为“必要的邪恶”。如果您使它易于使用，以使新手程序员可以开始使用它，那么就不必再痛苦了。  
> 全面-Apache Shiro声称没有其他具有范围广度的安全框架，因此它可能是满足安全需求的“一站式服务”。

(2)灵活

> \-Apache Shiro可以在任何应用程序环境中工作。虽然它可以在Web，EJB和IoC环境中运行，但不需要它们。Shiro也不要求任何规范，甚至没有很多依赖性。具有Web功能-Apache Shiro具有出色的Web应用程序支持，允许您基于应用程序URL和Web协议（例如REST）创建灵活的安全策略，同时还提供一组JSP库来控制页面输出。

(3)可插拔

> Shiro干净的API和设计模式使它易于与许多其他框架和应用程序集成。您会看到Shiro与Spring，Grails，Wicket，Tapestry，Mule，Apache Camel，Vaadin等框架无缝集成。

(4)受支持

> Apache Shiro是Apache Software Foundation（Apache软件基金会）的一部分，该组织被证明以其社区的最大利益行事。项目开发和用户群体友好的公民随时可以提供帮助。如果需要，像Katasoft这样的商业公司也可以提供专业的支持和服务。

以上为官方给出的shiro的优点，总而言之，shiro就是灵活、简便、不像springsercurity那样复杂（考虑密码、JVM什么的）、不符合人性。

## 2.大致使用流程 ##

围绕三大关键词：认证、授权、会话安全管理  
三个核心组件：Subject, SecurityManager 和 Realms.去理解

（1）配置Realms 封装DAO，可以理解为shiro来帮助封装role和permission(通过password和username)，因此需要在此进行授权和认证、即加入角色和权限  
（2）将Realms配置到SercurityManager（工厂）中去  
（3）controller中注解@RequireRole或permission  
（4）UserNamePasswordToken来验证

# 二、JWT使用步骤 #

## 1.引入依赖 ##

pom.xml加入

<dependency>
                <groupId>org.apache.shiro</groupId>
                <artifactId>shiro-spring</artifactId>
                <version>1.7.0</version>
            </dependency>

## 2.创建相应的表 ##

请参考[shiro的表的创建][shiro]  
由于时间有限，此处采用模拟数据简化

package com.lyf.service.impl;
    
    import com.lyf.dao.realm.Permissions;
    import com.lyf.dao.realm.Role;
    import com.lyf.dao.realm.User;
    import com.lyf.service.ShiroLoginService;
    import org.springframework.stereotype.Service;
    
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Map;
    import java.util.Set;
    
    @Service
    public class ShiroLoginServiceImpl implements ShiroLoginService { 
    
        @Override
        public User getUserByName(String name) { 
            return getUser(name);
        }
    
        /* 模拟数据库查询 */
    
        private User getUser(String userName){ 
    /* User {user_id,user_name,password,set<Role>} Role {role_id,role_name,set<Permission>} Permission {permission_id,permission_name} */
    
            // 管理员权限 -add(代码 1)
            Permissions permission1 = new Permissions("1","addUser");
            // 管理员权限 -delete（代码 2）
            Permissions permission2 = new Permissions("2","deleteUser");
            Permissions permission3 = new Permissions("3","query");
    
            Set<Permissions> permissionsSet1 = new HashSet<>();
            Set<Permissions> permissionsSet2 = new HashSet<>();
    
            // 添加管理员的权限集合
            permissionsSet1.add(permission1);
            permissionsSet1.add(permission2);
            permissionsSet1.add(permission3);
    
            // 添加普通用户的权限集合
            permissionsSet2.add(permission3);
    
            // 创建角色
            Role admin = new Role("1","admin",permissionsSet1);
            Role custom = new Role("2","custom",permissionsSet2);
            // 外访人员
            Role peripheral = new Role("3","peripheral",permissionsSet2);
    
    
            Set<Role> roleSet1 = new HashSet<>();
            Set<Role> roleSet2 = new HashSet<>();
    
            roleSet1.add(admin);
            roleSet2.add(custom);
            roleSet2.add(peripheral);
    
            User usr1 = new User("1","zhaorui","123321",roleSet1);
            User usr2 = new User("2","Tom22","123321",roleSet2);
            Map<String,User> map = new HashMap<>();
            map.put(usr1.getUserName(),usr1);
            map.put(usr2.getUserName(),usr2);
    
            return map.get(userName);
        }
    
    }

## 3.编写MyRealm ##

package com.lyf.dao.realm;
    
    import com.lyf.service.ShiroLoginService;
    import org.apache.shiro.authc.AuthenticationException;
    import org.apache.shiro.authc.AuthenticationInfo;
    import org.apache.shiro.authc.AuthenticationToken;
    import org.apache.shiro.authc.SimpleAuthenticationInfo;
    import org.apache.shiro.authz.AuthorizationInfo;
    import org.apache.shiro.authz.SimpleAuthorizationInfo;
    import org.apache.shiro.realm.AuthorizingRealm;
    import org.apache.shiro.subject.PrincipalCollection;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.util.StringUtils;
    
    /** * @AUTHO LYF * @DATE 2021-01-31 * @DESC shiro realm * */
        // 权限认证自定义Realm用于查询用户的角色和权限信息并保存到权限管理器
    public class MyRealm extends AuthorizingRealm { 
            @Autowired
            private ShiroLoginService loginService;
    
            @Override
            protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) { 
    
                // 查询用户名
                String name = (String)principalCollection.getPrimaryPrincipal();
                System.out.println("Realm=>"+name);
    
                // 根据用户名查询用户
                User usr = loginService.getUserByName(name);
    
                // 添加角色和权限
                SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
                // 添加角色（名称）
                for(Role role: usr.getRoles()){ 
                    simpleAuthorizationInfo.addRole(role.getRoleName());
    
                    // 添加权限
                    for(Permissions permissions:role.getPermissions()){ 
                        // 添加的权限名称（也可权限对象）
                        simpleAuthorizationInfo.addStringPermission(permissions.getPermissionName());
                    }
    
                }
                return simpleAuthorizationInfo;
            }
    
            @Override
            protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException { 
    if(StringUtils.isEmpty(authenticationToken.getPrincipal())){ 
                    return null;
                }
    
                String name = authenticationToken.getPrincipal().toString();
                User user = loginService.getUserByName(name);
    
                if(user == null){ 
                    return  null;
                }else{ 
                    // 验证
                    // SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo(name,user.getPassword());
                    SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(name,user.getPassword(),getName());
                    return simpleAuthenticationInfo;
                }
           }
    }

## 3.配置shiro以及拦截器 ##

package com.lyf.config;
    import com.lyf.dao.realm.MyRealm;
    import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
    import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
    import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
    import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import java.util.HashMap;
    import java.util.Map;
    
    @Configuration
    public class ShiroConfig { 
    
        @Bean
        @ConditionalOnMissingBean
        public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() { 
            DefaultAdvisorAutoProxyCreator defaultAAP = new DefaultAdvisorAutoProxyCreator();
            defaultAAP.setProxyTargetClass(true);
            return defaultAAP;
        }
    
        //将自己的验证方式加入容器
        @Bean
        public MyRealm myShiroRealm() { 
            MyRealm customRealm = new MyRealm();
            return customRealm;
        }
    
        //权限管理，配置主要是Realm的管理认证
        @Bean
        public DefaultWebSecurityManager securityManager() { 
            DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
            securityManager.setRealm(myShiroRealm());
            return securityManager;
        }
    
        //Filter工厂，设置对应的过滤条件和跳转条件
        @Bean
        public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager securityManager) { 
            ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
            shiroFilterFactoryBean.setSecurityManager((org.apache.shiro.mgt.SecurityManager) securityManager);
            Map<String, String> map = new HashMap<>();
            //登出
            map.put("/logout", "logout");
            //对所有用户认证
    // map.put("/**", "authc");
            //登录
            shiroFilterFactoryBean.setLoginUrl("/login");
            //首页
            shiroFilterFactoryBean.setSuccessUrl("/index");
            //错误页面，认证不通过跳转
            shiroFilterFactoryBean.setUnauthorizedUrl("/error");
            shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
            return shiroFilterFactoryBean;
        }
        @Bean
        public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) { 
            AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
            authorizationAttributeSourceAdvisor.setSecurityManager((org.apache.shiro.mgt.SecurityManager) securityManager);
            return authorizationAttributeSourceAdvisor;
        }
    }

@Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { 
    
            // token应该放在header
            String token = request.getHeader("token");//从header中获取token
    
            // handler??
            if(!(handler instanceof HandlerMethod)){ 
                return true;
            }
    
            HandlerMethod handlerMethod =(HandlerMethod) handler;
            Method method = handlerMethod.getMethod();
    
            // 检查是否有PassToken注解，有则跳过
            if(method.isAnnotationPresent(PassToken.class)){ 
                PassToken passToken = method.getAnnotation(PassToken.class);
                if(passToken.required()){ 
                    return true;
                }
            }
    
            // 检查有无需要用户权限的注解
            if(method.isAnnotationPresent(LoginToken.class)){ 
                LoginToken loginToken = method.getAnnotation(LoginToken.class);
    
                // 执行认证
                if(loginToken.required()){ 
    
                    if (token == null){ 
                       // return resp;
                      throw new RuntimeException("无token,请重新登录");
                    }
    
                    try{ 
    
                        Claim username = JwtUtil.parseToken(token).get("userName");
                        Claim password = JwtUtil.parseToken(token).get("password");
                        /*跳到shiro登录？*/
                        /*解析不出username,password?可能存在JWT生成的token可以解析但是不能解析出来吗*/
                        if(username==null||password==null){ 
                            throw new RuntimeException("无使用该系统权限");
                        }else { 
    
                            String userName = username.asString();
                            String pwd = password.asString();
    
                            /*判断用户名和密码是否为空*/
                            if (StringUtils.isEmpty(userName) || StringUtils.isEmpty(pwd)) { 
                                throw new RuntimeException("用户和密码有误");
                            }
    
                            //用户认证信息
                            Subject subject = SecurityUtils.getSubject();
                            UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(
                                    userName,
                                    pwd
                            );
    
                            try { 
                                //进行验证，这里可以捕获异常，然后返回对应信息
                                subject.login(usernamePasswordToken);
    // subject.checkRole("admin");
    // subject.checkPermissions("query", "add");
                            } catch (UnknownAccountException e) { 
                                throw new RuntimeException("用户名不存在");
                            } catch (AuthenticationException e) { 
                                throw new RuntimeException("账号或密码错误");
                            } catch (AuthorizationException e) { 
                                throw new RuntimeException("无该API权限");
                            }
    
    
                        }
                    }catch (JWTDecodeException e){ 
                        throw new RuntimeException("无使用该系统权限");
                    }
    
                    try { 
                        JwtUtil.verifyToken(token);
                    }catch (Exception e){ 
                        throw new RuntimeException("凭证已过期,请重新登录");
                    }
                    return true;
                }
            }
            return true;
        }

## 4.测试使用 ##

（1）采用不同权限的用户登录获取 不同token（在postman请求得到token在放到header去请求需要权限的api，此处就不贴图了）  
Tom22 (只有query用户)  
zhaorui(admin)

（2）编写测试controller

编写如下，按道理带Tom22用户的token去请求以下的URL只能index可以，admin就无权限，zhaorui就有权限。下面试试是否符合。见（3）的结果截图。

@RequiresRoles("admin")
        @LoginToken
        @GetMapping("/admin")
        public String admin() { 
            return "admin success!";
        }
    
        @RequiresPermissions("query")
        @LoginToken
        @GetMapping("/index")
        public String index() { 
            return "index success!";
        }
    
        @RequiresPermissions("addUser")
        @LoginToken
        @GetMapping("/add")
        public String add() { 
            return "add success!";
        }

（3）验证结果  
带Tom22的token去访问admin，如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NjU0OTc0_size_16_color_FFFFFF_t_70_pic_center 1]  
访问index，(query权限）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NjU0OTc0_size_16_color_FFFFFF_t_70_pic_center 2]  
带zhaorui的token访问admin如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NjU0OTc0_size_16_color_FFFFFF_t_70_pic_center 3]

# 总结 #

重点理解权限、角色的关系以及匹配url或者资源。然后关于shiro主要理解realm（授权）,sercurityManager（管理）,UserNamePasswodToken（认证）

[7 _jwt_shiro]: https://blog.csdn.net/qq_44654974/article/details/113447118
[3 springboot_Vue_Tomcat_NGINX]: https://blog.csdn.net/qq_44654974/article/details/112854834
[shiro_shiro]: https://www.infoq.com/articles/apache-shiro/
[realm]: https://blog.csdn.net/weixin_36833780/article/details/85111545
[shiro_realm]: https://www.cnblogs.com/fan-yuan/p/8072253.html
[UserNameToken]: https://blog.csdn.net/whiteclude/article/details/2554203
[token]: https://www.cnblogs.com/xuxinstyle/p/9675541.html
[shiro]: https://blog.csdn.net/m0_38065515/article/details/82421147
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NjU0OTc0_size_16_color_FFFFFF_t_70_pic_center]: /images/20221024/71a04f93d7f44a3383c7bcd12baa1dc7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NjU0OTc0_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221024/0cf03d8c87244906ae654acff24eb09a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NjU0OTc0_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221024/2f8ffbbd0f88438c9337577e4400fecc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NjU0OTc0_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221024/a0ddee052e6f4a34b8e85323805f272e.png