通知 网站从因情语写改为晴雨,这个网站的模板也从calmlog_ex改为 whimurmur
文章来源于网络,无法注明出处的还请谅解,如果出处注明错误(如仍是载转),请联系我修改

shiro框架详解(转载)

392人浏览 / 0人评论 / | 这是对我有帮助的文章  | 分类: 技术介绍使用  | 标签: 转载

作者:未知

链接:https://blog.csdn.net/pengjwhx/article/details/84867112

来源:CSDN

1. shiro简介以及功能描述

Shiro 是 Java 的一个安全框架。目前,使用 Apache Shiro 的人越来越多,因为它相 当简单,对比 Spring Security,可能没有 Spring Security 做的功能强大,但是在实际工作时 可能并不需要那么复杂的东西,所以使用小而简单的 Shiro 就足够了。

Authentication:身份认证/登录,验证用户是不是拥有相应的身份;
Authorization:授权,即权限验证,验证某个已认证的用户是否拥有某个权限;即判断用户是否能做事情,常见的如:验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限;
Session Manager:会话管理,即用户登录后就是一次会话,在没有退出之前,它的所有信息都在会话中;会话可以是普通 JavaSE 环境的,也可以是如 Web 环境的;
Cryptography:加密,保护数据的安全性,如密码加密存储到数据库,而不是明文存储;
Web Support:Web 支持,可以非常容易的集成到 Web 环境;
Caching:缓存,比如用户登录后,其用户信息、拥有的角色/权限不必每次去查,这样可以提高效率;
Concurrency:shiro 支持多线程应用的并发验证,即如在一个线程中开启另一个线程,能把权限自动传播过去;
Testing:提供测试支持;
Run As:允许一个用户假装为另一个用户(如果他们允许)的身份进行访问;
Remember Me:记住我,这个是非常常见的功能,即一次登录后,下次再来的话不用登录记住一点,Shiro 不会去维护用户、维护权限;这些需要我们自己去设计/提供;然后通过相应的接口注入给 Shiro 即可。

2. shiro实现原理理解

也就是说对于我们而言,最简单的一个 Shiro 应用:
应用代码通过 Subject 来进行认证和授权,而 Subject 又委托给 SecurityManager; 我们需要给 Shiro 的 SecurityManager 注入 Realm,从而让 SecurityManager 能得到合法
的用户及其权限进行判断。

3. shiro的架构理解

Subject:主体,可以看到主体可以是任何可以与应用交互的“用户”;
SecurityManager : 相 当 于 SpringMVC 中 的 DispatcherServlet 或 者 Struts2 中的FilterDispatcher;是 Shiro 的心脏;所有具体的交互都通过 SecurityManager 进行控制;它管理着所有 Subject、且负责进行认证和授权、及会话、缓存的管理。
Authenticator:认证器,负责主体认证的,这是一个扩展点,如果用户觉得 Shiro 默认的不好,可以自定义实现;其需要认证策略(Authentication Strategy),即什么情况下算用户认证通过了;
Authrizer:授权器,或者访问控制器,用来决定主体是否有权限进行相应的操作;即控制着用户能访问应用中的哪些功能;
Realm:可以有 1 个或多个 Realm,可以认为是安全实体数据源,即用于获取安全实体的;可以是 JDBC 实现,也可以是 LDAP 实现,或者内存实现等等;由用户提供;注意:Shiro不知道你的用户/权限存储在哪及以何种格式存储;所以我们一般在应用中都需要实现自己的 Realm;
SessionManager:如果写过 Servlet 就应该知道 Session 的概念,Session 呢需要有人去管理它的生命周期,这个组件就是 SessionManager;而 Shiro 并不仅仅可以用在 Web 环境,也可以用在如普通的 JavaSE 环境、EJB 等环境;所有呢,Shiro 就抽象了一个自己的 Session来管理主体与应用之间交互的数据;这样的话,比如我们在 Web 环境用,刚开始是一台Web 服务器;接着又上了台 EJB 服务器;这时想把两台服务器的会话数据放到一个地方,这个时候就可以实现自己的分布式会话(如把数据放到 Memcached 服务器);
SessionDAO:DAO 大家都用过,数据访问对象,用于会话的 CRUD,比如我们想把 Session保存到数据库,那么可以实现自己的 SessionDAO,通过如 JDBC 写到数据库;比如想把Session 放到 Memcached 中,可以实现自己的 Memcached SessionDAO;另外 SessionDAO中可以使用 Cache 进行缓存,以提高性能;
CacheManager:缓存控制器,来管理如用户、角色、权限等的缓存的;因为这些数据基本上很少去改变,放到缓存中后可以提高访问的性能
Cryptography:密码模块,Shiro 提高了一些常见的加密组件用于如密码加密

