Shiro框架

最新推荐文章于 2023-05-11 18:04:13 发布

WinerCode

最新推荐文章于 2023-05-11 18:04:13 发布

阅读量191

点赞数 2

CC 4.0 BY-SA版权

分类专栏： Java技术 Java 计算机编程集成后端开发文章标签： shiro 框架 Java 认证授权

本文链接：https://blog.youkuaiyun.com/WinerCode/article/details/95914650

Java技术同时被 3 个专栏收录

5 篇文章

订阅专栏

Java

5 篇文章

订阅专栏

编程

5 篇文章

订阅专栏

1.Shiro简介

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

1.1.shiro能干什么?

在这里插入图片描述
Shiro 开发团队称为“应用程序的四大基石” ——身份验证，授权，会话管理和加密作为其目标。
      Authentication(身份认证)：
           有时也简称为“登录”，这是一个证明用户是他们所说的他们是谁的行为。
      Authorization（授权）：
           访问控制的过程，也就是绝对“谁”去访问“什么”权限。
      Session Management：管理用户特定的会话，即使在非 Web 或 EJB 应用程序。
      Cryptography：通过使用加密算法保持数据安全同时易于使用。
也提供了额外的功能来支持和加强在不同环境下所关注的方面，尤其是以下这些：

Web Support： Shiro 的 web 支持的 API 能够轻松地帮助保护 Web 应用程序。
Caching：缓存是 Apache Shiro 中的第一层公民，来确保安全操作快速而又高效。
Concurrency： Apache Shiro 利用它的并发特性来支持多线程应用程序。
Testing：测试支持的存在来帮助你编写单元测试和集成测试，并确保你的能够如预期的一样安全。
“Run As”：一个允许用户假设为另一个用户身份（如果允许）的功能，有时候在管理脚本很有用。
“Remember Me”：在会话中记住用户的身份，所以他们只需要在强制时候登录。

1.2.架构

1.2.1.Shiro外部来看

从外部来看Shiro,即从应用程序角度来如何使用shiro来完成工作(认证、授权等)。
在这里插入图片描述

1.2.2.Shiro内部看

即shiro内部夹走
在这里插入图片描述

小结：
Shiro：是一个apache的安全框架，还有spring security；
Shiro：能做：身份认证(登录)authentication，授权authorization，密码学，会话管理。
应用–》Subject（当前用户）—》Security Mananger管理–》Realm----》db

1.3.Shiro入门

创建一个普通Maven项目

1.3.1.导入jar

<dependencies>
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-core</artifactId>
        <version>1.4.0</version>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

1.3.2.准备资源

这个资源我们可以到shiro的源码文件中拷备:
           /shiro-root-1.4.0-RC2/samples/quickstart/src/main/resources
           shiro.ini
           log4j.properties
注：users下面代表的登录的用户(用户名=密码)
shiro.ini文件(对拷备过来的数据进行了解释)：

# -----------------------------------------------------------------------------
# 所有的用户与对应的用户密码 ，用户的角色
# -----------------------------------------------------------------------------
[users]
# root用户有一个密码是secret，他的角色是admin
root = secret, admin
guest = guest, guest
presidentskroob = 12345, president
# darkhelmet用户有一个密码是ludicrousspeed，他的角色是darklord, schwartz
darkhelmet = ludicrousspeed, darklord, schwartz
lonestarr = vespa, goodguy, schwartz

# -----------------------------------------------------------------------------
# 所有的用户的角色
# -----------------------------------------------------------------------------
[roles]
# admin这个角色有所有权限功能
admin = *
#schwartz这个角色可以操作所有的lightsaber权限功能
schwartz = lightsaber:*
#goodguy这个角色可以操作winnebago下面的drive权限的一个eagle5资源
goodguy = winnebago:drive:eagle5

1.3.3.测试

Session数据
登录
授权
这个文件位置 : /shiro-root-1.4.0-RC2/samples/quickstart/src/main/java
我们下面对这个文件进行了中文的解释

