redis缓存和本地缓存的应用设计

数据查询顺序

一级缓存：本地缓存 -》二级缓存：redis缓存 -》数据库

在这里插入图片描述

本地缓存和分布式缓存

  • 本地缓存：基于jvm, 意思是程序放在哪，数据就存储在哪，不需要网络请求，特别快，但是需要占用jvm的内存，所以存储的东西不能太大，也不能太久，有内存淘汰机制。缓存组件包括： Guava Cache、Caffeine、Encache
  • 分布式缓存：请求需要网络传输，速度慢一点，组件包括：Redis，MongoDB

哪些场景用到缓存?

  • 邀请入会的助力排行榜，key= 活动id+pageSize，缓存过期时间1分钟
/**
     * 查询邀请入会的助力排行榜
     * @param activityId
     * @param pageSize
     * @return
     */

    @Override
    @MallCache(value = "queryHelpRankingList", expireTime = 1, timeUnit = TimeUnitEnum.MINUTES)
    public List<ActivityHelpStatisticsEntity> queryRankingList(String activityId, Integer pageSize) {
        List<ActivityHelpStatisticsLogPO> statisticsLogs = mapper.queryRankingList(activityId, pageSize);
        if (CollectionUtils.isEmpty(statisticsLogs)) {
            return new ArrayList<>();
        }
        return statisticsLogs.stream().map(po -> ActivityHelpStatisticsConverter.convert(po))
                .collect(Collectors.toList());
    }
  • 验证用户是否在分组中，可以=groupId, String nascentId, String groupIds，缓存五秒
 @MallCache(value = "checkExistGroup", expireTime = 5, timeUnit = TimeUnitEnum.SECONDS)
    private boolean checkExistGroupCache(long groupId, String nascentId, String groupIds){
        return OpenPlatformHelperV4.checkExistGroup(groupId, nascentId, groupIds);
    }
  • 等级体系，缓存30分钟
@MallCache(value = "GradeSystem", expireTime = 30)
    @Override
    public GradeSystem queryGradeSystem(Long groupId, Long viewId, Long shopId) {
        GradeSystemGetRequest gradeSystemGetRequest = new GradeSystemGetRequest();
        gradeSystemGetRequest.setViewId(viewId);
        gradeSystemGetRequest.setShopId(shopId);
        gradeSystemGetRequest.setGroupId(groupId);
        GradeSystemGetResponse gradeResponse = OpenPlatformClient.exec(groupId, gradeSystemGetRequest);
        GradeSystem result = gradeResponse.getResult();
        return result;
    }
  • 等级名称 30分钟，这种需要调用三方接口，缓存可以减少调用接口次数
/**
     * 获取等级名称
     *
     * @param groupId
     * @param shopId
     * @param grade
     * @return
     */
    @MallCache(value = "CustomerGradeName", expireTime = 30)
    public String getCustomerGradeName(long groupId, long shopId, int grade) {
        List<Long> viewIds = cloudPlatformService.queryViewIdByAreaIdOrBrandId(groupId, getMallId(), Arrays.asList(shopId));
        return getCustomerGradeName(groupId, shopId, grade, viewIds.get(0));
    }

    public String getCustomerGradeName(long groupId, long shopId, int grade, long viewId) {
        if (grade == 0) {
            return "非会员";
        }
        GradeInfoGetResponse response = OpenPlatformHelperV4.getGradeInfo(groupId, shopId, grade, viewId);
        AssertUtil.assertTrue(response != null && response.getSuccess(), "获取等级信息失败");
        GradeInfo gradeInfo = response.getResult();
        AssertUtil.assertNotNull(gradeInfo, "获取等级信息失败");
        return gradeInfo.getGradeName();
    }

@Override
    @MallCache(value = "VIEWID", expireTime = 60)
    public Long queryViewIdByAreaIdOrBrandId(Long groupId, Long mallId, Long shopId) {
        WmCompanyDO company = WmCompanyDao.dao().findByCompanyId(groupId);
        List<Long> viewIds = CloudPlatformHelper.queryViewIdByShopIds(Arrays.asList(shopId), groupId, company.getViewOperationType());
        AssertUtil.assertTrue(!CollectionUtils.isEmpty(viewIds), "查询运营视角失败，请检查");
        return viewIds.get(0);
    }
  • 线下门店列表 缓存60分钟，这种东西一般不会经常变化，且进入首页就要用，