4. shiro认证功能(Authentication)流程

@Test
public void testHelloworld() {
//1、获取 SecurityManager 工厂,此处使用 Ini 配置文件初始化 SecurityManager
Factory<org.apache.shiro.mgt.SecurityManager> factory =
new IniSecurityManagerFactory("classpath:shiro.ini");
//2、得到 SecurityManager 实例 并绑定给 SecurityUtils
org.apache.shiro.mgt.SecurityManager securityManager = factory.getInstance();
SecurityUtils.setSecurityManager(securityManager);
//3、得到 Subject 及创建用户名/密码身份验证 Token(即用户身份/凭证)
Subject subject = SecurityUtils.getSubject();
// UsernamePasswordToken 继承
UsernamePasswordToken token = new UsernamePasswordToken("zhang", "123");
try {
//4、登录,即身份验证
subject.login(token);
} catch (AuthenticationException e) {
//5、身份验证失败
}
Assert.assertEquals(true, subject.isAuthenticated()); //断言用户已经登录
//6、退出
subject.logout();

1、UsernamePasswordToken 实现HostAuthenticationToken和RemeberAuthenticationToken,HostAuthenticationToken实现AuthenticationToken
2、首先调用 Subject.login(token)进行登录,其会自动委托给 Security Manager,调用之前必须通过 SecurityUtils. setSecurityManager()设置;
3、SecurityManager 负责真正的身份验证逻辑;它会委托给 Authenticator 进行身份验证;SecurityManager j接口继承Authenticator、Authrizer、sessionManage接口
4、Authenticator 才是真正的身份验证者,Shiro API 中核心的身份认证入口点,此处可以自定义插入自己的实现;
5、Authenticator 可能会委托给相应的 AuthenticationStrategy 进行多 Realm 身份验证,默认ModularRealmAuthenticator 会调用 AuthenticationStrategy 进行多 Realm 身份验证;
6、Authenticator 会把相应的 token 传入 Realm,从 Realm 获取身份验证信息,如果没有返回/抛出异常表示身份验证失败了。此处可以配置多个 Realm,将按照相应的顺序及策略进行访问。

SecurityManager实现类结构关系。

Realm

一般继承 AuthorizingRealm(授权)即可;其继承了 AuthenticatingRealm(即身份验证),而且也间接继承了 CachingRealm(带有缓存实现),重写里面AuthenticationInfo 认证和doGetAuthorizationInfo授权方法。

5. shiro授权实现的方式以及流程

  • 基于角色的访问控制(隐式角色)
  • 基于资源的访问控制(显示角色)
    实现方式:
// 1. 编程式(单个和多个角色)
subject.hasRole(“admin”), Array.aslist("admin1","admin2");

//2. 注解
@RequiresRoles("admin")

//3. 页面控制
<shiro:hasRole name="admin">

//4. shiro配置文件中配置
 <property name="filterChainDefinitions">
            <value>
                /commons/** = anon
                /plugins/** = anon
                /assets/** = anon
                /css/** = anon
                /js/** = anon
                /img/** = anon
                /fonts/** = anon
                /bootstrap/** = anon
                /login = anon
                /interface/** = anon
                /** = user
                
            </value>
</property>

 shiro 拦截器规则:

实现流程:

6. shiro集成spring框架代码实现

引入的shiro-All jar包

        <!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-all  shiro-->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-all</artifactId>
            <version>1.4.0</version>
            <type>pom</type>
        </dependency>
        
        <!-- https://mvnrepository.com/artifact/org.ehcache/ehcache  缓存-->
        <dependency>
            <groupId>org.ehcache</groupId>
            <artifactId>ehcache</artifactId>
            <version>3.6.0</version>
        </dependency>

在web.xml中配置shiroFilter

<filter>
<filter-name>shiroFilter</filter-name>
<!--通过代理设置,有spring 创建交由servlet管理 -->
<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
<init-param>
 <!--表示用bean 的生命周期由servlet管理 -->
<param-name>targetFilterLifecycle</param-name>
<param-value>true</param-value>
</init-param>
<init-param>
 <!--表示spring中bean的id,若不配置,改属性默认和filter-name一致-->
<param-name>targetBeanName</param-name>
<param-value>shiroFilter</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>shiroFilter</filter-name>
<url-pattern>/*</url-pattern>
<dispatcher>REQUEST</dispatcher>
<dispatcher>FORWARD</dispatcher>
</filter-mapping>

添加spring-shiro.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">


    <!-- 定义shiro安全管理器,并配置需要实现的功能-->
    <bean id="securityManager" class="org.apache.shiro.mgt.DefaultSecurityManager">
   <!--实现realm功能-->
   <property name="shiroRealm"   ref="shiroRealm"/>
    <!--实现cacheManager功能-->
    <property name="cacheManager" ref="cacheManager"/>
     <!--实现seeionManager功能-->
    <property name="sessionManager" ref="sessionManager"/>
    <!--实现记住我功能-->
    <property name="remeberMe"  ref="remeberMe"/>
    </bean>


<!-- 定义自己实现的realm域,并配置凭证匹配器-->
    <bean id="shiroRealm" class="com.entity.ShiroRealm">
        <property name="credentialsMatcher" ref="credentialsMatcher"/>
    </bean>

<!-- 配置shiro过滤器-->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
    <property name="securityManager" ref="securityManager"/>
    <property name="loginUrl" value="/login"/>
    <property name="successUrl" value="/index"/>
    <property name="unauthorizedUrl" value="/unauth"/>
    <property name="filterChainDefinitions">
        <value>
            /commons/** = anon
            /plugins/** = anon
            /assets/** = anon
            /css/** = anon
            /js/** = anon
            /img/** = anon
            /fonts/** = anon
            /bootstrap/** = anon
            /index = user           <!--user表示用remeberMe功能-->
            /login = anon           <!--登录页面可以匿名访问 -->
            /interface/** = anon     <!--anon表示可以匿名访问-->
            /logout=logout          <!--登出功能 -->
            /** = user
        </value>
    </property>



</bean>

    <!--配置logout登出管理,id只能为logout,并且在shiro拦截器中需要定义lgout-->
    <bean id="logout" class="org.apache.shiro.web.filter.authc.LogoutFilter">
        <property name="redirectUrl" value="/login"/>
    </bean>

<!--实现cacha缓存,读取ehcache配置文件-->
    <bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
    <property name="cacheManagerConfigFile" value="classpath:config/ehcache.xml"/>
    </bean>

 <!--配置session管理器-->
    <bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
        <property name="globalSessionTimeout" ref="300000"/>
        <property name="deleteInvalidSessions" value="true"/>
    </bean>

    <!--设置记住我-->
    <bean id="remeberMe" class="org.apache.shiro.web.mgt.CookieRememberMeManager">
    <property name="cookie" ref="remeberMeCookies"/>
    </bean>

<!-- cookis配置-->
    <bean id="remeberMeCookies"  class="org.apache.shiro.web.servlet.SimpleCookie">
        <!--设置最大存活时间和cookie名称-->
        <property name="maxAge" value="604800"/>
        <property name="name" value="remeberMe"/>
    </bean>

    <!--开启shiro权限注解功能,并配置securityManager属性-->
    <aop:config proxy-target-class="true"></aop:config>
    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
        <property name="securityManager" ref="securityManager"/>
    </bean>


<!--定义凭证匹配器,也就是对密码进行算法加密和次数-->
    <bean id="credentialsMatcher" class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
        <property name="hashAlgorithmName" value="md5"/>
        <property name="hashIterations" value="2"/>
    </bean>

<!--配置ahtuc过滤器(表单域名称),在页面中账号和密码的name属性的值必须和下面定义的相同-->
    <bean id ="authc" class="org.apache.shiro.web.filter.authc.FormAuthenticationFilter">
        <property name="usernameParam" value="username"/>
        <property name="passwordParam" value="password"/>
        <property name="rememberMeParam" value="remeberMe"/>
    </bean>


    <!--异常处理-->
    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        <property name="exceptionMappings" >
 <props>
<!--认证异常和授权异常 -->
     <prop key="org.apache.shiro.authz.UnauthenticatedException">login</prop>
     <prop key="org.apache.shiro.authz.UnauthorizedException">refuse</prop>
 </props>
        </property>

    </bean>


    <!-- 保证实现了Shiro内部lifecycle函数的bean执行,另一种实现注解的方式 -->
  <!--  <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>
    &lt;!&ndash; AOP式方法级权限检查 &ndash;&gt;
    <bean
            class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
            depends-on="lifecycleBeanPostProcessor">
        <property name="proxyTargetClass" value="false" />
    </bean>
    &lt;!&ndash; 启用shrio授权注解拦截方式 &ndash;&gt;
    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
        <property name="securityManager" ref="securityManager"/>
    </bean>-->
</beans>

ehcache配置文件

<ehcache>
    <!-- 指定一个目录:当 EHCache 把数据写到硬盘上时, 将把数据写到这个目录下.-->
    <diskStore path="d:\\tempDirectory"/>
    <!-- 设置缓存的默认数据过期策略 -->
    <defaultCache
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            overflowToDisk="true"
    />
    <!--
        设定具体的命名缓存的数据过期策略。每个命名缓存代表一个缓存区域
        缓存区域(region):一个具有名称的缓存块,可以给每一个缓存块设置不同的缓存策略。
        如果没有设置任何的缓存区域,则所有被缓存的对象,都将使用默认的缓存策略。即:<defaultCache.../>
        Hibernate 在不同的缓存区域保存不同的类/集合。
         对于类而言,区域的名称是类名。如:com.atguigu.domain.Customer
         对于集合而言,区域的名称是类名加属性名。如com.atguigu.domain.Customer.orders
    -->
    <!--
        name: 设置缓存的名字,它的取值为类的全限定名或类的集合的名字
        maxElementsInMemory: 设置基于内存的缓存中可存放的对象最大数目

        eternal: 设置对象是否为永久的, true表示永不过期, 此时将忽略timeToIdleSeconds 和 timeToLiveSeconds属性; 默认值是false
       timeToIdleSeconds:设置对象空闲最长时间,以秒为单位, 超过这个时间,对象过期。当对象过期时,EHCache会把它从缓存中清除。如果此值为0,表示对象可以无限期地                  处于空闲状态。
        timeToLiveSeconds:设置对象生存最长时间,超过这个时间,对象过期。如果此值为0,表示对象可以无限期地存在于缓存中.
                该属性值必须大于或等于 timeToIdleSeconds 属性值

        overflowToDisk:设置基于内存的缓存中的对象数目达到上限后,是否把溢出的对象写到基于硬盘的缓存中
    -->
    <cache name="com.atguigu.hibernate.entities.Employee"
           maxElementsInMemory="1"
           eternal="false"
           timeToIdleSeconds="300"
           timeToLiveSeconds="600"
           overflowToDisk="true"
    />
    <cache name="com.atguigu.hibernate.entities.Department.emps"
           maxElementsInMemory="1000"
           eternal="true"
           timeToIdleSeconds="0"
           timeToLiveSeconds="0"
           overflowToDisk="false"
    />
</ehcache>

用户实体类 (实现Serializable)

public class StudentDTO implements Serializable {
    private String stuNo; //学生学号
    private String stuName; //名字
    private String stuAge; //年龄
    private  String cno; //课程号
    private  String score; //分数
    private String stuGender;//性别
    private String password; //密码
    private String salt; //密码加密盐
    /** 更新时间 */
    private Date modifyDate;

    public String getStuNo() {
        return stuNo;
    }

    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }

    public String getStuName() {
        return stuName;
    }

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public String getStuAge() {
        return stuAge;
    }

    public void setStuAge(String stuAge) {
        this.stuAge = stuAge;
    }

    public String getStuGender() {
        return stuGender;
    }

    public void setStuGender(String stuGender) {
        this.stuGender = stuGender;
    }

    public String getCno() {
        return cno;
    }

    public void setCno(String cno) {
        this.cno = cno;
    }

    public String getScore() {
        return score;
    }

    public void setScore(String score) {
        this.score = score;
    }

    public Date getModifyDate() {
        return modifyDate;
    }

    public void setModifyDate(Date modifyDate) {
        this.modifyDate = modifyDate;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getSalt() {
        return salt;
    }

    public void setSalt(String salt) {
        this.salt = salt;
    }
}

