shiro认证- SpringBoot（20）

1.认识shiro

  除Spring Security安全框架外，应用非常广泛的就是Apache的强大又灵活的开源安全框架 Shiro,在国内使用量远远超过Spring Security。它能够用于身份验证、授权、加密和会话管理， 有易于理解的API,可以快速、轻松地构建任何应用程序。而且大部分人觉得从Shiro入门要比 Spring Security 简单。
  1.1 认识Shiro的核心组件

Shiro有如下核心组件。

• Subject：代表当前“用户”。与当前应用程序交互的任何东西都是Subject,如爬虫、机器人、所有Subject都绑定到SecurityManager，与Subject的所有交互都会委托给 SecurityManager，Subject 是一个门面，SecurityManager 是实际的执行者。
  
• SecurityManager：与安全有关的操作都会与SecurityManager交互。它管理着所有 Subject，是Shiro的核心，员责与其他组件进行交互。
  
• Realm： Shiro从Realm中获取安全数据(用户、角色、权限)，SecurityManager 需要 从Realm中获取相应的用户信息进行比较用户身份是否合法，也需要从Realm中得到用户 相应的角色/权限进行验证，以确定用户是否能进行操作。
  

2.实例：用shiro实现管理后台的动态权限功能

  依赖：

1. <dependency>
2.     <groupId>org.apache.shiro</groupId>
3.     <artifactId>shiro-spring</artifactId>
4.     <version>1.9.1</version>
5. </dependency>
6. <dependency>
7.     <groupId>org.apache.commons</groupId>
8.     <artifactId>commons-lang3</artifactId>
9. </dependency>

复制代码

  2.1 创建实体


  2.1.1 创建管理员实体


  创建管理实体，用于存放管理员信息，见以下代码：

1. package com.intehel.demo.domain;
3. import lombok.Data;
4. import javax.persistence.*;
5. import java.io.Serializable;
6. import java.util.List;
8. @Entity
9. @Data
10. public class Admin implements Serializable {
11.     @Id
12.     @GeneratedValue
13.     private Integer id;
14.     @Column(unique = true)
15.     //账号
16.     private String username;
17.     //名称
18.     private String name;
19.     //密码
20.     private String password;
21.     //盐加密
22.     private String salt;
23.     //用户状态：0：创建未认证，等待验证 1：正常状态 2：用户被锁定
24.     private byte state;
25.     @ManyToMany(fetch = FetchType.EAGER)
26.     @JoinTable(name = "SysUserRole",joinColumns = {@JoinColumn(name = "uid")},
27.             inverseJoinColumns = {@JoinColumn(name = "roleId")})
28.     private List<SysRole> rolesList;
29. }

复制代码

  2.1.2 创建权限实体

  权限实体用于存放权限数据，见以下代码：

1. package com.intehel.demo.domain;
3. import lombok.Data;
4. import javax.persistence.*;
5. import java.io.Serializable;
6. import java.util.List;
8. @Entity
9. @Data
10. public class SysPermission implements Serializable {
11.     @Id
12.     @GeneratedValue
13.     private Integer id;
14.     private String name;
15.     @Column(columnDefinition = "enum('menu','button')")
16.     private String resourceType;
17.     private String url;
18.     private String permission;
19.     private Long parentId;
20.     private String parentIds;
21.     private Boolean avaliable = Boolean.FALSE;
22.     @ManyToMany
23.     @JoinTable(name = "SysRolePermission",joinColumns = {@JoinColumn(name = "permissionId")},
24.             inverseJoinColumns = {@JoinColumn(name = "roleId")})
25.     private List<SysRole> rolesList;
27. }

复制代码

  2.1.3 创建角色实体

  角色实体是管理员的角色，用于对管理员分组，并通过与权限表映射来确定管理员的权限，见以下代码：

1. package com.intehel.demo.domain;
3. import lombok.Data;
4. import javax.persistence.*;
5. import java.util.List;
7. @Entity
8. @Data
9. public class SysRole {
10.     @Id
11.     @GeneratedValue
12.     private Integer id;
13.     @Column(unique = true)
14.     private String role;
15.     private String description;
16.     private Boolean available = Boolean.FALSE;
17.     @ManyToMany(fetch = FetchType.EAGER)
18.     @JoinTable(name = "SysRolePermission",joinColumns = {@JoinColumn(name = "roleId")},
19.             inverseJoinColumns = {@JoinColumn(name = "permissionId")})
20.     private List<SysPermission> permissions;
21.     @ManyToMany
22.     @JoinTable(name = "SysUserRole",joinColumns = {@JoinColumn(name = "roleId")},
23.             inverseJoinColumns = {@JoinColumn(name = "uid")})
24.     private List<Admin> admins;
25. }