/**
     *
     * @Description  获取线下门店列表，并存入缓存
     * @Param
     * @param groupId
     * @param shopId
     * @return
     */
    @MallCache(value = "offlineShops", expireTime = 60)
    public TableResponse<Record> getOfflineShops(Long groupId,Long shopId){
        TableResponse<Record> tableResponse = new TableResponse<>();
        List<Record> offlineShops = WmOfflineShopDao.dao().getOfflineByDigitalShopId(groupId,shopId);
        tableResponse.setData(offlineShops);
        return tableResponse;
    }

/**
     * 积分别名
     *
     * @param groupId
     * @param shopId
     * @param sysId
     * @return
     */
    @MallCache(value = "getGameIntegralAlias", expireTime = 60)
    public String getIntegralAlias(Long groupId, Long mallId, Long shopId, String sysId) {
        Long viewId = cloudViewUtil.getViewId(groupId, mallId, shopId);
        return openIntegralCacheUtil.getIntegralAliasCache(groupId, mallId, shopId, sysId, viewId);
    }

项目中如何做缓存设计？

基于AOP的切面注解

目录结构

在这里插入图片描述

自定义@MallCache注解

/**
 * 二级缓存:redis+本地缓存
 * 默认启用redis缓存，本地缓存由withLocalCache控制
 * @author
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MallCache {

    String value() default "MallCache::";

    /**
     * 是否启用本地缓存
     *
     * @return
     */
    boolean withLocalCache() default false;

    /**
     * 分钟级缓存：
     * 一级缓存的失效时间为10分钟,这里二级缓存的失效时间应该大于等于10分钟,
     * 不然失去二级缓存的意义
     * 秒级缓存：本地缓存失效时间是5s
     * @return 缓存失效时间 （默认分钟）
     */
    long expireTime() default 20;

    /**
     * 缓存失效时间单位
     * TimeUnitEnum.MINUTES使用分钟级缓存
     * TimeUnitEnum.SECONDS使用秒级缓存
     *
     * @return
     */
    TimeUnitEnum timeUnit() default TimeUnitEnum.MINUTES;
}

引用注解@MallCache

	/**
     * 查询邀请入会的助力排行榜前100
     * @param activityId
     * @param pageSize
     * @return
     */
	@Override
    @MallCache(value = "queryHelpRankingList", expireTime = 1, timeUnit = TimeUnitEnum.MINUTES)
    public List<ActivityHelpStatisticsEntity> queryRankingList(String activityId, Integer pageSize) {
        List<ActivityHelpStatisticsLogPO> statisticsLogs = mapper.queryRankingList(activityId, pageSize);
        if (CollectionUtils.isEmpty(statisticsLogs)) {
            return new ArrayList<>();
        }
        return statisticsLogs.stream().map(po -> ActivityHelpStatisticsConverter.convert(po))
                .collect(Collectors.toList());
    }

需要得到的效果

比如 上面的queryRankingList(String activityId, Integer pageSize) 方法引用了@MallCache(value = "queryHelpRankingList", expireTime = 1, timeUnit = TimeUnitEnum.MINUTES)注解。
最终执行过程应该是：

  1. 首先用 queryHelpRankingList，activityId，pageSize拼接成key，比如activityId=hh34hrnih352nb3kh5o3g34, pageSize=100，那拼接的key = queryHelpRankingList_hh34hrnih352nb3kh5o3g34_100
  2. 拿着key去本地查缓存，本地缓存有的话返回给前端
  3. 本地缓存没有就去查redis缓存，redis缓存有的话返回给前端，同时更新到本地缓存
  4. redis缓存没有的话，调用queryRankingList(String activityId, Integer pageSize)的代码去查数据库
  5. 同时将数据库的最新数据更新到redis和本地缓存

LocalCacheAspect

用于切面加强

@Slf4j
@Aspect
@Component
@Order(-1)
@ConditionalOnBean(CommonCacheManager.class)
public class LocalCacheAspect {


