shiro权限管理框架学习

忘是亡心i 2021-09-23 10:46 419阅读 0赞

# 一、权限框架简介 #

基本上涉及到用户参与的系统都要进行权限管理，权限管理属于系统安全的范畴，权限管理实现对用户访问系统的控制，按照安全规则或者安全策略控制用户可以访问而且只能访问自己被授权的资源。权限管理包括用户身份认证和授权两部分，简称认证授权。对于需要访问控制的资源用户首先经过身份认证，认证通过后用户具有该资源的访问权限方可访问。

# 二、shiro介绍 #

Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。

# 三、shiro架构 #

![在这里插入图片描述][20191108214331497.png]

# 四、shiro架构中核心组件 #

## 4.1 Subject ##

Subject即主体，外部应用与subject进行交互，subject记录了当前操作用户，将用户的概念理解为当前操作的主体，可能是一个通过浏览器请求的用户，也可能是一个运行的程序。Subject在shiro中是一个接口，接口中定义了很多认证授相关的方法，外部程序通过subject进行认证授，而subject是通过SecurityManager安全管理器进行认证授权

## 4.2 SecurityManager ##

SecurityManager即安全管理器，对全部的subject进行安全管理，它是shiro的核心，负责对所有的subject进行安全管理。通过SecurityManager可以完成subject的认证、授权等，实质上SecurityManager是通过Authenticator进行认证，通过Authorizer进行授权，通过SessionManager进行会话管理等。

SecurityManager是一个接口，继承了Authenticator, Authorizer, SessionManager这三个接口。

## 4.3 Authenticator ##

Authenticator即认证器，对用户身份进行认证，Authenticator是一个接口，shiro提供ModularRealmAuthenticator实现类，通过ModularRealmAuthenticator基本上可以满足大多数需求，也可以自定义认证器。

## 4.4 Authorizer ##

Authorizer即授权器，用户通过认证器认证通过，在访问功能时需要通过授权器判断用户是否有此功能的操作权限。

## 4.5 realm ##

Realm即领域，相当于datasource数据源，securityManager进行安全认证需要通过Realm获取用户权限数据，比如：如果用户身份数据在数据库那么realm就需要从数据库获取用户身份信息。

注意：不要把realm理解成只是从数据源取数据，在realm中还有认证授权校验的相关的代码。

## 4.6 sessionManager ##

sessionManager即会话管理，shiro框架定义了一套会话管理，它不依赖web容器的session，所以shiro可以使用在非web应用上，也可以将分布式应用的会话集中在一点管理，此特性可使它实现单点登录。

## 4.7 SessionDAO ##

SessionDAO即会话dao，是对session会话操作的一套接口，比如要将session存储到数据库，可以通过jdbc将会话存储到数据库。

## 4.8 CacheManager ##

CacheManager即缓存管理，将用户权限数据存储在缓存，这样可以提高性能。

## 4.9 Cryptography ##

Cryptography即密码管理，shiro提供了一套加密/解密的组件，方便开发。比如提供常用的散列、加/解密等功能。

# 五、springboot+shiro+mybatis实现动态权限管理 #

## 5.1 创建ShiroConfig ##

