springboot 缓存框架Cache整合redis组成二级缓存

springboot 缓存框架Cache整合redis组成二级缓存
项目性能优化的解决方案除开硬件外的方案无非就是优化sql，减少sql 的执行时间，合理运用缓存让同样的请求和数据库之间的连接尽量减少，内存的处理速度肯定比直接查询数据库来的要快一些。今天就记录一下spring的缓存框架和redis形成二级缓存来优化查询效率，废话不多说直接上代码：
整体目录：
在这里插入图片描述
首先定义注解：缓存注解和删除注解

package com.example.test1.cache.aspect.annoation;import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.concurrent.TimeUnit;/*** @Author xx* @Date 2024/6/27 11:12* @Description: 数据缓存注解* @Version 1.0*/
@Target(value = ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DateCachePut {/*** 模块名：区分模块下的不同功能key，key可能重复*/String module() default "";/*** 缓存的数据key*/String key() default "";/*** key生成*/String keyGenerator() default "DefaultKeyGenerate";/*** 过期时间，默认30*/long passTime() default 30;/*** 过期时间单位，默认：秒*/TimeUnit timeUnit() default TimeUnit.SECONDS;/*** 是否出发条件，支持springEl表达式*/String condition() default "true";
}
package com.example.test1.cache.aspect.annoation;import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.concurrent.TimeUnit;/*** @Author xx* @Date 2024/6/27 11:13* @Description: 缓存删除注解* @Version 1.0*/
@Target(value = ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DataCacheEvict {/*** 模块名：区分模块下的不同功能key，key可能重复*/String module() default "";/*** 缓存的数据key*/String key() default "";/*** key生成*/String keyGenerator() default "DefaultKeyGenerate";/*** 删除时间，默认1*/long delay() default 1;/*** 过期时间单位，默认：秒*/TimeUnit timeUnit() default TimeUnit.SECONDS;/*** 是否出发条件，支持springEl表达式*/String condition() default "true";
}

注解切面类

package com.example.test1.cache.aspect;import com.example.test1.cache.aspect.annoation.DataCacheEvict;
import com.example.test1.cache.aspect.annoation.DateCachePut;
import com.example.test1.cache.generate.IKeyGenerate;
import com.example.test1.cache.handle.CacheHandle;
import com.example.test1.util.SpElUtils;
import com.example.test1.util.SpiUtils;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;import javax.annotation.Resource;
import java.util.Arrays;
import java.util.Optional;
import java.util.StringJoiner;/*** @Author xx* @Date 2024/6/27 11:34* @Description:* @Version 1.0*/
@Slf4j
@Aspect
@Component
public class CacheAspect {/*** 缓存前缀*/private static final String CHAR_PREFIX = "cache";@Resourceprivate CacheHandle cacheHandle;@Value(value = "${spring.application.name}")private String applicationName;@SneakyThrows@Around(value = "@annotation(dateCachePut)")public Object cachePut(ProceedingJoinPoint joinPoint, DateCachePut dateCachePut){String applicationName = StringUtils.isBlank(dateCachePut.module()) ?this.applicationName : dateCachePut.module();//解析key并查询缓存String key = buildCacheKey(applicationName,dateCachePut.module(),joinPoint,dateCachePut.key(),dateCachePut.keyGenerator());Object result = cacheHandle.get(key);if(result == null){result = joinPoint.proceed();if(result != null){Boolean condition = SpElUtils.getValue(joinPoint,dateCachePut.condition(),Boolean.class,result);if(condition){cacheHandle.put(key,result,dateCachePut.passTime(),dateCachePut.timeUnit());}}}return result;}/*** 删除缓存* @param joinPoint 连接点* @param dataCacheEvict 删除注解* @return*/@SneakyThrows@Around(value = "@annotation(dataCacheEvict)")public Object cacheRemove(ProceedingJoinPoint joinPoint, DataCacheEvict dataCacheEvict){String applicationName = StringUtils.isBlank(dataCacheEvict.module()) ?this.applicationName : dataCacheEvict.module();//解析key并查询缓存String key = buildCacheKey(applicationName,dataCacheEvict.module(),joinPoint,dataCacheEvict.key(),dataCacheEvict.keyGenerator());cacheHandle.evict(key);//执行目标方法Object result = joinPoint.proceed();// 条件成立则异步删除Boolean condition = SpElUtils.getValue(joinPoint, dataCacheEvict.condition(), Boolean.class, result);if(condition){cacheHandle.asyEvict(key,dataCacheEvict.delay(),dataCacheEvict.timeUnit());}return result;}/*** 构建缓存key* @param applicationName 服务名* @param module 模块名* @param joinPoint 链接点* @param key  编写的key表达式* @param keyGenerator key生成器实现类名称* @return*/private String buildCacheKey(String applicationName,String module,ProceedingJoinPoint joinPoint,String key,String keyGenerator){return new StringJoiner("::").add(CHAR_PREFIX).add(applicationName).add(module).add(generateKey(joinPoint,key,keyGenerator)).toString();}/*** 生成key* 1：key为空的情况下将会是方法参数列表中的toString集合* 2：将表达式传递的key生成器实现类生成** @param joinPoint 连接点* @param key 编写的key表达式* @param keyGenerator key生成器实现类名* @return*/private CharSequence generateKey(ProceedingJoinPoint joinPoint, String key, String keyGenerator) {return StringUtils.isEmpty(keyGenerator) ? Arrays.toString(joinPoint.getArgs()) :Optional.ofNullable(SpiUtils.getServiceImpl(keyGenerator, IKeyGenerate.class)).map(keyGenerate ->{Assert.notNull(keyGenerate,String.format("%s找不到keyGenerate实现类", keyGenerator));return keyGenerate.generateKey(joinPoint,key);}).orElse(null);}
}

工具类：

package com.example.test1.util;import lombok.SneakyThrows;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.DefaultParameterNameDiscoverer;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;import java.lang.reflect.Method;/*** @Author xx* @Date 2024/6/27 15:10* @Description:* @Version 1.0*/
public class SpElUtils {private final static String RESULT = "result";/*** 用于springEL表达式的解析*/private static SpelExpressionParser spelExpressionParser = new SpelExpressionParser();/*** 用于获取方法参数定义的名字*/private static DefaultParameterNameDiscoverer defaultParameterNameDiscoverer = new DefaultParameterNameDiscoverer();/*** 根据EL表达式获取值** @param joinPoint 连接点* @param key       springEL表达式* @param classes   返回对象的class* @return 获取值*/public static <T> T getValue(ProceedingJoinPoint joinPoint, String key, Class<T> classes) {// 解析springEL表达式EvaluationContext evaluationContext = getEvaluationContext(joinPoint, null);return spelExpressionParser.parseExpression(key).getValue(evaluationContext, classes);}/*** 根据EL表达式获取值** @param joinPoint  连接点* @param expression springEL表达式* @param classes    返回对象的class* @param result     result* @return 获取值*/public static <T> T getValue(JoinPoint joinPoint, String expression, Class<T> classes, Object result) throws NoSuchMethodException {// 解析springEL表达式EvaluationContext evaluationContext = getEvaluationContext(joinPoint, result);return spelExpressionParser.parseExpression(expression).getValue(evaluationContext, classes);}/*** 获取参数上下文** @param joinPoint 连接点* @return 参数上下文*/@SneakyThrowsprivate static EvaluationContext getEvaluationContext(JoinPoint joinPoint, Object result) {EvaluationContext evaluationContext = new StandardEvaluationContext();String[] parameterNames = defaultParameterNameDiscoverer.getParameterNames(getMethod(joinPoint));for (int i = 0; i < parameterNames.length; i++) {evaluationContext.setVariable(parameterNames[i], joinPoint.getArgs()[i]);}evaluationContext.setVariable(RESULT, result);return evaluationContext;}/*** 获取目标方法** @param joinPoint 连接点* @return 目标方法*/private static Method getMethod(JoinPoint joinPoint) throws NoSuchMethodException {Signature signature = joinPoint.getSignature();return joinPoint.getTarget().getClass().getMethod(signature.getName(), ((MethodSignature) signature).getParameterTypes());}
}
package com.example.test1.util;import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;import java.util.Objects;
import java.util.ServiceLoader;
import java.util.concurrent.TimeUnit;/*** @Author xx* @Date 2024/6/27 14:19* @Description:* @Version 1.0*/
public class SpiUtils {/*** SPI缓存key** @param <T>*/private static final class SpiCacheKeyEntity<T> {/*** 实现的接口class*/private Class<T> classType;/*** 实现类的名称*/private String serviceName;public SpiCacheKeyEntity(Class<T> classType, String serviceName) {this.classType = classType;this.serviceName = serviceName;}@Overridepublic boolean equals(Object o) {if (this == o) {return true;}if (o == null || getClass() != o.getClass()) {return false;}SpiCacheKeyEntity<?> spiCacheKeyEntity = (SpiCacheKeyEntity<?>) o;return Objects.equals(classType, spiCacheKeyEntity.classType) && Objects.equals(serviceName, spiCacheKeyEntity.serviceName);}@Overridepublic int hashCode() {return Objects.hash(classType, serviceName);}}private SpiUtils() {}/*** 单例* 根据接口实现类的名称以及接口获取实现类** @param serviceName 实现类的名称* @param classType   实现的接口class* @return 具体的实现类*/public static <T> T getServiceImpl(String serviceName, Class<T> classType) {return (T) SERVICE_IMPL_CACHE.get(new SpiCacheKeyEntity(classType, serviceName));}/*** SPI接口实现类 Caffeine软引用同步加载缓存（其内部做了同步处理)*/public final static LoadingCache<SpiCacheKeyEntity, Object> SERVICE_IMPL_CACHE = Caffeine.newBuilder().expireAfterAccess(24, TimeUnit.HOURS).maximumSize(100).softValues().build(spiCacheKeyEntity -> getServiceImplByPrototype(spiCacheKeyEntity.serviceName, spiCacheKeyEntity.classType));/*** 多例* 根据接口实现类的名称以及接口获取实现类** @param serviceName 实现类的名称* @param classType   实现的接口class* @return 具体的实现类*/public static <T> T getServiceImplByPrototype(String serviceName, Class<T> classType) {ServiceLoader<T> services = ServiceLoader.load(classType, Thread.currentThread().getContextClassLoader());for (T s : services) {if (s.getClass().getSimpleName().equals(serviceName)) {return s;}}return null;}
}

缓存key生成接口

package com.example.test1.cache.generate;import org.aspectj.lang.ProceedingJoinPoint;/*** @Author xx* @Date 2024/6/27 15:05`在这里插入代码片`* @Description: 缓存key 接口生成器* @Version 1.0*/
public interface IKeyGenerate {/***生成key* @param joinPoint 连接点* @param key 编写的key表达式* @return*/String generateKey(ProceedingJoinPoint joinPoint,String key);
}

实现

package com.example.test1.cache.generate.impl;import com.example.test1.cache.generate.IKeyGenerate;
import com.example.test1.util.SpElUtils;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;/*** @Author xx* @Date 2024/6/27 15:08* @Description: 默认key生成器* @Version 1.0*/
@Slf4j
public class DefaultKeyGenerate implements IKeyGenerate {@Overridepublic String generateKey(ProceedingJoinPoint joinPoint, String key) {try {return SpElUtils.getValue(joinPoint,key,String.class);} catch (Exception e) {log.error("DefaultKeyGenerate 抛出异常:{}", e.getMessage(), e);throw new RuntimeException("DefaultKeyGenerate 生成key出现异常", e);}}
}

缓存处理

package com.example.test1.cache.handle;import com.example.test1.cache.schema.ICacheSchema;
import org.springframework.stereotype.Component;import javax.annotation.Resource;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;/*** @Author xx* @Date 2024/6/27 15:26* @Description: 缓存处理* @Version 1.0*/
@Component
public class CacheHandle {@Resourceprivate ICacheSchema cacheSchema;@Resourceprivate ScheduledThreadPoolExecutor asyScheduledThreadPoolExecutor;/***查询缓存* @param key 缓存key* @return 缓存值*/public Object get(String key){return cacheSchema.get(key);}/***存入缓存* @param key  缓存key* @param value 缓存值* @param expirationTime 缓存过期时间* @param timeUnit 时间单位*/public void put(String key, Object value, long expirationTime, TimeUnit timeUnit){cacheSchema.put(key,value,expirationTime,timeUnit);}/*** 移除缓存* @param key 缓存key* @return*/public boolean evict(String key){boolean evict = cacheSchema.evict(key);if(evict){}return evict;}/*** 异步定时删除缓存* @param key 缓存key* @param passTime 定时删除时间* @param timeUnit 定时删除单位*/public void asyEvict(String key, long passTime, TimeUnit timeUnit) {asyScheduledThreadPoolExecutor.schedule(()->this.evict(key),passTime,timeUnit);}
}

缓存公共接口，和多级缓存接口

package com.example.test1.cache.schema;import java.util.concurrent.TimeUnit;/*** @Author xx* @Date 2024/6/27 15:28* @Description: 缓存公共接口* @Version 1.0*/
public interface ICacheSchema {/*** 查询缓存** @param key 缓存的key* @return 缓存的值*/Object get(String key);/*** 存入缓存** @param key            缓存的key* @param value          缓存的值* @param expirationTime 缓存的过期时间* @param timeUnit       缓存过期时间的单位*/void put(String key, Object value, long expirationTime, TimeUnit timeUnit);/*** 移除缓存** @param key 缓存的key* @return 移除操作结果*/boolean evict(String key);
}
package com.example.test1.cache.schema;/*** @Author xx* @Date 2024/6/27 16:25* @Description: 多级缓存* @Version 1.0*/
public interface IMultipleCache extends ICacheSchema{/*** 移除一级缓存** @param key 缓存的key* @return 移除状态*/boolean evictHeadCache(String key);
}

本地缓存实现类

package com.example.test1.cache.schema.caffeien;import com.example.test1.cache.schema.ICacheSchema;
import com.github.benmanes.caffeine.cache.Cache;import java.util.concurrent.TimeUnit;/*** @Author xx* @Date 2024/6/27 15:30* @Description: Caffeine 本地缓存* @Version 1.0*/
public class CaffeineCache implements ICacheSchema {private final Cache cache;public CaffeineCache(Cache cache) {this.cache = cache;}@Overridepublic Object get(String key) {return cache.getIfPresent(key);}@Overridepublic void put(String key, Object value, long expirationTime, TimeUnit timeUnit) {cache.put(key,value);}@Overridepublic boolean evict(String key) {cache.invalidate(key);return true;}
}

redis缓存实现类

package com.example.test1.cache.schema.redis;import com.example.test1.cache.schema.ICacheSchema;
import org.springframework.data.redis.core.RedisTemplate;import java.util.concurrent.TimeUnit;/*** @Author xx* @Date 2024/6/27 15:51* @Description: redis分布式缓存* @Version 1.0*/
public class RedisCache implements ICacheSchema {private final RedisTemplate redisTemplate;public RedisCache(RedisTemplate redisTemplate){this.redisTemplate = redisTemplate;}@Overridepublic Object get(String key) {return redisTemplate.opsForValue().get(key);}@Overridepublic void put(String key, Object value, long expirationTime, TimeUnit timeUnit) {if(expirationTime == -1){redisTemplate.opsForValue().set(key,value);}else {redisTemplate.opsForValue().set(key,value.toString(),expirationTime,timeUnit);}}@Overridepublic boolean evict(String key) {return redisTemplate.delete(key);}
}

多级缓存实现类

package com.example.test1.cache.schema.multiple;import com.example.test1.cache.config.CacheConfig;
import com.example.test1.cache.schema.ICacheSchema;
import com.example.test1.cache.schema.IMultipleCache;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import lombok.extern.slf4j.Slf4j;import java.util.concurrent.TimeUnit;/*** @Author xx* @Date 2024/6/27 16:23* @Description: 多级缓存实现* @Version 1.0*/
@Slf4j
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class MultipleCache implements IMultipleCache {/*** 一级缓存*/private ICacheSchema head;/***下级缓存实现*/private MultipleCache next;private CacheConfig cacheConfig;public MultipleCache(ICacheSchema head){this.head = head;}@Overridepublic Object get(String key) {Object value = head.get(key);if(value == null && next != null){value = next.get(key);if(value != null && cacheConfig != null){head.put(key,value,cacheConfig.getCaffeineDuration(),TimeUnit.SECONDS);}}return value;}@Overridepublic void put(String key, Object value, long expirationTime, TimeUnit timeUnit) {head.put(key,value,expirationTime,timeUnit);if(next != null){next.put(key,value,expirationTime,timeUnit);}}@Overridepublic boolean evict(String key) {head.evict(key);if(next != null){next.evict(key);}return true;}@Overridepublic boolean evictHeadCache(String key) {log.debug("移除一级缓存key={}", key);return head.evict(key);}
}

配置类：

package com.example.test1.cache.config;import com.example.test1.cache.schema.ICacheSchema;
import com.example.test1.cache.schema.caffeien.CaffeineCache;
import com.example.test1.cache.schema.multiple.MultipleCache;
import com.example.test1.cache.schema.redis.RedisCache;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.RemovalListener;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.concurrent.CustomizableThreadFactory;import javax.annotation.Resource;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;/*** @Author xx* @Date 2024/6/27 16:12* @Description: 缓存管理实例注册* @Version 1.0*/
@Slf4j
@EnableCaching
@Configuration
@ComponentScan("com.example.test1.cache")
@EnableConfigurationProperties(CacheConfig.class)
public class CacheManagerAutoConfiguration {@Resourceprivate CacheConfig cacheConfig;@Resourceprivate RedisTemplate redisTemplate;@Beanpublic ICacheSchema cacheSchema(){//构建多级缓存CaffeineCache caffeineCache = buildCaffeineCache();RedisCache redisCache = buildRedisCache();//构建组合多级缓存return new MultipleCache(caffeineCache).setNext(new MultipleCache(redisCache)).setCacheConfig(cacheConfig);}@Beanpublic ScheduledThreadPoolExecutor asyScheduledEvictCachePool() {return new ScheduledThreadPoolExecutor(cacheConfig.getAsyScheduledEvictCachePoolSize(),new CustomizableThreadFactory("asy-evict-cache-pool-%d"));}private RedisCache buildRedisCache() {return new RedisCache(redisTemplate);}/*** 构建Caffeine缓存** @return Caffeine缓存*/private CaffeineCache buildCaffeineCache() {Cache<String, Object> caffeineCache = Caffeine.newBuilder().expireAfterWrite(cacheConfig.getCaffeineDuration(), TimeUnit.SECONDS).maximumSize(cacheConfig.getCaffeineMaximumSize()).removalListener((RemovalListener) (k, v, removalCause) -> log.info("caffeine缓存移除:key={},cause={}", k, removalCause)).build();return new CaffeineCache(caffeineCache);}
}
package com.example.test1.cache.config;import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;/*** @Author xx* @Date 2024/6/27 16:10* @Description:* @Version 1.0*/
@Data
@ConfigurationProperties(prefix = "test-cache", ignoreInvalidFields = true)
public class CacheConfig {/*** 缓存模式(默认多级缓存)*/
//    private SchemaEnum schemaEnum = SchemaEnum.MULTIPLE;/*** 定时异步清理缓存线程池大小(默认50)*/private int asyScheduledEvictCachePoolSize = 50;/*** caffeine写入后失效时间（默认 5 * 60 秒）*/private long caffeineDuration = 5 * 60;/*** caffeine最大容量大小（默认500）*/private long caffeineMaximumSize = 5000;
}

具体使用示例：
在这里插入图片描述
经测试，请求详情后的10秒内（设置的有效时间是10秒）不论请求几次都仅和数据库连接一次，过期后重复第一次的结果，过期时间可以自定义。
如有不合理的地方还请指教！

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

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

逻辑这回事（七）---- 器件基础

逻辑这回事（七）---- 器件基础

Xilinx FPGA创建了先进的硅模块（ASMBL）架构，以实现FPGA具有针对不同应用程序领域优化的各种功能组合的平台。通过这一创新，Xilinx提供了更多的设备选择，使客户能够为其特定设计选择具有正确的功能和功能组合的FPGA。ASMBL体系结构通过以下方式突破了传统的设计障碍：消除几…
阅读更多...
使用Llama3/Qwen2等开源大模型，部署团队私有化Code Copilot和使用教程

使用Llama3/Qwen2等开源大模型，部署团队私有化Code Copilot和使用教程

目前市面上有不少基于大模型的 Code Copilot 产品&#xff0c;部分产品对于个人开发者来说可免费使用&#xff0c;比如阿里的通义灵码、百度的文心快码等。这些免费的产品均通过 API 的方式提供服务&#xff0c;因此调用时均必须联网、同时需要把代码、提示词等内容作为 API 的…
阅读更多...
数据倾斜优化：Hive性能提升的核心

数据倾斜优化：Hive性能提升的核心

文章目录 1. 定义2. 数据倾斜2.1 Map2.2 Join2.3 Reduce 3. 写在最后 1. 定义 数据倾斜&#xff0c;也称为Data Skew&#xff0c;是在分布式计算环境中&#xff0c;由于数据分布不均匀导致某些任务处理的数据量远大于其他任务&#xff0c;从而形成性能瓶颈的现象。这种情况在H…
阅读更多...
springboot 3.x相比之前版本有什么区别

springboot 3.x相比之前版本有什么区别

Spring Boot 3.x相比之前的版本&#xff08;尤其是Spring Boot 2.x&#xff09;&#xff0c;主要存在以下几个显著的区别和新特性&#xff1a; Java版本要求&#xff1a; Spring Boot 3.x要求至少使用Java 17作为最低版本&#xff0c;同时已经通过了Java 19的测试&#xff0c;…
阅读更多...
可信和可解释的大语言模型推理-RoG

可信和可解释的大语言模型推理-RoG

大型语言模型&#xff08;LLM&#xff09;在复杂任务中表现出令人印象深刻的推理能力。然而&#xff0c;LLM在推理过程中缺乏最新的知识和经验&#xff0c;这可能导致不正确的推理过程&#xff0c;降低他们的表现和可信度。知识图谱(Knowledge graphs, KGs)以结构化的形式存储了…
阅读更多...
马斯克的SpaceX发展历史：从濒临破产到全球领先

马斯克的SpaceX发展历史：从濒临破产到全球领先

本文首发于公众号“AntDream”&#xff0c;欢迎微信搜索“AntDream”或扫描文章底部二维码关注&#xff0c;和我一起每天进步一点点 Space Exploration Technologies Corp.&#xff0c;简称SpaceX&#xff0c;是由埃隆马斯克&#xff08;Elon Musk&#xff09;于2002年创办的一…
阅读更多...
百度Agent初体验（制作步骤+感想）

百度Agent初体验（制作步骤+感想）

现在AI Agent很火&#xff0c;最近注册了一个百度Agent体验了一下&#xff0c;并做了个小实验&#xff0c;拿它和零一万物&#xff08;Yi Large&#xff09;和文心一言&#xff08;ERNIE-4.0-8K-latest&#xff09;阅读了相同的一篇网页资讯&#xff0c;输出资讯摘要&#xff0…
阅读更多...
运维锅总详解Prometheus

运维锅总详解Prometheus

本文尝试从Prometheus简介、架构、各重要组件详解、relable_configs最佳实践、性能能优化及常见高可用解决方案等方面对Prometheus进行详细阐述。希望对您有所帮助&#xff01; 一、Prometheus简介 Prometheus 是一个开源的系统监控和报警工具&#xff0c;最初由 SoundCloud …
阅读更多...
[深入理解DDR] 总目录

[深入理解DDR] 总目录

依公知及经验整理&#xff0c;原创保护&#xff0c;禁止转载。 专栏 《深入理解DDR》 蓝色的是传送门&#xff0c;点击链接即可到达指定文章。 图。 DDR 分类 导论 [RAM] DRAM 导论&#xff1a;DDR4 | DDR5 | LPDDR5 | GDRR6 | HBM 应运而生 运存与内存&#xff1f;内存与存…
阅读更多...
UE5蓝图快速实现打开网页与加群

UE5蓝图快速实现打开网页与加群

蓝图节点&#xff1a;启动URL 直接将对应的网址输入&#xff0c;并使用即可快速打开对应的网页&#xff0c;qq、discord等群聊的加入也可以直接通过该节点来完成。 使用后会直接打开浏览器。
阅读更多...
pc端制作一个顶部固定的菜单栏

pc端制作一个顶部固定的菜单栏

效果 hsl颜色 hsl颜色在css中比较方便 https://www.w3school.com.cn/css/css_colors_hsl.asp 色相&#xff08;hue&#xff09;是色轮上从 0 到 360 的度数。0 是红色&#xff0c;120 是绿色&#xff0c;240 是蓝色。饱和度&#xff08;saturation&#xff09;是一个百分比值…
阅读更多...
帮助你简易起步一个BLOG（博客搭建）项目

帮助你简易起步一个BLOG（博客搭建）项目

Blog项目 后端项目结构1. 项目初始化2. 详细步骤3.postman测试 前端1. 项目初始化2. 详细步骤 本章节是为了帮助你起步一个完整的前后端分离项目。 前端技术栈&#xff1a; react、vite、mantine、tailwind CSS、zustand、rxjs、threejs 后端技术栈&#xff1a;nodemon、nodej…
阅读更多...
Django项目部署：uwsgi+daphne+nginx+vue部署

Django项目部署：uwsgi+daphne+nginx+vue部署

一、项目情况 项目根目录&#xff1a;/mnt/www/alert 虚拟环境目录&#xff1a;/mnt/www/venv/alert 激活虚拟环境&#xff1a;source /mnt/www/venv/alert/bin/activate 二、具体配置 1、uwsgi启动配置 根目录下&#xff1a;新增 uwsgi.ini 注意&#xff1a;使用9801端…
阅读更多...
redis实战-添加商户缓存

redis实战-添加商户缓存

为什么要使用缓存 言简意赅&#xff1a;速度快&#xff0c;好用缓存数据存储于代码中&#xff0c;而代码运行在内存中&#xff0c;内存的读写性能远高于磁盘&#xff0c;缓存可以大大降低用户访问并发量带来的服务器读写压力实际开发中&#xff0c;企业的数据量&#xff0c;少…
阅读更多...
短视频矩阵系统：打造品牌影响力的新方式

短视频矩阵系统：打造品牌影响力的新方式

一、短视频矩阵概念 短视频营销革命&#xff1a;一站式解决策略&#xff01;短视频矩阵系统是一款专为企业营销设计的高效工具&#xff0c;旨在通过整合和优化众多短视频平台资源&#xff0c;为企业呈现一个全面的短视频营销策略。该系统致力于协助企业以迅速且高效的方式制作…
阅读更多...
从万里长城防御体系看软件安全体系建设@安全历史03

从万里长城防御体系看软件安全体系建设@安全历史03

长城&#xff0c;是中华民族的一张重要名片&#xff0c;是中华民族坚韧不屈、自强不息的精神象征&#xff0c;被联合国教科文组织列入世界文化遗产名录。那么在古代&#xff0c;长城是如何以其复杂的防御体系&#xff0c;一次次抵御外族入侵&#xff0c;而这些防御体系又能给软…
阅读更多...
无人机挂载抛弹吊舱技术详解

无人机挂载抛弹吊舱技术详解

随着无人机技术的飞速发展&#xff0c;无人机在军事、安全、农业、环保等领域的应用越来越广泛。其中&#xff0c;挂载抛弹吊舱的无人机在精确打击、应急处置等场合发挥着重要作用。抛弹吊舱技术通过将弹药、物资等有效载荷挂载在无人机下方&#xff0c;实现了无人机的远程投放…
阅读更多...
MySQL表解锁

MySQL表解锁

查看锁信息 show full processlist 如果一个表被锁定了&#xff0c;会有一个 “Waiting for table metadata lock” 的提示&#xff0c;表明该表正在等待锁定。 解锁表 删除state上有值的事务 kill query 事务id 表解锁完成
阅读更多...
LDM论文解读

LDM论文解读

论文名称&#xff1a;High-Resolution Image Synthesis with Latent Diffusion Models 发表时间&#xff1a;CVPR2022 作者及组织&#xff1a;Robin Rombach, Andreas Blattmann, Dominik Lorenz,Patrick Esser和 Bjorn Ommer, 来自Ludwig Maximilian University of Munich &a…
阅读更多...
Markdown、Latex编辑小工具

Markdown、Latex编辑小工具

Markdown、Latex编辑小工具 文章说明主要代码效果展示源码下载 文章说明 本文主要为了书写Latex的书写风格&#xff0c;以及了解自己实现一个markdown类型的编辑器的过程&#xff1b;目前实现了当前的效果&#xff1b;书写文章进行记录&#xff0c;方便后续查阅 目前还未添加好…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023