    @Autowired
    private CommonCacheManager commonCacheManager;



    @Around("@annotation(com.nascent.ecrp.mall.core.cache.annotation.MallCache)")
    public Object mallCache(ProceedingJoinPoint proceedingJoinPoint){
        MethodSignature methodSignature = (MethodSignature) proceedingJoinPoint.getSignature();
        Method method = methodSignature.getMethod();
        Type genericReturnType = methodSignature.getMethod().getAnnotatedReturnType().getType();

        MallCache mallCache = method.getAnnotation(MallCache.class);

        String cachePrefix = mallCache.value();
        long expire = mallCache.expireTime();
        boolean withLocalCache = mallCache.withLocalCache();
        TimeUnitEnum timeUnit = mallCache.timeUnit();

        Object[] args = proceedingJoinPoint.getArgs();

        // 用切点方法的参数拼接成cacheKey 比如groupId_viewId_shopId
        String cacheKey = Arrays.stream(args).map(arg -> {
            return String.valueOf(arg);
        }).collect(Collectors.joining("_"));


        Object result = commonCacheManager.queryData(cachePrefix + "_" + cacheKey,
                    expire ,timeUnit, withLocalCache, genericReturnType ,()->{
                        try {
                            // 接口查询数据库拿到数据
                            return proceedingJoinPoint.proceed(args);
                        } catch (Throwable throwable) {
                            log.error("LocalCacheAspect.mallCache 异常:{}", throwable);
                            return null;
                        }
                    });

            return result;
        }
}

CommonCacheFactory

本地缓存的初始化类

  • 初始化缓存，设置缓存的级别，最大缓存数，过期时间
  • 增加缓存，删除缓存
public class CommonCacheFactory {

    /**
     * 秒级时间的缓存
     */
    private static Cache<String, Object> localCacheSecond;
    /**
     * 分钟时间的缓存
     */
    private static Cache<String, Object> localCacheMinute;

    static {
        localCacheSecond = Caffeine.newBuilder()
                .maximumSize(1000)
                .expireAfterWrite(5, TimeUnit.SECONDS)
                .recordStats()
                .build();

        localCacheMinute = Caffeine.newBuilder()
                .maximumSize(1000)
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .recordStats()
                .build();
    }
    private CommonCacheFactory(){

    }

    public static  Cache<String, ? > get() {
        return getMinute();
    }

    public static void set(String key, Object value){
        setMinute(key, value);
    }

    public static  Cache<String, ? > getSecond() {
        return localCacheSecond;
    }

    public static void setSecond(String key, Object value){
        localCacheSecond.put(key, value);
    }

    public static  Cache<String, ? > getMinute() {
        return localCacheMinute;
    }

    public static void setMinute(String key, Object value){
        localCacheMinute.put(key, value);
    }

}

CommonCacheManager

本地缓存管理类，用于本地缓存的查询和更新

@Slf4j
@Component
public class CommonCacheManager extends AbstractCacheManager<String, String>{


    private static final String LOCAL_CACHE_ENABLE_KEY =  "LOCAL_CACHE_ENABLE";

    @Autowired
    private RedisTemplate<String, String> redisTemplate;


    @Override
    public boolean useCache() {
        // todo 优化成直接在内存中获取
        String enable = redisTemplate.opsForValue().get(LOCAL_CACHE_ENABLE_KEY);
        if(StringUtil.isNotBlank(enable) && "CLOSE".equals(enable)){
            return false;
        }else {
            return true;
        }
    }

    @Override
    public Cache<String, String> primaryCache(TimeUnitEnum timeUnit) {
        if(TimeUnitEnum.SECONDS.equals(timeUnit)){
            Cache<String, String> stringResultCache = (Cache<String, String>) CommonCacheFactory.getSecond();
            return stringResultCache;
        }
        return (Cache<String, String>) CommonCacheFactory.getMinute();
    }


    @Override
    public String cacheKey() {
        return "LOCAL::CACHE::";
    }



