【Redis】3、Redis 作为缓存（Redis中的穿透、雪崩、击穿、工具类）

news2024/10/6 10:30:39

目录

  • 一、什么是缓存
  • 二、给业务添加缓存（减少数据库访问次数）
  • 三、给店铺类型查询业务添加缓存
    • (1) 使用 String 类型
    • (2) 使用 List 类型
  • 四、缓存的更新策略
    • (1) 主动更新
    • (2) 最佳实现方案
    • (3) 给查询商铺的缓存添加超时剔除和主动更新的策略
      • ① 存缓存，设置超时时间
      • ② 更新，先修改数据库后删除缓存
  • 五、缓存穿透
    • (1) 是啥
    • (2) 解决方案
    • (3) 添加缓存穿透代码
  • 六、缓存雪崩
  • 七、缓存击穿（热点 key 问题）
    • (1) 互斥锁
    • (2) 逻辑过期
    • (3) 基于【互斥锁】防止缓存击穿问题
    • (4) 基于【逻辑过期】防止缓存击穿问题
      • ① 把数据写入 Redis 并添加逻辑过期时间（缓存重建）
      • ② 代码实现
  • 八、缓存工具类 ★

一、什么是缓存

📗 缓存是数据交换的缓冲区（Cache [ kæʃ ] ），是临时存贮数据的地方，一般读写性能较高

在这里插入图片描述

缓存作用：
📗 降低后端负载
📗 提高读写效率
📗 降低响应时间

缓存的成本：
📗数据一致性成本
📗代码维护成本
📗运维成本

二、给业务添加缓存（减少数据库访问次数）

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Resource
    StringRedisTemplate stringRedisTemplate;

    @Override
    public Result getShopById(Long id) {
        String key = "cache:shop:" + id;

        String shopJSON = stringRedisTemplate.opsForValue().get(key);

        // 缓存中有数据
        if (StrUtil.isNotBlank(shopJSON)) {
            return Result.ok(JSONUtil.toBean(shopJSON, Shop.class));
        }

        // 缓存中无数据, 查询数据库
        Shop shopById = getById(id);

        if (null == shopById) {
            return Result.fail("没有查询到商铺信息");
        }

        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shopById));

        return Result.ok(shopById);
    }
}

三、给店铺类型查询业务添加缓存

(1) 使用 String 类型

@Service
public class ShopTypeServiceImpl extends ServiceImpl<ShopTypeMapper, ShopType> implements IShopTypeService {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public List<ShopType> listShopType() {
        String key = "cache:shopType";
        String shopTypeListString = stringRedisTemplate.opsForValue().get(key);

        if (StrUtil.isNotBlank(shopTypeListString)) {
            // 把数组类型的字符串转换为 List
            return JSONUtil.toList(shopTypeListString, ShopType.class);
        }

        List<ShopType> shopListBySort = query().orderByAsc("sort").list();

        if (shopListBySort == null || shopListBySort.size() < 1) {
            return null;
        }

        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shopListBySort));

        return shopListBySort;
    }
}

(2) 使用 List 类型

😂 改天补充

四、缓存的更新策略

在这里插入图片描述

🎁低一致性需求：使用内存淘汰机制。如：店铺类型的查询
🎁高一致性需求：主动更新，并以超时剔除作为兜底方案。如：店铺详情

(1) 主动更新

🎁① 更新数据库，同时更新缓存在这里插入图片描述

🎁② 缓存与数据库整合为一个服务，由服务来维护一致性。调用者调用该服务，无需关心缓存一致性问题

🎁③ 调用者只操作缓存，由其它线程异步地将缓存数据持久化到数据库，保证最终一致

操作缓存和数据库时有三个问题需要考虑：
❓删除缓存还是更新缓存？
😓更新缓存：每次更新数据库都更新缓存，无效写操作较多【NO】
😀删除缓存：更新数据库时让缓存失效，查询时再更新缓存 【YES】

❓如何保证缓存与数据库的操作的同时成功或失败？
🍀单体系统，将缓存与数据库操作放在一个事务
🍀分布式系统，利用 TCC 等分布式事务方案