复制代码

  2.2 进行权限配置

1. package com.intehel.demo.realm;
3. import com.intehel.demo.domain.Admin;
4. import com.intehel.demo.domain.SysPermission;
5. import com.intehel.demo.domain.SysRole;
6. import org.apache.shiro.authc.AuthenticationException;
7. import org.apache.shiro.authc.AuthenticationInfo;
8. import org.apache.shiro.authc.AuthenticationToken;
9. import org.apache.shiro.authc.SimpleAuthenticationInfo;
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.apache.shiro.util.ByteSource;
16. public class CustomerRealm extends AuthorizingRealm {
17.     @Override
18.     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
19.         SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
20.         Admin adminInfo = (Admin) principalCollection.getPrimaryPrincipal();
21.         for (SysRole role : adminInfo.getRolesList()) {
22.             info.addRole(role.getRole());
23.             for (SysPermission p:role.getPermissions()){
24.                 info.addStringPermission(p.getPermission());
25.             }
26.         }
27.         return info;
28.     }
30.     @Override
31.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
32.         String username = (String) authenticationToken.getPrincipal();
33.         System.out.println(authenticationToken.getCredentials());
34.         Admin adminInfo = new Admin();
35.         adminInfo.setUsername("long");
36.         adminInfo.setPassword("longzhonghua");
37.         adminInfo.setSalt("yan");
38.         SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(
39.                 adminInfo,adminInfo.getPassword(),
40.                 ByteSource.Util.bytes(adminInfo.getSalt()),
41.                 getName()
42.         );
43.         return info;
44.     }
45. }

复制代码

  2.3 将shiro注入到spring容器中

1. package com.intehel.demo.config;
3. import com.intehel.demo.realm.CustomerRealm;
4. import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
5. import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
6. import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
7. import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
8. import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
9. import org.springframework.context.annotation.Bean;
10. import org.springframework.context.annotation.Configuration;
11. import org.apache.shiro.mgt.SecurityManager;
12. import java.util.HashMap;
13. import java.util.Map;
15. @Configuration
16. public class ShiroConfig {
18.     @Bean
19.     @ConditionalOnMissingBean
20.     public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
21.         DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
22.         defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
23.         return  defaultAdvisorAutoProxyCreator;
24.     }
26.     // 将自己验证的方式加入到容器中
27.     @Bean
28.     public CustomerRealm customRealm() {
29.         CustomerRealm customRealm = new CustomerRealm();
30.         return customRealm;
31.     }
33.     //权限管理,配置主要是Realm的管理认证
34.     @Bean
35.     public SecurityManager securityManager() {
36.         DefaultWebSecurityManager  defaultSecurityManager = new DefaultWebSecurityManager ();
37.         defaultSecurityManager.setRealm(customRealm());
38.         return defaultSecurityManager;
39.     }
40.     @Bean
41.     public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
42.         ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
43.         shiroFilterFactoryBean.setSecurityManager(securityManager);
44.         Map<String,String> map = new HashMap<>();
45.         // 登出
46.         map.put("/logout","logout");
47.         // 对所有用户进行认证
48.         map.put("/**","authc");
49.         //登录
50.         shiroFilterFactoryBean.setLoginUrl("/login");
51.         // 首页
52.         shiroFilterFactoryBean.setSuccessUrl("/index");
53.         // 错误页面 认证不通过跳转
54.         shiroFilterFactoryBean.setUnauthorizedUrl("/error");
55.         shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
56.         return shiroFilterFactoryBean;
57.     }
60.     @Bean
61.     public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
62.         AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
63.         authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
64.         return authorizationAttributeSourceAdvisor;
65.     }
68. }

复制代码

  2.4 编写控制层