package com.lcy.demo.shiro;
    
    
    import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
    import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import java.util.LinkedHashMap;
    import java.util.Map;
    
    @Configuration
    public class ShiroConfig { 
        //创建一个ShiroFilterFactoryBean
    
        @Bean
        public ShiroFilterFactoryBean getshiroFilterFactoryBean(@Qualifier("securityManager") DefaultWebSecurityManager securityManager) { 
            ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
    
            //设置安全管理器
            shiroFilterFactoryBean.setSecurityManager(securityManager);
    
            //shiro的内置过滤器
    
            /** * shiro内置过滤器,可以实现权限相关的拦截器 * 常用的过滤器: * anon:无需认证(登录)可以访问 * authc:必须认证才可以访问 * User:如果使用rememberMe的功能可以直接访问 * perms: 该资源必须得到资源权限才可以访问 * role：该资源必须得到角色权限才可以直接访问 */
    
            //进行拦截
            Map<String, String> filtermap = new LinkedHashMap<String, String>();
    
    // filtermap.put("/add", "authc");
    // filtermap.put("/update", "authc");
    
    // 无需验证
            filtermap.put("/test", "anon");
    
    // 放行login.html页面
            filtermap.put("/login", "anon");
    
    //授权拦截器 当授权被拦截后 shiro会自动跳到未授权的页面
            filtermap.put("/add", "perms[user:add]");
            filtermap.put("/update", "perms[user:update]");
    
    // 使用通配的方式进行拦截(同一目录下的静态资源)
            filtermap.put("/*", "authc");
    
    
            shiroFilterFactoryBean.setLoginUrl("/toLogin");
    // 设置未授权提示的页面
            shiroFilterFactoryBean.setUnauthorizedUrl("/unAuth");
            shiroFilterFactoryBean.setFilterChainDefinitionMap(filtermap);
    
            return shiroFilterFactoryBean;
        }
    
        //创建一个DefaultWebSecuritManager
        @Bean(name = "securityManager")
        public DefaultWebSecurityManager getdefaultWebSecurityManager(@Qualifier("userRealm") UserRealm userRealm) { 
            DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
            //关联Realm
            securityManager.setRealm(userRealm);
            return securityManager;
        }
    
        //创建Realm
        @Bean(name = "userRealm")
        public UserRealm getRealm() { 
            return new UserRealm();
        }
    }

## 5.2 自定义UserRealm ##

package com.lcy.demo.shiro;
    
    import com.lcy.demo.Service.UserService;
    import com.lcy.demo.pojo.User;
    import org.apache.shiro.SecurityUtils;
    import org.apache.shiro.authc.*;
    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.apache.shiro.subject.Subject;
    import org.springframework.beans.factory.annotation.Autowired;
    
    
    /** * shiro的两大核心 认证和授权 */
    public class UserRealm extends AuthorizingRealm { 
    
        /** * 执行授权逻辑 * * @param principalCollection * @return */
        @Override
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) { 
            System.out.println("执行授权逻辑");
    
            SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
    
    // 添加资源的授权字符串
    // info.addStringPermission("user:add");
    
    // 到数据库查询当前登录用户的授权字符串
    // 获取当前的用户
    
            Subject subject = SecurityUtils.getSubject();
            User user = (User) subject.getPrincipal();
            System.out.println(user.getId());
            User dbUser = userService.findById(user.getId());
    
            info.addStringPermission(dbUser.getPerms());
    
            return info;
        }
    
    
        @Autowired
        private UserService userService;
    
        /** * 执行认证逻辑 * * @param authenticationToken * @return * @throws AuthenticationException */
        @Override
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException { 
            System.out.println("执行认证逻辑");
    
    // 编写shiro的认证逻辑 判断用户名和密码
    
            UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
    
            User user = userService.findByName(token.getUsername());
    
            if (user == null) { 
                //用户名不存在
                return null;//shiro底层会抛出UnknownAccountException
            }
    // 判断密码
            return new SimpleAuthenticationInfo(user, user.getPassword(), "");
        }
    }

## 5.3 UserMapper.java ##

package com.lcy.demo.mapper;
    
    import com.lcy.demo.pojo.User;
    
    import java.util.List;
    
    public interface UserMapper { 
    
        int deleteByPrimaryKey(Integer id);
    
    
        int insert(User record);
    
    
        User selectByPrimaryKey(Integer id);
    
        List<User> selectAll();
    
    
        int updateByPrimaryKey(User record);
    
    
        public User findByName(String name);
    
        public User findById(Integer id);
    }

## 5.4 UserMapper.xml ##

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    <mapper namespace="com.lcy.demo.mapper.UserMapper">
        <resultMap id="BaseResultMap" type="com.lcy.demo.pojo.User">
    
            <id column="id" property="id" jdbcType="INTEGER"/>
            <result column="user" property="user" jdbcType="VARCHAR"/>
            <result column="password" property="password" jdbcType="VARCHAR"/>
        </resultMap>
        <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
    
            delete from user
            where id = #{ id,jdbcType=INTEGER}
        </delete>
        <insert id="insert" parameterType="com.lcy.demo.pojo.User">
    
            insert into user (id, user, password
            )
            values (#{ id,jdbcType=INTEGER}, #{ user,jdbcType=VARCHAR}, #{ password,jdbcType=VARCHAR}
            )
        </insert>
        <update id="updateByPrimaryKey" parameterType="com.lcy.demo.pojo.User">
    
            update user
            set user = #{ user,jdbcType=VARCHAR},
            password = #{ password,jdbcType=VARCHAR}
            where id = #{ id,jdbcType=INTEGER}
        </update>
        <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Integer">
    
            select id, user, password
            from user
            where id = #{ id,jdbcType=INTEGER}
        </select>
        <select id="selectAll" resultMap="BaseResultMap">
    
            select id, user, password
            from user
        </select>
    
        <select id="findByName" resultMap="BaseResultMap">
        select id, user, password
        from user where user=#{ value}
      </select>
    
    
        <select id="findById" resultMap="BaseResultMap">
        select id, user, password,perms
        from user where id=#{ value}
    
      </select>
    </mapper>

