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.mzph.cn/diannao/36512.shtml

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

相关文章

CDP问卷的常见问题

CDP问卷的常见问题

CDP问卷的常见问题可以归纳如下&#xff1a; 哪些企业会收到CDP邀请&#xff1f; 企业会收到来自投资和/或采购机构的邀请&#xff0c;以填写CDP问卷并披露相应的环境管理信息。 未收到邀请的企业可否填报&#xff1f; 未收到邀请的企业可以选择自行填报。他们需发送申请自愿…
阅读更多...
多线程（基础）

多线程（基础）

前言&#x1f440;~ 上一章我们介绍了什么是进程&#xff0c;对于进程就了解那么多即可&#xff0c;我们作为java程序员更关注线程&#xff0c;线程内容比较多&#xff0c;所以我们要分好几部分才能讲完 目录 进程的缺点 多线程&#xff08;重要&#xff09; 进程和线程的区…
阅读更多...
鸿蒙开发Ability Kit（程序框架服务）：【FA模型切换Stage模型指导】 module的切换

鸿蒙开发Ability Kit（程序框架服务）：【FA模型切换Stage模型指导】 module的切换

module的切换 从FA模型切换到Stage模型时&#xff0c;开发者需要将config.json文件module标签下的配置迁移到module.json5配置文件module标签下&#xff0c;具体差异见下列表格。 表1 FA模型module标签与Stage模型module标签差异对比 FA标签标签说明对应的Stage标签差异说明…
阅读更多...
LeetCode刷题之HOT100之课程表

LeetCode刷题之HOT100之课程表

吃完普通的食堂饭菜&#xff0c;回到实验室&#xff0c;继续做一道题&#xff01; 1、题目描述 2、逻辑分析 这道题涉及到图相关知识&#xff0c;应用到了拓扑排序。 题意解释 一共有 n 门课要上&#xff0c;编号为 0 ~ n-1。先决条件 [1, 0]&#xff0c;意思是必须先上课 0…
阅读更多...
触动心弦的成语之旅：《米小圈动画成语》带你走进中华智慧

触动心弦的成语之旅：《米小圈动画成语》带你走进中华智慧

成语&#xff0c;这些古老而典雅的语言精华&#xff0c;如同中华文化的晶莹明珠&#xff0c;闪耀着历史的光辉和智慧的火花。从古至今&#xff0c;它们在中国人的日常交流中扮演着重要角色&#xff0c;不仅传递着深刻的哲理和文化内涵&#xff0c;更是凝聚了世代智者的思想和智…
阅读更多...
【Linux】线程id与互斥（线程三）

【Linux】线程id与互斥（线程三）

上一期我们进行了线程控制的了解与相关操作&#xff0c;但是扔就有一些问题没有解决 本章第一阶段就是解决tid的问题&#xff0c;第二阶段是进行模拟一个简易线程库&#xff08;为了加深对于C库封装linux原生线程的理解&#xff09;&#xff0c;第三阶段就是互斥。 目录 线程id…
阅读更多...
链在一起怎么联机 链在一起远程同玩联机教程

链在一起怎么联机 链在一起远程同玩联机教程

steam中最近特别热门的多人跑酷冒险的游戏&#xff1a;《链在一起》&#xff0c;英文名称叫做Chained Together&#xff0c;在游戏中我们需要开始自己的旅程&#xff0c;在地狱的深处&#xff0c;与我们的同伴被链在一起。我们的任务是通过尽可能高的攀登逃离地狱。每一次跳跃都…
阅读更多...
Python第三方库GDAL 安装

Python第三方库GDAL 安装

安装GDAL的方式多种&#xff0c;包括pip、Anaconda、OSGeo4W等。笔者在安装过程中&#xff0c;唯独使用pip安装遇到问题。最终通过轮子文件&#xff08;.whl&#xff09;成功安装。 本文主要介绍如何下载和安装较新版本的GDAL轮子文件。 一、GDAL轮子文件下载 打开Github网站…
阅读更多...
Python学习打卡：day16

Python学习打卡：day16

day16 笔记来源于&#xff1a;黑马程序员python教程&#xff0c;8天python从入门到精通&#xff0c;学python看这套就够了 目录 day16116、SQL 基础和 DDLSQL的概述SQL语言的分类SQL的语法特征DDL — 库管理DDL — 表管理 117、SQL — DMLDML概述数据插入 INSERT数据删除 DEL…
阅读更多...
深入理解 Dubbo：分布式服务框架的核心原理与实践

深入理解 Dubbo：分布式服务框架的核心原理与实践

目录 Dubbo 概述Dubbo 的架构Dubbo 的关键组件 服务提供者&#xff08;Provider&#xff09;服务消费者&#xff08;Consumer&#xff09;注册中心&#xff08;Registry&#xff09;监控中心&#xff08;Monitor&#xff09;调用链追踪&#xff08;Trace&#xff09; Dubbo 的…
阅读更多...
专题页面设计指南：从构思到实现