1. package com.intehel.demo.controller;
2. import com.intehel.demo.domain.Admin;
3. import lombok.extern.slf4j.Slf4j;
4. import org.apache.commons.lang3.StringUtils;
5. import org.apache.shiro.SecurityUtils;
6. import org.apache.shiro.authc.AuthenticationException;
7. import org.apache.shiro.authc.UnknownAccountException;
8. import org.apache.shiro.authc.UsernamePasswordToken;
9. import org.apache.shiro.authz.AuthorizationException;
10. import org.apache.shiro.authz.annotation.RequiresPermissions;
11. import org.apache.shiro.authz.annotation.RequiresRoles;
12. import org.apache.shiro.subject.Subject;
13. import org.springframework.web.bind.annotation.GetMapping;
14. import org.springframework.web.bind.annotation.RestController;
16. @RestController
17. @Slf4j
18. public class LoginController {
20.     @GetMapping("/login")
21.     public String login(Admin user) {
22.         if(StringUtils.isEmpty(user.getUsername()) || StringUtils.isEmpty(user.getPassword())) {
23.             return "请输入用户名和密码";
24.         }
26.         // 用户认证信息
27.         Subject subject = SecurityUtils.getSubject();
28.         UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(user.getUsername(),user.getPassword());
29.         try {
30.             // 进行验证,这里可以捕获异常,然后返回对应信息
31.             subject.login(usernamePasswordToken);
32.         }catch (UnknownAccountException e) {
33.             log.error("用户名不存在",e);
34.             return "用户名不存在";
35.         } catch (AuthenticationException e) {
36.             log.error("账号或者密码错误!",e);
37.             return "账号或者密码错误!";
38.         } catch (AuthorizationException e) {
39.             log.error("没有权限！",e);
40.             return "没有权限";
41.         }
42.         return "login success";
43.     }
46.     @RequiresRoles("admin")
47.     @GetMapping("/admin")
48.     public String admin() {
49.         return "admin Success!";
50.     }
52.     @RequiresPermissions("query")
53.     @GetMapping("/index")
54.     public String index() {
55.         return "index success";
56.     }
58.     @RequiresPermissions("add")
59.     @GetMapping("/add")
60.     public String add() {
61.         return "add success";
62.     }
64. }

复制代码

  2.5 测试权限

  （1）向sql中插入数据

1. INSERT INTO `admin` (`id`, `name`, `password`, `salt`, `state`, `username`) VALUES (1, '管理员', '32baebda76498588dabf64c6e8984097', 'yan', 0, 'long');
2. INSERT INTO `sys_permission` (`id`, `avaliable`, `name`, `parent_id`, `parent_ids`, `permission`, `resource_type`, `url`) VALUES (1, b'0', '用户管理', 0, '0/', 'admin:view', 'menu', 'admin/list');
3. INSERT INTO `sys_permission` (`id`, `avaliable`, `name`, `parent_id`, `parent_ids`, `permission`, `resource_type`, `url`) VALUES (2, b'0', '用户添加', 1, '0/1', 'admin:add', 'button', 'admin/add');
4. INSERT INTO `sys_permission` (`id`, `avaliable`, `name`, `parent_id`, `parent_ids`, `permission`, `resource_type`, `url`) VALUES (3, b'0', '用户删除', 1, '0/1', 'admin:del', 'button', 'admin/del');
5. INSERT INTO `sys_role` (`id`, `available`, `description`, `role`) VALUES (1, b'0', '管理员', 'admin');
6. INSERT INTO `sys_role_permission` (`role_id`, `permission_id`) VALUES (1, 1);
7. INSERT INTO `sys_role_permission` (`role_id`, `permission_id`) VALUES (1, 2);
8. INSERT INTO `sys_role_permission` (`role_id`, `permission_id`) VALUES (1, 3);
9. INSERT INTO `sys_user_role` (`role_id`, `uid`) VALUES (1, 1);

复制代码

   （2）测试登录

  
  2.6  对比 Spring Security 与 Shiro

  （1）Shiro的特点

• 功能强大，且简单、灵活。
  
• 拥有易于理解的API。
  
• 简单的身份认证(登录)，支持多种数据源(LDAP、JDBC、Kerberos、ActiveDirectory等)。
  
• 支持对角色的简单签权，并且支持细粒度的签权。
  
• 支持一级缓存，以提升应用程序的性能。
  
• 内置的基于POJO会话管理，适用于Web,以及非Web环境。
  
• 不跟任何的框架或容器捆绑，可以独立运行。
  

  （2）Spring Security 的特点。

• Shiro的功能它都有
  
• 对防止CSRF跨站、XSS跨站脚本可以很好地实现，对Oauth、OpenlD也有支持。Shiro 则需要开发者自己手动实现。
  
• 因为Spring Security是Spring自己的产品，所以对Spring的支持极好，但也正是因为这个，所以仅仅支持自己的产品，导致其捆绑到了 Spring框架，而不支持其他框架。
  
• Spring Security的权限细粒度更高(这不是绝对的，Shiro也可以实现)。
  

 

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