自定义的ShiroRealm域

    @Autowired
    StudentService studentService;

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {

 
        // 从 principals获取主身份信息,将getPrimaryPrincipal方法返回值转为真实身份类型(在上边的doGetAuthenticationInfo认证通过填充到SimpleAuthenticationInfo中身份类型),
        String userName = (String) principalCollection.getPrimaryPrincipal()
        
        // 根据身份信息获取权限信息,模拟从数据库获取到数据
        List<String> permissions = new ArrayList<String>();
        permissions.add("user:create");// 用户的创建
        permissions.add("items:add");// 商品添加权限
      
        // 查到权限数据,返回授权信息(要包括 上边的permissions)
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        // 将上边查询到授权信息填充到simpleAuthorizationInfo对象中
        simpleAuthorizationInfo.addStringPermissions(permissions);

        return simpleAuthorizationInfo;
    
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
        //从authenticationToken获取用户名
        StudentDTO un = studentService.getStudentDTOBystuNo(token.getUsername());
        // 账号不存在
        if (un == null) {
            return null;
        }
        //去认证
        return new SimpleAuthenticationInfo(un, un.getPassword(), ByteSource.Util.bytes(un.getSalt()),getName());
    }


    //清理缓存方法
    public void clearCache(){
        Subject subject= SecurityUtils.getSubject();
        //获得用户信息,并清除
        super.clearCache(subject.getPrincipals());
    }
}

