Redis-Day3实战篇-商户查询缓存(缓存的添加和更新, 缓存穿透/雪崩/击穿, 缓存工具封装)

Redis-Day3实战篇-商户查询缓存

  • 什么是缓存
  • 添加Redis缓存
    • 业务流程
    • 项目实现
    • 练习 - 给店铺类型查询业务添加缓存
  • 缓存更新策略
    • 最佳实践方案
    • 案例 - 给查询商铺的缓存添加超时剔除和主动更新
  • 缓存穿透/雪崩/击穿
    • 缓存穿透
      • 概述
      • 项目实现 - 商铺查询缓存
    • 缓存雪崩
    • 缓存击穿
      • 概述
      • 互斥锁
      • 逻辑过期
  • 练习 - 缓存工具封装
  • 来源
  • Gitee地址

什么是缓存

  • 缓存(cache): 数据交换的缓冲区, 贮存数据的临时地方, 一般读写性能较高
  • 作用:
    • 降低后端负载
    • 提高读写效率, 降低响应时间
  • 成本:
    • 数据一致性成本
    • 代码维护成本
    • 运维成本

添加Redis缓存

业务流程

在这里插入图片描述

项目实现

public Result queryShopById(Long id) {
    String shopKey = CACHE_SHOP_KEY + id;
    // 1. 从Redis查询商铺缓存
    String cacheShop = stringRedisTemplate.opsForValue().get(shopKey);
    // 2. 判断缓存是否命中
    if(StringUtils.isNotBlank(cacheShop)){
        // 3. 命中, 返回商铺信息
        Shop shop = JSON.parseObject(cacheShop, Shop.class);
        return Result.ok(shop);
    }
    // 4. 未命中, 根据id查询数据库
    Shop shop = getById(id);
    // 5. 判断商铺是否存在
    if(shop == null){
        // 6. 不存在, 返回404
        return Result.fail("商铺不存在");
    }
    // 7. 存在, 将商铺数据写入Redis并返回
    stringRedisTemplate.opsForValue().set(shopKey, JSON.toJSONString(shop));
    return Result.ok(shop);
}

练习 - 给店铺类型查询业务添加缓存

public Result queryTypeList() {
    String shopTypeKey = CACHE_SHOP_TYPE_KEY;
    // 1. 从Redis查询商户类型缓存
    String shopTypeJson = stringRedisTemplate.opsForValue().get(shopTypeKey);
    // 2. 判断缓存是否命中
    if(StringUtils.isNotBlank(shopTypeJson)){
        // 3. 命中, 返回商户类型
        List<ShopType> shopTypes = JSON.parseArray(shopTypeJson, ShopType.class);
        return Result.ok(shopTypes);
    }
    // 4. 未命中, 从数据库查询商户类型
    List<ShopType> shopTypes = query().orderByAsc("sort").list();
    // 5. 将商户类型数据写入Redis并返回
    stringRedisTemplate.opsForValue().set(shopTypeKey, JSON.toJSONString(shopTypes));
    stringRedisTemplate.expire(shopTypeKey, CACHE_SHOP_TYPE_TTL, TimeUnit.MINUTES);
    return Result.ok(shopTypes);
}

缓存更新策略

最佳实践方案

  • 低一致性需求: 使用Redis自带的内存淘汰机制
  • 高一致性需求: 主动更新, 并以超时剔除作为兜底方案
    • 读操作
      • 缓存命中则直接返回
      • 缓存未命中则查询数据库, 并写入缓存, 设定超时时间
    • 写操作
      • 先写数据库, 然后在删除缓存
      • 要确保数据库与缓存操作的原子性

案例 - 给查询商铺的缓存添加超时剔除和主动更新

@Override
public Result queryShopById(Long id) {
    ...
    // 8. 超时剔除
    stringRedisTemplate.expire(shopKey, CACHE_SHOP_TTL, TimeUnit.MINUTES);
    return Result.ok(shop);
}

// 主动更新
@Override
@Transactional
public Result updateShop(Shop shop) {
    Long id = shop.getId();
    if(id == null){
        return Result.fail("店铺id不能为空!");
    }
    String shopKey = CACHE_SHOP_KEY + id;
    // 1. 修改数据库
    updateById(shop);
    // 2. 删除缓存
    stringRedisTemplate.delete(shopKey);
    // 3. 返回ok
    return Result.ok();
}

缓存穿透/雪崩/击穿