❓先操作缓存还是先操作数据库？
🍀先操作数据库，再删除缓存【YES】
🍀先删除缓存，再操作数据库

(2) 最佳实现方案

在这里插入图片描述

(3) 给查询商铺的缓存添加超时剔除和主动更新的策略

修改 ShopController 中的业务逻辑，满足下面的需求：
① 根据 id 查询店铺时，如果缓存未命中，则查询数据库，将数据库结果写入缓存，并设置超时时间
② 根据 id 修改店铺时，先修改数据库，再删除缓存

① 存缓存，设置超时时间

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Resource
    StringRedisTemplate stringRedisTemplate;

    @Override
    public Result getShopById(Long id) {
        // cache:shop: + id
        String key = RedisConstants.CACHE_SHOP_KEY + id;

        String shopJSON = stringRedisTemplate.opsForValue().get(key);

        // 缓存中有数据
        if (StrUtil.isNotBlank(shopJSON)) {
            return Result.ok(JSONUtil.toBean(shopJSON, Shop.class));
        }

        // 缓存中无数据, 查询数据库
        Shop shopById = getById(id);

        if (null == shopById) {
            return Result.fail("没有查询到商铺信息");
        }

        // 要设置过期时间
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shopById), 33L, TimeUnit.MINUTES);

        return Result.ok(shopById);
    }
}

② 更新，先修改数据库后删除缓存

  @Override
  public Result updateShop(Shop shop) {
      if (shop == null) {
          return Result.fail("商铺信息不能为空（null）");
      }

      Long id = shop.getId();
      if (id == null || id < 1) {
          return Result.fail("商铺 id 不能为空");
      }

      boolean updateByIdRet = updateById(shop);

      if (updateByIdRet) { // 更新数据库成功
          // 删除缓存
          // cache:shop: + id
          stringRedisTemplate.delete(RedisConstants.CACHE_SHOP_KEY + id);
          return Result.ok("修改店铺信息成功");
      }

      return Result.fail("服务器忙（更新数据库失败）");
  }

五、缓存穿透

(1) 是啥

❤️ 缓存穿透：客户端请求的数据在缓存中和数据库中都没有
❤️ 缓存永远不生效，这些请求都会到达数据库

(2) 解决方案

🍀 ① 缓存空对象

  • 优点：实现简单，维护方便
  • 缺点：额外的内存消耗；可能造成数据短期不一致

🍀 布隆过滤

  • 优点：内存占用较少，Redis 中没有多余的 key
  • 缺点：实现复杂；存在误判可能

在这里插入图片描述

在这里插入图片描述

(3) 添加缓存穿透代码

在这里插入图片描述

在这里插入图片描述

   @Override
   public Result getShopById(Long id) {
       // cache:shop: + id
       String key = RedisConstants.CACHE_SHOP_KEY + id;

       String shopJSON = stringRedisTemplate.opsForValue().get(key);

       // 缓存中有数据
       if (StrUtil.isNotBlank(shopJSON)) {
           return Result.ok(JSONUtil.toBean(shopJSON, Shop.class));
       }

       if (shopJSON != null) {
           return Result.fail("店铺不存在");
       }

       // 缓存中无数据, 查询数据库
       Shop shopById = getById(id);

       if (null == shopById) {
           // 防止缓存穿透（存储空数据）
           stringRedisTemplate.opsForValue().set(key, "", 2L, TimeUnit.MINUTES);
           return Result.fail("没有查询到商铺信息");
       }

       // 要设置过期时间
       stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shopById), 33L, TimeUnit.MINUTES);

       return Result.ok(shopById);
   }

在这里插入图片描述

六、缓存雪崩

📖 缓存雪崩：同一时段大量的缓存 key 同时失效或者 Redis 服务宕机，导致大量请求到达数据库

  • 解决方案：
    📖 给不同的 Key 设置不同的过期时间（随机值）
    📖 利用 Redis 集群提高服务的高可用性
    📖 给缓存业务添加降级限流策略
    📖 给业务添加多级缓存

在这里插入图片描述

七、缓存击穿（热点 key 问题）