常用的权限注解

@RequiresAuthentication
表示当前 Subject 已经通过 login 进行了身份验证;即 Subject. isAuthenticated()返回 true
@RequiresUser
表示当前 Subject 已经身份验证或者通过记住我登录的。
@RequiresGuest
表示当前 Subject 没有身份验证或通过记住我登录过,即是游客身份
@RequiresRoles(value={“admin”, “user”}, logical= Logical.AND)
表示当前 Subject 需要角色 admin 和 user。
@RequiresPermissions (value={“user:a”, “user:b”}, logical= Logical.OR)
表示当前 Subject 需要权限 user:a 或 user:b

shiro 框架controller实现

@SystemControllerLog(operatePoint=OperatePointConstants.LOGIN, operateType=OperateTypeConstants.LOGIN)
   @PostMapping("/login")
   @CsrfToken(remove = true)
   @ResponseBody
   public Object loginPost(String username, String password) {
       logger.info("POST请求登录");


       if (StringUtils.isBlank(username)) {
           return renderError("用户名不能为空");
       }
       if (StringUtils.isBlank(password)) {
           return renderError("密码不能为空");
       }else{
       password = SymmetricEncoder.encryptStr(secretkey, password);
        LOGGER.info(password);
       }
       Subject user = SecurityUtils.getSubject();
       UsernamePasswordToken token = new UsernamePasswordToken(username,password);
       Result result=new Result();
       try {
           user.login(token);                                                                                                                                                          //在这一步跳入入自己实现的域即shiroDbRealm中验证
           return renderSuccess();
       } catch (UnknownAccountException e) {
       result.setMsg("账号不存在");
       return result;
           /*throw new RuntimeException("账号不存在!", e);*/
       } catch (DisabledAccountException e) {
       result.setMsg("账号未启用");
       return result;
           /*throw new RuntimeException("账号未启用", e);*/
       } catch (IncorrectCredentialsException e) {
       result.setMsg("密码错误,请重试");
       return result;
           /*throw new RuntimeException("密码错误,请重试", e);*/
       } catch (Throwable e) {
       result.setMsg("未知错误,请联系管理员");
       return result;
          throw new RuntimeException("未知错误,请联系管理员", e);
       }
      
   }

 


亲爱的读者:如果你喜欢文章的话,不妨点赞评论支持原作者一下吧


点赞(0) 打赏

全部评论

还没有评论!