专题页面设计指南：从构思到实现

如何设计专题页&#xff1f;你有什么想法&#xff1f;专题页的设计主要以发扬产品优势为核心。一个好的专题页可以从不同的角度向用户介绍产品&#xff0c;扩大产品的相关优势&#xff0c;表达产品的优势&#xff0c;让用户在短时间内了解产品。因此&#xff0c;在设计详细信息…
阅读更多...
纯血鸿蒙Beta版本发布，中国华为，站起来了！

纯血鸿蒙Beta版本发布，中国华为，站起来了！

2024年6月21日至23日&#xff0c;华为开发者大会2024&#xff08;HDC 2024&#xff09;于东莞盛大举行。 此次大会不仅在会场设置了包括鸿蒙原生应用、统一生态统一互联等在内的11个展区&#xff0c;以供展示HarmonyOS NEXT的强大实力&#xff0c;还对外宣布了HarmonyOS的最新进…
阅读更多...
240627_关于CNN中图像维度变化问题

240627_关于CNN中图像维度变化问题

240627_关于CNN中图像维度变化问题 在学习一些经典模型时&#xff0c;其中得维度变化关系总搞不太明白&#xff0c;集中学习了以下&#xff0c;在此作以梳理总结&#xff1a; 一般来说涉及到的维度变换都是四个维度&#xff0c;当batch size4&#xff0c;图像尺寸为640*640&a…
阅读更多...
kylin v10 离线安装chrome centos离线安装chrome linux离线安装谷歌浏览器

kylin v10 离线安装chrome centos离线安装chrome linux离线安装谷歌浏览器

1. 先用自己联网的计算机&#xff0c;下载离线安装包&#xff0c;浏览器输入链接下载安装包&#xff1a; https://dl.google.com/linux/direct/google-chrome-stable_current_x86_64.rpm 1.2. 信创环境不用执行下面&#xff0c;因为没网 1.3. 若为阿里云服务器&#xff0c;或服…
阅读更多...
AR导航技术加持，图书馆阅读体验智慧升级

AR导航技术加持，图书馆阅读体验智慧升级

在信息爆炸的今天&#xff0c;图书馆作为知识的宝库&#xff0c;其藏书量和种类日益增多。然而&#xff0c;传统的图书馆导航方式已逐渐无法满足用户对快速、准确定位图书的需求。本文将探讨图书馆AR地图导航的实现原理、技术优势、功能特点以及市场前景&#xff0c;揭示为何AR…
阅读更多...
VS studio2019配置远程连接Ubuntu

VS studio2019配置远程连接Ubuntu

VS studio2019配置远程连接Ubuntu 1、网络配置 &#xff08;1&#xff09;获取主机IP &#xff08;2&#xff09;获取Ubuntu的IP &#xff08;3&#xff09;在 windows 的控制台中 ping 虚拟机的 ipv4 地址&#xff0c;在 Ubuntu 中 ping 主机的 ipv4 地址。 ubuntu: ping…
阅读更多...
【Linux】对共享库加载问题的深入理解——基本原理概述

【Linux】对共享库加载问题的深入理解——基本原理概述

原理概述 【linux】详解——库-CSDN博客 共享库被加载后&#xff0c;系统会为该共享库创建一个结构&#xff0c;这个结构体中的字段描述了库的各种属性。在内存中可能会加载很多库&#xff0c;每一个库都用一个结构体描述。把这些结构体用一些数据结构管理起来&#xff0c;系…
阅读更多...
WordPress Dokan Pro插件 SQL注入漏洞复现(CVE-2024-3922)

WordPress Dokan Pro插件 SQL注入漏洞复现(CVE-2024-3922)

0x01 产品简介 WordPress Dokan Pro插件是一款功能强大的多供应商电子商务市场解决方案，功能全面、易于使用的多供应商电子商务平台解决方案，适合各种规模的电商项目。允许管理员创建一个多卖家平台，卖家可以注册账户并在平台上创建自己的店铺，展示和销售自己的产品。提供…
阅读更多...
kali下安装使用蚁剑（AntSword）

kali下安装使用蚁剑（AntSword）

目录 0x00 介绍0x01 安装0x02 使用1. 设置代理2. 请求头配置3. 编码器 0x00 介绍 蚁剑&#xff08;AntSword&#xff09;是一个webshell管理工具。 官方文档&#xff1a;https://www.yuque.com/antswordproject/antsword 0x01 安装 在kali中安装蚁剑&#xff0c;分为两部分&am…
阅读更多...
Zabbix 监控系统部署

Zabbix 监控系统部署

Zabbix 监控系统部署 Zabbix是一个企业级开源分布式监控解决方案&#xff0c;可监控网络的众多参数以及服务器、虚拟机、应用程序、服务、数据库、网站、云等的运行状况和完整性。 Zabbix 使用灵活的通知机制&#xff0c;允许用户为几乎任何事件配置基于电子邮件的警报。这允许…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023