shiro学习五：使用springboot整合shiro。在前面学习四的基础上，增加shiro的缓存机制，源码讲解：认证缓存、授权缓存。

文章目录

  • 前言
  • 1. 直接上代码最后在讲解
    • 1.1 新增的pom依赖
    • 1.2 RedisCache.java
    • 1.3 RedisCacheManager.java
    • 1.4 jwt的三个类
    • 1.5 ShiroConfig.java新增Bean
  • 2. 源码讲解。
    • 2.1 shiro 缓存的代码流程。
    • 2.2 缓存流程
      • 2.2.1 认证和授权简述
      • 2.2.2 AuthenticatingRealm.getAuthenticationInfo() 认证缓存。
      • 2.2.3 AuthorizingRealm.getAuthorizationInfo() 授权缓存。
    • 2.3 redis缓存的设置入口（个人认为是重点）
  • 3. 问题解决
    • 3.1 授权的流程是怎么做的
    • 3.2 @RequiresPermissions("sys:user:list")是如何工作的
      • **1. 基本原理**
      • **2. 具体流程**
        • **1. 用户登录阶段**
        • **2. 调用 `listUsers` 方法时**
        • **3. 匹配机制**

前言

  • shiro学习一：了解shiro，学习执行shiro的流程。使用springboot的测试模块学习shiro单应用（demo 6个）

  • shiro学习二：shiro的加密认证详解，加盐与不加盐两个版本。

  • shiro学习三：shiro的源码分析

  • 密码专辑：对密码加盐加密，对密码进行md5加密，封装成密码工具类

  • shiro学习四：使用springboot整合shiro，正常的企业级后端开发shiro认证鉴权流程。使用redis做token的过滤。md5做密码的加密。

  • 代码所在地：https://github.com/fengfanli/springboot-shiro 记得给个星哦。

  • 本文详细介绍了在Java Spring Boot项目中使用Apache Shiro进行权限管理的实现方式。通过整合Redis作为缓存管理器，实现了用户权限的缓存，提高了权限验证的效率。文章还解析了@RequiresPermissions注解的工作原理，说明了如何通过AOP机制拦截方法，并进行权限字符串的匹配校验，确保只有具备相应权限的用户能够访问受保护的方法。整体上，文章为Shiro在Spring Boot项目中的应用提供了全面的技术指导。

1. 直接上代码最后在讲解

1.1 新增的pom依赖

<!--JWT-->
 <dependency>
     <groupId>io.jsonwebtoken</groupId>
     <artifactId>jjwt</artifactId>
     <version>0.9.1</version>
 </dependency>

1.2 RedisCache.java

package com.feng.shiro;

import com.alibaba.fastjson.JSON;
import com.feng.constant.Constant;
import com.feng.jwt.JwtTokenUtil;
import com.feng.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.apache.shiro.util.CollectionUtils;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * @ClassName: RedisCache
 * @Description： 缓存工具类
 * @createTime: 2020/2/9 20:42
 * @Author: 冯凡利
 * @UpdateUser: 冯凡利
 * @Version: 0.0.1
 */

/**
 * 这里的 RedisUtils 不能注入
 *
 * @param <K>
 * @param <V>
 */
@Slf4j
public class RedisCache<K, V> implements Cache<K, V> {

    private final static String PREFIX = "shiro-cache:";
    private String cacheKey;
    private long expire = 24;  // 24 小时

    private RedisUtil redisUtil;

    public RedisCache(String name, RedisUtil redisUtil) {
//        this.cacheKey=PREFIX+name+":";
        this.cacheKey = Constant.IDENTIFY_CACHE_KEY;
        this.redisUtil = redisUtil;
    }


    /**
     * 根据 key 值 获取 权限信息
     *
     * @param key  jwt
     * @return
     * @throws CacheException
     */
    @Override
    public V get(K key) throws CacheException {
        log.info("Shiro 从缓存中获取数据 KEY 值[{}]", key);
        if (key == null) {
            return null;
        }
        try {
            String redisCacheKey = getRedisCacheKey(key);
            Object rawValue = redisUtil.get(redisCacheKey);  // 根据key 获取 数据
            if (rawValue == null) {
                return null;
            }
            SimpleAuthorizationInfo info = JSON.parseObject(rawValue.toString(), SimpleAuthorizationInfo.class);
            V value = (V) info;
            return value;
        } catch (Exception e) {
            throw new CacheException(e);
        }
    }

