精华内容
下载资源
问答
  • shiro知识点整理

    2020-08-16 21:17:04
    shiro是一个强大易用的安全框架,提供了认证、授权、加密、会话管理、与web集成、缓存等功能,对于任何一个应用程序,都可以提供全面的安全服务,相比其他安全框架shiro要简单的多。 三个核心组件:Subject, ...

    一、 什么是shiro

    shiro是一个强大易用的安全框架,提供了认证、授权、加密、会话管理、与web集成、缓存等功能,对于任何一个应用程序,都可以提供全面的安全服务,相比其他安全框架,shiro要简单的多。

    三个核心组件:Subject, SecurityManager 和 Realms

    1、subject

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

    2、SecurityManager

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

    3、Realm

    Realm充当了Shiro与应用安全数据间的“桥梁”或者“连接器”。也就是说,当对用户执行认证(登录)和授权(访问控制)验证时,Shiro会从应用配置的Realm中查找用户及其权限信息。

    从这个意义上讲,Realm实质上是一个安全相关的DAO:它封装了数据源的连接细节,并在需要时将相关数据提供给Shiro。当配置Shiro时,你必须至少指定一个Realm,用于认证和(或)授权。配置多个Realm是可以的,但是至少需要一个。

    二、shiro框架的核心功能

    1、Authentication 身份认证
    身份认证/登录,验证用户是不是拥有相应的身份;

    1、收集用户身份/凭证
    2、调用 Subject.login 进行登录
    3、创建自定义的 Realm类,继承 org.apache.shiro.realm.AuthorizingRealm 类,实现 doGetAuthenticationInfo() 方法
    4、提供 principals (身份)和 credentials(证 明)给 shiro,从而应用能验证用户身份

    2、Authorization 授权

    授权,即权限验证,验证某个已认证的用户是否拥有某个权限;即判断用户是否能做事情,常见的如:验证某个用户是否拥有某个角色。或者验证某个用户对某个资源是否具有某个权限

    3、sessionManager

    会话管理,即用户登录后就是一次会话,在没有退出之前,它的所有信息都在会话中;会话可以是普通 JavaSE 环境的,也可以是如 Web 环境的;
    它不依赖web容器的session,所以shiro可以使用在非web应用上,也可以将分布式应用的会话集中在一点管理,此特性可使它实现单点登录。

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

    比如用户登录后,其用户信息、拥有的角色/权限不必每次去查,这样可以提高效率;

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

    加密,保护数据的安全性,如密码加密存储到数据库,而不是明文存储

    6、session DAO
    提供了session的增删改插

    7、Web Support

    Web 支持,可以非常容易的集成到 Web 环境;

    8、Remember Me

    记住我,这个是非常常见的功能,即一次登录后,下次再来的话不用登录。
    记住一点,Shiro 不会去维护用户、维护权限;这些需要我们自己去设计/提供;然后通过相应的接口注入给 Shiro 即可

    三、Shiro的优点

    简单的身份认证,支持多种数据源

    非常简单的加密API

    对角色的简单的授权,支持细粒度的授权(方法级)

    支持一级缓存,以提升应用程序的性能

    内置的基于POJO企业会话管理,适用于Web以及非Web的环境

    不跟任何的框架或者容器捆绑,可以独立运行

    四、比较Spring Security和Apache Shiro

    相比Spring Security,Shiro在保持强大功能的同时,使用简单性和灵活性

    Spring Security:即便是一个一个简单的请求,最少得经过它的8个Filter

    Spring Security必须在Spring的环境下使用

    初学Spring Security,曲线还是较大,需要深入学习其源码呵呵框架,配置起来也较费力

    展开全文
  • 安全框架Shiro使用.doc

    2020-08-22 17:46:37
    安全框架Shiro的上课知识点整理。由上课老师编写的每一个知识点与整合的概要。非常好的整体复习方案, 需要的赶紧下载
  • Java系列技术之安全框架Shiro

    千人学习 2018-12-31 23:47:02
    在SSM基础下整合使用安全框架Shiro,本课将设计导Spring和Shrio整合起来应用的核心知识点都讲到了,学习本课后能够在项目中将Shro用起来。
  • 通过阅读这篇文章,你可以了解到shiro是什么、shiro的架构、shiro如何支持web环境的安全验证等。

     推荐文章

    安全框架对比:shiro vs spring-security_陈海龙的格物之路-CSDN博客shiro和spring-security都是安全框架,两者有哪些相同点和差异呢?https://blog.csdn.net/chl87783255/article/details/120436997shiro实现分布式session和url权限验证_陈海龙的格物之路-CSDN博客本文讲述了如何基于shiro实现分布式session和url权限验证。https://blog.csdn.net/chl87783255/article/details/120435903

    目标

    通过阅读这篇文章,你可以了解到shiro是什么、shiro的架构、shiro如何支持web环境的安全验证等。

    what

    shiro作为安全框架,保证应用程序可以安全的使用,针对认证、授权、加密、session管理提供了综合解决方案。 

    架构

    直接看图

    组件介绍

    组件名简介
    Subject与应用进行交互的用户视图。shiro以Subject为中心提供API
    SecurityManager

    作为shiro架构的核心,负责协调各种组件开展工作。

    Authenticator负责用户登录时的身份认证。协调一个或多个Realms以获取用户信息,由Authentication Strategy决定身份认证的结果。
    Authorizer负责用户的授权验证。协调一个或多个数据源以获取角色权限信息,然后进行访问控制。
    SessionManager

    负责创建和管理用户session。

    与其他安全框架相比,shiro有个独特特性,即无论什么环境(不仅仅是web容器),都能提供健壮的session体验。

    SessionDAO,负责session持久化。

    CacheManager创建和管理Cache实例,以便其他shiro组件使用。shiro在提供身份认证、授权验证、session管理的能力时,提供了多种数据源支持,为了提升性能,使用cache时必然的要求,而且支持多种cache框架。
    Realms作为shiro与数据源之间的桥梁,将两者联系起来。身份认证、授权验证,shiro都需要通过Realms去读取数据。

    身份认证

    术语

    subject与应用进行交互的实体(用户\第三方服务\定时任务)的安全视图  用户指与应用程序交互的任何事物、
    principals当事人,subject的识别属性
    credentials凭证,用于身份验证的机密数据
    realms代表访问接口,用于访问存储安全信息的后端数据源,例如DAO。每个realm对应一个数据源。

    认证流程

    1. 收集subject的识别属性和机密数据
    2. 向认证系统提交收集的数据
    3. 结果:允许访问、再次认证、拒绝访问 

    授权验证

    三个元素:权限、角色、用户

    权限细粒度的安全策略,可作为能力的描述,代表可以在系统中做什么。
    角色代表一批权限,简便管理权限和用户的关系
    用户应用的访问者,shiro使用subject代表一个用户。

    控制方式

    编码 

    • 角色检查
      • subject.hasRole("role")
    • 权限检查
      • subject.isPermitted(Permission)
      • subject.isPermitted("PermissionPath") 

    注解(方法级别 )

    • @RequiresPermissions("account:create")
    • @RequiresRoles( "teller" ) 

    原理

    提供web支持

    ShiroWebAutoConfiguration

    • autoconfig的配置 
    @Configuration
    @AutoConfigureBefore(ShiroAutoConfiguration.class)
    @AutoConfigureAfter(ShiroWebMvcAutoConfiguration.class)
    @ConditionalOnProperty(name = "shiro.web.enabled", matchIfMissing = true)
    • 生成DefaultWebSecurityManager bean,以及生成各种可扩展的bean default实例。

    ShiroWebFilterConfiguration

    • ShiroFilterFactoryBean作为提供SpringShiroFilter实例的工厂。
    • 注册SpringShiroFilter,其继承AbstractShiroFilter。

    shiroFilter内部可以调用filters

    public enum DefaultFilter {
        anon(AnonymousFilter.class),
        authc(FormAuthenticationFilter.class),
        authcBasic(BasicHttpAuthenticationFilter.class),
        authcBearer(BearerHttpAuthenticationFilter.class),
        logout(LogoutFilter.class),
        noSessionCreation(NoSessionCreationFilter.class),
        perms(PermissionsAuthorizationFilter.class),
        port(PortFilter.class),
        rest(HttpMethodPermissionFilter.class),
        roles(RolesAuthorizationFilter.class),
        ssl(SslFilter.class),
        user(UserFilter.class),
        invalidRequest(InvalidRequestFilter.class);
    }

    通过定义ShiroFilterChainDefinition Bean,可以自定义配置url使用哪些filter。

    @Bean
        public ShiroFilterChainDefinition shiroFilterChainDefinition() {
            DefaultShiroFilterChainDefinition chainDefinition = new DefaultShiroFilterChainDefinition();
            /*
             * 按照添加顺序进行匹配,建议之前的urlPattern不要包含之后的urlPattern
             */
    
            // 使用authc、roles filters, 即需要登录,且角色admin
            chainDefinition.addPathDefinition("/demo/**", "authc, roles[admin]");
    
            // 使用authc、logout filters,需要登录
            chainDefinition.addPathDefinition("/logout", "authc, logout");
    
            // 使用authc filters,需要登录,不做授权验证
            chainDefinition.addPathDefinition("/**", "authc");
    
            return chainDefinition;
        }

    InvalidRequestFilter

    • 检查URL path,拒绝分号、反斜杆、非ascii码字符

    FormAuthenticationFilter

    处理的请求为:POST 且 loginUrl。

    流程

    • 获取username password数据,组装成usernamePasswordToken
    • 从上下文读取(组装)subject,WebDelegatingSubject
    • 调用subject.login(AuthenticationToken)
      • securityManager.login(subject,token)
        • authenticator.authenticate(token)
          • realm获取用户信息并进行身份认证
        • 认证成功则新建subject

    若欲详细查看流程,我建议的debug起点 

    org.apache.shiro.web.servlet.AbstractShiroFilter#doFilterInternal 

    DefaultWebSessionManager

    • sessionId存储到cookie
    • 依赖SessionDAO读取session

    注解支持

    主要类作用
    ShiroAnnotationProcessorAutoConfiguration支持shiro注解而进行的配置
    AuthorizationAttributeSourceAdvisor定义切面:关注点(joinPoint)作为匹配器的筛选条件,匹配结果作为切入点(pointCut),且需要提供个性化切面行为(advice),构成一个advisor。
    AopAllianceAnnotationsAuthorizingMethodInterceptor切面行为advice  由注解对应的拦截器构成拦截器责任链,遍历拦截器进行授权检测
    MethodInterceptor实现invoke(MethodInvocation),在原行为前后添加自定义行为。

    自定义扩展

    Realm

    定义如何获取安全数据,如用户、权限。

    不建议直接实现该接口,而是建议继承AuthenticatingRealm或AuthorizingRealm。

    继承类AuthenticatingRealm,可方便实现获取身份信息的realm,实现抽象方法doGetAuthenticationInfo,例如返回SimpleAuthenticationInfo。

    继承类AuthorizingRealm,可方便实现获取身份信息和角色权限信息的realm。实现抽象方法doGetAuthenticationInfo,返回值参考SimpleAuthorizationInfo。实现抽象方法doGetAuthenticationInfo,例如返回SimpleAuthenticationInfo。

    SessionDAO

    自定义如何存取session,可继承AbstractSessionDAO。

    参考

    Apache Shiro | Simple. Java. Security.https://shiro.apache.org/documentation.html

    你还可查看

    安全框架对比:shiro vs spring-security_陈海龙的格物之路-CSDN博客shiro和spring-security都是安全框架,两者有哪些相同点和差异呢?https://blog.csdn.net/chl87783255/article/details/120436997shiro实现分布式session和url权限验证_陈海龙的格物之路-CSDN博客本文讲述了如何基于shiro实现分布式session和url权限验证。https://blog.csdn.net/chl87783255/article/details/120435903

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

    shiro (java安全框架)

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

    三个核心组件:Subject, SecurityManager 和 Realms.

    Subject: 即“当前操作用户”。但是,在Shiro中,Subject这一概念并不仅仅指人,也可以是第三方进程、后台帐户(Daemon Account)或其他类似事物。它仅仅意味着“当前跟软件交互的东西”。但考虑到大多数目的和用途,你可以把它认为是Shiro的“用户”概念。
      Subject 代表了当前用户的安全操作,SecurityManager则管理所有用户的安全操作。
      SecurityManager: 它是Shiro框架的核心,典型的Facade模式,Shiro通过SecurityManager来管理内部组件实例,并通过它来提供安全管理的各种服务。
      Realm: Realm充当了Shiro与应用安全数据间的“桥梁”或者“连接器”。也就是说,当对用户执行认证(登录)和授权(访问控制)验证时,Shiro会从应用配置的Realm中查找用户及其权限信息。
      从这个意义上讲,Realm实质上是一个安全相关的DAO:它封装了数据源的连接细节,并在需要时将相关数据提供给Shiro。当配置Shiro时,你必须至少指定一个Realm,用于认证和(或)授权。配置多个Realm是可以的,但是至少需要一个。
      Shiro内置了可以连接大量安全数据源(又名目录)的Realm,如LDAP、关系数据库(JDBC)、类似INI的文本配置资源以及属性文件等。如果缺省的Realm不能满足需求,你还可以插入代表自定义数据源的自己的Realm实现。

    以上信息百度百科提供,下面开始最简单的使用shiro

    SimpleAccountRealm

    SimpleAccountRealm是一个简单的realm,可以不用管数据库等问题,直观的拦截shiro认证使用步骤
    认证 步骤如下:
    1、创建SecurityManager环境

    2、Subject主体提交认证

    3、SecurityManager认证

    4、Authenticator认证器认证

    5、Realm验证

    • 先配置pom.xml,依赖shiro核心包
     		<dependency>
                <groupId>org.apache.shiro</groupId>
                <artifactId>shiro-core</artifactId>
                <version>1.2.3</version>
            </dependency>
    
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
            </dependency>
    

    写一个测试类,实现认证功能

    public class AuthenticationTest {
    
        SimpleAccountRealm simpleAccountRealm =new SimpleAccountRealm();
        //在认证之前需要在simpleAccountRealm添加用户
        @Before
        public void addUser(){
            simpleAccountRealm.addAccount("maniy","123456","admin","user1");
        }
    
        @Test
        public void testAUthentication(){
            //1.构建SecurityManager环境
            DefaultSecurityManager defaultSecurityManager=new DefaultSecurityManager();
       //把 simpleAccountRealm设置到SecurityManager环境中    defaultSecurityManager.setRealm(simpleAccountRealm);
            //2.主体提交认证请求
            SecurityUtils.setSecurityManager(defaultSecurityManager);
            Subject subject= SecurityUtils.getSubject();
    
            UsernamePasswordToken token=new UsernamePasswordToken("maniy","123456");
            //登录
            subject.login(token);
    
            System.out.println("isAuthenticated:"+subject.isAuthenticated());
            调用subject是否认证方法
           // subject.isAuthenticated();
    
    		//登出,没有认证了
    //        subject.logout();
    //        System.out.println("isAuthenticated:"+subject.isAuthenticated());
    		//检查用户权限
            subject.checkRoles("admin","user1");
        }
    }
    
    展开全文
  • SSM集成安全框架shiro

    千次阅读 2017-11-11 13:58:03
    SSM集成安全框架shiro 前言,阅读这篇博客前可以先看看RBAC打造通用的权限管理平台http://blog.csdn.net/sinat_15153911/article/details/55046741 之前小编一直用拦截器来实现权限登录的拦截,现在使用高大上的...

    SSM集成安全框架shiro
    这里写图片描述
    前言,阅读这篇博客前可以先看看RBAC打造通用的权限管理平台http://blog.csdn.net/sinat_15153911/article/details/55046741
    之前小编一直用拦截器来实现权限登录的拦截,现在使用高大上的shiro,多重拦截,大量拦截,其中一个安全知识点是md5颜值加密,噢,是盐值。现在就一步一步教大家怎么配置。
    也可以加Q490647751,回复‘开通VIP获取SSM集成安全框架shiro’,获取源码研究,当然你还可以使用shiro二级缓存ehcache或者redis缓存session。

    视频教程:链接:http://pan.baidu.com/s/1geQJCH1 密码:mo22

    第一步导入jar包
    shir-core-1.2.3.jar
    shiro-ehcache-1.2.3.jar
    shiro-spring-1.2.3.jar
    shiro-web-1.2.3.jar

    第二步配置web.xml

    <!-- shiro的filter -->
        <!-- shiro过虑器,DelegatingFilterProxy通过代理模式将spring容器中的bean和filter关联起来 -->
        <filter>
            <filter-name>shiroFilter</filter-name>
            <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
            <init-param>
                <param-name>targetFilterLifecycle</param-name>
                <param-value>true</param-value>
            </init-param>
            <init-param>
                <param-name>targetBeanName</param-name>
                <param-value>shiroFilter</param-value>
            </init-param>
        </filter>
        <filter-mapping>
            <filter-name>shiroFilter</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>

    第三步加配置文件applicationContext-shiro.xml

    <import resource="applicationContext-*.xml"/>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="http://www.springframework.org/schema/beans 
            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd 
            http://www.springframework.org/schema/mvc 
            http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd 
            http://www.springframework.org/schema/context 
            http://www.springframework.org/schema/context/spring-context-3.2.xsd 
            http://www.springframework.org/schema/aop 
            http://www.springframework.org/schema/aop/spring-aop-3.2.xsd 
            http://www.springframework.org/schema/tx 
            http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">
    
    <!-- web.xml中shiro的filter对应的bean -->
    <!-- Shiro 的Web过滤器 -->
        <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
            <property name="securityManager" ref="securityManager" />
            <!-- loginUrl认证提交地址,如果没有认证将会请求此地址进行认证,请求此地址将由formAuthenticationFilter进行表单认证 -->
            <property name="loginUrl" value="/manage/login.html" />
            <!-- 认证成功统一跳转到index.html,建议不配置,shiro认证成功自动到上一个请求路径 -->
            <property name="successUrl" value="/manage/index.html"/>
            <!-- 通过unauthorizedUrl指定没有权限操作时跳转页面-->
            <property name="unauthorizedUrl" value="/manage/refuse.html" />
            <!-- 自定义filter配置 -->
            <!-- <property name="filters">
                <map>
                    将自定义 的FormAuthenticationFilter注入shiroFilter中
                    <entry key="authc" value-ref="formAuthenticationFilter" />
                </map>
            </property> -->
    
            <!-- 过虑器链定义,从上向下顺序执行,一般将/**放在最下边 -->
            <property name="filterChainDefinitions">
                <value>
                    <!-- 对静态资源设置匿名访问 -->
                    /resource/** = anon
                    /file/** = anon
                    <!-- 验证码,可匿名访问 -->
                    /validatecode.jsp = anon
    
                    <!-- 请求 logout.action地址,shiro去清除session-->
                    /logout.html = logout
                    <!--商品查询需要商品查询权限 ,取消url拦截配置,使用注解授权方式 -->
                    <!-- /items/queryItems.action = perms[item:query]
                    /items/editItems.action = perms[item:edit] -->
                    <!-- 配置记住我或认证通过可以访问的地址 -->
                    /login.jsp  = user
                    /index.html = user
                    /welcome.jsp = user 
                    <!-- /** = authc 所有url都必须认证通过才可以访问-->
                    /** = authc
                    <!-- /** = anon所有url都可以匿名访问 -->
    
                </value>
            </property>
        </bean>
    
    <!-- securityManager安全管理器 -->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
            <property name="realm" ref="customRealm" />
            <!-- 注入缓存管理器 -->
            <!-- <property name="cacheManager" ref="cacheManager"/>  -->
            <!-- 注入session管理器 -->
            <property name="sessionManager" ref="sessionManager" /> 
            <!-- 记住我 -->
            <property name="rememberMeManager" ref="rememberMeManager"/> 
    
        </bean>
    
    <!-- realm -->
    <bean id="customRealm" class="com.yanhui.shiro.CustomRealm">
    <!-- 将凭证匹配器设置到realm中,realm按照凭证匹配器的要求进行散列 -->
        <property name="credentialsMatcher" ref="credentialsMatcher"/> 
    </bean>
    
    <!-- 凭证匹配器 -->
    <bean id="credentialsMatcher"
        class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
        <property name="hashAlgorithmName" value="md5" />
        <property name="hashIterations" value="1" />
    </bean> 
    
    <!-- 缓存管理器 -->
    <!-- <bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
        <property name="cacheManagerConfigFile" value="classpath:shiro-ehcache.xml"/>
    </bean> -->
    
    <!-- 会话管理器 -->
    <bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
        <!-- session的失效时长,单位毫秒 -->
        <property name="globalSessionTimeout" value="600000"/>
        <!-- 删除失效的session -->
        <property name="deleteInvalidSessions" value="true"/>
    </bean>
    
    <!-- rememberMeManager管理器 -->
    <bean id="rememberMeManager" class="org.apache.shiro.web.mgt.CookieRememberMeManager">
        <property name="cookie" ref="rememberMeCookie" />
    </bean>
    <!-- 记住我cookie -->
    <bean id="rememberMeCookie" class="org.apache.shiro.web.servlet.SimpleCookie">
        <constructor-arg value="rememberMe" />
        <!-- 记住我cookie生效时间30天 -->
        <property name="maxAge" value="2592000" />
    </bean>
    
    
    
    </beans>

    第四步添加CustomRealm的类

    package com.yanhui.shiro;
    
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import org.apache.shiro.SecurityUtils;
    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.authc.UsernamePasswordToken;
    import org.apache.shiro.authz.AuthorizationInfo;
    import org.apache.shiro.authz.SimpleAuthorizationInfo;
    import org.apache.shiro.crypto.hash.Md5Hash;
    import org.apache.shiro.crypto.hash.SimpleHash;
    import org.apache.shiro.realm.AuthorizingRealm;
    import org.apache.shiro.subject.PrincipalCollection;
    import org.apache.shiro.util.ByteSource;
    import org.springframework.beans.factory.annotation.Autowired;
    
    import com.yanhui.mapping.system.UserManagerMapper;
    import com.yanhui.pojo.auth.Permission;
    import com.yanhui.pojo.system.UserManager;
    import com.yanhui.service.auth.PermissionService;
    
    
    public class CustomRealm extends AuthorizingRealm {
    
        public static void main(String[] args) {
            //所需加密的参数  即  密码
            String source = "123456";
            //[盐] 一般为用户名 或 随机数
            String salt = "customRealm";
            //加密次数
            int hashIterations = 1;
    
            //调用 org.apache.shiro.crypto.hash.Md5Hash.Md5Hash(Object source, Object salt, int hashIterations)构造方法实现MD5盐值加密
            Md5Hash mh = new Md5Hash(source, salt, hashIterations);
            //打印最终结果
            System.out.println(mh.toString());
    
    
            /*调用org.apache.shiro.crypto.hash.SimpleHash.SimpleHash(String algorithmName, Object source, Object salt, int hashIterations)
             * 构造方法实现盐值加密  String algorithmName 为加密算法 支持md5 base64 等*/
            SimpleHash sh = new SimpleHash("md5", source, salt, hashIterations);
            //打印最终结果
            System.out.println(sh.toString());
        }
    
        @Autowired
        private UserManagerMapper userMapper;
    
        @Autowired
        private PermissionService permissionService;
    
        @Override
        public String getName() {
            return "customRealm";
        }
    
        // 支持什么类型的token
        @Override
        public boolean supports(AuthenticationToken token) {
            return token instanceof UsernamePasswordToken;
        }
    
        // 认证
        @Override
        protected AuthenticationInfo doGetAuthenticationInfo(
                AuthenticationToken token) throws AuthenticationException {
    
            // 从token中 获取用户身份信息
            String username = (String) token.getPrincipal();
            // 拿username从数据库中查询
    //      UserExample example = new UserExample();
    //      Criteria criteria = example.createCriteria();
    //      criteria.andNameEqualTo(username);
            Map<String,Object> map = new HashMap<String,Object>();
            map.put("name", username);
            List<UserManager> list = userMapper.listForPage(map);
            if(list.size() < 1){
                // 如果查询不到则返回null
                return null;
            }
    
            UserManager user = list.get(0);
            // 获取从数据库查询出来的用户密码
            String password = user.getPassword();
    //      String salt = user.getSalt();
    //      String password = "cb571f7bd7a6f73ab004a70322b963d5";
            String salt = "customRealm";
    
            // 如果查询到返回认证信息AuthenticationInfo
    
            //activeUser就是用户身份信息
            UserManager activeUser = new UserManager();
            activeUser.setId(user.getId());
    //      activeUser.setUsercode(user.getPhone());
            activeUser.setUsername(user.getUsername());
            // 返回认证信息由父类AuthenticatingRealm进行认证
            SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(
    //              employee.getPhone(), "123456", ByteSource.Util.bytes(salt), this.getName());
                    user, password, ByteSource.Util.bytes(salt), getName());
    
    
            return simpleAuthenticationInfo;
        }
    
    
        // 授权
        @Override
        protected AuthorizationInfo doGetAuthorizationInfo(
                PrincipalCollection principals) {
    
            //身份信息
            UserManager activeUser = (UserManager) principals.getPrimaryPrincipal();
    //      Employee activeUser = (Employee) subject.getPrincipal();
            //用户id
            Integer userid = activeUser.getId();
            //获取用户权限
            List<Permission> permissions = null;
            try {
                permissions = permissionService.findPermissionList(userid);
            } catch (Exception e) {
                e.printStackTrace();
            }
            //构建shiro授权信息
            SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
            for(Permission permission : permissions){
                simpleAuthorizationInfo.addStringPermission(permission.getPercode());
            }
    
            return simpleAuthorizationInfo;
        }
    
            //清除缓存
            public void clearCached() {
                PrincipalCollection principals = SecurityUtils.getSubject().getPrincipals();
                super.clearCache(principals);
            }
    
    
    
    }

    第五步登录方法

    /**
         * 后台管理主页
         * @return
         */
        @RequestMapping("/index")
        public String indexAdmin(HttpServletRequest request){
            //主体
            Subject subject = SecurityUtils.getSubject();
    //      //身份
            UserManager activeUser = (UserManager) subject.getPrincipal();
            request.setAttribute("activeUser", activeUser);
            HttpSession session = request.getSession(); 
            session.setAttribute(Global.USER_BACKEND_SESSION, activeUser);
    
            request.setAttribute("mainPage", "welcome.html");
            return Global.WEB_BACK_PAGE + "/index";
        }
    /**
         * 后台登录
         * @return
         * @throws Exception 
         */
        @RequestMapping("/login")
        public String login(String username,String password,HttpServletRequest request) throws Exception{
            //如果登陆失败从request中获取认证异常信息,shiroLoginFailure就是shiro异常类的全限定名
                    String exceptionClassName = (String) request.getAttribute("shiroLoginFailure");
                    //根据shiro返回的异常类路径判断,抛出指定异常信息
                    if(exceptionClassName!=null){
                        if (UnknownAccountException.class.getName().equals(exceptionClassName)) {
                            //最终会抛给异常处理器
                            //throw new CustomException("账号不存在");
                            System.out.println("账号不存在");
                        } else if (IncorrectCredentialsException.class.getName().equals(exceptionClassName)) {
                            //throw new CustomException("用户名/密码错误");
                            System.out.println("用户名/密码错误");
                        } /*else if("randomCodeError".equals(exceptionClassName)){
                            //throw new CustomException("验证码错误 ");
                        }*/else {
                            System.out.println("未知错误");
                            throw new Exception();//最终在异常处理器生成未知错误
                        }
                    }
    
    //      String result = "";
    //      UserManager user = userService.login(username,password);
    //      if(user != null){
    //          HttpSession session = request.getSession(); 
    //          session.setAttribute(Global.USER_BACKEND_SESSION, user);
    //          result = "redirect:/manage/index.html";
    //      }else{
    //          result = "redirect:/manage/toSignIn.html";
    //      }
    //      return result;
            return Global.WEB_BACK_PAGE + "/signin";
        }

    第六步前端显示

    <%@ taglib uri="http://shiro.apache.org/tags" prefix="shiro" %>
    
    <shiro:hasPermission name="dic:query">
            <a href="http://www.baidu.com" class="list-title">dic列表</a>
            </shiro:hasPermission>

    知识点:
    1、自定义Realm

    自定义Realm一般需要实现AuthorizingRealm接口,该接口有两个接口,一个是doGetAuthorizationInfo,另一个是doGetAuthenticationInfo。
    doGetAuthenticationInfo(认证)
    该接口方法的逻辑是验证用户登录的合法性,通常在这里面来判断用户名是否存在、密码是否正确、用户账号状态是否被禁用或者锁定等操作。
    doGetAuthorizationInfo(授权)
    该接口方法的逻辑是在用户身份验证完成后,设置用户的权限信息,一般包括设置用户所拥有的角色信息和相应的权限字信息。

    2、MD5盐值加密

     int temp;
                temp = ss < 0 ? ss + 256 : ss;
                return GOAL[temp / 16] + GOAL[temp % 16];       //自己实现转化
                /*
                    用现有的方法实现转化
                    StringBuffer s = new StringBuffer();
                    if(temp < 16)s.append("0");
                    s.append(Integer.toHexString(temp));
                    return s.toString();   
                 */
    String password_md5_sale_1 = new Md5Hash("123456", "customRealm", 1).toString(); 
    <!-- 凭证匹配器 -->
    <bean id="credentialsMatcher"
        class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
        <property name="hashAlgorithmName" value="md5" />
        <property name="hashIterations" value="1" />
    </bean> 
    展开全文
  • 综述:之前做过一些小项目,都是手动进行安全和权限验证,相当的麻烦,而且权限验证又是实际开发时必不可少的步骤,因此我们可以借助一些框架来实现,今天开始学习Shiro权限框架 一、Shiro简介 Apache Shiro 是 Java...
  • Shiro相关知识点

    2016-10-31 17:22:32
    shiro相关知识点shiro获取登录名在Servlet,Action或者Controller中的代码 java Subject subject = SecurityUtils.getSubject(); String username = (String) subject.getPrincipal(); shiro检查用户是否包含...
  • 安全框架shiro

    2017-09-11 10:12:56
    我并没有全部看完,只是选择了一部分对我来说急需在项目中使用的知识加以学习。并且对于大多数第一次接触Shiro的同学来说,掌握这些也应该足够了。 一、架构 要学习如何使用Shiro必须先从它的
  • shiro和spring-security都是安全框架,两者有哪些相同和差异呢?
  • Shiro 安全框架入门知识

    千次阅读 2019-01-07 10:54:26
    Shiro 简介 照例又去官网扒了扒介绍: Apache Shiro™is a powerful and easy-to-use Java security framework that performs authentication, authorization, cryptography, and session management. With Shiro...
  • 在SSM基础下整合使用安全框架Shiro,本课将设计导Spring和Shrio整合起来应用的核心知识点都讲到了,学习本课后能够在项目中将Shro用起来。
  • shiro知识点总结

    2020-09-18 14:11:18
    1.书写配置类,用来整合shiro框架相关的配置 1.1配置类上需要添加@Configuration注解 1.2 获取拦截器对象,目的是拦截请求 1.写一个返回值类型为ShiroFilterFactoryBean的方法,在方法上添加@Bean注解 2.创建...
  • shiro知识点整理(一) shiro是一个大家熟悉的权限控制框架,但是很多的细节大家有没有注意到。今天我就来分享下我使用过程中遇到的一个个细节问题。 依赖 <dependencies> <dependency> <groupId&...
  • Apache Shiro是一个强大且易用的Java安全框架,执行身份认证、授权、加密和会话管理。使用Shiro的易于理解的API,可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。2.Shiro可以...
  • shiro安全框架

    2019-09-15 21:48:04
    本篇内容大多总结自张开涛的《跟我学Shiro》原文地址:...我并没有全部看完,只是选择了一部分对我来说急需在项目中使用的知识加以学习。并且对于大多数第一次接触Shiro的同学来说,掌握这些也应该足够...
  • shiro (java安全框架Shiro简介 Apache Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大...
  • Apache Shiro(发音为“ shee-roh”,日语为“ castle”)是一种功能强大且易于使用的Java安全框架,可执行身份验证,授权,加密和会话管理,可用于保护任何应用程序的安全-从命令行应用程序,移动应用程序到最大的...
  • Java系列技术之安全框架Shiro 钟洪发,于2008年7月毕业于西南交通...
  • Shiro是一套是Java的一个安全框架,实现对用户访问系统的控制,按照安全规则或者安全策略控制用户可以访问而且只能访问自己被授权的资源。   其主要功能为用户身份认证和授权两部分,简称认证授权。对于需要访问...
  • Shiro安全框架入门 Shiro安全框架实战:基于前后端... ACL和RBAC的概念二、主流权限框架介绍三、Apache Shiro基础概念知识和架构讲解1. Shiro四大核心模块2. 访问Shiro的权限控制运行流程和常见名称讲解四、Springboo
  • 欢迎关顾我的博客 开端 好的,起因是我把最近做好的项目给一部分人进行了测试,发现大部分朋友都提出了同一个问题,你的系统权限管理是如何...而对于权限控制的框架呢,听的最多的还是 Shiro 还有 Spring Security。Sp
  • 1.认证(Authentication)     在Shiro中,认证指的是识别和证明操作者是一个合法用户。“用户”这个概念在框架中抽象...这些身份和凭证信息,在Shiro框架中以Token口令的概念进行封装。Shiro中...
  • Shiro框架学习

    2021-02-27 20:39:14
    文章目录1、Shiro简介1.1 介绍1.2 功能1.3 Shiro构架(外部)1.4 Shiro构架(内部)2、快速开始Demo2.1 ...​ Apache Shiro 是 Java 的一个安全框架。目前,使用 Apache Shiro 的人越来越多,因为它相当简单,对比 S
  • mapping> web-app> 3.shiroRealm public class ShiroRealm implements Realm { @Override public String getName() { return "my-shiro"; } @Override public boolean supports(AuthenticationToken token) { return...
  • shiro框架java使用

    千次阅读 2018-08-10 11:09:49
    大纲 ...知识点详解 一、Shiro简介 1.Shiro一个Java权限框架. 1.1在项目中把涉及到权限的业务提出来用shiro完成. 2.Shiro架构图 2.1 Subject 主体.对应一个用户,用户所有的信息都存放在Subjec...
  • Shiro知识概括

    2020-10-15 23:03:50
    Shiro知识概括一级目录 一级目录
  • 框架知识点

    2018-09-18 11:47:57
    Apache Shiro 是一个强大易用的java安全框架,提供了认证、授权、加密和会话管理等功能。 认证 :验证用户来核实他们的身份 授权:会话管理 RESTful(表现层状态转化)架构 (1)每一个URI代表一种资源; ...
  • Apache Shiro是Java的一个安全框架。目前,使用Apache Shiro的人越来越多,因为它相当简单,对比Spring Security,可能没有Spring Security做的功能强大,但是在实际工作时可能并不需要那么复杂的东西,所以使用小而...
  • shiro权限框架

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,661
精华内容 1,464
关键字:

安全框架shiro知识点