缓存穿透

概述

  • 缓存穿透: 指客户端请求的数据在缓存中和数据库中都不存在, 这样缓存永远不会生效, 这些请求都会打到数据库
  • 解决方案
    • 缓存空对象
      • 优点
        • 实现简单, 维护方便
      • 缺点
        • 额外的内存消耗
        • 可能造成短期的不一致
    • 布隆过滤
      • 优点
        • 内存占用较少, 没有多余key
      • 缺点
        • 实现复杂
        • 存在误判可能
    • 增强id的复杂度, 并做好数据的基础格式校验
    • 加强用户权限校验
    • 做好热点参数的限流

在这里插入图片描述

项目实现 - 商铺查询缓存

public Result queryShopById(Long id) {
    String shopKey = CACHE_SHOP_KEY + id;
    // 1. 从Redis查询商铺缓存
    String cacheShop = stringRedisTemplate.opsForValue().get(shopKey);
    // 2. 判断缓存是否命中
    if(StringUtils.isNotBlank(cacheShop)){
        // 3. 命中, 返回商铺信息
        Shop shop = JSON.parseObject(cacheShop, Shop.class);
        return Result.ok(shop);
    }
    // 缓存穿透: 判断是否是空对象, 健不存在的话需要去数据库查, 键存在但是是空对象则直接返回
    if(cacheShop != null){
        return Result.fail("商铺不存在");
    }
    // 4. 未命中, 根据id查询数据库
    Shop shop = getById(id);
    // 5. 判断商铺是否存在
    if(shop == null){
        // 6. 缓存穿透, 缓存空对象
        stringRedisTemplate.opsForValue().set(shopKey, "");
        stringRedisTemplate.expire(shopKey, CACHE_NULL_TTL, TimeUnit.MINUTES);
        return Result.fail("商铺不存在");
    }
    // 7. 存在, 将商铺数据写入Redis并返回
    stringRedisTemplate.opsForValue().set(shopKey, JSON.toJSONString(shop));
    stringRedisTemplate.expire(shopKey, CACHE_SHOP_TTL, TimeUnit.MINUTES);
    return Result.ok(shop);
}

缓存雪崩

  • 缓存雪崩: 指在同一时段大量的缓存key同时失效或者redis服务宕机, 导致大量请求到达数据库, 带来巨大压力
  • 解决方案
    • 给不同的key的ttl添加随机值
    • 利用redis集群提高服务的可用性
    • 给缓存业务添加降级限流策略
    • 给业务添加多级缓存

缓存击穿

概述

  • 缓存击穿(热点key问题): 指一个被高并发访问并且缓存重建业务较复杂的key突然失效了, 无数的请求访问会在瞬间给数据库带来巨大的冲击
  • 解决方案
    • 互斥锁
      • 优点
        • 没有额外的内存消耗
        • 保证一致性
        • 实现简单
      • 缺点
        • 线程需要等待, 性能受影响
        • 可能有死锁风险
    • 逻辑过期
      • 优点
        • 线程无需等待, 性能较好
      • 缺点
        • 不保证一致性
        • 有额外的内存消耗
        • 实现复杂
  • 热点数据是提前存储的

在这里插入图片描述

互斥锁

在这里插入图片描述

