Shiro入门之基本概念

最新推荐文章于 2022-08-26 09:59:43 发布

倪家李子

最新推荐文章于 2022-08-26 09:59:43 发布

阅读量151

点赞数

分类专栏： shiro 文章标签：架构

本文链接：https://blog.csdn.net/m0_57806252/article/details/121227153

版权

shiro 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

核心架构图：

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

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

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

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

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

- 注意：不要把Realm 理解成只是从数据库中获取数据源，在realm中还是认证授权校验的相关操作

shiro中热证的关键对象

1.Subject：主体
访问系统的用户，主体可以是用户、程序等，进行认证的都称之为主体

2.Principal：身份信息
是主体（subject）进行身份认证的标识，标识必须具有唯一性，如用户名、手机号、邮箱地址等，一个主体可以有多个身份，但是必须有一个主身份（Primary Principal）

3.credential：凭证信息
只有主体自己知道的安全信息，如密码、证书等。

认证流程

自定义realm:

通过Reaml 类可以看到如下的类关系：

源码查看

package org.apache.shiro.realm;



public class SimpleAccountRealm extends AuthorizingRealm {
    
    // 授权
    protected AuthenticationInfo doGetAuthenticationInfo(
                AuthenticationToken token) throws AuthenticationException {

        UsernamePasswordToken upToken = (UsernamePasswordToken) token;
        SimpleAccount account = getUser(upToken.getUsername());

        if (account != null) {

            if (account.isLocked()) {
                throw new LockedAccountException("Account [" + account + "] is locked.");
            }
            if (account.isCredentialsExpired()) {
                String msg = "The credentials for account [" + account + "] are expired";
                throw new ExpiredCredentialsException(msg);
            }

        }

        return account;
    }

    // 认证
    protected AuthorizationInfo doGetAuthorizationInfo(
                 PrincipalCollection principals) {

        String username = getUsername(principals);
        USERS_LOCK.readLock().lock();
        try {
            return this.users.get(username);
        } finally {
            USERS_LOCK.readLock().unlock();
        }
    }
}

自定义realm

我们从源码中可以观察到，当我们需要自己去写realm时，只需要重写doGetAuthenticationInfo() 和doGetAuthorizationInfo() 方法即可

package com.any.realm;

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;

/**
 * CustomerRealm
 *
 * @author nni
 * @date 8:23 2021/11/10
 */
public class CustomerRealm extends AuthorizingRealm {
    /**
     * 授权
     * @param principals
     * @return org.apache.shiro.authz.AuthorizationInfo
     * @throws
     * @update 2021-11-10 08:23 by 15821
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        return null;
    }

    /**
     * 认证
     * @param token
     * @return org.apache.shiro.authc.AuthenticationInfo
     * @throws
     * @update 2021-11-10 08:24 by 15821
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) 
    throws AuthenticationException {
        //在token中获取 用户名
        String principal = (String) token.getPrincipal();
        System.out.println(principal);
        //实际开发中应当 根据身份信息使用jdbc mybatis查询相关数据库
        //在这里只做简单的演示
        //假设username,password是从数据库获得的信息
        String username = "admin";
        String password = "admin";
        if(username.equals(principal)){
            //参数1:返回数据库中正确的用户名
            //参数2:返回数据库中正确密码
            //参数3:提供当前realm的名字 this.getName();
            SimpleAuthenticationInfo simpleAuthenticationInfo = 
                    new SimpleAuthenticationInfo(principal,password,this.getName());
            return simpleAuthenticationInfo;
        }
        return null;
    }
}

测试自定义realm

package com.any.test;

import com.any.realm.CustomerRealm;
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.mgt.DefaultSecurityManager;
import org.apache.shiro.subject.Subject;
import org.junit.jupiter.api.Test;

/**
 * TestCustomerRealm
 *
 * @author nni
 * @date 8:31 2021/11/10
 */
public class TestCustomerRealm {