    public <T> T queryData(String k, Long expireTime, TimeUnitEnum timeUnit, boolean withLocalCache, Type type, Supplier<T> supplier) {
        if (!useCache()) {
            // 不使用本地缓存，默认是使用的
            log.info("直接在缓存中获取数据:{}", k);
            return supplier.get();// supplier.get()能获取函数的返回值，直接返回数据库数据
        }
        try {
            CacheContext<String,T> resultCacheContext =
                    CacheContext
                            .<String,T>builder()
                            .key(cacheKey() + k)
                            .reference(type)
                            .expireSeconds(expireTime)
                            .timeUnit(timeUnit.getTimeUnit())
                            .callback(() -> supplier.get())// 数据库数据，这里只作为实参，还并没有调用
                            .build();
            // 不用本地缓存，用redis缓存
            if(!withLocalCache){
                return JSON.parseObject(getFromSecondary(resultCacheContext), type);
            }
            // 用本地缓存
            String result = primaryCache(timeUnit).get(k, (x) -> getFromSecondary(resultCacheContext));
            return JSON.parseObject(result, type);
        } catch (Exception e) {
            log.error("一级缓存获取数据失败:{}", e.getMessage());
            return supplier.get();
        }
    }


}

AbstractCacheManager

redis缓存的管理接口类

@Slf4j
public abstract class AbstractCacheManager<K, V> implements CacheManage<K, V> {

    /** 查询redis缓存、存在则读取并返回，不存在则更新成最新数据
     *
     * @param context
     * @return
     * @param <T>
     */

    protected <T> V getFromSecondary(CacheContext<K,T> context) {
        K key = context.key;
        T dbValue = null;
        try {

            String valueFromSecondary = secondaryCache().getValueFromSecondary(key);
            // 二级缓存，即redis层缓存，有数据就使用redis缓存
            if (StringUtil.isNotBlank(valueFromSecondary)) {
                return (V) valueFromSecondary;
            }
            // redis缓存没有，查询数据库
            dbValue = context.getCallback().get();

            if (dbValue == null) {
                return null;
            }

            Object jsonValue = JSONObject.toJSONString(dbValue);
            //把数据库的数据跟新到二级缓存
            secondaryCache().setValueForSecondary(key, context.expireSeconds, context.timeUnit, jsonValue);

            return (V)jsonValue;
        } catch (Exception e) {
            log.error("二级缓存中获取数据失败:{}", e.getMessage());
            return null;
        }
    }



    @Override
    public SecondaryCache secondaryCache() {
        RedisSecondaryCache redisSecondaryCache = SecondaryCacheFactory.create(RedisSecondaryCache.class);
        return redisSecondaryCache;
    }


    @Override
    public void invalidate(Object o) {
        for(TimeUnitEnum timeUnit : TimeUnitEnum.values()){
            primaryCache(timeUnit).invalidate(o);
        }
        secondaryCache().invalidate(o);
    }


    @Override
    public void invalidateAll(List o) {
        for(TimeUnitEnum timeUnit : TimeUnitEnum.values()){
            primaryCache(timeUnit).invalidateAll();
        }
        secondaryCache().invalidateAll(o);
    }


    @Override
    public Map<String,Map<String, V>> showAsMap() {
        Map<String,Map<String, V>> map = Maps.newHashMap();
        for(TimeUnitEnum timeUnit : TimeUnitEnum.values()) {
            Map<String,V> newMap = Maps.newHashMap();
            primaryCache(timeUnit).asMap().entrySet().forEach(entry -> newMap.put(Objects.toString(entry.getKey()),entry.getValue()));
            map.put(timeUnit.name(), newMap);
        }
        return map;
    }

    @Override
    public Map<String,Set<K>> keys() {
        Map<String,Set<K>> map = new HashMap();
        for(TimeUnitEnum timeUnit : TimeUnitEnum.values()) {
            map.put(timeUnit.name(), primaryCache(timeUnit).asMap().keySet());
        }
        return map;
    }

}

RedisSecondaryCache

@Slf4j
@Component
public class RedisSecondaryCache implements SecondaryCache<String>{


    @Autowired
    private RedisTemplate<String, Object> redisTemplate;


    @Override
    public String getValueFromSecondary(String key){
        Object redisCache = redisTemplate.opsForValue().get(key);
        return redisCache == null ? null : redisCache.toString();
    }