public Shop queryWithMutex(Long id){
    String shopKey = CACHE_SHOP_KEY + id;
    // 1. 从Redis查询商铺缓存
    String cacheShop = stringRedisTemplate.opsForValue().get(shopKey);
    // 2. 判断缓存是否命中
    if(StringUtils.isNotBlank(cacheShop)){
        // 3. 命中, 返回商铺信息
        Shop shop = JSON.parseObject(cacheShop, Shop.class);
        return shop;
    }
    // 缓存穿透: 判断是否是空对象, 健不存在的话需要去数据库查, 键存在但是是空对象则直接返回
    if(cacheShop != null){
        return null;
    }

    // 4. 未命中, 缓存重建
    // 4.1 尝试获取互斥锁

    String lockKey = LOCK_SHOP_KEY+id;
    Shop shop = null;
    try {
        boolean isLock = tryLock(lockKey);
        // 4.2 判断是否获取成功
        if(!isLock){
            // 4.3 失败, 休眠并重试
            Thread.sleep(50);
            return queryWithMutex(id);
        }
        // 4.4 获取锁, 根据id查询数据库
        shop = getById(id);
        // 5. 判断商铺是否存在
        if(shop == null){
            // 6. 缓存穿透, 缓存空对象
            stringRedisTemplate.opsForValue().set(shopKey, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
            return null;
        }
        // 7. 存在, 将商铺数据写入Redis并返回
        stringRedisTemplate.opsForValue().set(shopKey, JSON.toJSONString(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    } finally {
        // 8. 释放锁
        unLock(lockKey);
    }

    // 9. 返回
    return shop;
}

private boolean tryLock(String key){
    Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", LOCK_SHOP_TTL, TimeUnit.SECONDS);
    return Boolean.TRUE.equals(flag);
}

private void unLock(String key){
    stringRedisTemplate.delete(key);
}

逻辑过期

在这里插入图片描述

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

    @Resource
    private StringRedisTemplate stringRedisTemplate;

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

    @Override
    public Result queryShopById(Long id) {
        // // 缓存穿透
        // Shop shop = queryWithPassThrough(id);

        // // 缓存击穿 - 互斥锁
        // Shop shop = queryWithMutex(id);

        // 缓存击穿 - 逻辑过期
        Shop shop = queryWithLogicalExpire(id);

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

        return Result.ok(shop);
    }

    // 缓存击穿 - 逻辑过期
    public Shop queryWithLogicalExpire(Long id){
        String shopKey = CACHE_SHOP_KEY + id;
        // 1. 从Redis查询商铺缓存
        String cacheShop = stringRedisTemplate.opsForValue().get(shopKey);
        // 2. 判断缓存是否命中
        if(StringUtils.isBlank(cacheShop)){
            // 3. 未命中, 返回空
            return null;
        }
        // 4. 命中, 取出商铺数据和过期时间
        RedisData redisData = JSON.parseObject(cacheShop, RedisData.class);
        JSONObject data = (JSONObject)redisData.getData();
        Shop shop = JSON.parseObject(data.toJSONString(), Shop.class);
        LocalDateTime expireTime = redisData.getExpireTime();


        // 5. 判断缓存是否过期
        if(expireTime.isAfter(LocalDateTime.now())){
            // 6. 未过期
            return shop;
        }
        // 7. 过期, 尝试获取互斥锁
        String lockKey = LOCK_SHOP_KEY+id;
        boolean isLock = tryLock(lockKey);
        if(isLock){
            // 8. 获取成功, 开启独立线程, 缓存数据
            CACHE_REBUILD_EXECUTOR.submit(()->{
                try {
                    // 重建缓存
                    saveShopToRedis(id, 20L);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    // 释放锁
                    unLock(lockKey);
                }
            });
        }
        // 9. 获取失败, 返回商铺信息
        return shop;
    }

    private boolean tryLock(String key){
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", LOCK_SHOP_TTL, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(flag);
    }

    private void unLock(String key){
        stringRedisTemplate.delete(key);
    }

    public void saveShopToRedis(Long id, Long expireSeconds) throws InterruptedException {
        // 1. 查询商铺数据
        Shop shop = getById(id);
        // 1.1 模拟复杂查询
        Thread.sleep(200);
        // 2. 创建缓存数据
        RedisData redisData = new RedisData();
        redisData.setData(shop);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
        // 3. 将数据缓存导redis
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY+id, JSON.toJSONString(redisData));
    }
}
  • 获取锁成功后需要再次检测缓存是否过期(懒得写, 没写)

练习 - 缓存工具封装

@Slf4j
@Component
public class CacheClient {

    private final StringRedisTemplate stringRedisTemplate;

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

    public CacheClient(StringRedisTemplate stringRedisTemplate){
        this.stringRedisTemplate = stringRedisTemplate;
    }

    // 将任意java对象序列化为json并存储在string类型的key中, 并且可以设置TTL过期时间
    public void set(String key, Object value, Long time, TimeUnit unit){
        String valueJson = JSON.toJSONString(value);
        stringRedisTemplate.opsForValue().set(key, valueJson, time, unit);
    }

    // 将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓存击穿问题
    public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit){
        RedisData redisData = new RedisData();
        redisData.setData(value);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));

        String redisJson = JSON.toJSONString(redisData);
        stringRedisTemplate.opsForValue().set(key, redisJson);
    }

    // 根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
    public <R, ID>  R queryWithPassThrough(
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit){
        String key = keyPrefix + id;
        // 1. 从Redis查询缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        // 2. 判断缓存是否命中
        if(StringUtils.isNotBlank(json)){
            // 3. 命中, 返回
            return JSON.parseObject(json, type);
        }
        // 缓存穿透: 判断是否是空对象, 健不存在的话需要去数据库查, 键存在但是是空对象则直接返回
        if(json != null){
            return null;
        }
        // 4. 未命中, 根据id查询数据库
        R r = dbFallback.apply(id);
        // 5. 判断数据是否存在
        if(r == null){
            // 6. 缓存穿透, 缓存空对象
            stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
            return null;
        }
        // 7. 存在, 将数据写入Redis并返回
        set(key, r, time, unit);
        return r;
    }

    // 根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题
    public <R, ID> R queryWithLogicalExpire(
            String cachePrefix, String lockPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit){
        String key = cachePrefix + id;
        // 1. 从Redis查询缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        // 2. 判断缓存是否命中
        if(StringUtils.isBlank(json)){
            // 3. 未命中, 返回空
            return null;
        }
        // 4. 命中, 取出数据和过期时间
        RedisData redisData = JSON.parseObject(json, RedisData.class);
        JSONObject data = (JSONObject)redisData.getData();
        R r = JSON.parseObject(data.toJSONString(), type);
        LocalDateTime expireTime = redisData.getExpireTime();


        // 5. 判断缓存是否过期
        if(expireTime.isAfter(LocalDateTime.now())){
            // 6. 未过期
            return r;
        }
        // 7. 过期, 尝试获取互斥锁
        String lockKey = lockPrefix+id;
        boolean isLock = tryLock(lockKey);
        if(isLock){
            // 8. 获取成功, 开启独立线程, 缓存数据
            CACHE_REBUILD_EXECUTOR.submit(()->{
                try {
                    // 查询数据库
                    R newR = dbFallback.apply(id);
                    // 写入缓存
                    setWithLogicalExpire(key, newR, time, unit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    // 释放锁
                    unLock(lockKey);
                }
            });
        }
        // 9. 获取失败, 返回旧信息
        return r;
    }

    private boolean tryLock(String key){
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", LOCK_SHOP_TTL, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(flag);
    }

    private void unLock(String key){
        stringRedisTemplate.delete(key);
    }
}