📖 缓存击穿问题也叫热点 Key 问题
📖 一个被高并发访问并且缓存重建业务较复杂的 key 突然失效，无数的请求瞬间到达数据库

在这里插入图片描述

📖 常见的解决方案有两种：

在这里插入图片描述

(1) 互斥锁

在这里插入图片描述

(2) 逻辑过期

在这里插入图片描述

(3) 基于【互斥锁】防止缓存击穿问题

修改根据id查询商铺的业务，基于互斥锁方式来解决缓存击穿问题

在这里插入图片描述

✌ 使用 Redis 的 setnx 方式实现互斥锁的效果【① 获取锁：设置 key 的值；② 释放锁：删除 key】

  /**
   * 尝试获取锁
   */
  private boolean tryLock(String key) {
      Boolean ret = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10L, TimeUnit.SECONDS);

      return BooleanUtil.isTrue(ret);
  }

  /**
   * 释放锁
   */
  public void unLock(String key) {
      Boolean ret = stringRedisTemplate.delete(key);
  }

    private Result queryByMutex(Long id) {
        String key = RedisConstants.CACHE_SHOP_KEY + id;

        Result shopFromRedis = getShopFromRedis(key);
        if (shopFromRedis.getSuccess()) {
            return shopFromRedis;
        }

        /* 缓存中无数据 */
        // 尝试获取锁
        String lockKey = "lock:shop:" + id;
        boolean isGetLock = tryLock(lockKey);

        try {
            if (isGetLock) { // 获取到锁
                // DoubleCheck
                Result shopFromRedis2 = getShopFromRedis(key);

                if (shopFromRedis2.getSuccess()) {
                    return shopFromRedis2;
                }

                // 缓存中没有数据，查询数据库
                Shop shopById = getById(id);

                if (null == shopById) {
                    // 防止缓存穿透（存储空数据）
                    stringRedisTemplate.opsForValue().set(key, "", 2L, TimeUnit.MINUTES);
                    return Result.fail("没有查询到商铺信息");
                }

                // （把查询到的商铺数据保存到 Redis）要设置过期时间
                stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shopById), 33L, TimeUnit.MINUTES);

                return Result.ok(shopById);
            } else { // 没有获取到锁
                Thread.sleep(66);
                return queryByMutex(id); // 重试
            }
        } catch (Exception e) {
            e.printStackTrace();

            return Result.fail("缓存重建抛异常");
        } finally {
            unLock(lockKey);
        }
    }

j

(4) 基于【逻辑过期】防止缓存击穿问题

🍀 修改根据 id 查询商铺的业务，基于逻辑过期方式来解决缓存击穿问题

在这里插入图片描述

① 把数据写入 Redis 并添加逻辑过期时间（缓存重建）

🎄 不把逻辑过期字段 expireTime 直接加入 Shop 类中，这对原有代码进行了修改，不是好的编程方式
🎄 可创建一个新的类（RedisData），类中包含 expireTime 字段，然后让 Shop 继承 RedisData【对原有代码还是有修改】
🎄 最好的方式是：在 RedisData 中再包含 Object data 属性，该 data 属性可以是任何类型（包括：Shop）

/**
 * 逻辑过期
 */
@Data
public class RedisData {
    private LocalDateTime expireTime;

    private Object data;
}

  /**
   * 给店铺信息添加逻辑过期时间, 并保存到 Redis
   *
   * @param shopId        店铺 id
   * @param expireSeconds 过期秒数
   */
  public void cacheShop2Redis(Long shopId, Long expireSeconds) {
      RedisData redisData = new RedisData();

      Shop shopById = getById(shopId);
      if (shopById != null) {
          redisData.setData(shopById);
          redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
      }

      // 保存到 Redis
      stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + shopId,
              JSONUtil.toJsonStr(redisData));
  }

在这里插入图片描述

② 代码实现