    @Override
    public String getValueFromSecondaryBatch(List<String> cacheKeys) {
        Object redisCache = redisTemplate.opsForValue().multiGet(cacheKeys);
        return redisCache == null ? null : redisCache.toString();
    }

    @Override
    public <T> void setValueForSecondary(String cacheKey,long expireSeconds, TimeUnit timeUnit, T value) {
        redisTemplate.opsForValue().set(cacheKey,JSONObject.toJSON(value),expireSeconds, timeUnit);
    }

    @Override
    public <T> void setValueForSecondaryBatch(Map<String, T> kv, long expireSeconds) {
        kv.forEach((k, v) -> {
            redisTemplate.opsForValue().set(k, v, expireSeconds, TimeUnit.MINUTES);
        });
    }

    @Override
    public void invalidate(Object o) {
        redisTemplate.delete(String.valueOf(o));
    }

    @Override
    public void invalidateAll(List keys) {
        redisTemplate.delete(keys);
    }

}

CacheContext

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class CacheContext<K, T> {
    K key;

    Type reference;

    // 传递函数，Supplier可以把函数作为实参传递，调用Supplier.get()时返回函数的结果
    Supplier<T> callback;

    Long expireSeconds;

    TimeUnit timeUnit;
}

CacheManage

缓存管理接口

-定义

public interface CacheManage<K, V> extends InvalidateCommand {

    boolean useCache();

    String cacheKey();

    Cache<K, V> primaryCache(TimeUnitEnum timeUnit);

    SecondaryCache secondaryCache();

    Map<String, Map<String, V>> showAsMap();

    Map<String,Set<K>> keys();

}

SecondaryCache

redis缓存接口类

  • 定义一些接口，比如获取缓存，设置缓存
public interface SecondaryCache<K> extends InvalidateCommand{

    String getValueFromSecondary(K key);

    String getValueFromSecondaryBatch(List<K> keys);

    <T> void setValueForSecondary(K key, long expireSeconds, TimeUnit timeUnit, T value);

    <T> void setValueForSecondaryBatch( Map<K, T > kv, long expireSeconds);
}

SecondaryCacheFactory

二级缓存工厂类

  • 感觉啥也没干，不知道这个有什么用
public class SecondaryCacheFactory {

    private SecondaryCacheFactory(){

    }

    public static <T> T create(Class<T> clazz) {
        return (T) SpringContext.me().getBean(clazz);
    }
}

TimeUnitEnum

/**
 * 缓存支持的时间的单位
 * @author
 */
public enum TimeUnitEnum {
    MINUTES(TimeUnit.MINUTES),
    SECONDS(TimeUnit.SECONDS);

    @Getter
    private TimeUnit timeUnit;

    TimeUnitEnum(TimeUnit timeUnit){
        this.timeUnit = timeUnit;
    }
}

InvalidateCommand

public interface InvalidateCommand<K> {

    void invalidate(K k);

    void invalidateAll(List<K> k);
}

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

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

相关文章

Redis--Zset使用场景举例(滑动窗口实现限流)

Redis--Zset使用场景举例(滑动窗口实现限流)

文章目录 前言什么是滑动窗口zset实现滑动窗口小结附录 前言 在Redis–Zset的语法和使用场景举例&#xff08;朋友圈点赞&#xff0c;排行榜&#xff09;一文中&#xff0c;提及了redis数据结构zset的指令语法和一些使用场景&#xff0c;今天我们使用zset来实现滑动窗口限流&a…
阅读更多...
Docker 仓库管理

Docker 仓库管理

Docker 仓库管理 仓库&#xff08;Repository&#xff09;是集中存放镜像的地方。以下介绍一下 Docker Hub。当然不止 docker hub&#xff0c;只是远程的服务商不一样&#xff0c;操作都是一样的。 Docker Hub 目前 Docker 官方维护了一个公共仓库 Docker Hub。 大部分需求…
阅读更多...
Oracle命令大全

Oracle命令大全