    /**
     * 存值
     *
     * @param key jwt
     * @param value
     * @return
     * @throws CacheException
     */
    @Override
    public V put(K key, V value) throws CacheException {
        log.info("put key [{}]", key);
        if (key == null) {
            log.warn("Saving a null key is meaningless, return value directly without call Redis.");
            return value;
        }
        try {
            String redisCacheKey = getRedisCacheKey(key); // cacheKey + userId
            redisUtil.set(redisCacheKey, value != null ? value : null, expire, TimeUnit.HOURS);
            return value;
        } catch (Exception e) {
            throw new CacheException(e);
        }
    }

    /**
     * 根据 key 值 删除缓存的值
     *
     * @param key
     * @return
     * @throws CacheException
     */
    @Override
    public V remove(K key) throws CacheException {
        log.info("remove key [{}]", key);
        if (key == null) {
            return null;
        }
        try {
            String redisCacheKey = getRedisCacheKey(key);
            Object rawValue = redisUtil.get(redisCacheKey);
            V previous = (V) rawValue;
            redisUtil.delete(redisCacheKey);
            return previous;
        } catch (Exception e) {
            throw new CacheException(e);
        }
    }

    /**
     * 清除 所有的值
     *
     * @throws CacheException
     */
    @Override
    public void clear() throws CacheException {
        log.debug("clear cache");
        Set<String> keys = null;
        try {
            keys = redisUtil.keys(this.cacheKey + "*");
        } catch (Exception e) {
            log.error("get keys error", e);
        }
        if (keys == null || keys.size() == 0) {
            return;
        }
        for (String key : keys) {
            redisUtil.delete(key);
        }
    }

    /**
     * 获取 redis 所存的 缓存数的大小
     *
     * @return
     */
    @Override
    public int size() {
        int result = 0;
        try {
            result = redisUtil.keys(this.cacheKey + "*").size();
        } catch (Exception e) {
            log.error("get keys error", e);
        }
        return result;
    }

    /**
     * 获取key值
     *
     * @return
     */
    @SuppressWarnings("unchecked")
    @Override
    public Set<K> keys() {
        Set<String> keys = null;
        try {
            keys = redisUtil.keys(this.cacheKey + "*");
        } catch (Exception e) {
            log.error("get keys error", e);
            return Collections.emptySet();
        }
        if (CollectionUtils.isEmpty(keys)) {
            return Collections.emptySet();
        }
        Set<K> convertedKeys = new HashSet<>();
        for (String key : keys) {
            try {
                convertedKeys.add((K) key);
            } catch (Exception e) {
                log.error("deserialize keys error", e);
            }
        }
        return convertedKeys;
    }

    /**
     * 获取 value值
     *
     * @return
     */
    @Override
    public Collection<V> values() {
        Set<String> keys = null;
        try {
            keys = redisUtil.keys(this.cacheKey + "*");
        } catch (Exception e) {
            log.error("get values error", e);
            return Collections.emptySet();
        }
        if (CollectionUtils.isEmpty(keys)) {
            return Collections.emptySet();
        }
        List<V> values = new ArrayList<V>(keys.size());
        for (String key : keys) {
            V value = null;
            try {
                value = (V) redisUtil.get(key);
            } catch (Exception e) {
                log.error("deserialize values= error", e);
            }
            if (value != null) {
                values.add(value);
            }
        }
        return Collections.unmodifiableList(values);
    }

    /**
     * 获取 redis 中的 缓存 key  ,很重要，
     *
     * @param key
     * @return
     */
    private String getRedisCacheKey(K key) {
        if (null == key) {
            return null;
        } else {
            return this.cacheKey + JwtTokenUtil.getUserId(key.toString());
        }
    }
}

1.3 RedisCacheManager.java

package com.feng.shiro;

import com.feng.utils.RedisUtil;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.apache.shiro.cache.CacheManager;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @ClassName: RedisCacheManager
 * @Description： 描述
 * @createTime: 2020/2/9 21:14
 * @Author: 冯凡利
 * @UpdateUser: 冯凡利
 * @Version: 0.0.1
 */
public class RedisCacheManager implements CacheManager {

    @Autowired
    private RedisUtil redisUtil;