/**
 * 简单的入门示例，教我们怎么使用shiro中的一个API
 */
public class Quickstart {
    private static final transient Logger log = LoggerFactory.getLogger(Quickstart.class);
    public static void main(String[] args) {
        //读取到shiro.ini文件，并且根据文件创建SecurityManager对象
        //  SecurityManager：权限的核心管理对象
        Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");
        SecurityManager securityManager = factory.getInstance();

        // 为了程序正常运行，需要设计一个这个securityManager(相当于把这个管理放到环境中去了)
        SecurityUtils.setSecurityManager(securityManager);

        //拿到当前用户【Subject:操作当前系统的一个用户】
        Subject currentUser = SecurityUtils.getSubject();

        //拿到一个会话(它在咱们的所有类型系统都可以使用【不要求必需是web项目】)
        Session session = currentUser.getSession();
        //会话操作【可以在会话中设置值与获取值】
        session.setAttribute("someKey", "aValue");
        String value = (String) session.getAttribute("someKey");
        if (value.equals("aValue")) {
           // log.info("Retrieved the correct value! [" + value + "]");
            System.out.println("可以获取到这个值"+value);
        }

        //判断这个用户是否经过验证(没有登录我们可以认为是一个游客)
        //没有登录，我们就可以完成登录
        if (!currentUser.isAuthenticated()) {
            //拿到用户名与密码令牌【拿到用户名与密码】
            UsernamePasswordToken token = new UsernamePasswordToken("lonestarr", "vespa");
            //设置记住我的功能
            token.setRememberMe(true);
            try {
                //完成登录功能
                currentUser.login(token);
            } catch (UnknownAccountException uae) {
                //log.info("There is no user with username of " + token.getPrincipal());
                //token.getPrincipal()[ˈprɪnsəpl] -> 拿到主体（登录用户的主要标识【用户名】）
                System.out.println("这没有这个账号（用户名）"+token.getPrincipal());
            } catch (IncorrectCredentialsException ice) {
                //incorrect [ˌɪnkəˈrekt]:不正确的，错误的
                //Credentials[krəˈdenʃlz]:证书; 凭证，证件
                //log.info("Password for account " + token.getPrincipal() + " was incorrect!");
                System.out.println("这个密码是错误的"+token.getPrincipal());
            } catch (LockedAccountException lae) {
                System.out.println("这个账号已经被锁定");
            }
            //其它的登录失败异常【它是所有登录异常的父类】
            catch (AuthenticationException ae) {
                //unexpected condition?  error?
            }
        }

        //用户登录成功
        log.info("User [" + currentUser.getPrincipal() + "] logged in successfully.");

        //判断这个用户是否是某一个角色
        if (currentUser.hasRole("schwartz")) {
            log.info("May the Schwartz be with you!");
        } else {
            log.info("Hello, mere mortal.");
        }

        //测试用户是否有某一个权限
        if (currentUser.isPermitted("lightsaber:wield")) {
            log.info("You may use a lightsaber ring.  Use it wisely.");
        } else {
            log.info("Sorry, lightsaber rings are for schwartz masters only.");
        }

        //a (very powerful) Instance Level permission:
        if (currentUser.isPermitted("winnebago:drive:eagle5")) {
            log.info("You are permitted to 'drive' the winnebago with license plate (id) 'eagle5'.  " +
                    "Here are the keys - have fun!");
        } else {
            log.info("Sorry, you aren't allowed to drive the 'eagle5' winnebago!");
        }

        //登出(注销当前登录用户)
        currentUser.logout();

        System.exit(0);
    }
}

1.3.4.总结

通过SecurityManger获取Suject :
        SecurityUtils.setSecurityManager(securityManager);
        Subject currentUser = SecurityUtils.getSubject();
通过Subject来做事情：
        获取Session-存值和获取值 Suject.getSession session.setAttribute session.getAttribute
        认证（登录）:
                判断是否登录Suject.isAuthenticated()
                如果没有登录，通过用户名和密码创建UsernamePasswordToken
                                调用subject.login(UsernamePasswordToken)来进行登录判断
                                登陆成功: 返回principal给当前用户
                                登陆失败: 抛出异常
        授权
                判断是否具有某个角色subject .hasRole
                判断是否有权限subject .isPrermited(resource:操作)