使用示例

public Result queryShopById(Long id) {
    // 缓存穿透
    // Shop shop = cacheClient.
    //         queryWithPassThrough(CACHE_SHOP_KEY, id, Shop.class, id2->getById(id2), CACHE_SHOP_TTL, TimeUnit.MINUTES);

    // 缓存击穿 - 互斥锁
    // Shop shop = queryWithMutex(id);

    // 缓存击穿 - 逻辑过期
    Shop shop = cacheClient.
            queryWithLogicalExpire(CACHE_SHOP_KEY, LOCK_SHOP_KEY, id, Shop.class, this::getById, 20L, TimeUnit.SECONDS);

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

    return Result.ok(shop);
}

来源

黑马程序员. Redis入门到实战教程

Gitee地址

https://gitee.com/Y_cen/redis

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

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

相关文章

HBase基础知识（二）：HBase集群部署、HBaseShell操作

HBase基础知识（二）：HBase集群部署、HBaseShell操作

1. HBase安装部署 1.1 Zookeeper正常部署 首先保证Zookeeper集群的正常部署&#xff0c;并启动之&#xff1a; 创建集群启动脚本&#xff1a; #!/bin/bash case $1 in "start"){ for i in hadoop100 hadoop101 hadoop102 do echo----------zookeeper $i 启动----…
阅读更多...
vue2 之 实现pdf电子签章

vue2 之 实现pdf电子签章

一、前情提要 1. 需求 仿照e签宝&#xff0c;实现pdf电子签章 > 拿到pdf链接&#xff0c;移动章的位置&#xff0c;获取章的坐标 技术 : 使用fabric pdfjs-dist vuedraggable 2. 借鉴 一位大佬的代码仓亏 : 地址 一位大佬写的文章 &#xff1a;地址 3. 优化 在大佬的代码…
阅读更多...
【算法与数据结构】135、LeetCode分发糖果

【算法与数据结构】135、LeetCode分发糖果

文章目录 一、题目二、解法三、完整代码 所有的LeetCode题解索引&#xff0c;可以看这篇文章——【算法和数据结构】LeetCode题解。 一、题目 二、解法 思路分析&#xff1a;本题的思路是要相比较一边&#xff0c;然后在比较另外一边&#xff0c;左右两边一起比较的代码非常难写…
阅读更多...
​ SK Ecoplant借助亚马逊云科技，海外服务器为环保事业注入新活力

