2流高手速成记（之五）：Springboot整合Shiro实现安全管理 ...

废话不多说，咱们直接接上回
上一篇我们讲了如何使用Springboot框架整合Nosql，并于文章最后部分引入了服务端Session的概念
而早在上上一篇中，我们则已经讲到了如何使用Springboot框架整合Mybatis/MybatisPlus实现业务数据的持久化（写入数据库）
本篇我们把关注点放在一个于这两部分有共同交集的内容——安全管理，并且引入我们今天的主角——Shiro框架

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

Shiro框架包含三个核心组件：

Subject —— 泛指当前与Shiro交互中的实体，可以是用户或者某后台进程
SecurityManager —— Shiro的核心组件，对内管理各种组件实例，对外提供各种安全服务
Realm —— Shiro与安全数据之间的桥接器

Shiro框架还包含有其他诸多概念，为降低大家的心智负担，这些我们暂且不谈，文末会给大家推荐延展阅读的相关文章
还是老规矩直接上干货，以完整的实例让大家对【如何基于Shiro实现权限的细粒度控制】有一个整体上的认知
 
 
 
不知道大家会不会觉得项目结构突然变复杂？别担心，接下来我会给大家逐一拆解
1. 创建数据表

首先是角色表——role

 

 
 
 
 然后是用户表——user

 

 
 
 最后是权限表——permission


 

 2. 创建三个对应的Mapper

1. package com.example.hellospringboot.mapper;
3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
4. import com.example.hellospringboot.model.Role;
5. import org.apache.ibatis.annotations.Mapper;
6. import org.springframework.stereotype.Repository;
8. @Mapper
9. @Repository
10. public interface RoleMapper extends BaseMapper<Role> {
11. }

复制代码

1. package com.example.hellospringboot.mapper;
3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
4. import com.example.hellospringboot.model.User;
5. import org.apache.ibatis.annotations.Mapper;
6. import org.springframework.stereotype.Repository;
8. @Mapper
9. @Repository
10. public interface UserMapper extends BaseMapper<User> {
11. }

复制代码

1. package com.example.hellospringboot.mapper;
3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
4. import com.example.hellospringboot.model.Permission;
5. import org.apache.ibatis.annotations.Mapper;
6. import org.springframework.stereotype.Repository;
8. @Mapper
9. @Repository
10. public interface PermissionMapper extends BaseMapper<Permission> {
11. }

复制代码

这里我们用到了上上一节讲到的内容
这里的Mapper会辅助于后续的安全数据读取

3. 接下来是Service及其实现类

1. package com.example.hellospringboot.service;
3. import com.example.hellospringboot.model.Role;
5. public interface RoleService {
6.     Role findRoleById(int id);
7. }

复制代码

1. package com.example.hellospringboot.service.impl;
3. import com.example.hellospringboot.mapper.RoleMapper;
4. import com.example.hellospringboot.model.Role;
5. import com.example.hellospringboot.service.RoleService;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.stereotype.Service;
9. @Service
10. public class RoleServiceImpl implements RoleService {
12.     @Autowired
13.     RoleMapper mapper;
15.     public Role findRoleById(int id){
16.         Role role = mapper.selectById(id);
17.         return role;
18.     }
19. }

复制代码

1. package com.example.hellospringboot.service;
3. import com.example.hellospringboot.model.User;
5. public interface UserService {
6.     boolean checkUserByUsernameAndPassword(String userName, String passWord);
7.     User findUserByUserName(String userName);
8. }

复制代码

1. package com.example.hellospringboot.service.impl;
3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
4. import com.example.hellospringboot.mapper.UserMapper;
5. import com.example.hellospringboot.model.User;
6. import com.example.hellospringboot.service.UserService;
7. import org.springframework.beans.factory.annotation.Autowired;
8. import org.springframework.stereotype.Service;
10. import java.util.List;
12. @Service
13. public class UserServiceImpl implements UserService {
15.     @Autowired
16.     UserMapper mapper;
18.     public boolean checkUserByUsernameAndPassword(String userName, String passWord){
19.         QueryWrapper<User> wrapper = new QueryWrapper<User>();
20.         wrapper = wrapper.eq("user_name", userName).eq("pass_word",passWord);
21.         List<User> userList = mapper.selectList(wrapper);
22.         return userList.size() > 0;
23.     }
25.     public User findUserByUserName(String userName){
26.         QueryWrapper<User> wrapper = new QueryWrapper<User>();
27.         wrapper = wrapper.eq("user_name", userName);
28.         User user = mapper.selectOne(wrapper);
29.         return user;
30.     }
32. }

复制代码

1. package com.example.hellospringboot.service;
3. import com.example.hellospringboot.model.Permission;
5. import java.util.List;
7. public interface PermissionService {
8.     List<Permission> findPermissionsByRoleId(int roleId);
9. }

复制代码