2.Shiro框架对Spring的集成

2.1.为什么要集成Spring

我们的项目基本都是通过Spring来管理bean的，如果要想使用Shiro,那就要把shiro集成到Spring。集成Spring的核心就是把框架的核心类(SecurityManager,Subject,Realm)交给Spring管理！

2.2.集成

2.2.1.准备Spring-web项目

拷备咱们的SSJ集成项目/直接在当前配置中完成

2.2.2.集成

导入shiro-all-1.3.2.ja(现升级到1.4.0)r
参考官方demo做示例:

<!-- shiro的支持包 -->
 <dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-all</artifactId>
    <version>1.4.0</version>
    <type>pom</type>
</dependency>
  <!-- shiro与Spring的集成包 -->
  <dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring</artifactId>
    <version>1.4.0</version>
  </dependency>

在这里插入图片描述

拷贝shiroFilter配置到web.xml

<!-- Spring与shiro集成:需要定义一个shiro过滤器(这是一个代理过滤器，它会到spring的配置中找一个名称相同的真实过滤器) -->
<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>
</filter>

<filter-mapping>
  <filter-name>shiroFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

拷贝shiro Spring配置文件并集成到Spring
applicationContext.xml 改名为applicationContext-shiro.xml并在applicationContext.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"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <!-- 1.配置apache的管理器 -->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <!-- 配置一个realm，到数据库中获取权限数据 -->
        <property name="realm" ref="jpaRealm"/>
    </bean>

    <!-- 2.我们可以自定义一个realm【暂时未实现功能】这个必需实现org.apache.shiro.realm.Realm接口 -->
    <bean id="jpaRealm" class="cn.itsource.yxb.shiro.realm.JpaRealm">
    </bean>

    <!-- 3.lifecycleBeanPostProcessor：可以自动调用在Spring Ioc窗口中 Shiro bean的生成周期方法 -->
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>
    
    <!-- 4.启动ioc容器中使用 shiro的注解，但是必需配置在Spring Ioc容器中Shiro bean的生成周期方法 -->
    <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>

    <!-- 5.shiro的真实过滤器(注：这个名称必需和web.xml的代表过滤器【DelegatingFilterProxy】名称一样) -->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager"/>
        <!-- 登录的url,如果没有登录，你访问的路径会跳到这个页面 -->
        <property name="loginUrl" value="/s/login.jsp"/>
        <!-- 登录成功的url,如果登录成功，会跳转到这个页面 -->
        <property name="successUrl" value="/s/main.jsp"/>
        <!-- 没有权限时跳转到这个位置 -->
        <property name="unauthorizedUrl" value="/s/unauthorized.jsp"/>
        <!--
            配置哪些资源被保护，哪些资源需要权限
            anon：不需要登录也可以访问相应的权限
            authc：需要权限才能访问
              /** ：所有文件及其子文件
        -->
        <property name="filterChainDefinitions">
            <value>
                /s/login.jsp = anon
                /** = authc
            </value>
        </property>
    </bean>
</beans>

测试

除了登录界面能够被正常访问，其他的都要跳转到登录界面！

2.3.小结

注意：需要一个Spring的环境，不能全部都在SpringMVC那儿初始化

3.Authentication（身份认证）

3.1.引入

在集成Spring的例子中，只有登录页面是不需要登录可以直接访问。其他的页面需要认证（即登录）后才能访问。

3.2.概念

在这里插入图片描述
做认证需要用户名和密码
认证流程：

3.3.详细步骤分析

       要想实现登录，分前台和后台两部分：
       前台：
              实现一个login.jsp的页面，用来搜集登录信息（用户名和密码）！当点击登录时把登录信息提交到后台完成认证。
       后台：
              写一个Controller接收前台传入的登录信息，完成登录认证。
              具体步骤如下：

创建LoginConroller,写一个方法接收前台登录请求并接受登录信息(用户名和密码)
获取当前的 Subject. 调用 SecurityUtils.getSubject();
测试当前的用户是否已经被认证. 即是否已经登录. 调用 Subject 的 isAuthenticated()
若没有被认证, 则把用户名和密码封装为 UsernamePasswordToken 对象
执行登录: 调用 Subject 的 login(AuthenticationToken) 方法.
自定义 Realm 的方法, 从数据库中获取对应的记录, 返回给 Shiro.
        入门中使用的是Shiro自带的IniRealm，IniRealm从ini配置文件中读取用户的信息，大部分情况下需要从系统的数据库中读取用户信息，所以需要自定义realm。
       实际上需要继承 org.apache.shiro.realm.AuthenticatingRealm 类
       实现 doGetAuthenticationInfo(AuthenticationToken) 方法.
由 shiro 完成对密码的比对.

3.4.简单认证实现

3.4.1.login.jsp

<form action="/login" method="post">
    用户名<input type="text" name="username" /> <br />
    密码:<input type="password" name="password" /> <br />
    <input type="submit" value="登录" />
</form>

3.4.2.LoginController

@Controller
public class LoginController {
    @RequestMapping("/login")
    public String login(String username,String password){
        /**
         * 获取当前的 Subject. 调用 SecurityUtils.getSubject();
         * 测试当前的用户是否已经被认证. 即是否已经登录. 调用 Subject 的 isAuthenticated()
         * 若没有被认证, 则把用户名和密码封装为 UsernamePasswordToken 对象
         * 执行登录: 调用 Subject 的 login(AuthenticationToken) 方法.
         */
        //1.拿到访问的主体(当前登录用户)
        Subject subject = SecurityUtils.getSubject();
        //2.判断这个用户是否已经登录(通过验证)
        if(!subject.isAuthenticated()){
            //3.如果没有验证，就要完成登录
            UsernamePasswordToken token = new UsernamePasswordToken(username,password);
            try{
                //4.根据toke完成登录功能
                subject.login(token);
            }catch (UnknownAccountException e){
                System.out.println("用户名不存在！！");
                e.printStackTrace();
            }catch (IncorrectCredentialsException e){
                System.out.println("密码不存在！");
                e.printStackTrace();
            }catch (AuthenticationException e){
                System.out.println("登录出错！");
                e.printStackTrace();
            }
        }
        return "redirect:/s/main.jsp";
    }
}