​ SK Ecoplant借助亚马逊云科技，海外服务器为环保事业注入新活力

在当今全球面临着资源紧缺和环境挑战的大背景下&#xff0c;数字技术所依赖的海外服务器正成为加速循环经济转型的关键利器。然而&#xff0c;很多企业在整合数字技术到运营中仍然面临着一系列挑战&#xff0c;依然存在低效流程导致的不必要浪费。针对这一问题&#xff0c;SK E…
阅读更多...
使用HTTP协议有哪些风险？HTTP与HTTPS的区别是什么

使用HTTP协议有哪些风险？HTTP与HTTPS的区别是什么

作为两种常见的网络协议&#xff0c;HTTP和HTTPS都是用于在浏览器和服务器之间传输数据的。然而在保障数据安全性方面&#xff0c;HTTPS远远优于HTTP。在网络安全愈发重要的当下&#xff0c;HTTP协议的不安全性使得其逐渐被淘汰弃用。那么使用HTTP协议有哪些风险呢&#xff1f;…
阅读更多...
开发知识点-HTML/JavaScript

开发知识点-HTML/JavaScript

HTML/JavaScript xlinksvgviewBoxuse基础预热与语法基础知识js 如何运行页面适用js 及输出 面向对象抽奖功能 json 支持 字符串转数组数组转字符串数组元素删除长度0位添加一个元素// 表示在下标为1处添加一项tttarray.splice(1,0,ttt)//[123,ttt,456]// 数组是否包含某个元素a…
阅读更多...
KoPA: Making Large Language Models Perform Better in Knowledge Graph Completion

KoPA: Making Large Language Models Perform Better in Knowledge Graph Completion

本来这个论文用来组会讲的&#xff0c;但是冲突了&#xff0c;没怎么讲&#xff0c;记录一下供以后学习。 创新点 按照我的理解简单概述一下这篇论文的创新点 提出使用大模型补全知识图谱&#xff0c;并且融合知识图谱的结构信息提出一个新的模型KoPA模型&#xff0c;采用少…
阅读更多...
Django 简单图书管理系统

Django 简单图书管理系统

一、图书需求 1. 书籍book_index.html中有超链接&#xff1a;查看所有的书籍列表book_list.html页面 2. 书籍book_list.html中显示所有的书名&#xff0c;有超链接&#xff1a;查看本书籍详情book_detail.html(通过书籍ID)页面 3. 书籍book_detail.html中书的作者和出版社&…
阅读更多...
说说 style gan 中的感知路径长度（Perceptual Path Length）

说说 style gan 中的感知路径长度（Perceptual Path Length）

我在之前的博库中介绍了 style gan 的基本原理&#xff0c;原文中有提出感知路径长度&#xff08;Perceptual Path Length&#xff09;的概念。这是一种评价生成器质量的方式。 PPL基本思想&#xff1a;给出两个随机噪声 z 1 , z 2 ​ &#xff0c;为求得两点的感知路径长度PPL…
阅读更多...
竞赛保研 基于Django与深度学习的股票预测系统

竞赛保研 基于Django与深度学习的股票预测系统

文章目录 0 前言1 课题背景2 实现效果3 Django框架4 数据整理5 模型准备和训练6 最后 0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; **基于Django与深度学习的股票预测系统 ** 该项目较为新颖&#xff0c;适合作为竞赛课题方向&#xff…
阅读更多...
WMS仓储管理系统的基本架构和功能模块

WMS仓储管理系统的基本架构和功能模块

在数字化时代&#xff0c;WMS仓储管理系统解决方案已经成为了企业物流管理的重要组成部分。WMS仓储管理系统通过先进的信息化技术&#xff0c;实现了对仓库的全面管理&#xff0c;提高了仓库的运营效率&#xff0c;降低了成本。本文将详细解析WMS仓储管理系统的基本架构和功能模…
阅读更多...
C#合并多个Word文档（微软官方免费openxml接口）

C#合并多个Word文档（微软官方免费openxml接口）

g /// <summary>/// 合并多个word文档&#xff08;合并到第一文件&#xff09;/// </summary>/// <param name"as_word_paths">word文档完整路径</param>/// <param name"breakNewPage">true(默认值)&#xff0c;合并下一个…
阅读更多...
深信服技术认证“SCSA-S”划重点：命令执行漏洞