    @Override
    public <K, V> Cache<K, V> getCache(String s) throws CacheException {
        return new RedisCache<>(s, redisUtil);
    }
}

1.4 jwt的三个类

我不贴了，不是核心代码，可直接看GitHub。
四个部分：

  1. JwtTokenUtil.java：jwt的工具类
  2. JwtPropertiesConfig.java：application.properties 中的jwt的属性读取类
  3. InitializerJwtPropertiesConfig.java：将 JwtPropertiesConfig.java进行注入。
  4. application.properties 中的jwt的自定义属性配置。

1.5 ShiroConfig.java新增Bean

新增了redisCacheManager bean，然后再 getShiroRealm() 函数中 ，通过 Realm（ShiroRealm） 进行设置 缓存。

    /**
     * shiro 的 缓存管理器
     * 需要在 ShiroRealm bean 中进行设置
     * @return
     */
    @Bean(name = "redisCacheManager")
    public RedisCacheManager redisCacheManager() {
        return new RedisCacheManager();
    }


    /**
     * 登录的 认证域
     *
     * @param hashedCredentialsMatcher
     * @return
     */
    @Bean(name = "shiroRealm")
    public ShiroRealm getShiroRealm(@Qualifier("shiroHashedCredentialsMatcher") HashedCredentialsMatcher hashedCredentialsMatcher,
                                    @Qualifier("redisCacheManager") RedisCacheManager redisCacheManager) {
        ShiroRealm shiroRealm = new ShiroRealm();
        // 自定义 处理 token 过滤
        shiroRealm.setCredentialsMatcher(hashedCredentialsMatcher);
        // 自定义 缓存管理器
        shiroRealm.setCacheManager(redisCacheManager);
        return shiroRealm;
    }

shiro 新增的 shiro 缓存 代码到此结束。
其他代码没有展示，是因为 shiro 缓存的代码只有这些。

2. 源码讲解。

2.1 shiro 缓存的代码流程。

  1. 首先编写 RedisCache.java：实现 Cache 接口，再这里重写redis的一些操作函数
  2. 编写RedisCacheManager.java 类：实现 CacheManager 接口，将RedisCache.java 类加入到 缓存管理中。
  3. 编写ShiroConfig.java 类：将RedisCacheManager注入生Bean，然后再Realm（本案例是ShiroRealm）中设置 缓存管理，同时也是设置 资格匹配 的地方。

2.2 缓存流程

shiro的核心是再 数据域中，也就是Realm，本案例的是ShiroRealm，继承 AuthorizingRealm 授权域， 授权域 继承了 AuthenticatingRealm 认证域，认证域 又继承了 CachingRealm 缓存域。这三个类是shiro 认证、授权、缓存 三个最重要的类。

2.2.1 认证和授权简述

继承了 AuthorizingRealm 授权域，就要重写两个最重要的方法

  1. 认证函数 doGetAuthenticationInfo()，既然认证，重写的就是 AuthenticatingRealm 认证域 中的函数。在函数getAuthenticationInfo() 中。源码截图如下：
    在这里插入图片描述

  2. 授权函数 doGetAuthorizationInfo()，既然授权，重写的就是 AuthorizingRealm 授权域 中的函数。在函数 getAuthorizationInfo() 中,源码截图如下：
    在这里插入图片描述

在 Shiro 中，认证缓存（authentication cache） 和 授权缓存（authorization cache） 是两个不同的缓存，它们用于不同的目的：

  • 认证缓存 (authenticationCache)：用于缓存用户的认证信息（如，用户是否存在，凭证是否正确等）。这通常是一个比较频繁更新的缓存，因为用户登录的凭证（如密码）是动态变化的，可能会变得无效。
  • 授权缓存 (authorizationCache)：用于缓存用户的授权信息（如，用户的角色、权限等）。授权信息通常不太会频繁变动，因此可以缓存很长时间。它一般是用于存储用户的角色和权限信息，以减少每次请求时对数据库或外部系统的查询。

2.2.2 AuthenticatingRealm.getAuthenticationInfo() 认证缓存。

该函数的第一句就是：AuthenticationInfo info = this.getCachedAuthenticationInfo(token); 该函数就是从缓存中获取认证信息。
先说答案：shiro不推荐、默认不支持 认证从缓存中获取。