@Service
public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Resource
    StringRedisTemplate stringRedisTemplate;

    @Override
    public Result getShopById(Long id) {
        // 逻辑过期避免缓存击穿
        Shop shop = queryByLogicExpire(id);

        if (shop == null) {
            return Result.fail("没有查询到商铺信息");
        }

        return Result.ok(shop);
    }

    // 线程池（10个线程）
    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    private Shop queryByLogicExpire(Long id) {
        String key = CACHE_SHOP_KEY + id;

        // 从 Redis 中查询商铺信息
        String shopJson = stringRedisTemplate.opsForValue().get(key);

        if (StrUtil.isBlank(shopJson)) {
            return null; // 缓存中没有查询到商铺信息
        }

        /* 缓存中有数据（命中） */
        // 1.把 Redis 中的数据反序列化为 Java 实体
        RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
        JSONObject jsonObject = (JSONObject) redisData.getData();
        Shop shop = JSONUtil.toBean(jsonObject, Shop.class);

        // 2.判断是否过期
        LocalDateTime expireTime = redisData.getExpireTime();
        LocalDateTime nowTime = LocalDateTime.now();
        if (expireTime.isAfter(nowTime)) { // 没有过期
            return shop;
        }

        // 3.已过期
        // 3.1 尝试获取锁
        String lockKey = LOCK_SHOP_KEY + id;
        boolean lockGet = tryLock(lockKey);
        if (lockGet) { // 获取到锁, 开启子线程（缓存重建）
            // 新线程执行缓存重建操作
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    // 缓存重建
                    cacheShop2Redis(id, 15L);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    // 释放锁
                    unLock(lockKey);
                }
            });
        }

        // 获取锁是否成功都返回数据
        return shop;
    }

    /**
     * 尝试获取锁
     */
    private boolean tryLock(String key) {
        Boolean ret = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 30L, TimeUnit.SECONDS);

        return BooleanUtil.isTrue(ret);
    }

    /**
     * 释放锁
     */
    public void unLock(String key) {
        stringRedisTemplate.delete(key);
    }

    /**
     * 给店铺信息添加逻辑过期时间, 并保存到 Redis
     *
     * @param shopId        店铺 id
     * @param expireSeconds 过期秒数
     */
    public void cacheShop2Redis(Long shopId, Long expireSeconds) throws InterruptedException {
        RedisData redisData = new RedisData();

        Thread.sleep(200);

        Shop shopById = getById(shopId);
        if (shopById != null) {
            redisData.setData(shopById);
            redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
        }


        // 保存到 Redis
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + shopId,
                JSONUtil.toJsonStr(redisData));
    }

}

八、缓存工具类 ★

基于 StringRedisTemplate 封装一个缓存工具类，满足下列需求：
🍀 将任意 Java 对象序列化为 json 并存储在 string 类型的 key 中，并且可以设置 TTL 过期时间
🍀 将任意 Java 对象序列化为 json 并存储在 string 类型的 key 中，并且可以设置逻辑过期时间，用于处理缓存击穿问题
🍀 根据指定的 key 查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
🍀 根据指定的 key 查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题

@Component
public class MyRedisUtil {

    public static final String NULL_STRING = "";
    public static final String CACHE_SHOP_KEY = "cache:shop:";
    public static final Long CACHE_SHOP_TTL = 20L;
    public static final Long NULL_KEY_TTL = 2L;

    @Resource
    private StringRedisTemplate stringRedisTemplate;


    /**
     * 往 Redis 中写入数据（可设置存活时间）
     *
     * @param key      key
     * @param data     写入的数据
     * @param time     ttl：存活时间
     * @param timeUnit 时间单位
     */
    public void set(String key, Object data, Long time, TimeUnit timeUnit) {
        stringRedisTemplate.opsForValue().set(key,
                JSONUtil.toJsonStr(data),
                time,
                timeUnit);
    }