深信服技术认证“SCSA-S”划重点：命令执行漏洞

为帮助大家更加系统化地学习网络安全知识&#xff0c;以及更高效地通过深信服安全服务认证工程师考核&#xff0c;深信服特别推出“SCSA-S认证备考秘笈”共十期内容&#xff0c;“考试重点”内容框架&#xff0c;帮助大家快速get重点知识~ 划重点来啦 *点击图片放大展示 深信服…
阅读更多...
深入理解 Spring Boot：核心知识与约定大于配置原则

深入理解 Spring Boot：核心知识与约定大于配置原则

深入理解 Spring Boot&#xff1a;核心知识与约定大于配置原则 简单说一下为什么要有 Spring Boot&#xff1f; 因为 Spring 的缺点。 虽然 Spring 的组件代码是轻量级的&#xff0c;但它的配置却是重量级的(需要大量 XML 配置) 为了减少配置文件&#xff0c;简化开发 Spri…
阅读更多...
【Pytorch】学习记录分享6——PyTorch经典网络 ResNet与手写体识别

【Pytorch】学习记录分享6——PyTorch经典网络 ResNet与手写体识别

【Pytorch】学习记录分享5——PyTorch经典网络 ResNet 1. ResNet &#xff08;残差网络&#xff09;基础知识2. 感受野3. 手写体数字识别3. 0 数据集&#xff08;训练与测试集&#xff09;3. 1 数据加载3. 2 函数实现&#xff1a;3. 3 训练及其测试&#xff1a; 1. ResNet &…
阅读更多...
JFreeChart 生成图表，并为图表标注特殊点、添加文本标识框

JFreeChart 生成图表，并为图表标注特殊点、添加文本标识框

一、项目场景&#xff1a; Java使用JFreeChart库生成图片&#xff0c;主要场景为将具体的数据 可视化 生成曲线图等的图表。 本篇文章主要针对为数据集生成的图表添加特殊点及其标识框。具体包括两种场景&#xff1a;x轴为 时间戳 类型和普通 数值 类型。&#xff08;y轴都为…
阅读更多...
阿里云林立翔：基于阿里云 GPU 的 AIGC 小规模训练优化方案

阿里云林立翔：基于阿里云 GPU 的 AIGC 小规模训练优化方案

云布道师 本篇文章围绕生成式 AI 技术栈、生成式 AI 微调训练和性能分析、ECS GPU 实例为生成式 AI 提供算力保障、应用场景案例等相关话题展开。 生成式 AI 技术栈介绍 1、生成式 AI 爆发的历程 在 2022 年的下半年&#xff0c;业界迎来了生成式 AI 的全面爆发&#xff0c…
阅读更多...
RAG实战案例：如何基于 LangChain 实现智能检索生成系统

RAG实战案例：如何基于 LangChain 实现智能检索生成系统

在人工智能领域&#xff0c;如何有效结合大型语言模型&#xff08;LLM&#xff09;的常识性知识与特定的专有数据&#xff0c;一直是业界探索的热点。微调&#xff08;Fine-tuning&#xff09;与检索增强生成&#xff08;Retrieval-Augmented Generation&#xff0c;简称RAG&am…
阅读更多...
5. 行为模式 - 备忘录模式

5. 行为模式 - 备忘录模式

亦称&#xff1a; 快照、Snapshot、Memento 意图 备忘录模式是一种行为设计模式&#xff0c; 允许在不暴露对象实现细节的情况下保存和恢复对象之前的状态。 问题 假如你正在开发一款文字编辑器应用程序。 除了简单的文字编辑功能外&#xff0c; 编辑器中还要有设置文本格式和…
阅读更多...
【Docker】基于华为 openEuler 应用 Docker 镜像体积压缩

【Docker】基于华为 openEuler 应用 Docker 镜像体积压缩

书接 openEuler 系列文章&#xff08;可以翻看测试系列&#xff09;&#xff0c;本次跟大家说说如何将 Java 包轻量化地构建到 openEuler 镜像中且保持镜像内操作系统是全补丁状态。 之前我们都是使用现成的 jdk 镜像进行构建的&#xff0c;如下图&#xff1a; FROM ibm-seme…
阅读更多...
最新文章

Copyright @ 2022~2023