3.4.3.JpaRealm

public class JpaRealm extends AuthenticatingRealm {
    //AuthenticationInfo:认证; 身份验证; 证明
    //登录的时候就会调用这个方法来做验证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        //System.out.println(token.getClass().getName());
        //可以转成相应的token
        //UsernamePasswordToken upToken =(UsernamePasswordToken)token;
        //拿到传过来的用户名
        //String username = upToken.getUsername();
        //自定义Realm中，需要根据用户名到数据库中拿到密码，然后返回给shiro
        //String password = "123456";
        //身份认证(用户名)
        Object principal = token.getPrincipal();
        Object credentials = "123456"; //密码假设是根据用户名到数据库中查询出来的
        // Object principal, Object credentials, String realmName
        return new SimpleAuthenticationInfo(principal,credentials,getName());
    }
}

4.Authorizing（授权）

4.1.为什么要授权

用户(n)-角色(n)-权限(n)-资源(n)
有的资源需要有对应的权限才能访问，如果想要某个用户能够访问某个资源，必须给对应用户授权。
对于授权需要做两个事情：
权限拦截：当用户访问没有权限的资源时进行拦截
权限判断：给用户授权

4.2.授权

4.2.1.概念

在这里插入图片描述
用户–角色—权限–资源

4.2.2.Shiro的三种权限判断方式

1.编程式:通过写if/else 授权代码块完成：

Subject subject = SecurityUtils.getSubject();
if(subject.hasRole(“admin”)) {
//有权限
} else {
//无权限
}

