安全认证框架Shrio学习，入门到深度学习,SpringBoot整合Shiro小案例，含代码

news2024/11/15 8:48:40

权限概述

什么是权限

  • 什么是权限

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

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

    访问权限

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

    数据权限

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

认证概念

  • 认证：

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

  • 认证流程

    在这里插入图片描述

  • 关键对象

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

    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文件坐标

    <!--shiro-->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-core</artifactId>
    <version>1.3.2</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>
<!--日志-->
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.1.3</version>
</dependency>

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

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

  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());
}

    此处构造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文件：

    <!--shiro-->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-core</artifactId>
    <version>1.3.2</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>
<!--日志-->
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.1.3</version>
</dependency>

  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("账号密码错误");
    }
  }
}

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

    配置加载MyReaml

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

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

代码实现：

  1. 导入pom.xml文件

    <!--shiro-->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-core</artifactId>
    <version>1.3.2</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>
<!--日志-->
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.1.3</version>
</dependency>

  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);
    }
}

  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));
    }
}

    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.shiro</groupId>
  <artifactId>shiro-core</artifactId>
  <version>1.3.2</version>
</dependency>
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
  <scope>test</scope>
</dependency>
<dependency>
  <groupId>commons-logging</groupId>
  <artifactId>commons-logging</artifactId>
  <version>1.1.3</version>
</dependency>

  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;
    }
}

  3. 测试：

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

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

加密解密整合案例

实现步骤：

  1. pom文件：

    <!--shiro-->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-core</artifactId>
    <version>1.3.2</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>
<!--日志-->
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.1.3</version>
</dependency>

  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;
  }
}

  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;
    }
}

  4. 配置Realm

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

  5. 模拟一个认证业务

    接口：

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

    实现类：

    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;
  }
}

  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());
    }
}

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

身份授权

在这里插入图片描述

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

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

代码实现：

  1. pom文件导坐标

    <!--shiro-->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-core</artifactId>
    <version>1.3.2</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>
<!--日志-->
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.1.3</version>
</dependency>

  2. 配置类shiro-test.ini

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

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

  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
}

    先授权，再鉴权

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

Shiro默认过滤器

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

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

  • 认证相关过滤器

在这里插入图片描述

  • 授权相关

在这里插入图片描述

实现分布式会话SessionManager

也叫有状态的身份认证

  1. 会话问题

    在这里插入图片描述

  2. 分布式会话实现思路

    在这里插入图片描述

    ​ 所有服务器的session信息都存储到了同一个Redis集群中，即所有的服务都将 Session 的信息存储到 Redis 集群中，无论是对 Session 的注销、更新都会同步到集群中，达到了 Session 共享的目的。

    ​ Cookie 保存在客户端浏览器中，而 Session 保存在服务器上。客户端浏览器访问服务器的候，服务器把客户端信息以某种形式记录在服务器上，这就是 Session。客户端浏览器再次访问时只需要从该 Session 中查找该客户的状态就可以了。

    ​ 在实际工作中我们建议使用外部的缓存设备(包括Redis)来共享 Session，避免单个服务器节点挂掉而影响服务，共享数据都会放到外部缓存容器中

  3. 实现步骤

    1. 创建RedisSessionDao extends AbstractSessionDAO
    2. 配置ShiroConfig

    代码实现见SpringBoot中间件技术

SpringBoot+Shiro+Jwt前后端分离鉴权

Jwt也叫无状态的身份验证

前后端分离绘画问题

  • 问题追踪：

    前面我们实现分布式的会话缓存，但是我们发现此功能的实现是基于浏览的cookie机制，也就是说用户禁用cookie后，我们的系统会就会产生会话不同的问题

  • 解决方案：

    我们的前端可能是web、Android、ios等应用，同时我们每一个接口都提供了无状态的应答方式，这里我们提供了基于JWT的token生成方案

JWT概述

JWT（JSON WEB TOKEN）：JSON网络令牌，JWT是一个轻便的安全跨平台传输格式，定义了一个紧凑的自包含的方式在不同实体之间安全传输信息（JSON格式）。它是在Web环境下两个实体之间传输数据的一项标准。实际上传输的就是一个字符串。

首先Shiro是一套安全认证框架，已经有了对token的相关封装。而JWT只是一种生成token的机制，需要我们自己编写相关的生成逻辑

最后 Shiro是基于session保持会话 的，也就是说是有状态的。而JWT则是无状态的（服务端不保存session，而是生成token发送给客户端进行保存，之后的所有的请求都需要携带token，再对token进行解析判断）。

虽然Shiro也有相关的token（比如UsernamePasswordToken类），但是只是Shiro在服务端对用户信息进行判断的方式而已，并不是JWT所生成的可发送给客户端的字符串token。也就是说Shiro的token并不能响应给客户端。

  • 广义上：JWT是一个标准的名称
  • 狭义上：JWT指的就是用来传递的那个token字符串

