• 安全认证框架Shiro入门学习（shiro概述和shiro入门小案例）；后续整合SpringBoot，应用程序安全；

    权限概述

    什么是权限

    • 什么是权限

      权限管理，一般指根据系统设置的安全策略或者安全规则，用户可以访问而且只能访问自己被授权的资源，不多不少。权限管理几乎出现在任何系统里面，只要有用户和密码的系统。

    • 权限管理再系统中一般分为

      访问权限

      一般表示你能做什么样的操作，或者能够访问那些资源。例如：给张三赋予“店铺主管”角色，“店铺主管”具有“查询员工”、“添加员工”、“修改员工”和“删除员工”权限。此时张三能够进入系统，则可以进行这些操作

      • 1

      数据权限

      一般表示某些数据你是否属于你，或者属于你可以操作范围。例如：张三是"店铺主管"角色，他可以看他手下客服人员所有的服务的买家订单信息，他的手下只能看自己负责的订单信息

      • 1

    认证概念

    • 认证：

      ​ 身份认证，就是判断一个用户是否为合法用户的处理过程。最常用的简单身份认证方式是系统通过核对用户输入的用户名和密码，看其是否与系统中存储的该用户的用户名和密码一致，来判断用户身份是否正确。例如：密码登录，手机短信验证、三方授权等

    • 认证流程

      在这里插入图片描述

    • 关键对象

      上边的流程图中需要理解以下关键对象

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

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

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

    授权概念

    • 什么是授权

      授权，即访问控制，控制谁能访问哪些资源。主体进行身份认证后，系统会为其分配对应的权限，当访问资源时，会校验其是否有访问此资源的权限

      用户对象user：当前操作的用户、程序

      资源对象resource：当前被访问的对象

      角色对象role ：一组 “权限操作许可权” 的集合

      权限对象permission：权限操作许可权

    • 授权流程

      在这里插入图片描述

    Shrio概述

    shiro简介

    • 什么是shiro

      Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。

    • shiro的特点

      Shiro 是一个强大而灵活的开源安全框架，能够非常清晰的处理认证、授权、管理会话以及密码加密。如下是它所具有的特点：

      • 易于理解的 Java Security API；
      • 简单的身份认证（登录），支持多种数据源（LDAP，JDBC 等）；
      • 对角色的简单的签权（访问控制），也支持细粒度的鉴权
      • 支持一级缓存，以提升应用程序的性能
      • 内置的基于 POJO 企业会话管理，适用于 Web 以及非 Web 的环境
      • 异构客户端会话访问
      • 非常简单的加密 API
      • 不跟任何的框架或者容器捆绑，可以独立运行

    核心组件

    Shiro架构图

    在这里插入图片描述

    1. Subject

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

    2. SecurityManager

      SecurityManager权限管理器，它是shiro的核心，负责对所有的subject进行安全管理。通过SecurityManager可以完成subject的认证、授权等，SecurityManager是通过Authenticator进行认证，通过Authorizer进行授权，通过SessionManager进行会话管理等。SecurityManager是一个接口，继承了Authenticator, Authorizer, SessionManager这三个接口

    3. Authenticator

      Authenticator即认证器，对用户登录时进行身份认证

    4. Authorizer

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

    5. Realm==（数据库读取+认证功能+授权功能实现）==

      比如：

      ​ 如果用户身份数据在数据库那么realm就需要从数据库获取用户身份信息。

      注意：

      ​ 不要把realm理解成只是从数据源取数据，在realm中还有认证授权校验的相关的代码。

    6. SessionManager

      SessionManager会话管理，shiro框架定义了一套会话管理，它不依赖web容器的session，所以shiro可以使用在非web应用上，也可以将分布式应用的会话集中在一点管理，此特性可使它实现单点登录。

    7. SessionDAO

      SessionDAO即会话dao，是对session会话操作的一套接口

      比如：

      ​ 可以通过jdbc将会话存储到数据库

      ​ 也可以把session存储到缓存服务器

    8. CacheManager

      CacheManager缓存管理，将用户权限数据存储在缓存，这样可以提高性能

    9. Cryptography

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

    Shiro入门

    身份认证

    身份认证基本流程

    在这里插入图片描述

    1. Shiro把用户的数据封装成标识token，token一般封装着用户名，密码等信息
    2. 使用Subject门面获取到封装着用户的数据的标识token
    3. Subject把标识token交给SecurityManager，在SecurityManager安全中心中，SecurityManager把标识token委托给认证器Authenticator进行身份验证。认证器的作用一般是用来指定如何验证，它规定本次认证用到哪些Realm
    4. 认证器Authenticator将传入的标识token，与数据源Realm对比，验证token是否合法

    代码实现身份认证：

    1. 导入pom.xml文件坐标

      