代码中可以看到 在AuthenticatingRealm类属性 this.authenticationCachingEnabled = false; 在构造函数中 默认为 false，不开启缓存。

究其原因：用于缓存用户的认证信息（如，用户是否存在，凭证是否正确等）。这通常是一个比较频繁更新的缓存，因为用户登录的凭证（如密码）是动态变化的，可能会变得无效。

所以不推荐缓存，通过debug，也可以看到。

2.2.3 AuthorizingRealm.getAuthorizationInfo() 授权缓存。

授权缓存 在shiro 中是支持的。因为 AuthorizingRealm 授权域类中的 类属性 this.authorizationCachingEnabled = true; 在构造函数中默认为true的。

getAuthorizationInfo() 函数就是从缓存中进行获取的，没有获取到在 进入 到 doGetAuthorizationInfo() 函数中进行获取、授权。

可以通过debug的方式一点点去查看。

如果没有设置redis作为缓存管理，默认可以配置缓存，但是shiro并没有帮我指定缓存，估计是怕默认指定之后怕内存使用过高，需要自行设定，接下来讲解。

2.3 redis缓存的设置入口（个人认为是重点）

前边讲的都是逻辑流程，如何从缓存中获取。我在读源码的时候我就很好奇，那设置redis作为缓存的地方在哪里呢？默认是用内存作为缓存的设置又在哪里呢？抱着这些疑问继续走。

答案：入口就在ShiroConfig中 Realm 的配置中。

     ShiroRealm shiroRealm = new ShiroRealm();
     // 自定义 处理 token 过滤
     shiroRealm.setCredentialsMatcher(hashedCredentialsMatcher);
     // 自定义 缓存管理器
     shiroRealm.setCacheManager(redisCacheManager);

new ShiroRealm()时 ;会执行 AuthorizingRealm、AuthenticatingRealm的构造函数。构造函数中会设置 缓存启动情况、缓存的配置情况。

  • 其中 AuthenticatingRealm 认证域的构造函数中，会默认指定 SimpleCredentialsMatcher 作为 凭证匹配器 的 类，shiro还提供了 HashedCredentialsMatcher 作为 凭证匹配器 类（具体有几个，看 CredentialsMatcher 类的实现类有几个即可，下图所示）。后面我们自定义了 凭证匹配器 类 CustomHashedCredentialsMatcher，其中的 doCredentialsMatch（） 函数就是默认 认证的最核心的函数。
    在这里插入图片描述

  • AuthorizingRealm 授权域的构造函数中，会默认指定 缓存管理（在CachingRealm 类中）、凭证匹配器（认证域类中） 的初始化，默认都是null。

  • shiroRealm.setCredentialsMatcher(hashedCredentialsMatcher);：调用 认证域类 中的方法设置 凭证匹配器 。

  • shiroRealm.setCacheManager(redisCacheManager);：调用 缓存域类 中的方法设置缓存管理器 以及 实现缓存的方式（第二行语句），该方法是个接口，有两个实现方法：一个是 认证域，一个是授权域。往下走。在这里插入图片描述

  • 这里就是 授权域 中的 afterCacheManagerSet() 函数，

    • 第一个函数调用父类也就是认证域上的函数，会继续调用 this.getAvailableAuthenticationCache()。认证域前边说了，认证缓存shiro默认是关闭的，debug走一边流程就明白了；重点就是授权域了。
    • 在第二个函数上，先判断是否有缓存，为null，然后再看 授权域 是否支持 授权缓存（默认支持，前边说了）；然后进入懒加载缓存（下面第二张图）；到获取缓存的地方，缓存管理不为null，是redis的，接着从158行，获取缓存，158行往下debug，就是上面的1.3小节的 RedisCacheManager.java，将redis返回。
      在这里插入图片描述
      在这里插入图片描述

  • 我又来问题了，如果没有redis，走的是哪个呢?首先我也不知道，得先把redis缓存管理给去掉。看看使用的哪个。CacheManager.java 是接口，其实现类截图如下，第一个是我实现的，其余三个都是shiro自带的（第二个应该不是，看源码）。

  • 通过源码查看，shiro并没有默认使用缓存配置，仅仅是打开了缓存配置，可以供我们使用，如果想用使用缓存需要自行配置缓存，想上面配置 redis一样，将下面的第二个或者第四个配置到缓存管理中去。
    在这里插入图片描述