JWT由三部分构成：header（头部）、payload（载荷）和signature（签名）。

  1. Header：

    存储两个变量

    1. 秘钥（可以用来比对）
    2. 算法（也就是下面将Header和payload加密成Signature）

  2. payload

    存储很多东西，基础信息有如下几个

    1. 签发人，也就是这个“令牌”归属于哪个用户。一般是 userId
    2. 创建时间，也就是这个令牌是什么时候创建的
    3. 失效时间，也就是这个令牌什么时候失效(session的失效时间)
    4. 唯一标识，一般可以使用算法生成一个唯一标识（jti==>sessionId）

  3. Signature

    ​ 这个是上面两个经过Header中的算法加密生成的，用于比对信息，防止篡改Header和payload然后将这三个部分的信息经过加密生成一个 JwtToken 的字符串，发送给客户端，客户端保存在本地。当客户端发起请求的时候携带这个到服务端(可以是在 cookie ，可以是在 header )，在服务端进行验证，我们需要解密对于的payload的内容

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1201571.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

两个序列（数论）

两个序列（数论）

两个序列 Problem:B Time Limit:1000ms Memory Limit:65535K Description Gugu 有两个长度无限长的序列A,BA0a^0/0!,A1a^1/1!,A2a^2/2!,A3a^3/3!…. B00, B1b^1/1!,B20,B3b^3/3!,B40, B5b^5/5! … Douge 看到这道这两个序列很觉得很麻烦&#xff0c;所以他想到一个好点子&…
阅读更多...
【LeetCode刷题-二分查找】--704.二分查找

【LeetCode刷题-二分查找】--704.二分查找