文章目录 1. SQL*Plus命令&#xff08;用于连接与管理Oracle数据库&#xff09;2. SQL数据定义语言&#xff08;DDL&#xff09;命令3. SQL数据操作语言&#xff08;DML&#xff09;命令4. PL/SQL程序块5. 系统用户管理6. 数据备份与恢复相关命令1. SQL*Plus命令&#xff08;用…
阅读更多...
java-log4j日志冲突解决

java-log4j日志冲突解决

一、概述 java日志框架较多&#xff0c;其中主流的slf4j和commons-logging是日志接口&#xff0c;log4j、log4j2和logback是真正的日志实现库。 二、具体库单独使用 2.1 log4j <dependency><groupId>log4j</groupId><artifactId>log4j</artifa…
阅读更多...
CentOS stream 9配置网卡

CentOS stream 9配置网卡

CentOS stream9的网卡和centos 7的配置路径&#xff1a;/etc/sysconfig/network-scripts/ifcfg-ens32不一样。 CentOS stream 9的网卡路径&#xff1a; /etc/NetworkManager/system-connections/ens32.nmconnection 方法一&#xff1a; [connection] idens32 uuid426b60a4-4…
阅读更多...
【鸿蒙4.0】详解harmonyos开发语言ArkTS

【鸿蒙4.0】详解harmonyos开发语言ArkTS

文章目录 一.什么是ArkTS&#xff1f;1.ArkTS的背景2.了解js&#xff0c;ts&#xff0c;ArkTS的演变js(Javascript)Javascript的简介Javascript的特点 ts(Typescript)ArkTS 二. ArkTS的特点 一.什么是ArkTS&#xff1f; 1.ArkTS的背景 如官方文档所描述&#xff0c;ArkTS是基…
阅读更多...
《Linux C编程实战》笔记：Linux信号介绍

《Linux C编程实战》笔记：Linux信号介绍

信号是一种软件中断&#xff0c;它提供了处理一种异步事件的方法&#xff0c;也是进程惟一的异步通信方式。在Linux系统中&#xff0c;根据POSIX标准扩展的信号机制&#xff0c;不仅可以用来通知某进程发生了什么事&#xff0c;还可以给进程传递数据。 信号的来源 信号的来源…
阅读更多...
广东金牌电缆：法大大电子合同助力业务风险管控

广东金牌电缆：法大大电子合同助力业务风险管控

广东金牌电缆集团股份有限公司&#xff08;以下简称“广东金牌电缆”&#xff09;成立于2013年&#xff0c;现为广东省电线电缆重点生产企业、广东省守合同重信用单位、国家专精特新小巨人企业、国家高新技术企业&#xff0c;拥有自主商标“夺冠”&#xff0c;“夺冠”商标被评…
阅读更多...
一文读懂「Fine-tuning」微调

一文读懂「Fine-tuning」微调

一、什么是微调&#xff1f; 1. 什么是微调&#xff1f; 微调是指在预训练模型&#xff08;Pre-trained model&#xff09;的基础上&#xff0c;针对特定任务或数据领域&#xff0c;对部分或全部模型参数进行进一步的训练和调整&#xff08;Fine Tune&#xff09;。预训练模型…
阅读更多...
File 类的用法和 InputStream, OutputStream 的用法

File 类的用法和 InputStream, OutputStream 的用法

1.File类的用法 下面就用几个简单的代码案例来熟悉File类里面函数的用法&#xff1a; public class IODemo1 {public static void main(String[] args) throws IOException {File f new File("./test2.txt");//File f new File("C:/User/1/test.txt");S…
阅读更多...
redis数据安全（二）数据持久化 RDB

redis数据安全（二）数据持久化 RDB

目录 一、RDB快照持久化 原理 二、RDB快照持久化配置&#xff08;redis.conf&#xff09;&#xff1a; 三、触发RDB备份&#xff1a; 1、自动备份&#xff0c;需配置备份规则&#xff1a; 2、手动执行命令备份&#xff08;save | bgsave&#xff09;&#xff1a; 3、flus…
阅读更多...
排序：非递归的归并排序

排序：非递归的归并排序