1. package com.example.hellospringboot.service.impl;
3. import com.baomidou.mybatisplus.core.conditions.Wrapper;
4. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
5. import com.example.hellospringboot.mapper.PermissionMapper;
6. import com.example.hellospringboot.model.Permission;
7. import com.example.hellospringboot.service.PermissionService;
8. import org.springframework.beans.factory.annotation.Autowired;
9. import org.springframework.stereotype.Service;
11. import java.util.List;
13. @Service
14. public class PermissionServiceImpl implements PermissionService {
16.     @Autowired
17.     PermissionMapper mapper;
19.     public List<Permission> findPermissionsByRoleId(int roleId){
20.         QueryWrapper<Permission> wrapper = new QueryWrapper<>();
21.         wrapper = wrapper.eq("role_id", roleId);
22.         List<Permission> list = mapper.selectList(wrapper);
23.         return list;
24.     }
26. }

复制代码

ok，我们已经准备好了所有的安全数据，及对应的读取方法
到这里，我们就算是做好了所有的准备工作
接下来看我们如何通过Shiro框架来运用这些已经装配好的枪炮子弹
4. 引入Shiro框架相关依赖（pom.xml）

1.         
2.         <dependency>
3.             <groupId>org.apache.shiro</groupId>
4.             <artifactId>shiro-spring</artifactId>
5.             <version>1.10.0</version>
6.         </dependency>

复制代码

这次pom.xml终于不是第一步了，哈哈哈。。。
5. 创建Realm嫁接Shiro框架及安全数据（realm/MyAuthorizingRealm）

1. package com.example.hellospringboot.realm;
3. import com.example.hellospringboot.model.Permission;
4. import com.example.hellospringboot.model.Role;
5. import com.example.hellospringboot.model.User;
6. import com.example.hellospringboot.service.PermissionService;
7. import com.example.hellospringboot.service.RoleService;
8. import com.example.hellospringboot.service.UserService;
9. import org.apache.shiro.authc.*;
10. import org.apache.shiro.authz.AuthorizationInfo;
11. import org.apache.shiro.authz.SimpleAuthorizationInfo;
12. import org.apache.shiro.realm.AuthorizingRealm;
13. import org.apache.shiro.subject.PrincipalCollection;
14. import org.springframework.beans.factory.annotation.Autowired;
16. import java.util.HashSet;
17. import java.util.List;
18. import java.util.Set;
20. public class MyAuthorizingRealm extends AuthorizingRealm {
22.     @Autowired
23.     UserService userService;
25.     @Autowired
26.     RoleService roleService;
28.     @Autowired
29.     PermissionService permissionService;
31.     @Override
32.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) {
33.         UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
34.         String userName = token.getUsername();
35.         String passWord = String.valueOf(token.getPassword());
36.         if (!userService.checkUserByUsernameAndPassword(userName, passWord)) {//判断用户账号是否正确
37.             throw new UnknownAccountException("用户名或密码错误!");
38.         }
39.         return new SimpleAuthenticationInfo(userName, passWord, getName());
40.     }
42.     @Override
43.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
44.         SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
45.         String userName = principalCollection.getPrimaryPrincipal().toString();
46.         User user = userService.findUserByUserName(userName);
47.         if (user == null) {
48.             throw new UnknownAccountException("用户名或密码错误!");
49.         }
50.         List<Integer> rolesList = user.rolesList();
51.         Set<String> roles = new HashSet<>();
52.         Set<String> permissions = new HashSet<>();
53.         for (Integer roleId : rolesList) {
54.             Role role = roleService.findRoleById(roleId);
55.             roles.add(role.getName());
56.             List<Permission> permissionList = permissionService.findPermissionsByRoleId(roleId);
57.             for (Permission permission : permissionList) {
58.                 permissions.add(permission.getName());
59.             }
60.         }
61.         info.setRoles(roles);
62.         info.setStringPermissions(permissions);
63.         return info;
64.     }
65. }

复制代码

Realm的创建对于整个Shiro安全验证体系搭建而言是至关重要的一步！
其中两个抽象方法

doGetAuthenticationInfo —— 用于校验用户名及密码的合法性
doGetAuthorizationInfo —— 用于赋予实体对应的角色及交互权限

6. 测试用Controller创建