    /**
     * 往 Redis 中写入数据（可设置逻辑过期）
     *
     * @param key      key
     * @param data     写入的数据
     * @param time     ttl：逻辑过期时间
     * @param timeUnit 时间单位
     */
    public void setWithLogicExpire(String key, Object data, Long time, TimeUnit timeUnit) {
        RedisData redisData = new RedisData();
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(timeUnit.toSeconds(time)));
        redisData.setData(data);

        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }

    /**
     * 可防止缓存穿透的获取
     */
    public <R, ID> R getWithPassThrough(String keyPrefix, ID id,
                                        Class<R> type,
                                        Long ttl,
                                        TimeUnit unit,
                                        Function<ID, R> dbFallback) {
        String key = keyPrefix + id;

        String shopJSON = stringRedisTemplate.opsForValue().get(key);

        // 缓存中有数据
        if (StrUtil.isNotBlank(shopJSON)) {
            return JSONUtil.toBean(shopJSON, type);
        }

        if (shopJSON != null) {
            return null;
        }

        // 缓存中无数据, 查询数据库
        R dbData = dbFallback.apply(id);

        if (null == dbData) { // 数据库中无数据
            // 防止缓存穿透（存储空数据）
            this.set(key, NULL_STRING, NULL_KEY_TTL, TimeUnit.MINUTES);

            return null;
        }

        // 数据库中有数据, 把数据缓存到 Redis, 需设置存活时间
        this.set(key, dbData, ttl, unit);

        return dbData;
    }

    // 线程池（10个线程）
    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    public <ID, T> T getByLogicExpire(String prefix,
                                      ID id,
                                      Class<T> type,
                                      Long time,
                                      TimeUnit unit,
                                      Function<ID, T> queryData) {
        String key = prefix + id;

        // 从 Redis 中查询数据
        String json = stringRedisTemplate.opsForValue().get(key);

        if (StrUtil.isBlank(json)) {
            return null; // 缓存中没有查询到数据
        }

        /* 缓存中有数据（命中） */
        // 1.把 Redis 中的数据反序列化为 Java 实体
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        JSONObject jsonObject = (JSONObject) redisData.getData();
        T data = JSONUtil.toBean(jsonObject, type);

        // 2.判断是否过期
        LocalDateTime expireTime = redisData.getExpireTime();
        LocalDateTime nowTime = LocalDateTime.now();
        if (expireTime.isAfter(nowTime)) { // 没有过期
            return data;
        }

        // 3.已过期
        // 3.1 尝试获取锁
        String lockKey = LOCK_SHOP_KEY + id;
        boolean lockGet = tryLock(lockKey);
        if (lockGet) { // 获取到锁, 开启子线程（缓存重建）
            // 新线程执行缓存重建操作
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    // 缓存重建
                    T dbData = queryData.apply(id);

                    this.setWithLogicExpire(key, dbData, time, unit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    // 释放锁
                    unLock(lockKey);
                }
            });
        }

        // 获取锁是否成功都返回数据
        return data;
    }


    /**
     * 尝试获取锁
     */
    private boolean tryLock(String key) {
        Boolean ret = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 30L, TimeUnit.SECONDS);

        return BooleanUtil.isTrue(ret);
    }

    /**
     * 释放锁
     */
    public void unLock(String key) {
        stringRedisTemplate.delete(key);
    }


}

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

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

相关文章

mysql 练习---表和表的字段的增删改

mysql 练习---表和表的字段的增删改

环境&#xff1a; 命令&#xff1a; (1)create database Market; (2) create table customers( c_num int(11) primary key auto_increment, c_name varchar(50), c_contact varchar(50), c_city varchar(50), c_birth datetime not null );(3) alter table customers mod…
阅读更多...
[github-100天机器学习]day1 data preprocessing-版本问题已修正

[github-100天机器学习]day1 data preprocessing-版本问题已修正

https://github.com/LiuChuang0059/100days-ML-code/blob/master/Day1_Data_preprocessing/README.md#step-6-feature-scaling—特征缩放 数据预处理 导入库&#xff1a;numpy包含数学计算函数&#xff0c;pandas用于导入和管理数据集 #!/usr/bin/env python3 # -*- coding: …
阅读更多...
flutter 更新分支内容

flutter 更新分支内容

有三个分支&#xff0c;主分支&#xff0c;A分支&#xff0c;B分支&#xff0c;别人在B分支开发了内容&#xff0c;我在A分支进行开发。别人在B分支提交了代码&#xff0c;让我去拉下来。这时候我就是需要切到B分支&#xff0c;拉代码下来&#xff0c;然后再回到A分支&#xff…
阅读更多...
python使用代理ip——案例