目录 递归与非递归的思想对比&#xff1a; 递归&#xff1a; 非递归&#xff1a; 代码解析&#xff1a; 完整代码&#xff1a; 递归与非递归的思想对比&#xff1a; 递归&#xff1a; 在之前的归并排序&#xff0c;它的核心思想是通过不断的分割&#xff0c;从一个数组变…
阅读更多...
JAVA实现向Word模板中插入Base64图片和数据信息

JAVA实现向Word模板中插入Base64图片和数据信息

目录 需求一、准备模板文件二、引入Poi-tl、Apache POI依赖三、创建实体类&#xff08;用于保存向Word中写入的数据&#xff09;四、实现Service接口五、Controller层实现 需求 在服务端提前准备好Word模板文件&#xff0c;并在用户请求接口时服务端动态获取图片。数据等信息插…
阅读更多...
数据结构图算法

数据结构图算法

算法就要多练,我在国庆节放假的时间编写了图的算法题,写完让我受益匪浅,希望可以帮助到大家. 文章目录 前言 一、图的数据结构 1.图的邻接表数据结构定义 2.图的邻接矩阵的存储形式 二、邻接表建立图代码 三、邻接表删除边(基本操作考试不考) 四、邻接表删除顶点及销毁整…
阅读更多...
【LLM】Prompt微调

【LLM】Prompt微调

Prompt 在机器学习中&#xff0c;Prompt通常指的是一种生成模型的输入方式。生成模型可以接收一个Prompt作为输入&#xff0c;并生成与该输入相对应的输出。Prompt可以是一段文本、一个问题或者一个片段&#xff0c;用于指导生成模型生成相应的响应、续写文本等。 Prompt优化…
阅读更多...
.pings勒索病毒的无声侵袭：保护你的数据财产免受.pings的侵害

.pings勒索病毒的无声侵袭：保护你的数据财产免受.pings的侵害

尊敬的读者&#xff1a; 在数字时代&#xff0c;网络犯罪者不断推陈出新&#xff0c;而.pings勒索病毒则是一种极富威胁的加密型恶意软件。本文将深入探讨.pings勒索病毒的攻击方式&#xff0c;为您提供从数据恢复到全面预防的完整指南&#xff0c;帮助您有效对抗这一威胁。如…
阅读更多...
安全帽识别：智能监控新趋势

安全帽识别：智能监控新趋势

在现代工业安全领域&#xff0c;安全帽识别技术已成为一项关键的创新。这项技术通过智能监控系统确保工作人员在危险环境中佩戴安全帽&#xff0c;显著提升了工作场所的安全标准。本文将探讨这一技术的工作原理、应用前景及其在现代工业中的重要性。 安全帽识别的工作机制 安全…
阅读更多...
【漏洞攻击之文件上传条件竞争】

【漏洞攻击之文件上传条件竞争】

漏洞攻击之文件上传条件竞争 wzsc_文件上传漏洞现象与分析思路编写攻击脚本和重放措施中国蚁剑拿flag wzsc_文件上传 漏洞现象与分析 只有一个upload前端标签元素&#xff0c;并且上传任意文件都会跳转到upload.php页面&#xff0c;判定是一个apache容器&#xff0c;开始扫描…
阅读更多...
什么是车载信息娱乐系统和集成驾驶舱

什么是车载信息娱乐系统和集成驾驶舱

什么是车载信息娱乐系统(IVI)? “车载信息娱乐(IVI)”通过向驾驶员和乘客提供信息和娱乐&#xff0c;为驾驶提供便利和舒适。为了理解这个概念&#xff0c;有必要知道“信息娱乐”的含义。“信息娱乐”是这个市场中使用的一个词&#xff0c;它结合了“信息”和“娱乐”两个词…
阅读更多...
「达摩院MindOpt」优化形状切割问题（MILP）

「达摩院MindOpt」优化形状切割问题（MILP）

1. 形状切割问题 在制造业&#xff0c;高效地利用材料不仅是节约成本的重要环节&#xff0c;也是可持续发展的关键因素。无论是在金属加工、家具制造还是纺织品生产中&#xff0c;原材料的有效利用都直接影响了整体效率和环境影响。 形状切割问题&#xff08;Shape Cutting o…
阅读更多...
最新文章

Copyright @ 2022~2023