精华内容
下载资源
问答
  • Shiro详解

    2020-11-04 19:16:29
    什么是Shiro: 是一个轻量级的安全框架,主要提供了 授权、认证、加密、会话管理这几个功能。Shiro 的优点有以下几点 简单的身份认证, 支持多种数据源 非常简单的加密 API 对角色的简单的授权, 支持细粒度的授权...
    什么是Shiro:
    是一个轻量级的安全框架,主要提供了 授权、认证、加密、会话管理这几个功能。Shiro 的优点有以下几点
    简单的身份认证, 支持多种数据源
    非常简单的加密 API
    对角色的简单的授权, 支持细粒度的授权(方法级)
    支持一级缓存,以提升应用程序的性能;
    内置的基于 POJO 企业会话管理, 适用于 Web 以及非 Web 的环境
    不跟任何的框架或者容器捆绑, 可以独立运行
    
    比较 SpringSecurity 和 Shiro的区别
    1、Spring Security 基于Spring 开发,项目若使用 Spring 作为基础,配合 Spring Security 做权限更加方便,而 Shiro 需要和 Spring 进行
    整合开发;
    2、Spring Security 功能比 Shiro 更加丰富些,例如安全维护方面;
    3、Spring Security 社区资源相对比 Shiro 更加丰富;
    Spring Security对Oauth、OpenID也有支持,Shiro则需要自己手动实现。而且Spring Security的权限细粒度更高
    spring security 接口 RequestMatcher 用于匹配路径,对路径做特殊的请求,类似于shiro的抽象类 PathMatchingFilter,但是 RequestMatcher 作用粒度更细
    4、Shiro 的配置和使用比较简单,Spring Security 上手复杂些;
    5、Shiro 依赖性低,不需要任何框架和容器,可以独立运行.Spring Security 依赖Spring容器;
    6、shiro 不仅仅可以使用在web中,还支持非web项目它可以工作在任何应用环境中。在集群会话时Shiro最重要的一个好处或许就是它的会话是独立于容器的。
    shiro的话,简单,易用,功能也强大,spring官网就是用的shiro,可见shiro的强大。
    
    简述 Shiro 的3个核心组件
    1.Subject
    正与系统进行交互的人, 或某一个第三方服务.
    所有 Subject 实例都被绑定到一个SecurityManager 上。
    2.SecurityManager
    Shiro 架构的心脏, 用来协调内部各安全组件, 管理内部组件实例, 并通过它来提供安全管理的各种服务.
    当 Shiro 与一个 Subject 进行交互时, 实质上是幕后的 SecurityManager 处理所有繁重的 Subject 安全操作。
    3.Realms
    本质上是一个特定安全的 DAO. 当配置 Shiro 时, 必须指定至少一个 Realm 用来进行身份验证和授权.
    Shiro 提供了多种可用的 Realms 来获取安全相关的数据. 例如关系数据库(JDBC), INI 及属性文件等.
    可以定义自己 Realm 实现来代表自定义的数据源。
    
    Shiro认证过程
    1subject(主体)请求认证,调用subject.login(token)
    2、SecurityManager (安全管理器)执行认证
    3、SecurityManager通过ModularRealmAuthenticator进行认证。
    4、ModularRealmAuthenticator将token传给realm,realm根据token中用户信息从数据库查询用户信息(包括身份和凭证)
    5、realm如果查询不到用户给ModularRealmAuthenticator返回null,ModularRealmAuthenticator抛出异常(用户不存在)
    6、realm如果查询到用户给ModularRealmAuthenticator返回AuthenticationInfo(认证信息)
    7、ModularRealmAuthenticator拿着AuthenticationInfo(认证信息)去进行凭证(密码 )比对。如果一致则认证通过,如果不致抛出异常(凭证错误)
    
    Shiro授权过程
    1、对subject进行授权,调用方法isPermitted("permission串"2、SecurityManager执行授权,通过ModularRealmAuthorizer执行授权
    3、ModularRealmAuthorizer执行realm(自定义的CustomRealm)从数据库查询权限数据调用realm的授权方法:doGetAuthorizationInfo
    4、realm从数据库查询权限数据,返回ModularRealmAuthorizer
    5、ModularRealmAuthorizer调用PermissionResolver进行权限串比对
    6、如果比对后,isPermitted中"permission串"在realm查询到权限数据中,说明用户访问permission串有权限,否则 没有权限,抛出异常。
    
    
    什么是粗颗粒和细颗粒权限?
    对资源类型的管理称为粗颗粒度权限控制,即只控制到菜单、按钮、方法。粗粒度的例子比如:用户具有用户管理的权限,具有导出订单明细的权限。
    对资源实例的控制称为细颗粒度权限管理,即控制到数据级别的权限,比如:用户只允许修改本部门的员工信息,用户只允许导出自己创建的订单明细。
    
    粗颗粒和细颗粒如何授权?
     对于粗颗粒度的授权可以很容易做系统架构级别的功能,即系统功能操作使用统一的粗颗粒度的权限管理。对于细颗粒度的授权不建议做成系统架构级别的功能,因为对数据级别的控制是系统的业务需求,随着业务需求的变更业务功能变化的可能性很大,建议对数据级别的权限控制在业务层个性化开发,比如:用户只允许修改自己创建的商品信息可以在service接口添加校验实现,service接口需要传入当前操作人的标识,与商品信息创建人标识对比,不一致则不允许修改商品信息。
    粗颗粒权限:可以使用过虑器统一拦截url。
    细颗粒权限:在service中控制,在程序级别来控制,个性化编程。
    
    
    Shiro 如何自实现认证
    Shiro 的认证过程由 Realm 执行,SecurityManager 会调用 org.apache.shiro.realm.Realm 的 getAuthenticationInfo(AuthenticationToken token) 方法。 实际开发中, 通常提供 org.apache.shiro.realm.AuthenticatingRealm 的实现类, 并在该实现类中提供 doGetAuthenticationInfo(AuthenticationToken token)方法的具体实现
    
    如何实现自实现授权
    实际开发中, 通常提供 org.apache.shiro.realm.AuthorizingRealm 的实现类,并提供 doGetAuthorizationInfo(PrincipalCollection principals) 方法的具体实现
    
    如何配置在 Spring 中配置使用 Shiro
    1、引入jar包并在 web.xml 中配置 Shiro 的 Filter
    2、在 Spring 的配置文件中配置 Shiro
    3、配置自定义 Realm:实现自定义认证和授权
    4、配置 SecurityManager
    5、配置保证 Shiro 内部 Bean 声明周期都得到执行的 Lifecycle Bean 后置处理器
    6、配置AOP 式方法级权限检查
    7、配置Shiro过滤器
    
    展开全文
  • shiro 详解

    2016-06-18 09:01:24
    shiro笔记 梦想只要能持久,就能成为现实。我们不就是生活在梦想中的吗? ——丁尼生 最近研究了一下 shiro 分享一下我对shiro 的理解. Apache shiro 是一个 java 的安全的框架 相当简单 不仅可以用在 java...

     

    shiro笔记


    梦想只要能持久,就能成为现实。我们不就是生活在梦想中的吗?

    ——丁尼生



    最近研究了一下 shiro   分享一下我对shiro 的理解.


    Apache shiro 是一个 java 的安全的框架  相当简单 不仅可以用在 java SE 也可以用在 java EE

    接下来我们分别从外部和内部来看看Shiro的架构,对于一个好的框架,从外部来看应该具有非常简单易于使用的API,且API契约明确;从内部来看的话,其应该有一

    个可扩展的架构,即非常容易插入用户自定义实现,因为任何框架都不能满足所有需求.而shiro就做到了这一点

    优点:简单(相对于Spring Security)、可以在javaSE、JavaEE开发,帮助我们完成:认证、 授权、加密、会话管理、web集成、缓存等。


    核心 : 

    Authentication: 身份认证/*登录, 验证用户是否拥有相应的身份.

    Authorization: 授权,权限认证,验证某个以认证用户是否拥有某个权限.

    Session Manager:会话管理,用户登录就是一次会话,退出之前所有信息都将存入.

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

    我们 就先说一下核心功能  通过以上了解我们就能看出 shiro 其实就是将 认证、 授权、加密、会话管理、web集成、缓存单独做成的但是

    记住一点,Shiro不会去维护用户、维护权限;这些需要我们自己去设计/提供;然后通过相应的接口注入给Shiro即可。


    以上是一些见解 下面我们用代码展示一下 shiro 的具体实现

    用户表  t_user

    user_id

    user_name

    user_password

    role_id 


    角色表 t_role

    role_id

    role_name


    权限表 t_permission

    permission_id

    permission_name

    role_id

    好 我们就用这个简单的结构来说一下shiro

    既然它是一个框架 就有框架的通性那就是配置文件下面来说一下它的配置

    pom.xml配置

    下面是web.xml  中的 shiro过滤器  以及周期


    至于bean  什么的就自己搞一下吧 这里就不和大家发表了


    下面大家可以看一下 mapper.xml 给大家参考一下 


    自定义realm类


    为了方便大家使用这个reaml 我就不放图片了

    package realm;


    import javax.annotation.Resource;


    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.authz.AuthorizationInfo;
    import org.apache.shiro.authz.SimpleAuthorizationInfo;
    import org.apache.shiro.realm.AuthorizingRealm;
    import org.apache.shiro.subject.PrincipalCollection;


    import com.cn.dto.User;
    import com.cn.service.LoginService;


    public class MyRealm extends AuthorizingRealm {


    @Resource
    private LoginService service;
    /**
    * 为当前登录的Subject进行授权
    * */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(
    PrincipalCollection principals) {
    // TODO Auto-generated method stub
    //从当前登录的Subject中取到用户名
    String username=(String) principals.getPrimaryPrincipal();

    SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
    //通过用户名查到当前用户的角色信息放到simpleAuthorizationInfo对象中
    simpleAuthorizationInfo.setRoles(service.getbyroles(username));
    //通过用户名查到当前用户的权限信息放到simpleAuthorizationInfo对象中 
    simpleAuthorizationInfo.setStringPermissions(service.getbypermission(username));
    return simpleAuthorizationInfo;
    }

    /**
    * 认证当前登录用户

    */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(
    AuthenticationToken token) throws AuthenticationException {
    // TODO Auto-generated method stub

    //从token中取到用户名
    String username =(String) token.getPrincipal();
    //通过用户名查询用户信息
    User user=service.getbyname(username);
    if(user!=null){
    //当user不为空时将user中的信息封装成AuthenticationInfo对象
    AuthenticationInfo aut = new SimpleAuthenticationInfo(user.getUserName(), user.getPassword(),"");
    return aut;
    }else{
    return null;
    }

    }


    }

    下面spring.xml 中 的

    shiro 的核心配置接口以及一些跳转配置


    好了 以上便是shiro 的所需的以下配置 中 所需要注意的地方 希望能够为大家带来帮助

    另外这是一个加密工具类 大家可以借鉴一下


    展开全文
  • 权限框架之Shiro详解(非原创)
    展开全文
  • ssm整合shiro详解

    千次阅读 多人点赞 2020-10-02 12:10:40
    这里有详细的ssm整合shiro步骤,需要先搭建ssm框架,教程在 https://blog.csdn.net/qq_41150890/article/details/108419455 整合shiro: 1.在pom.xml中引入依赖 <!-- shiro --> <!-- ...

    这里有详细的ssm整合shiro步骤,需要先搭建ssm框架,教程在
    https://blog.csdn.net/qq_41150890/article/details/108419455

    整合shiro:

    1.在pom.xml中引入依赖

    <!--  shiro -->
        <!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-core -->
        <dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-core</artifactId>
          <version>1.6.0</version>
        </dependency>
    
        <!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-web -->
        <dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-web</artifactId>
          <version>1.6.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-spring -->
        <dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-spring</artifactId>
          <version>1.6.0</version>
        </dependency>
    
        <!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-ehcache -->
        <dependency>
          <groupId>org.apache.shiro</groupId>
          <artifactId>shiro-ehcache</artifactId>
          <version>1.6.0</version>
        </dependency>
    
    

    2.新建并配置缓存ehcache.xml

    在这里插入图片描述

    <ehcache>
    
        <!-- Sets the path to the directory where cache .data files are created.
    
             If the path is a Java System Property it is replaced by
             its value in the running VM.
    
             The following properties are translated:
             user.home - User's home directory
             user.dir - User's current working directory
             java.io.tmpdir - Default temp file path -->
        <diskStore path="java.io.tmpdir"/>
        
        <cache name="authorizationCache"
               eternal="false"
               timeToIdleSeconds="3600"
               timeToLiveSeconds="0"
               overflowToDisk="false"
               statistics="true">
        </cache>
    
        <cache name="authenticationCache"
               eternal="false"
               timeToIdleSeconds="3600"
               timeToLiveSeconds="0"
               overflowToDisk="false"
               statistics="true">
        </cache>
    
        <cache name="shiro-activeSessionCache"
               eternal="false"
               timeToIdleSeconds="3600"
               timeToLiveSeconds="0"
               overflowToDisk="false"
               statistics="true">
        </cache>
    
        <!--Default Cache configuration. These will applied to caches programmatically created through
            the CacheManager.
    
            The following attributes are required for defaultCache:
    
            maxInMemory       - Sets the maximum number of objects that will be created in memory
            eternal           - Sets whether elements are eternal. If eternal,  timeouts are ignored and the element
                                is never expired.
            timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used
                                if the element is not eternal. Idle time is now - last accessed time
            timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used
                                if the element is not eternal. TTL is now - creation time
            overflowToDisk    - Sets whether elements can overflow to disk when the in-memory cache
                                has reached the maxInMemory limit.
    
            -->
        <defaultCache
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            overflowToDisk="true"
            />
    
        <!--Predefined caches.  Add your cache configuration settings here.
            If you do not have a configuration for your cache a WARNING will be issued when the
            CacheManager starts
    
            The following attributes are required for defaultCache:
    
            name              - Sets the name of the cache. This is used to identify the cache. It must be unique.
            maxInMemory       - Sets the maximum number of objects that will be created in memory
            eternal           - Sets whether elements are eternal. If eternal,  timeouts are ignored and the element
                                is never expired.
            timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used
                                if the element is not eternal. Idle time is now - last accessed time
            timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used
                                if the element is not eternal. TTL is now - creation time
            overflowToDisk    - Sets whether elements can overflow to disk when the in-memory cache
                                has reached the maxInMemory limit.
    
            -->
    
        <!-- Sample cache named sampleCache1
            This cache contains a maximum in memory of 10000 elements, and will expire
            an element if it is idle for more than 5 minutes and lives for more than
            10 minutes.
    
            If there are more than 10000 elements it will overflow to the
            disk cache, which in this configuration will go to wherever java.io.tmp is
            defined on your system. On a standard Linux system this will be /tmp"
            -->
        <cache name="sampleCache1"
            maxElementsInMemory="10000"
            eternal="false"
            timeToIdleSeconds="300"
            timeToLiveSeconds="600"
            overflowToDisk="true"
            />
    
        <!-- Sample cache named sampleCache2
            This cache contains 1000 elements. Elements will always be held in memory.
            They are not expired. -->
        <cache name="sampleCache2"
            maxElementsInMemory="1000"
            eternal="true"
            timeToIdleSeconds="0"
            timeToLiveSeconds="0"
            overflowToDisk="false"
            />
    
        <!-- Place configuration for your caches following -->
    
    </ehcache>
    
    

    3.在spring配置文件applicationContext.xml配置shiro

    在这里插入图片描述

    <?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: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.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
        <!-- spring 配置文件  主要配置和业务逻辑有关的 -->
        <context:property-placeholder location="classpath:dbconfig.properties"/>
        <!-- 数据源 -->
        <bean id="pooledDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
            <property name="driverClass" value="${jdbc.driverClass}"></property>
            <property name="user" value="${jdbc.user}"></property>
            <property name="password" value="${jdbc.password}"></property>
        </bean>
    
    
        <context:component-scan base-package="com.liuzhan">
            <!-- 不能扫描控制器 -->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/> </context:component-scan>
    
    
        <!-- 配置和mybatis的整合 -->
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <!-- 指定mybatis 全局配置文件的位置 -->
            <property name="configLocation" value="classpath:mybatis-config.xml"></property>
            <property name="dataSource" ref="pooledDataSource"></property>
            <!-- 指定mybatismapper文件的位置 -->
    <!--        <property name="mapperLocations" value="classpath:mapper/*.xml"></property>-->
        </bean>
    
    
        <!-- 配置扫描器,将mybatis接口的实现加入到ioc容器中 -->
        <bean class="tk.mybatis.spring.mapper.MapperScannerConfigurer">
            <!-- 扫描所有的dao接口 -->
            <property name="basePackage" value="com.liuzhan.dao"></property>
        </bean>
    
        <!-- 事务控制的配置 -->
    
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <!-- 控制数据源 -->
            <property name="dataSource" ref="pooledDataSource"></property>
        </bean>
    
        <aop:config>
            <!-- 切入点表达式 -->
            <aop:pointcut expression="execution(* com.liuzhan.service..*(..) )" id="txPoint"/>
            <!-- 配置事务 -->
            <aop:advisor advice-ref="txAdvice" pointcut-ref="txPoint"/>
        </aop:config>
        <!-- 配置事务增强  事务如何切入 -->
        <tx:advice id="txAdvice">
    
            <tx:attributes>
                <!-- 所有方法都是事务方法 -->
                <tx:method name="*"/>
                <!-- 以get开头的所有方法 -->
                <tx:method name="get*" read-only="true"/>
            </tx:attributes>
        </tx:advice>
    
    
    
    
    
        <!-- shiro -->
    
        <!-- 配置自定义Realm -->
        <bean id="myRealm" class="com.liuzhan.relams.ShiroRealm"/>
        <!-- 安全管理器 -->
        <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
            <property name="realm" ref="myRealm"/>
        </bean>
        <!-- Shiro过滤器 核心-->
        <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
            <!-- Shiro的核心安全接口,这个属性是必须的 -->
            <property name="securityManager" ref="securityManager"/>
            <!-- 身份认证失败,则跳转到登录页面的配置 -->
            <property name="loginUrl" value="/login.jsp"/>
    
            <!-- 权限认证失败,则跳转到指定页面 -->
            <property name="unauthorizedUrl" value="/noPermission.jsp"/>
    
            <!-- Shiro连接约束配置,即过滤链的定义 -->
            <property name="filterChainDefinitions">
                <value>
                    <!--设置jsp文件可以匿名访问,静态文件,如js\html\css\img等
                    -->
                    <!--login/**= anon
                    /css/**=anon
                    /html/**=anon
                    /images/**=anon
                    /js/**=anon
                    -->
    
    
                    /noPermission.jsp=anon
                    <!--anon 表示匿名访问,不需要认证以及授权-->
                    /login.jsp=anon
                    <!-- 由于该请求http://localhost:8080/ssm_shiro_war_exploded/login是执行认证的请求路径,因此不能被拦截,不然永远无法执行认证 -->
                    /login = anon
                    <!-- logout 表示退出,当有/logout请求时,会执行退出,清除用户信息及角色和权限信息-->
                    /logout = logout
    
    
    
    <!--             先登录验证 -->
                    /**=authc
    
                    <!-- 角色验证方式一(单个角色),判断该用户是否拥有admin角色 -->
                    <!--  注意,登录验证时不会执行该过滤规则,权限验证会执行user过滤规则,如果没有roles条件,默认是所有权限          -->
                    /**=user,roles[admin]
                    <!-- 或/**=roles[admin]  -->
                    <!-- 角色验证方式二(多个角色),判断该用户是否拥有admin、user角色 -->
    <!--                /**=roles["admin,user"]-->
                    <!-- /**放在最下边,如果一个url有多个过虑器则多个过虑器中间用逗号分隔,如:/** = user,roles[admin]-->
    
                </value>
            </property>
    
        </bean>
        <!-- 保证实现了Shiro内部lifecycle函数的bean执行 -->
        <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>
        <!-- 开启Shiro注解 -->
        <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
              depends-on= "lifecycleBeanPostProcessor"/>
        <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
            <property name="securityManager" ref="securityManager"/>
        </bean>
    </beans>
    

    4.自定义realm(内部定义认证和授权的逻辑代码)

    在这里插入图片描述

    package com.liuzhan.relams;
    
    import com.liuzhan.entity.Users;
    import com.liuzhan.service.UserService;
    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.authz.AuthorizationInfo;
    import org.apache.shiro.authz.SimpleAuthorizationInfo;
    import org.apache.shiro.realm.AuthorizingRealm;
    import org.apache.shiro.subject.PrincipalCollection;
    import org.springframework.beans.factory.annotation.Autowired;
    
    import java.util.HashSet;
    import java.util.List;
    import java.util.Set;
    
    public class ShiroRealm extends AuthorizingRealm {
    
        @Autowired
        UserService userService;
    
    
        /**
         * 用于授权。
         * @param principalCollection
         * @return
         */
        @Override
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
            System.out.println("开始授权");
            String uName = principalCollection.getPrimaryPrincipal().toString() ;
            SimpleAuthorizationInfo info = new SimpleAuthorizationInfo() ;
            List<Users> list=userService.loginCheck(uName);
            //查询当前用户的角色,放在roleName中
            Set<String> roleName = new HashSet<>();
            roleName.add(list.get(0).getRole());
    
            //查询角色具有的权限,放在permissions中
            Set<String> permissions = new HashSet<>();
            permissions.add("manage other users");
    
            //把角色和权限放在授权类的对象中
            info.addRole(list.get(0).getRole());
            info.addStringPermission("manage other users");
    
            System.out.println("当前用户角色:"+info.getRoles());
            return info;
        }
    
    
    
    
        //认证
        //用户输入用户名和密码后,在controller调用login(token),进行认证,这边通过用户名查询密码
        //和token中用户名和密码进行比对,成功认证或失败
        @Override
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    
            System.out.println("开始登录认证");
    
            //获取用户名,去数据库取对应密码
            String uName = (String) authenticationToken.getPrincipal();
            List<Users> list=userService.loginCheck(uName);
    
            if(list.size()>0){
                System.out.println("用户存在");
                String uPwd=list.get(0).getuPwd();
                // 用户名存在,去数据库中去获取密码
                // 然后和token的用户名和密码对比
                // 第三个参数是选择realm,当有多个自定义realm时有用
                SimpleAuthenticationInfo info=new
                        SimpleAuthenticationInfo(uName, uPwd, "ShiroRealm");
                return info;
            }
            else{
                System.out.println("用户不存在");
                return null;
            }
    
        }
    }
    
    

    5.controller中相关代码

    在这里插入图片描述

    package com.liuzhan.controller;
    
    import com.liuzhan.entity.Users;
    import com.liuzhan.service.UserService;
    import org.apache.shiro.SecurityUtils;
    import org.apache.shiro.authc.AuthenticationException;
    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.web.bind.annotation.RequestMapping;
    
    
    
    @Controller
    public class UserController {
    
        @Autowired
        UserService userService;
    
        @RequestMapping("/login")
        public String loginCheck(Users users){
    
            Subject subject=SecurityUtils.getSubject();
            if(!subject.isAuthenticated()) {
                UsernamePasswordToken token=new UsernamePasswordToken(users.getuName(),users.getuPwd());
                token.setRememberMe(true);
                try {
                    //执行登录,会调用认证方法,如果认证失败,会抛出异常,执行catch
                    subject.login(token);
                } catch (AuthenticationException e) {
                    // TODO Auto-generated catch block
                    System.out.println("登录失败:"+e.getMessage());
                    return "login";
                }
            }
            //login(token)认证成功会执行这些语句
            System.out.println("登录成功");
    
            //这里如果直接 return "WEB-INF/jsp/index"的话,由于默认转发,地址栏不变,还是http://localhost:8080/ssm_shiro_war_exploded/login
            //仍然执行/login = anon过滤规则,不会执行下面的权限验证过滤规则 /**=user,roles[admin]
    
            //因此需要使用重定向"redirect:index",才能让 /**=user,roles[admin]过滤规则生效
            return "redirect:index";
        }
    
        @RequestMapping("/index")
        public String index() {
           return "WEB-INF/jsp/index";
        }
    }
    
    

    在这里插入图片描述在这里插入图片描述

    这里到dao service entity就不再粘贴代码了

    6.数据库连接配置相关

    在这里插入图片描述

    jdbc.jdbcUrl=jdbc:mysql://localhost:3306/ssm-shiro?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
    jdbc.driverClass=com.mysql.cj.jdbc.Driver
    jdbc.user=root
    jdbc.password=root
    

    applicationContext.xml
    在这里插入图片描述

    项目中用到的是通用mapper,实体类的类名和数据库的表名对应,实体类的属性和数据库表的字段名对应

    在这里插入图片描述

    测试

    运行项目

    在这里插入图片描述
    因为我shiro过滤链配置的是只有角色为admin的能进首页,角色为user不能进首页,会被拦截(数据库jake为admin,tom为user)
    在这里插入图片描述
    运行结果:
    在这里插入图片描述

    在这里插入图片描述

    展开全文
  • Shiro详解笔记

    2021-01-31 22:45:53
    shiro笔记链接: 点我跳转. 有道云笔记!!!!
  • shiro详解-shiro史上最全学习笔记

    万次阅读 多人点赞 2018-12-13 15:54:16
    1.shiro简介 1.1.基本功能点 Shiro 可以非常容易的开发出足够好的应用,其不仅可以用在 JavaSE 环境,也可以用在 JavaEE 环境。Shiro 可以帮助我们完成:认证、授权、加密、会话管理、与 Web 集成、缓存等。其基本...
  • shiro(二)shiro详解

    千次阅读 2016-11-24 15:33:32
    一、HelloWorld 在类路径下加入如下 jar 包 在类路径下加入如下配置文件: samples\quickstart\src\main\resources*。...修改 log4j.properties,只保留如下部分 二、Shiro 配置基础:users1、Shiro 被设计
  • Shiro详解与说明

    2018-05-11 19:15:04
    ApacheShiro权限控制Apache Shiro是Java的一个安全框架。目前,使用Apache Shiro的人越来越多,因为它相当简单,对比Spring Security,可能没有Spring Security做的功能强大,但是在实际工作时可能并不需要那么复杂...
  • shiro详解(1)

    2020-02-18 01:26:03
    shiro 在java世界中,安全管理框架有spring security 和shiro 。spring security 要依赖于spring,并且比较复杂,学习曲线比较高。shiro比较简单,而且shiro比较独立,既可以在java se中使用,也可以在java ee中使用,...
  • 权限框架之Shiro详解

    2021-02-23 14:08:59
    二、Shiro基础介绍 三、Spring Boot整合Shiro代码实战 四、项目源码与资料下载 五、参考文章 一、权限框架介绍 1. 什么是权限管理   权限管理属于系统安全的范畴,权限管理实现对用户访问系统的控制,按照...
  • shiro详解第一篇

    2021-03-23 11:56:18
    此内容根据官方文档翻译,加上自己的理解 1. SecurityManager ... factory = new IniSecurityManagerFactory("classpath:shiro.ini") SecurityManager securityManager = factory.getInstance(); S
  • apache-shiro详解

    2016-09-13 17:15:31
    http://www.infoq.com/cn/articles/apache-shiro/
  • 关于 Apache Shiro 详解

    2015-12-30 10:01:00
    目前,使用Apache Shiro的人越来越多,因为它相当简单,对比Spring Security,可能没有Spring Security做的功能强大,但是在实际工作时可能并不需要那么复杂的东西,所以使用小而简单的Shiro就足够了。对于它俩到底...
  • Shiro详解之Subject

    2017-06-10 12:18:41
    方法详解 Object getPrincipal(); PrincipalCollection getPrincipals(); boolean isPermitted(String permission); boolean isPermitted(Permission permission); boolean[] isPermitted(String... permis
  • (1) shiro详解

    2020-02-19 17:32:18
    上面说到 角色 和 权限 都是使用字符串来表示的,其实 shiro 提供了一套比较强大有点复杂的权限字符串表示格式(分为:分割的三个部分): “ 资源:操作:对象实例ID ” 表示:对那个资源的哪个实例可以进行哪些...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 945
精华内容 378
关键字:

shiro详解