<dependency>
    <groupId>org.apache.shirogroupId>
    <artifactId>shiro-coreartifactId>
    <version>1.3.2version>
dependency>
<dependency>
    <groupId>junitgroupId>
    <artifactId>junitartifactId>
    <version>4.12version>
    <scope>testscope>
dependency>

<dependency>
    <groupId>commons-logginggroupId>
    <artifactId>commons-loggingartifactId>
    <version>1.1.3version>
dependency>

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18

    2. 编写配置文件shiro-test.ini

      [users]
#模拟从数据库查询用户
#数据格式 用户名=密码
liuls=654321
wangls=123456

      • 1
      • 2
      • 3
      • 4
      • 5

    3. 编写代码

      1. 根据配置文件创建SecurityManagerFactory
      2. 通过工厂获取SecurityManager
      3. 将SecurityManager绑定到当前运行环境
      4. 从当前运行环境中构造subject
      5. 构造shiro登录的数据
      6. 主体登陆
      @Test
public void testLogin() {
  //1.根据配置文件创建SecurityManagerFactory
  Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-test-1.ini");
  //2.通过工厂获取SecurityManager
  SecurityManager securityManager = factory.getInstance();
  //3.将SecurityManager绑定到当前运行环境
  SecurityUtils.setSecurityManager(securityManager);
  //4.从当前运行环境中构造subject
  Subject subject = SecurityUtils.getSubject();
  //5.构造shiro登录的数据
  String username = "liuls";
  String password = "65432";
  UsernamePasswordToken token = new UsernamePasswordToken(username,password);
  //6.主体登陆
  subject.login(token);
  //7.验证用户是否登录成功
  System.out.println("用户是否登录成功="+subject.isAuthenticated());
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19

      此处构造shiro登录的数据若和配置文件中写的相同，是否登陆成功显示true，否则false

    ★★★Realm★★★

    在这里插入图片描述

    Reaml：顶级接口

    CachingRealm：带有缓存的Reaml

    AuthenticatingRealm：继承CachingRealm，支持认证；能缓存能认证

    AuthorizingRealm：继承AuthenticatingRealm，支持授权；能缓存能认证能授权

    Realm域：Shiro从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源

    自定义realms对象–>继承AuthorizingRealm–>重新方法：

    doGetAuthorizationInfo：授权；获取到用户的授权数据（用户的权限数据）

    doGetAuthenticationInfo：认证；根据用户名密码登录，将用户数据保存（安全数据）

    逻辑：用户输入账号密码，构造令牌token，通过realm查找，realm中一个方法做认证一个方法做授权

    代码实现：

    1. pom文件：

      
<dependency>
    <groupId>org.apache.shirogroupId>
    <artifactId>shiro-coreartifactId>
    <version>1.3.2version>
dependency>
<dependency>
    <groupId>junitgroupId>
    <artifactId>junitartifactId>
    <version>4.12version>
    <scope>testscope>
dependency>

<dependency>
    <groupId>commons-logginggroupId>
    <artifactId>commons-loggingartifactId>
    <version>1.1.3version>
dependency>

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18

    2. MyRealm：

      创建MyRealm继承AuthorizingRealm；

      doGetAuthorizationInfo方法：做授权

      doGetAuthoricationInfo方法：做认证

      public class MyRealm extends AuthorizingRealm {
  //授权:授权的主要目的就是根据认证数据获取到用户的权限信息
  protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    System.out.println("执行授权方法");
    //1.获取安全数据  username，用户id
    String username = (String) principalCollection.getPrimaryPrincipal();
    //2.通过认证传递的安全数据，去数据库查询角色以及权限，实现授权
    List<String> perms = new ArrayList<String>();
    perms.add("user:save");
    perms.add("user:update");
    perms.add("user:delete");
    perms.add("user:find");
    List<String> roles = new ArrayList<String>();
    roles.add("role1");
    roles.add("role2");
    // 构造返回值
    SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
    // 设置角色和权限集合
    info.addStringPermissions(perms);
    info.addRoles(roles);
    return info;
  }
  //认证：认证的主要目的，比较用户名和密码是否与数据库中的一致
  //将安全数据存入到shiro进行保管
  //参数：authenticationToken登录构造的usernamepasswordtoken
  protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    System.out.println("执行认证方法");
    //1.构造uptoken
    // subject.loogin传递过来的参数是UsernamePasswordToken类型，
    // 是AuthenticationToken的一个子类，向下类型转化一下拿到构造的用户令牌
    UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken; 	 		//2.获取输入的用户名密码
    String username = token.getUsername();
    String password = new String(token.getPassword());
		//3.根据用户名查询数据库，正式系统查询
    //4.比较密码和数据库中的密码是否一致
    if("123456".equals(password) && username.equals("dongjianxiang")){
      //5.如果成功，向shiro存入安全数据
      SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(username, password,"MyRealm");
      return info;
    }else{
      //6.失败，抛出异常或返回null
      throw new RuntimeException("账号密码错误");
    }
  }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45

    3. 配置文件shiro-test.ini：

      配置加载MyReaml

      [main]