到这里为止源码讲解完啦。

3. 问题解决

3.1 授权的流程是怎么做的

这个需要有背景的。
我基于这个项目来说一下
前端 LayUI+thymeleaf
后端使用springboot、shiro作为权限管理。
根据请求 /api/users，进行举例。
前端发请求后，会先认证，此处略。
然后会先从前端标签获取 权限字符串 sys:user:list，这里使用到了 thymeleaf，然后 通过 doGetAuthorizationInfo()获取所有权限字符串和角色，然后与从前端拿到的 权限字符串 sys:user:list进行对比，若包含，这通过。否则失败

3.2 @RequiresPermissions(“sys:user:list”)是如何工作的

1. 基本原理

@RequiresPermissions("sys:user:list") 是 Apache Shiro 提供的权限控制注解，用于声明访问某个方法或类需要的特定权限。

它的工作机制如下：

  1. 拦截注解：

    • Shiro 提供了 AuthorizationAttributeSourceAdvisor 和 AOP（切面编程）机制来拦截被注解标记的类或方法。
    • 当调用被标记的方法时，Shiro 拦截并执行权限校验。

  2. 获取当前用户的权限：

    • Shiro 从当前登录用户的 Subject（主体）中获取用户的权限信息（通常是一组权限字符串）。

  3. 权限字符串匹配：

    • Shiro 将注解中的权限字符串（如 "sys:user:list"）与当前用户的权限列表进行比对。
    • 如果用户的权限列表中包含注解指定的权限字符串，则校验通过；否则抛出 AuthorizationException，拒绝访问。

2. 具体流程

假设你有以下代码：

@RequiresPermissions("sys:user:list")
public void listUsers() {
    // 获取用户列表逻辑
}
1. 用户登录阶段
  • 用户通过登录接口认证成功后，Shiro 会根据用户身份（如用户名）从数据库或缓存中加载用户的所有权限，并存储在 Subject 中。
  • 示例权限列表：
    ["sys:user:list", "sys:user:edit", "sys:user:delete"]
2. 调用 listUsers 方法时
  • Shiro 拦截 @RequiresPermissions 注解，通过当前用户的 Subject 获取权限列表。
  • 调用 Subject.isPermitted("sys:user:list") 方法，具体逻辑如下：
    1. Shiro 将注解中的权限字符串 "sys:user:list" 传递给 AuthorizingRealm 的 doGetAuthorizationInfo 方法。
    2. doGetAuthorizationInfo 返回用户的权限列表。
    3. Shiro 比较 "sys:user:list" 是否存在于用户的权限列表中：
      • 存在：校验通过，继续执行方法。
      • 不存在：抛出异常 AuthorizationException。
3. 匹配机制
  • 权限字符串可以使用通配符（Wildcard）进行匹配：
    • 完全匹配："sys:user:list" 对比 "sys:user:list"，通过。
    • 通配符匹配："sys:user:*" 对比 "sys:user:list"，通过。
    • 多级通配符："sys:*:*" 对比 "sys:user:list"，通过。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【QT】 控件 -- 显示类

【QT】 控件 -- 显示类

&#x1f525; 目录 [TOC]( &#x1f525; 目录) 1. 前言 2. 显示类控件2.1 Label 1、显示不同文本2、显示图片3、文本对齐、自动换行、缩进、边距4、设置伙伴 3.2 LCD Number 3.3 ProgressBar 3.4 Calendar Widget 3. 共勉 &#x1f525; 1. 前言 之前我在上一篇文章【QT】…
阅读更多...
location的使用规则

location的使用规则

1、基于URL的location 负责均衡配置 后端集群中的web服务器&#xff0c;必须要有对应的目录和文件才能被访问到 http {include mime.types;default_type application/octet-stream;sendfile on;keepalive_timeout 65;upstream default_pool {server 10.0.0.7:…
阅读更多...
如何制作浪漫风格的壁纸

如何制作浪漫风格的壁纸

制作浪漫风格的壁纸需要营造出温馨、柔和、梦幻的氛围&#xff0c;通过色彩、元素和构图来传达浪漫的情感。以下是一个详细的步骤指南&#xff0c;帮助你制作浪漫风格的壁纸&#xff1a; 一、明确设计目标 确定用途&#xff1a; 个人使用&#xff1a;如果是为了个人设备&#…
阅读更多...
SpringBoot支持动态更新配置文件参数