## 5.5 UserService ##

package com.lcy.demo.Service;
    
    import com.lcy.demo.pojo.User;
    
    public interface UserService { 
        public User findByName(String name);
    
        public User findById(Integer id);
    }

## 5.6 UserServiceImpl ##

package com.lcy.demo.ServiceImpl;
    
    import com.lcy.demo.Service.UserService;
    import com.lcy.demo.mapper.UserMapper;
    import com.lcy.demo.pojo.User;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    
    @Service
    public class UserServiceImpl implements UserService { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Override
        public User findByName(String name) { 
            return userMapper.findByName(name);
        }
    
        @Override
        public User findById(Integer id) { 
            return userMapper.findById(id);
        }
    }

## 5.7 application.properties ##

server.port=8080
    spring.mvc.view.prefix=/
    spring.mvc.view.suffix=.html
    spring.datasource.driver-class-name=com.mysql.jdbc.Driver
    spring.datasource.url=jdbc:mysql://localhost:3306/shiro?useUnicode=true&characterEncoding=utf8
    spring.datasource.username=root
    spring.datasource.password=111111
    
    spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
    mybatis.type-aliases-package=com.lcy.demo.pojo
    
    # mybatis 配置
    mybatis.mapper-locations=classpath:mapper/*.xml

## 5.8 UserController ##

package com.lcy.demo.controller;
    
    import com.lcy.demo.Service.UserService;
    import org.apache.shiro.SecurityUtils;
    import org.apache.shiro.authc.IncorrectCredentialsException;
    import org.apache.shiro.authc.UnknownAccountException;
    import org.apache.shiro.authc.UsernamePasswordToken;
    import org.apache.shiro.subject.Subject;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    @Controller
    public class UserController { 
    
        @Autowired
        private UserService userService;
    
        /** * 处理登录逻辑 * * @param name * @param password * @param model * @return */
        @RequestMapping("/login")
        public String login(String name, String password, Model model) { 
    
            System.out.println("name" + name);
            /** * 使用shiro编写认证操作 */
    // 1、获取subject
            Subject subject = SecurityUtils.getSubject();
    // 2、封装用户数据
            UsernamePasswordToken token = new UsernamePasswordToken(name, password);
    // 3、执行登录的方法
            /** * 没有出现异常： * 则登录成功 * 出现异常： * UnknownAccountException： 用户名不存在 * IncorrectCredentialsException： 密码错误 */
            try { 
                subject.login(token);
                return "redirect:/test";
            } catch (UnknownAccountException e) { 
                model.addAttribute("msg", "用户名不存在");
                return "login";
            } catch (IncorrectCredentialsException e) { 
                model.addAttribute("msg", "密码错误");
                return "login";
            }
        }
    
        @RequestMapping("/hh")
        public String tm(Model model) { 
            model.addAttribute("name", "lcy ");
            return "tm";
        }
    
    
    }

# 六、所需要的依赖 #

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.apache.shiro</groupId>
                <artifactId>shiro-spring</artifactId>
                <version>1.4.0</version>
            </dependency>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-thymeleaf</artifactId>
                <version>2.1.9.RELEASE</version>
            </dependency>
            
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>1.3.2</version>
            </dependency>
            
            <dependency>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-core</artifactId>
                <version>1.3.2</version>
                <scope>compile</scope>
                <optional>true</optional>
            </dependency>
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.38</version>
            </dependency>
            
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.12</version>
            </dependency>

[20191108214331497.png]: /images/20210923/95bc8306643c43f289af4b3953132e84.png