#声明Realm
myClass=com.dong.shiro.MyRealm
#注册realm到securityManager中
securityManager.realms=$myClass

      • 1
      • 2
      • 3
      • 4
      • 5

    4. 测试类：

      @Test
public void testLogin() {
  //1.根据配置文件创建SecurityManagerFactory
  Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-test.ini");
  //2.通过工厂获取SecurityManager
  SecurityManager securityManager = factory.getInstance();
  //3.将SecurityManager绑定到当前运行环境
  SecurityUtils.setSecurityManager(securityManager);
  Subject subject = SecurityUtils.getSubject();
  String username = "liuls";
  String password = "654321";
  UsernamePasswordToken token = new UsernamePasswordToken(username,password);

  //执行login-->realm域中的认证方法
  subject.login(token);
  System.out.println(subject.isAuthenticated());
  //鉴权
  System.out.println(subject.hasRole("role1"));//true
  System.out.println(subject.hasRole("role2"));//true
  System.out.println(subject.isPermitted("user:save"));//true
  System.out.println(subject.isPermitted("user:update"));//true
  System.out.println(subject.isPermitted("user:find"));//true
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23

    编码与解码

    1. Shiro提供了base64和16进制字符串编码/解码的API支持，方便一些编码解码操作
    2. Shiro内部的一些数据的【存储/表示】都使用了base64和16进制字符串

    代码实现：

    1. 导入pom.xml文件

      
<dependency>
    <groupId>org.apache.shirogroupId>
    <artifactId>shiro-coreartifactId>
    <version>1.3.2version>
dependency>
<dependency>
    <groupId>junitgroupId>
    <artifactId>junitartifactId>
    <version>4.12version>
    <scope>testscope>
dependency>

<dependency>
    <groupId>commons-logginggroupId>
    <artifactId>commons-loggingartifactId>
    <version>1.1.3version>
dependency>

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18

    2. 实现编码与解码

      import org.apache.shiro.codec.Base64;
import org.apache.shiro.codec.Hex;
public class EncodesUtil {
    // 16进制编码
    public static String encodeHex(byte[] input){
        return Hex.encodeToString(input);
    }
    // 16进制解码
    public static byte[] decodeHex(String input){
        return Hex.decode(input);
    }
    // base64编码
    public static String encodeBase64(byte[] input){
        return Base64.encodeToString(input);
    }
    // base64解码
    public static byte[] decodeBase64(String input){
        return Base64.decode(input);
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20

    3. 测试

      public class ClientTest {
    // 16进制编码测试
    @Test
    public void testHex(){
        String val = "apache";
        String falg = EncodesUtil.encodeHex(val.getBytes());
        String valHandler = new String(EncodesUtil.decodeHex(falg));
        System.out.println("编码内容"+falg);
        System.out.println("解码内容"+valHandler);
        System.out.println("比较结果："+val.equals(valHandler));
    }
    // base64 编码测试
    @Test
    public void testBase64(){
        String val= "shiro";
        String falg = EncodesUtil.encodeBase64(val.getBytes());
        String valHandler = new String(EncodesUtil.decodeBase64(falg));
        System.out.println("编码内容"+falg);
        System.out.println("解码内容"+valHandler);
        System.out.println("比较结果："+val.equals(valHandler));
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22

      16进制和base64编码再解码后的内容与编码前的值相同，比较结果返回true

    散列算法

    散列算法一般用于生成数据的摘要信息，是一种不可逆的算法，一般适合存储密码之类的数据，常见的散列算法如MD5、SHA等。一般进行散列时最好提供一个salt（盐），比如加密密码“admin”，产生的散列值是“21232f297a57a5a743894a0e4a801fc3”，可以到一些md5解密网站很容易的通过散列值得到密码“admin”，即如果直接对密码进行散列相对来说破解更容易，此时我们可以加一些只有系统知道的干扰数据，如salt（即盐）；这样散列的对象是“密码+salt”，这样生成的散列值相对来说更难破解。shiro支持的散列算法：

    Md2Hash、Md5Hash、Sha1Hash、Sha256Hash、Sha384Hash、Sha512Hash

    散列算法主要用于密码的加密和解密

    散列算法密码加密

    代码实现：

    1. pom文件到坐标

      <dependency>
  <groupId>org.apache.shirogroupId>
  <artifactId>shiro-coreartifactId>
  <version>1.3.2version>
dependency>
<dependency>
  <groupId>junitgroupId>
  <artifactId>junitartifactId>
  <version>4.12version>
  <scope>testscope>
dependency>
<dependency>
  <groupId>commons-logginggroupId>
  <artifactId>commons-loggingartifactId>
  <version>1.1.3version>
dependency>

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16

    2. 加密工具类：

      public class DigestsUtil {

    private static final String SHA1="SHA-1";  // 加密的方式（加密算法）

    private static final Integer COUNTS=369;   // 加密的次数
    
  	// 获取salt混淆字符串（固定方法）
    public static String generateSalt(){
          SecureRandomNumberGenerator randomNumberGenerator = new SecureRandomNumberGenerator();
          return randomNumberGenerator.nextBytes().toHex();
      }
  
		// SimpleHash方法生成密文密码，需要四个参数，加密方式，输入的明文密码
  	// salt混淆字符串，加密次数
    public static String show(String input ,String salt){
        return new SimpleHash(SHA1,input,salt,COUNTS).toString();
    }
	
  	// 模拟存数据，以便测试查看
    public static Map<String,String> entryptPassword(String passwordPlain){
        Map<String,String> map = new HashMap<String, String>();
        String salt = generateSalt();
        String password = show(passwordPlain,salt);
        map.put("salt",salt);
        map.put("password(明文)：",passwordPlain);
        map.put("password(密文)",password);
        return map;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29

    3. 测试：

      public class Test01 {
    @Test
    public void testDigestsUtil(){
        Map<String, String> map = DigestsUtil.entryptPassword("123666");
        System.out.println("结果："+map.toString());
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7

      结果：{password(密文)=8ec65316412c6b8725730bf6ac8c73a1cf27f3ce, salt=b8317a553b2b64ce5c78144d1bacaf7f, password(明文)：=123666}

    加密解密整合案例

    实现步骤：

    1. pom文件：

      
<dependency>
    <groupId>org.apache.shirogroupId>
    <artifactId>shiro-coreartifactId>
    <version>1.3.2version>
dependency>
<dependency>
    <groupId>junitgroupId>
    <artifactId>junitartifactId>
    <version>4.12version>
    <scope>testscope>
dependency>

<dependency>
    <groupId>commons-logginggroupId>
    <artifactId>commons-loggingartifactId>
    <version>1.1.3version>
dependency>

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18

    2. 加密工具类：

      模拟演示，数据写死

      public class DigestsUtil {
  public static final String SHA1= "SHA-1";
  public static final Integer COUNTS = 369;

  // 获取salt字符串
  public static String generateSalt(){
    SecureRandomNumberGenerator randomNumberGenerator = new SecureRandomNumberGenerator();
    return randomNumberGenerator.nextBytes().toHex();
  }

  //  加密得到密文密码
  public static String show(String input,String salt){
    return new SimpleHash(SHA1,input,salt,COUNTS).toString();
  }

  // 生成用户信息（账号，密文密码，salt混淆字符串）
  public static Map<String,String> entryptPassword(String passwordPlain){
    HashMap<String, String> map = new HashMap<String, String>();
    String salt = generateSalt();
    String password = show(passwordPlain, salt);
    map.put("name","刘老板");
    map.put("salt",salt);
    map.put("password",password);
    return map;
  }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26

    3. MyRealm：

      public class MyRealm extends AuthorizingRealm {
  //告诉shiro使用的散列算法
  public MyRealm() {
    //指定密码匹配方式sha1
    HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher(DigestsUtil.SHA1);
    //指定密码迭代此时
    hashedCredentialsMatcher.setHashIterations(DigestsUtil.COUNTS);
    //使用父层方法是匹配方式生效
    setCredentialsMatcher(hashedCredentialsMatcher);
  }
    
  // 认证方法
  @Override
  protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    //获取登录名
    //1.构造uptoken
    UsernamePasswordToken upToken = (UsernamePasswordToken) authenticationToken;
    //2.获取输入的用户名密码
    String username = upToken.getUsername();
    //3.通过用户名称查询数据库相关信息
    SecurityService securityService = new SecurityServiceImpl();//创建业务对象
    //4.调用业务方法(按照用户名称查询用户相关信息)
    Map<String, String> map = securityService.findPasswordByLoginName(username);
    if(map == null){
      throw  new UnknownAccountException("账户不存在");
    }
    String salt = map.get("salt");
    String password = map.get("password");//匿名密码
    //参数1：安全数据   参数2：密码   参数3：混淆字符串  参数4：realm名称
    return new SimpleAuthenticationInfo(username,password, ByteSource.Util.bytes(salt),"myRealm");
    // 参数1：安全数据写什么，未来授权方法就能拿到什么
    // 参数2：现在认证需要给shiro密文密码
    // 参数3：shiro需要知道混淆字符串
    
  }
  
  // 授权方法
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41

    4. 配置Realm

      [main]
# 配置realm
myRealm=com.dong.realm.MyRealm
securityManager.rea lms=$myRealm

      • 1
      • 2
      • 3
      • 4

    5. 模拟一个认证业务

      接口：

      public interface IService {
  public Map<String,String> findPasswordByLoginName(String loginName);
}

      • 1
      • 2
      • 3

      实现类：

      public class ServiceImp implements IService {
  public Map<String, String> findPasswordByLoginName(String loginName) {
    if(loginName.equals("刘老板")){
      Map<String, String> map = DigestsUtil.entryptPassword("123456");
      return map;
    }
    return  null;
  }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9

    6. juint测试：

      public class Test01 {
    @Test
    public void shiroLogin(){
        // 导入ini配置创建工厂
        IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro-test-1.ini");
        // 工厂构建安全管理器
        SecurityManager instance = factory.getInstance();
        // 使用工具生效安全管理器
        SecurityUtils.setSecurityManager(instance);
        // 使用工具获取subject主体
        Subject subject = SecurityUtils.getSubject();
        // 构建账号密码
        UsernamePasswordToken token = new UsernamePasswordToken("刘老板", "123456");
        // 使用subject主体登录
        subject.login(token);

        // 打印登录信息
        System.out.println("登陆结果："+subject.isAuthenticated());
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20

      加密数据时数据写死了用户叫"刘老板"，密码123456，如果登录信息匹配则登录结果为true，否则false

    身份授权

    在这里插入图片描述

    1. 首先调用Subject.isPermitted/hasRole接口，其会委托给SecurityManager
    2. SecurityManager接着会委托给内部组件Authorizer
    3. Authorizer再将其请求委托给我们的Realm去做；Realm才是真正干活的
    4. Realm将用户请求的参数封装成权限对象。再从我们重写的doGetAuthorizationInfo方法中获取从数据库中查询到的权限集合
    5. Realm将用户传入的权限对象，与从数据库中查出来的权限对象，进行一一对比。如果用户传入的权限对象在从数据库中查出来的权限对象中，则返回true，否则返回false

    进行授权操作的前提：用户必须通过认证。

    代码实现：

    1. pom文件导坐标

      
<dependency>
    <groupId>org.apache.shirogroupId>
    <artifactId>shiro-coreartifactId>
    <version>1.3.2version>
dependency>
<dependency>
    <groupId>junitgroupId>
    <artifactId>junitartifactId>
    <version>4.12version>
    <scope>testscope>
dependency>

<dependency>
    <groupId>commons-logginggroupId>
    <artifactId>commons-loggingartifactId>
    <version>1.1.3version>
dependency>

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18

    2. 配置类shiro-test.ini

      [users]
#用户信息
huichenyi=123456,role2
dongjianxiang=654321,role1,role2

[roles]
# 角色
# 角色名=权限列表
role1=user:save,user:update,user:delete
role2=user:find

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10

    3. juint单元测试：

      public class ShiroTest02 {
  @Test
  public void testShiro2(){
    //1.根据配置文件创建SecurityManagerFactory
    Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-test-2.ini");
    //2.通过工厂获取SecurityManager
    SecurityManager securityManager = factory.getInstance();
    //3.将SecurityManager绑定到当前运行环境
    SecurityUtils.setSecurityManager(securityManager);

    Subject subject = SecurityUtils.getSubject();
    String username = "liuls";
    String password = "654321";
    UsernamePasswordToken token = new UsernamePasswordToken(username,password);
    //登录成功之后，完成授权
    subject.login(token);
    //开始鉴权
    System.out.println(subject.hasRole("role1"));//false
    System.out.println(subject.hasRole("role2"));//true
    System.out.println(subject.isPermitted("user:save"));//false
    System.out.println(subject.isPermitted("user:find"));//true
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22

      先授权，再鉴权

      shiro鉴权逻辑：登录成功后，先不授权鉴权，当访问资源，需要权限时，shiro会先查权限授权，再鉴权，判断是否具有访问权

    Shiro默认过滤器

    Shiro内置了很多默认的过滤器，比如身份验证、授权等相关的。默认过滤器可以参考

    org.apache.shiro.web.filter.mgt.DefaultFilter中的枚举过滤器

    • 认证相关过滤器

    在这里插入图片描述

    • 授权相关

    在这里插入图片描述

  • 相关阅读:
    4.累积分布函数CDF
    uniapp vue3 使用pinia存储 并获取数据
    内容营销专家刘鑫炜：全网简单易上手的品牌打造法教程第二节
    Leetcode2246. 相邻字符不同的最长路径
    字典、哈希表、数组的概念
    三步学会如何构建平衡二叉树（简单好理解）
    【自然语言处理】潜在语义分析【上】潜在语义分析
    [论文笔记]Poly-encoder
    MySQL安装TokuDB引擎
    LeetCode-高频 SQL 50 题：查询 篇
  • 原文地址：https://blog.csdn.net/HakerDONG/article/details/134279167