python使用代理ip——案例

python爬虫是指使用Python编写的程序&#xff0c;通过网络爬取信息并提取有效数据。它通过模拟浏览器请求&#xff0c;获取网页数据&#xff0c;并通过解析HTML/XML等文档结构&#xff0c;从中提取数据。 Python爬虫常用的库和工具包括&#xff1a; Requests&#xff1a;用于…
阅读更多...
Lightroom Classic 2023(12.4) for Mac

Lightroom Classic 2023(12.4) for Mac

Lightroom Classic是一款图像处理软件&#xff0c;是数字摄影后期制作的重要工具之一。与其他图像处理软件相比&#xff0c; Lightroom Classic具有以下特点&#xff1a; 高效的图像管理&#xff1a;Lightroom Classic提供了强大的图像管理功能&#xff0c;可以轻松导入、整理…
阅读更多...
Springboot接口返回参数以及入参RSA加密解密

Springboot接口返回参数以及入参RSA加密解密

网上有好多通过aop切面以及自定义的RSA工具类进行加密解密的方法&#xff0c;期中的过程繁琐也不好用&#xff0c;博主研究了一天从网上到了超好用的基于Springboot框架实现的接口RSA加密解密方式&#xff0c;通过rsa-encrypt-body-spring-boot实现了对Spring Boot接口返回值、…
阅读更多...
MySQL库表操作

MySQL库表操作

目录 1、SQL语句分类 2、书写规范 &#xff08;二&#xff09;关键字不区分大小写 &#xff08;三&#xff09;字符串和日期时间常数要用单引号 &#xff08;四&#xff09;单词之间需要使用半角空格或者换行符进行分隔 &#xff08;五&#xff09;注释 3、库操作 创建…
阅读更多...
关于PHP 使用 Elastic Search8的相关经历

关于PHP 使用 Elastic Search8的相关经历

你好&#xff01; 如果你也是第一次使用ES8和PHP对接使用&#xff0c;这里或许有一些心得可以为你解决一些问题。 本地环境所需工具 windows 版本搭建 Elastic Search 如下图&#xff0c;通过官网下载一个windows版本的Elastic Search 执行.bat文件即可启动 https://localhos…
阅读更多...
基于OpenCV 和 Python 实现车牌检测--附免费源码

基于OpenCV 和 Python 实现车牌检测--附免费源码

文末提供免费的源代码下载链接 车牌检测是使用计算机视觉技术自动检测和识别图像或视频流中的车牌/车牌的过程。 此任务在许多应用中都很有用，例如交通管理、自动收费和停车控制。 车牌检测基本上分为两个任务： 车牌检测：这是指识别图像或视频帧中车牌位置的过程。这涉…
阅读更多...
优化篇--vxe-table 大数据表格替代方案

优化篇--vxe-table 大数据表格替代方案

解决数据量过大及内容复杂时造成的Table渲染滚动的卡顿问题 vxe-table官方文档 npm install xe-utils vxe-tablelegacyvex-table.vue <template><div class"page"><vxe-gridclass"mytable"ref"xGrid2"v-bind"gridOptions2&…
阅读更多...
langchain系列1- langchain-ChatGLM

langchain系列1- langchain-ChatGLM

源码阅读 1 服务启动 (demo.queue(concurrency_count3).launch(server_name0.0.0.0,server_port7860,show_apiFalse,shareFalse,inbrowserFalse))这部分代码使用了 Gradio 库提供的两个函数&#xff1a;queue 和 launch。 在这里&#xff0c;demo 是一个 Interface 类的实例…
阅读更多...
win go vscode安装配置-智能提示

win go vscode安装配置-智能提示

win go vscode安装配置-智能提示 0.前提 go1.17.1之后不允许go get安装库 vscode是免费的go开发工具&#xff0c;想要代码智能提示 go推荐go mod和go install&#xff0c;不推荐GOPATH了 1.安装步骤 [1] vscode安装-百度一堆 [2] go安装-从官网 https://go.dev/dl/ 下载win 6…
阅读更多...
SpringBoot——在开发阶段对表现层进行测试