2.注解式:通过在执行的Java方法上放置相应的注解完成：

@RequiresRoles("admin")
public void hello() {
//有权限
}

3.JSP/GSP 标签:在JSP/GSP 页面通过相应的标签完成：

<%@taglib prefix=”shiro” uri=”http://shiro.apache.org/tags”%>
<shiro:hasRole name="admin">
<!— 有权限—>
<button>删除</button>
</shiro:hasRole>

1、控制哪些资源要做权限拦截如果不做拦截，直接放行，如果要拦截就要做权限判断
2、获取用户能够访问资源，如果你访问资源在里面，说明有权限。可以访问，否则不能访问。
不控制直接放行,要控制查看用户是否拥有,如果有直接访问,否则不能访问。

4.3.授权拦截

权限拦截同样需要从数据库中获取权限或角色信息，所以同样需要自定义Realm.
注意:现要权限写死在配置中！

<!-- 5.shiro的真实过滤器(注：这个名称必需和web.xml的代表过滤器【DelegatingFilterProxy】名称一样) -->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
    <property name="securityManager" ref="securityManager"/>
    <!-- 登录的url,如果没有登录，你访问的路径会跳到这个页面 -->
    <property name="loginUrl" value="/s/login.jsp"/>
    <!-- 登录成功的url,如果登录成功，会跳转到这个页面 -->
    <property name="successUrl" value="/s/main.jsp"/>
    <!-- 没有权限时跳转到这个位置 -->
    <property name="unauthorizedUrl" value="/s/unauthorized.jsp"/>
    <!--
        配置哪些资源被保护，哪些资源需要权限
        anon：不需要登录也可以访问相应的权限
        authc：需要权限才能访问
          /** ：所有文件及其子文件
    -->
    <property name="filterChainDefinitions">
        <value>
            /s/login.jsp = anon
            /login = anon
            <!--对资源进行权限控制，要控制的资源都应该从数据库查出，现在咱们先写死-->
            /s/permission.jsp = perms[user:*]
            /** = authc
        </value>
    </property>
</bean>

自定义Realm授权
授权需要继承 AuthorizingRealm 类, 并实现其 doGetAuthorizationInfo 方法
AuthorizingRealm 类继承自 AuthenticatingRealm，但没有实现 AuthenticatingRealm 中的doGetAuthenticationInfo，所以认证和授权只需要继承 AuthorizingRealm 就可以了，同时实现他的两个抽象方法。
具体实现：

public class JpaRealm extends AuthorizingRealm {
    //AuthorizationInfo:授权(是否有权限进入操作)
    // 我们只需要把相应的权限交给Shiro，它就会自动比对
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        //拿到主体信息(指的就是当前登录用户名) -> 咱们的权限应该是根据当前用户进行查询到的
        String username = (String) principals.getPrimaryPrincipal();
        System.out.println("后面需要根据用户名获取资源"+username);
        //获取权限资源(这里假设已经根据用户名到数据库中获取到了)
        Set<String> permissions = new HashSet<>();
        permissions.add("user:*");
        //拿到授权对象，并且所有权限交给它
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        simpleAuthorizationInfo.setStringPermissions(permissions);
        //返回授权对象
        return simpleAuthorizationInfo;
    }

    //AuthenticationInfo:认证; 身份验证; 证明
    //登录的时候就会调用这个方法来做验证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        /**
         * Object principal：主体(现在就是登录的用户名)
         * Object hashedCredentials：编码后的认证密码
         * ByteSource credentialsSalt:加盐
         * String realmName
         */
        //身份认证(用户名)
        Object principal = token.getPrincipal();
        //密码假设是根据用户名到数据库中查询出来的（数据库密码是经过加密的）
        Object credentials = "d5a3fedf6c59c2ecbe7f7a6c1a22da37";
        //加盐的数据
        ByteSource byteSource = ByteSource.Util.bytes("itsource");
        return new SimpleAuthenticationInfo(principal,credentials,byteSource,getName());
    }
}