704.二分查找 class Solution {public int search(int[] nums, int target) {if(nums.length 0){return -1;}int left 0,right nums.length - 1;while(left < right){int mid (right - left) / 2 left;if(nums[mid] target){return mid;}else if(nums[mid] < targe…
阅读更多...
模拟信号数字化--低通抽样与带通抽样

模拟信号数字化--低通抽样与带通抽样

模拟信号数字化 本文主要涉及模拟信号数字化的基本概念&#xff0c;以及对低通抽样与带通抽样以及其公式推导的详细介绍。关于通信原理还有其他文章可参考&#xff1a; 1、信息量、码元、比特、码元速率、信息速率详细解析——实例分析 2、模拟系统的AM信号的调制与频域分析 3、…
阅读更多...
HCIE-Rainbow迁移工具

HCIE-Rainbow迁移工具

Rainbow迁移工具 Rainbow迁移工具支持p2v&#xff08;物理机到虚拟机的迁移&#xff09; v2v&#xff08;虚拟机到虚拟机的迁移&#xff09; Rainbow业务上云迁移&#xff1a; Rainbow迁移到公有云&#xff08;利用公有云SMS服务&#xff0c;付费&#xff09; Rainbow迁移到公…
阅读更多...
【python】sys-path和模块搜索路径

【python】sys-path和模块搜索路径

我们在导入一个模块的时候&#xff0c;比如说&#xff1a; import math它必然是有搜索路径的&#xff0c;那到底是在哪个目录下面找呢&#xff1f;Python解释器去哪里找这个文件呢&#xff1f;只有找到这个文件才能读取、装载运行该模块文件。 它一般按照如下路径寻找模块文件…
阅读更多...
matlab simulink PSO算法优化simulink的PID参数

matlab simulink PSO算法优化simulink的PID参数

1、内容简介 略 13-可以交流、咨询、答疑 PSO算法优化simulink的PID参数 2、内容说明 标准的PSO算法优化simulink的PID参数 PSO、粒子群算法、simulink参数优化 3、仿真分析 4、参考论文 略 链接&#xff1a;https://pan.baidu.com/s/1yQ1yDfk-_Qnq7tGpa23L7g 提取码&…
阅读更多...
企业知识库建设指南：实用经验分享

企业知识库建设指南：实用经验分享

企业知识库建设是提升内部协作和客户支持效率的重要举措。一个完善的知识库可以帮助企业集中管理和传播知识&#xff0c;提供便捷的自助服务和丰富的编辑工具&#xff0c;从而提升用户体验和品牌好感度。接下来就分享一些经验&#xff0c;关于该如何构建一个高效的企业知识库。…
阅读更多...
27 _ 递归树：如何借助树来求解递归算法的时间复杂度？

27 _ 递归树：如何借助树来求解递归算法的时间复杂度？

我们都知道，递归代码的时间复杂度分析起来很麻烦。有一个巧妙的方式是借助递归树来分析递归算法的时间复杂度。 递归树与时间复杂度分析 我们前面讲过，递归的思想就是，将大问题分解为小问题来求解，然后再将小问题分解为小小问题。这样一层一层地分解，直到问题的数据规模…
阅读更多...
不可思议，才一周，阅读量就突破千万了

不可思议，才一周，阅读量就突破千万了

这段时间&#xff0c;我发布的文章阅读量看上去还算可以&#xff0c;但我知道&#xff0c;这并不是终点&#xff0c;而是起点。我深知&#xff0c;写作的道路永无止境&#xff0c;只有不断努力&#xff0c;才能在文字的海洋中游得更远。 在这条道路上&#xff0c;我始终坚持用心…
阅读更多...
将VS工程转为Qt的pro工程及VS安装Qt插件后没有create basic .pro file菜单问题解决

将VS工程转为Qt的pro工程及VS安装Qt插件后没有create basic .pro file菜单问题解决

目录 1. 前言 2. VS工程转为pro工程 3. 没有create basic .pro file菜单 1. 前言 很多小伙伴包括本人&#xff0c;如果是在Windows下开发Qt程序&#xff0c;偏好用Visual Studio外加装个Qt插件进行Qt开发&#xff0c;毕竟Visual Studio确实是功能强大的IDE&#xff0c;但有时…
阅读更多...
牛客刷题记录11.12

牛客刷题记录11.12

继承和组合 二进制数统计 1的个数 和 0 的个数
阅读更多...
vmware workstation 与 device/credential guard 不兼容

vmware workstation 与 device/credential guard 不兼容

VM虚拟机报错 vmware虚拟机启动时报错&#xff1a;vmware workstation 与 device/credential guard 不兼容&#xff1a; 系统是win10专业版&#xff0c;导致报错原因最终发现是安装了docker&#xff0c;docker自带下载虚拟机Hyper-V&#xff0c;而导致vmware workstation 与 …
阅读更多...
基于51单片机篮球控制器12864显示仿真及源程序

基于51单片机篮球控制器12864显示仿真及源程序

一、系统方案 1、本设计采用51单片机作为主控器。 2、比分液晶12864显示。 3、主客队加减分、节数、24秒、复位等功能。 二、硬件设计 原理图如下&#xff1a; 三、单片机软件设计 1、首先是系统初始化 void Timer_0()interrupt 1 { TL0 0x00; TH0 0xDC; Count; if(Coun…
阅读更多...
[云原生案例2.3 ] Kubernetes的部署安装 【多master集群架构高可用 ---- （二进制安装部署）】

[云原生案例2.3 ] Kubernetes的部署安装 【多master集群架构高可用 ---- （二进制安装部署）】

文章目录 1. Kubernetes多Master集群高可用方案1.1 多节点Master高可用的实现过程1.2 实现高可用方法 2. 新Master节点的部署2.1 前置准备2.2 系统初始化操作2.2.1 关闭防火墙、selinux和swap分区2.2.2 修改主机名&#xff0c;添加域名映射2.2.3 修改内核参数2.2.4 时间同步 2.…
阅读更多...
Pinia 状态管理器 菠萝:Option Store风格

Pinia 状态管理器 菠萝:Option Store风格

Pinia介绍&#xff1a; Pinia 是 Vue 的专属状态管理库&#xff0c;它允许你跨组件或页面共享状态。 Pinia 大小只有 1kb 左右&#xff0c;超轻量级&#xff0c;你甚至可能忘记它的存在&#xff01; 相比 Vuex,Pinia 的优点&#xff1a; 更贴合 Vue 3 的 Composition API 风…
阅读更多...
从0到0.01入门React | 010.精选 React 面试题

从0到0.01入门React | 010.精选 React 面试题

🤍 前端开发工程师（主业）、技术博主（副业）、已过CET6 🍨 阿珊和她的猫_CSDN个人主页 🕠 牛客高级专题作者、在牛客打造高质量专栏《前端面试必备》 🍚 蓝桥云课签约作者、已在蓝桥云课上架的前后端实战课程《Vue.js 和 Egg.js 开发企业级健康管理项目》、《带你从入…
阅读更多...
消息队列原理和实现

消息队列原理和实现

实现原理 消息队列的本质就是在内核态开辟一块内核态的内存&#xff0c;用于存储数据和从这块内存读取数据而已。 实现函数
阅读更多...
STM32F407: CMSIS-DSP库的移植(基于源码)

STM32F407: CMSIS-DSP库的移植(基于源码)

上一篇&#xff1a;STM32F407: CMSIS-DSP库的移植(基于库文件)-CSDN博客 1. 拷贝源码 仿照官方源码目录&#xff0c;新建一个source目录&#xff1a;\Drivers\CMSIS\DSP\Source 将所有源文件拷贝过来&#xff0c;如下&#xff1a; 然后在每个目录下新建一个总的c文件&#x…
阅读更多...
模拟退火算法MATLAB实现

模拟退火算法MATLAB实现

介绍 算法试图随着控制参数T的降低&#xff0c;使目标函 数值f&#xff08;内能E&#xff09;也逐渐降低&#xff0c;直至趋于全局最 小值&#xff08;退火中低温时的最低能量状态&#xff09;&#xff0c;算法 工作过程就像固体退火过程一样。 Metropolis准则——–以概率接受…
阅读更多...
如何有效的保护Windows登录 安当加密

如何有效的保护Windows登录 安当加密

为了有效保护Windows安全登录&#xff0c;以下是一些建议&#xff1a; 使用强密码&#xff1a;强密码是保护Windows登录安全的重要措施之一。确保密码包含大写字母、小写字母、数字和特殊字符&#xff0c;长度至少为8位&#xff0c;并且不要使用容易猜到的单词或短语。启用多因…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023