SpringBoot——在开发阶段对表现层进行测试

在开发阶段对表现层进行测试 之前在做测试的时候&#xff0c;我们对Dao层做了测试&#xff0c;对Service层做了测试&#xff0c;但是在测试表现层的时候&#xff0c;我们并不是在测试类中启动的Web端口&#xff0c;还是直接启动了引导类&#xff0c;并在浏览器中打开本地网址或…
阅读更多...
优思学院｜带你轻松驾驭六西格玛：解答大家的五大疑问

优思学院｜带你轻松驾驭六西格玛：解答大家的五大疑问

在业务改进和质量管理领域&#xff0c;六西格玛被公认为一种卓越的方法和工具&#xff0c;可以帮助企业实现接近完美的质量水平。无论是制造业、医疗保健、金融还是服务行业&#xff0c;六西格玛都被广泛采用&#xff0c;并取得了令人瞩目的成果。它不仅可以降低缺陷和错误&…
阅读更多...
【IoT物联网】IoT小程序在展示中央空调采集数据和实时运行状态上的应用

【IoT物联网】IoT小程序在展示中央空调采集数据和实时运行状态上的应用

利用前端语言实现跨平台应用开发似乎是大势所趋&#xff0c;跨平台并不是一个新的概念&#xff0c;“一次编译、到处运行”是老牌服务端跨平台语言Java的一个基本特性。随着时代的发展&#xff0c;无论是后端开发语言还是前端开发语言&#xff0c;一切都在朝着减少工作量&#…
阅读更多...
基于知识图谱的《红楼梦》人物关系可视化及问答系统（含码源）：命名实体识别、关系识别、LTP简单教学

基于知识图谱的《红楼梦》人物关系可视化及问答系统（含码源）：命名实体识别、关系识别、LTP简单教学

基于知识图谱的《红楼梦》人物关系可视化及问答系统&#xff08;含码源&#xff09;&#xff1a;命名实体识别、关系识别、LTP简单教学 文件树: app.py是整个系统的主入口templates文件夹是HTML的页面 |-index.html 欢迎界面 |-search.html 搜索人物关系页面 |-all_relation.…
阅读更多...
JMeter参数化（6）

JMeter参数化（6）

JMeter参数化 一、JMeter用户参数1、作用2、案例1&#xff1a;百度搜索接口&#xff1a;使用用户参数模拟不同线程操作时&#xff0c;搜索不同的数据 二、用户自定义变量案例1&#xff1a;演示用户定义的变量具有全局性案例2&#xff1a;使用用户定义的变量&#xff0c;分组管理…
阅读更多...
基于Java的电影购票系统的设计与实现（源码+文档+数据库）

基于Java的电影购票系统的设计与实现（源码+文档+数据库）

本系统是一个网上电影售票系统&#xff0c;可以为用户提供方便的在线订票环境。主要实现了用户注册、登录、查询、订购电影票、管理已订购电影票等功能。通过后台管理模块可以实现对用户、播放厅、电影、影片安排、电影票等的管理等功能。本系统以IntelliJ IDEA 作为开发环境&a…
阅读更多...
2.3 Web应用 -- 2. HTTP 连接

2.3 Web应用 -- 2. HTTP 连接

2.3 Web应用 -- 2. HTTP 连接 HTTP连接的两种类型非持久性连接响应时间分析与建模持久性HTTP HTTP连接的两种类型 非持久性连接(Nonpersistent HTTP) 每个TCP连接最多允许传输一个对象HTTP 1.0版本使用非持久性连接 持久性连接(Persistent HTTP) 每个TCP连接允许传输多个对象H…
阅读更多...
vue3项目创建部署

vue3项目创建部署

别名联想路径提示&#xff1a; Element-plus默认的颜色是蓝色&#xff0c;以下修改成我们自己的主题色&#xff1a; css预处理语言 “scss是一种css预处理语言,是一个css的扩展,它在css语法的基础上,允许您使用变量,嵌套规则,混合,导入,继承等功能,使得css更加强大和优雅,而…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023