1. package com.example.hellospringboot.controller;
3. import org.apache.shiro.SecurityUtils;
4. import org.apache.shiro.authc.AuthenticationException;
5. import org.apache.shiro.authc.UsernamePasswordToken;
6. import org.apache.shiro.subject.Subject;
7. import org.springframework.web.bind.annotation.GetMapping;
8. import org.springframework.web.bind.annotation.PostMapping;
9. import org.springframework.web.bind.annotation.RequestMapping;
10. import org.springframework.web.bind.annotation.RestController;
12. @RequestMapping("/user")
13. @RestController
14. public class UserController {
16.     @PostMapping("/login")
17.     public String login(String user, String pass) {
18.         UsernamePasswordToken token = new UsernamePasswordToken(user, pass);
19.         Subject subject = SecurityUtils.getSubject();
20.         if(!subject.isAuthenticated()) {
21.             try {
22.                 subject.login(token);
23.             } catch (AuthenticationException e) {
24.                 return e.getMessage();
25.             }
26.         }
27.         return "ok";
28.     }
30.     @PostMapping("/logout")
31.     public String logout(){
32.         Subject subject = SecurityUtils.getSubject();
33.         if(subject.isAuthenticated()) {
34.             try {
35.                 subject.logout();
36.             } catch (AuthenticationException e) {
37.                 return e.getMessage();
38.             }
39.         }
40.         return "ok";
41.     }
43.     @GetMapping("/admin")
44.     public String admin() {
45.         return "admin";
46.     }
48.     @GetMapping("/user")
49.     public String user() {
50.         return "user";
51.     }
53. }

复制代码

内容很简单：

login——登录方法
logout——登出方法
admin、user——两个测试方法，用于测试不同角色对于不同方法可访问的细粒度控制

7. ShiroConfig配置类创建，实现用户访问权限的细粒度控制

1. package com.example.hellospringboot.configure;
3. import com.example.hellospringboot.realm.MyAuthorizingRealm;
4. import org.apache.shiro.mgt.SecurityManager;
5. import org.apache.shiro.realm.Realm;
6. import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
7. import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
8. import org.springframework.context.annotation.Bean;
9. import org.springframework.context.annotation.Configuration;
11. import java.util.LinkedHashMap;
12. import java.util.Map;
14. @Configuration
15. public class ShiroConfig {
17.     @Bean
18.     public SecurityManager securityManager(Realm realm) {
19.         DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
20.         securityManager.setRealm(realm);
21.         return securityManager;
22.     }
24.     @Bean
25.     public MyAuthorizingRealm getRealm() {
26.         MyAuthorizingRealm realm = new MyAuthorizingRealm();
27.         return realm;
28.     }
30.     @Bean
31.     public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
32.         ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean();
33.         shiroFilter.setSecurityManager(securityManager);
34.         Map<String, String> filterChainMap = new LinkedHashMap<String, String>();
35.         filterChainMap.put("/user/login", "anon");
36.         filterChainMap.put("/user/logout", "anon");
37.         filterChainMap.put("/user/admin", "authc,roles[admin],perms[admin:read]");
38.         filterChainMap.put("/user/user", "authc,roles[user],perms[user:read]");
39.         shiroFilter.setFilterChainDefinitionMap(filterChainMap);
40.         return shiroFilter;
41.     }
42. }

复制代码

 
securityManager 和 getRealm 显示指定了Shiro两大组件的实例声明
shiroFilterFactoryBean 则是实现角色访问权限控制的重要方法

        filterChainMap.put("/user/login", "anon"); // 代表login方法可以匿名访问
        filterChainMap.put("/user/logout", "anon"); // 代表logout方法可以匿名访问
        filterChainMap.put("/user/admin", "authc,roles[admin],perms[admin:read]"); // 代表admin方法需要用户满足admin角色，同时具备admin:read权限
        filterChainMap.put("/user/user", "authc,roles[user],perms[user:read]"); // 代表user方法需要用户满足user角色，同时具备user:read权限

至此，整个接入流程便结束了
我们再次结合最开始我们配置的数据来对业务逻辑进行分析

用户 admin，同时具备admin、user两种角色
用户 juste，仅具备user一种角色
角色 admin，同时具备admin:write、admin:read两种权限
角色 user，同时具备user:write、user:read两种权限

因此

用户 admin，同时具备admin:write、admin:read、user:write、user:read 四种操作权限
用户 juste，同时具备user:write、user:read两种操作权限

大家理清楚这其中的关系了吗？^ ^
8. 执行Postman验证结果


 
 我们在执行login之前，admin方法无权访问

 
 
 
 
 
 登录admin之后，同时具备admin和user方法的访问权限



 
logout登出，然后login登录普通用户juste
会发现依然具备user方法的访问权限，但是失去了admin方法的访问权限
到此，验证我们基于Shiro框架的细粒度权限控制已经实现
除了Shiro框架，我们还有另一个选择，那就是同样可以通过集成Spring Security框架来达成相同的目的
关于更多Shiro框架的内容，及其和Spring Security之间的异同，大家感兴趣可以参考这篇文章：
Shiro最全基础教程_思月行云的博客-CSDN博客
对于Spring Security框架，我们暂且留个悬念，以后会专门再给大家讲解这部分内容
下一节，我们将把关注点投向微服务领域，SpringCloudAlibaba将会是接下来几个章节的重头戏，敬请期待~
 
 
 

1. MyAuthorizingRealm

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！