SpringBoot支持动态更新配置文件参数

前言 博主介绍&#xff1a;✌目前全网粉丝3W&#xff0c;csdn博客专家、Java领域优质创作者&#xff0c;博客之星、阿里云平台优质作者、专注于Java后端技术领域。 涵盖技术内容&#xff1a;Java后端、大数据、算法、分布式微服务、中间件、前端、运维等。 博主所有博客文件…
阅读更多...
题海拾贝：P2085 最小函数值

题海拾贝：P2085 最小函数值

Hello大家好&#xff01;很高兴我们又见面啦&#xff01;给生活添点passion&#xff0c;开始今天的编程之路&#xff01; 我的博客&#xff1a;<但凡. 我的专栏&#xff1a;《编程之路》、《数据结构与算法之美》、《题海拾贝》 欢迎点赞&#xff0c;关注&#xff01; 1、题…
阅读更多...
企业微信SCRM开创客户管理新纪元推动私域流量高效转化

企业微信SCRM开创客户管理新纪元推动私域流量高效转化

内容概要 在当今瞬息万变的数字化时代&#xff0c;企业面临着前所未有的客户管理挑战。消费者的需求日益多样化&#xff0c;他们希望能够随时随地与品牌沟通。因此&#xff0c;越来越多的企业意识到&#xff0c;传统的客户管理方式已无法满足市场的需求。在这样的背景下&#…
阅读更多...
电子应用设计方案104：智能家庭AI弹簧床系统设计

电子应用设计方案104：智能家庭AI弹簧床系统设计

智能家庭 AI 弹簧床系统设计 一、引言 智能家庭 AI 弹簧床系统旨在为用户提供更加舒适、个性化的睡眠体验&#xff0c;通过结合人工智能技术和先进的床垫设计&#xff0c;实时监测和调整睡眠环境&#xff0c;以满足不同用户的需求。 二、系统概述 1. 系统目标 - 自动适应用户…
阅读更多...
【25考研】人大计算机考研复试该怎么准备？有哪些注意事项？

【25考研】人大计算机考研复试该怎么准备？有哪些注意事项？

人大毕竟是老牌985&#xff0c;复试难度不会太低&#xff01;建议同学认真复习&#xff01;没有机试还是轻松一些的&#xff01; 一、复试内容 由公告可见&#xff0c;复试包含笔试及面试&#xff0c;没有机试&#xff01; 二、参考书目 官方无给出参考书目&#xff0c;可参照…
阅读更多...
随着监测技术的不断升级，将为智能决策提供强大的数据支持和智能帮助的智慧能源开源了

随着监测技术的不断升级，将为智能决策提供强大的数据支持和智能帮助的智慧能源开源了

简介 AI视频监控平台, 是一款功能强大且简单易用的实时算法视频监控系统。愿景在最底层打通各大芯片厂商相互间的壁垒&#xff0c;省去繁琐重复的适配流程&#xff0c;实现芯片、算法、应用的全流程组合&#xff0c;减少企业级应用约 95%的开发成本&#xff0c;用户仅需在界面上…
阅读更多...
vim如何设置自动缩进

vim如何设置自动缩进

:set autoindent 设置自动缩进 :set noautoindent 取消自动缩进 &#xff08;vim如何使设置自动缩进永久生效&#xff1a;vim如何使相关设置永久生效-CSDN博客&#xff09;
阅读更多...
字节跳动发布UI-TARS，超越GPT-4o和Claude，能接管电脑完成复杂任务

字节跳动发布UI-TARS，超越GPT-4o和Claude，能接管电脑完成复杂任务

每周跟踪AI热点新闻动向和震撼发展 想要探索生成式人工智能的前沿进展吗&#xff1f;订阅我们的简报&#xff0c;深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同&#xff0c;从行业内部的深度分析和实用指南中受益。不要错过这个机会&#xff0c;成为AI领…
阅读更多...
使用eNSP配置GRE VPN实验

使用eNSP配置GRE VPN实验