    @Test
    public void testCustomerRealm(){
        // 1.创建安全管理器
        DefaultSecurityManager securityManager = new DefaultSecurityManager();

        // 安全管理器添加 自定义的realm
        securityManager.setRealm(new CustomerRealm());

        // 3.SecurityUtils 给全局安全工具类设置安全管理器
        SecurityUtils.setSecurityManager(securityManager);

        // 4.获取主题对象
        Subject subject = SecurityUtils.getSubject();

        // 5.创建token 令牌
        UsernamePasswordToken token = new UsernamePasswordToken("admin","admin");
        try {
            // 用户验证
            subject.login(token);
            System.out.println("登录成功");
        }catch (UnknownAccountException unknownAccountException){
            unknownAccountException.printStackTrace();
            System.out.println("用户名错误");
        }catch (IncorrectCredentialsException credentialsException){
            credentialsException.printStackTrace();
            System.out.println("密码错误");
        }
    }
}

MD5 Salt Hash

测试 shiro提供的Md5Hash类

    @Test
    public void testMD5(){

        String val = "admin";    // 原始密码
        String salt = "admin";    // 加盐
        int hashNum = 10;    // hash 次数

        // 1.不加盐 hash一次
        Md5Hash valMd5 = new Md5Hash(val);
        System.out.println(valMd5);

        // 2.加盐 hash一次
        Md5Hash valMd5Salt = new Md5Hash(val,salt);
        System.out.println(valMd5Salt);

        // 2.加盐 hash十次
        Md5Hash valMd5SaltHash = new Md5Hash(val,salt,hashNum);
        System.out.println(valMd5SaltHash);

    }


执行结果：

21232f297a57a5a743894a0e4a801fc3
2fb8253776cbe5e37696bc64642d9db7
d4328904ed141eab1e18d653a6aa89e1

更改自定义realm

package com.any.realm;

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;

/**
 * CustomerRealm
 *
 * @author nni
 * @date 8:23 2021/11/10
 */
public class CustomerRealm extends AuthorizingRealm {
    /**
     * 授权
     * @param principals
     * @return org.apache.shiro.authz.AuthorizationInfo
     * @throws
     * @update 2021-11-10 08:23 by 15821
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        return null;
    }

    /**
     * 认证
     * @param token
     * @return org.apache.shiro.authc.AuthenticationInfo
     * @throws
     * @update 2021-11-10 08:24 by 15821
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) 
    throws AuthenticationException {
        //在token中获取 用户名
        String principal = (String) token.getPrincipal();
        System.out.println(principal);
        //实际开发中应当 根据身份信息使用jdbc mybatis查询相关数据库
        //在这里只做简单的演示
        //假设username,password是从数据库获得的信息
        String username = "admin";
        String password = "d4328904ed141eab1e18d653a6aa89e1";
        if(username.equals(principal)){
            //参数1:返回数据库中正确的用户名
            //参数2:返回数据库中正确密码
            //参数3:提供当前realm的名字 this.getName();
            SimpleAuthenticationInfo simpleAuthenticationInfo = 
                    new SimpleAuthenticationInfo(
                        principal
                        ,password
                        , ByteSource.Util.bytes("admin")    // 所加的盐
                        ,this.getName());
            return simpleAuthenticationInfo;
        }
        return null;
    }
}

测试修改后的realm

@Test
    public void testCustomerRealm(){
        // 1.创建安全管理器
        DefaultSecurityManager securityManager = new DefaultSecurityManager();
        CustomerRealm customerRealm = new CustomerRealm();

        // 2.设置realm使用hash凭证匹配器
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        matcher.setHashAlgorithmName("md5");
        matcher.setHashIterations(hashNum);

        // 3.安全管理器添加 自定义的realm
        customerRealm.setCredentialsMatcher(matcher);
        securityManager.setRealm(customerRealm);

        // 3.SecurityUtils 给全局安全工具类设置安全管理器
        SecurityUtils.setSecurityManager(securityManager);

        // 4.获取主题对象
        Subject subject = SecurityUtils.getSubject();

        // 5.创建token 令牌
        UsernamePasswordToken token = new UsernamePasswordToken("admin","admin");
        try {
            // 用户验证
            subject.login(token);
            System.out.println("登录成功");
        }catch (UnknownAccountException unknownAccountException){
            unknownAccountException.printStackTrace();
            System.out.println("用户名错误");
        }catch (IncorrectCredentialsException credentialsException){
            credentialsException.printStackTrace();
            System.out.println("密码错误");
        }
    }

Shiro 中的授权

概述：

授权，即访问控制，控制访问者能够使用哪些资源，主体认证后，只能访问已经授权的资源，对于未授权的资源无法访问

关键对象：

授权可简单理解为 who 对 what(which) 进行how 操作
who 即主体（Subject）：主体需要访问系统的资源
what 即资源（Resource）: 如系统菜单、页面、按钮、类方法、系统商品信息。
how 即权限，许可（permission）: 规定了主体对资源的操作许可，权限离开资源没有意义。如用户查询权限、用户添加权限、某个类方法的调用权限等等；

授权流程

授权方式

基于角色的访问控制
RBAC基于角色的访问控制(Role-Based Access Control) 是以角色为中心进行访问控制的

if(subject.hasRole("admin")){
   //操作什么资源
}

基于资源的访问控制
RBAC基于资源的访问控制(Resource-Based Access Control) 是以资源为中心进行访问控制

if(subject.isPermission("user:update:01")){ //资源实例
  //对资源01用户具有修改的权限
}

权限字符串

权限字符串的规则是：资源标识符：操作：资源实例标识符，意思是对哪个资源的哪个实例具有什么操作，“:”是资源/操作/实例的分割符，权限字符串也可以使用*通配符。

例子：

用户创建权限：user:create，或user:create:*
用户修改实例001的权限：user:update:001
用户实例001的所有权限：user:*：001

代码实例

package com.any.realm;

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;

/**
 * CustomerRealm
 *
 * @author nni
 * @date 8:23 2021/11/10
 */
public class CustomerRealm extends AuthorizingRealm {
    /**
     * 授权
     * @param principals
     * @return org.apache.shiro.authz.AuthorizationInfo
     * @throws
     * @update 2021-11-10 08:23 by 15821
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        System.out.println("------------doGetAuthorizationInfo------------");
        String primaryPrincipal = (String) principals.getPrimaryPrincipal();
        System.out.println("【用户身份信息】"+primaryPrincipal);
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        authorizationInfo.addRole("admin");
        authorizationInfo.addRole("user");
        return authorizationInfo;
    }

    /**
     * 认证
     * @param token
     * @return org.apache.shiro.authc.AuthenticationInfo
     * @throws
     * @update 2021-11-10 08:24 by 15821
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) 
    throws AuthenticationException {
        //在token中获取 用户名
        String principal = (String) token.getPrincipal();
        System.out.println(principal);
        //实际开发中应当 根据身份信息使用jdbc mybatis查询相关数据库
        //在这里只做简单的演示
        //假设username,password是从数据库获得的信息
        String username = "admin";
        String password = "d4328904ed141eab1e18d653a6aa89e1";
        if(username.equals(principal)){
            //参数1:返回数据库中正确的用户名
            //参数2:返回数据库中正确密码
            //参数3:提供当前realm的名字 this.getName();
            SimpleAuthenticationInfo simpleAuthenticationInfo = 
                    new SimpleAuthenticationInfo(
                        principal
                        ,password
                        , ByteSource.Util.bytes("admin")    // 所加的盐
                        ,this.getName());
            return simpleAuthenticationInfo;
        }
        return null;
    }
}

倪家李子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Shiro入门之基本概念

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

扫一扫