实验拓扑 实验需求 1.按照图示配置IP地址 2.在R1和R3上配置默认路由使公网区域互通 3.在R1和R3上配置GRE VPN&#xff0c;使两端私网能够互相访问&#xff0c;Tunne1口IP地址如图 4.在R1和R3上配置RIPv2来传递两端私网路由 实验步骤 GRE VPN配置方法&#xff1a; 发送端&#x…
阅读更多...
机器学习-线性回归（对于f(x；w)=w^Tx+b理解）

机器学习-线性回归（对于f(x；w)=w^Tx+b理解）

一、&#x1d453;(&#x1d499;;&#x1d498;) &#x1d498;T&#x1d499;的推导 学习线性回归&#xff0c;我们那先要对于线性回归的表达公示&#xff0c;有所认识。 我们先假设空间是一组参数化的线性函数&#xff1a; 其中权重向量&#x1d498; ∈ R&#x1d437; …
阅读更多...
Swing使用MVC模型架构

Swing使用MVC模型架构

什么是MVC模式？ MVC是一组英文的缩写，其全名是Model-View-Controller，也就是“模型-视图-控制器”这三个部分组成。这三个部分任意一个部分发生变化都会引起另外两个发生变化。三者之间的关系示意图如下所示： MVC分为三个部分，所以在MVC模型中将按照此三部分分成三…
阅读更多...
Windows 环境下 Docker Desktop + Kubernetes 部署项目指南

Windows 环境下 Docker Desktop + Kubernetes 部署项目指南

Windows 环境下 Docker Desktop Kubernetes 部署项目指南 一、环境准备二、安装与配置 Kubernetes安装 windows 版的 docker启动 kubernetes安装 windows 版的 kubectl 工具下载 k8s-for-docker-desktop启动 Kubernetes Dashboard 二、在 Kubernetes 上部署项目创建一个 demo …
阅读更多...
redis实现lamp架构缓存

redis实现lamp架构缓存

redis服务器环境下mysql实现lamp架构缓存 ip角色环境192.168.242.49缓存服务器Redis2.2.7192.168.242.50mysql服务器mysql192.168.242.51web端php ***默认已安装好redis&#xff0c;mysql 三台服务器时间同步&#xff08;非常重要&#xff09; # 下载ntpdate yum -y install…
阅读更多...
【Excel】【VBA】Reaction超限点筛选与散点图可视化

【Excel】【VBA】Reaction超限点筛选与散点图可视化

【Excel】【VBA】Reaction超限点筛选与散点图可视化 功能概述 这段代码实现了以下功能&#xff1a; 从SAFE输出的结果worksheet通过datalink获取更新数据从指定工作表中读取数据检测超过阈值的数据点生成结果表格并添加格式化创建可视化散点图显示执行时间 流程图 #mermaid-…
阅读更多...
Java导出通过Word模板导出docx文件并通过QQ邮箱发送

Java导出通过Word模板导出docx文件并通过QQ邮箱发送

一、创建Word模板 {{company}}{{Date}}服务器运行情况报告一、服务器&#xff1a;总告警次数&#xff1a;{{ServerTotal}} 服务器IP:{{IPA}}&#xff0c;总共告警次数:{{ServerATotal}} 服务器IP:{{IPB}}&#xff0c;总共告警次数:{{ServerBTotal}} 服务器IP:{{IPC}}&#x…
阅读更多...
智能化加速标准和协议的更新并推动验证IP（VIP）在芯片设计中的更广泛应用

智能化加速标准和协议的更新并推动验证IP（VIP）在芯片设计中的更广泛应用

作者&#xff1a;Karthik Gopal, SmartDV Technologies亚洲区总经理 智权半导体科技&#xff08;厦门&#xff09;有限公司总经理 随着AI技术向边缘和端侧设备广泛渗透&#xff0c;芯片设计师不仅需要考虑在其设计中引入加速器&#xff0c;也在考虑采用速度更快和带宽更高的总…
阅读更多...
RabbitMQ5-死信队列

RabbitMQ5-死信队列

目录 死信的概念 死信的来源 死信实战 死信之TTl 死信之最大长度 死信之消息被拒 死信的概念 死信&#xff0c;顾名思义就是无法被消费的消息&#xff0c;一般来说&#xff0c;producer 将消息投递到 broker 或直接到queue 里了&#xff0c;consumer 从 queue 取出消息进…
阅读更多...
最新文章

Copyright @ 2022~2023