使用SpringTask+数据库+Redis，自定义切面对不同入参的接口数据进行Redis缓存，并根据不同频率进行刷新

已于 2023-07-27 22:24:15 修改
阅读量441 收藏
点赞数 1
文章标签： 缓存 redis spring java
于 2023-07-18 02:14:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60534886/article/details/131778280
版权
该方案提出了一种接口缓存策略，利用SpringAOP和Redis实现接口数据的缓存。通过注解定义超时时间和更新cron表达式，当接口被调用时，数据会被存储到Redis中。同时，通过前端Header参数判断接口调用方式，更新接口活跃时间，并根据活跃时间管理缓存更新。此外，使用MySQL存储接口信息，通过线程池和定时任务对不同接口进行不同频率的更新，以及在服务关闭时优雅地停止定时任务。
摘要由CSDN通过智能技术生成

概要

  • 本方案是由于工作中出现的系统数据库某些表数据量大(几千万)、关联表多等业务情况，导致接口响应速度过长，同时业务接口数量也过多，故而需要个方案对部分旧接口进行改造，所以自己便在工作之余设想的一个较为通用的接口缓存方案
  • 本方案主要采用了注解的方式，利用Spring的Aop特性，通过把接口放回数据更新进Redis中，实现接口数据的缓存
  • 同时采用数据库(案例是mysql)，对接口的类名、方法、入参、更新cron等进行存储，采用反序列化的方式来实现接口的调用，并通过SpringTask对不同的接口进行不同频率的定时更新
  • 采用前端Headers添加isActive入参的方式(试过其他的方式但需要适配)，判断接口是否是接口请求方式调用，当是接口请求方式调用时会更新表字段last_active_time,根据该时间可以对长期没被主动调用过的接口进行停止缓存更新，一定程度上防止系统的内存占用越来越大

 导入依赖：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
            <version>3.0.4</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3.1</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>31.1-jre</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.32</version>
        </dependency>

类介绍  

  • RedisCache: 自定义接口缓存注解 
    @Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RedisCache {

    /**
     * 超时时间
     * */
    int timeout() default 61*3;

    /**
     * 超时时间单位
     * */
    TimeUnit timeUnit() default TimeUnit.SECONDS;

    /**
     * 自定义cron
     * */
    String cron() default "*/3 * * * * *";

}

  • RedisCacheAspect: 自定义接口缓存注解RedisCache的切面 
    /**
 * @author yuqingxin
 * 自定义接口缓存注解RedisCache的切面
 * */
@Aspect
@Component
@Log4j2
public class RedisCacheAspect {

    final RedisCacheService redisCacheService;

    final Executor threadPool;

    final ApiActiveService apiActiveService;

    final ApiScheduleMapper apiScheduleMapper;

    public RedisCacheAspect(RedisCacheService redisCacheService,
                            Executor threadPool,
                            ApiActiveService apiActiveService,
                            ApiScheduleMapper apiScheduleMapper){
        this.redisCacheService = redisCacheService;
        this.threadPool = threadPool;
        this.apiActiveService = apiActiveService;
        this.apiScheduleMapper = apiScheduleMapper;
    }

    private final ObjectMapper objectMapper = new ObjectMapper();

    @Around("@annotation(redisCache)")
    public Object getControllerData(ProceedingJoinPoint joinPoint, RedisCache redisCache) throws Throwable {
         //采用前端Header入参方式判断调用该方法的方式
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        String isActive = null;
        if (attributes != null) {
            HttpServletRequest request = attributes.getRequest();
            isActive = request.getHeader("isActive");
        }

        //获取方法的相关信息
        String className = joinPoint.getTarget().getClass().getName();
        String arguments = objectMapper.writeValueAsString(joinPoint.getArgs());
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        String methodName = method.getName();
        String argumentsType = Arrays.toString(method.getParameterTypes());

        // 构建缓存键：类名 + 方法 + 参数值
        String key = className + ":" + methodName + ":" + arguments;
        String result = redisCacheService.get(key);
        log.info("RedisCache:{}",result);
        if (result == null) {
            //调用接口逻辑并获取对应的返回数据并转换为字符串
            result =  objectMapper.writeValueAsString(joinPoint.proceed());
            log.info("set RedisCache:{} :: {}",key,result);
            redisCacheService.set(key, result, redisCache.timeout(),redisCache.timeUnit());
        }

        //定时调用->更新redis数据
        if (null == isActive){
            threadPool.execute(()-> {
                try {
                    String updateResult = objectMapper.writeValueAsString(joinPoint.proceed());
                    log.info("Set RedisCache:{} :: {}", key, updateResult);
                    redisCacheService.set(key, updateResult, redisCache.timeout(), redisCache.timeUnit());
                } catch (Throwable e) {
                    log.error("Set RedisCache Error:{}", key);
                    e.printStackTrace();
                }
            });
        }

        //把记录更新到api缓存表
        String finalIsActive = isActive;
        threadPool.execute(()->{
            LocalDateTime now = LocalDateTime.now();
            LambdaQueryWrapper<ApiScheduleEntity> asL = new LambdaQueryWrapper<>();
            asL.eq(ApiScheduleEntity::getClassName,className)
                    .eq(ApiScheduleEntity::getMethodName,method.getName())
                    .eq(ApiScheduleEntity::getArgumentsType,argumentsType)
                    .eq(ApiScheduleEntity::getArguments,arguments);
            ApiScheduleEntity apiSchedule = apiScheduleMapper.selectOne(asL);
            if (apiSchedule != null){
                apiSchedule.setUpdateAt(now);
                //主动调用 则 更新 主动调用时间
                if ("1".equals(finalIsActive)){
                    apiSchedule.setLastActiveTime(now);
                }if (1 != apiSchedule.getStatus()){
                    apiSchedule.setStatus(1);
                    //添加对应的定时任务
                    log.info("addApiScheduledTask:{}"+key);
                    apiActiveService.addApiScheduledTask(apiSchedule);
                }
                apiScheduleMapper.updateById(apiSchedule);
            }else {
                ApiScheduleEntity apiScheduleEntity = new ApiScheduleEntity();
                apiScheduleEntity.setClassName(className);
                apiScheduleEntity.setMethodName(method.getName());
                apiScheduleEntity.setArgumentsType(argumentsType);
                apiScheduleEntity.setArguments(arguments);
                apiScheduleEntity.setCron(redisCache.cron());
                apiScheduleEntity.setLastActiveTime(now);
                apiScheduleEntity.setUpdateAt(now);
                apiScheduleMapper.insert(apiScheduleEntity);

                //添加对应的定时任务
                log.info("addApiScheduledTask:{}"+key);
                apiActiveService.addApiScheduledTask(apiScheduleEntity);
            }
        });
        //把获取到的字符串转化为接口的返回类型
        return objectMapper.readValue(result,method.getReturnType());
    }
}

  • RedisCacheService: RedisTemplate<String,String>的部分简单封装 
    @Service
public class RedisCacheService {

    private final RedisTemplate<String,String> redisTemplate;

    public RedisCacheService(RedisTemplate<String,String> redisTemplate){
        this.redisTemplate = redisTemplate;
    }

    public String get(String key){
        return redisTemplate.opsForValue().get(key);
    }

    public void set(String key, String value){
        redisTemplate.opsForValue().set(key,value,60, TimeUnit.SECONDS);
    }

    public void set(String key, String value, long seconds){
        redisTemplate.opsForValue().set(key,value,seconds, TimeUnit.SECONDS);
    }

    public void set(String key, String value, long seconds, TimeUnit timeUnit){
        redisTemplate.opsForValue().set(key,value,seconds, timeUnit);
    }
}

  • RedisScheduleConfig：自定义定时任务配置，主要作用为在服务启动时添加添加需要缓存的接口的定时任务 
    /**
 * @author yuqingxin
 * */
@Log4j2
@Configuration
@EnableScheduling
public class RedisScheduleConfig implements SchedulingConfigurer {

    final Executor threadPool;

    final ApplicationContext applicationContext;

    final ApiActiveService apiActiveService;

    final ThreadPoolTaskScheduler threadPoolTaskScheduler;

    final Map<String,ScheduledFuture<?>> scheduledFutureMap;

    public RedisScheduleConfig(Executor threadPool,
                               ApplicationContext applicationContext,
                               ApiActiveService apiActiveService,
                               ThreadPoolTaskScheduler threadPoolTaskScheduler,
                               Map<String,ScheduledFuture<?>> scheduledFutureMap){
        this.threadPool = threadPool;
        this.applicationContext = applicationContext;
        this.apiActiveService = apiActiveService;
        this.threadPoolTaskScheduler = threadPoolTaskScheduler;
        this.scheduledFutureMap = scheduledFutureMap;
    }

    /**
     * 程序启动时添加定时任务
     * 如果是分布式服务，一般只用一台服务器更新接口缓存就行
     * 可以简单通过设置服务器/容器的环境变量，使用@Value获取变量值来判断该服务器/容器是否是启用更新接口缓存
     * */
    @Override
    public void configureTasks(@Nonnull ScheduledTaskRegistrar scheduledTaskRegistrar) {
        //查询所有需要更新缓存的接口的定时任务
        log.info("初始化需缓存接口的定时任务");
        List<ApiScheduleEntity> apiScheduleList = apiActiveService.getApiScheduleList();
        for (ApiScheduleEntity apiSchedule : apiScheduleList) {
            try {
                apiActiveService.addApiScheduledTask(apiSchedule);
            }catch (Exception e){
                log.error("Init Active Api Error:{}",apiSchedule);
            }
        }
    }

}

  • ApplicationClosedListenerConfig：自定义监听服务关闭配置，主要目的为在服务关闭时先关闭正在运行的定时任务 
    @Configuration
public class ApplicationClosedListenerConfig implements ApplicationListener<ContextClosedEvent> {

    final ThreadPoolTaskScheduler threadPoolTaskScheduler;

    public ApplicationClosedListenerConfig(ThreadPoolTaskScheduler threadPoolTaskScheduler){
        this.threadPoolTaskScheduler = threadPoolTaskScheduler;
    }

    @Override
    public void onApplicationEvent(@Nonnull ContextClosedEvent contextClosedEvent) {
        threadPoolTaskScheduler.shutdown();
    }
}

  • ThreadPoolConfig: 线程池相关配置，包括线程池、线程池任务调度器、定时任务类缓存 
    
@Log4j2
@Configuration
public class ThreadPoolConfig {

    @Value("${thread-pool.core-pool-size}")
    private int corePoolSize;

    @Value("${thread-pool.max-pool-size}")
    private int maxPoolSize;

    @Value("${thread-pool.keep-alive-time}")
    private long keepAliveTime;

    @Bean
    public Executor threadPool() {
        log.info("创建自定义线程池");
        return new ThreadPoolExecutor(
                corePoolSize,
                maxPoolSize,
                keepAliveTime,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(1000),
                new ThreadFactoryBuilder().setNameFormat("Thread-pool-%d").build(),
                new ThreadPoolExecutor.AbortPolicy()
        );
    }

    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler(){
        log.info("创建自定义线程池任务调度器");
        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
        threadPoolTaskScheduler.setPoolSize(20);
        threadPoolTaskScheduler.setThreadGroupName("TaskScheduler-");
        threadPoolTaskScheduler.setAwaitTerminationSeconds(60);
        threadPoolTaskScheduler.setWaitForTasksToCompleteOnShutdown(true);
        return threadPoolTaskScheduler;
    }

    @Bean
    public Map<String, ScheduledFuture<?>> scheduledFutureMap(){
        log.info("创建定时任务缓存集合");
        return new HashMap<>();
    }
}

  • ArgumentsUtil：实现参数更对应类的转换方法类 
    /**
 * @author yuqingxin
 * */
@Service
public class ArgumentsUtil {

    final ObjectMapper objectMapper;

    public ArgumentsUtil(ObjectMapper objectMapper){
        this.objectMapper = objectMapper;
    }

    /**
     * 参数类型转换为对应对象
     * */
    public Class<?>[] getClassArray(String typesString){
        String[] classNames = typesString.substring(1, typesString.length() - 1).split("class ");
        Class<?>[] classes = new Class<?>[classNames.length-1];

        for (int i = 1; i < classNames.length; i++) {
            try {
                Class<?> clazz = Class.forName(classNames[i].replace(", ",""));
                classes[i-1] = clazz;
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        return classes;
    }

    /**
     * 参数值转换为对象
     * */
    public Object[] getObjectArray(String argumentsString,Class<?>[] parameterTypes) {
        Object[] objects = JSON.parseObject(argumentsString,Object[].class);
        for (int i = 0; i < objects.length; i++) {
            try {
                objects[i] = objectMapper.readValue(objectMapper.writeValueAsString(objects[i]),parameterTypes[i]);
            } catch (JsonProcessingException e) {
                throw new RuntimeException(e);
            }
        }
        return objects;
    }
}

  • ApiScheduleEntity: 接口缓存调用表对应的实体类 
    /**
 * @author yuqingxin
 * */
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("tbl_api_schedule")
public class ApiScheduleEntity {

    private Long id;

    /**
     * 类名
     * */
    private String className;

    /**
     * 方法名
     * */
    private String methodName;

    /**
     * 参数类型
     * */
    private String argumentsType;

    /**
     * 参数值
     * */
    private String arguments;

    /**
     * 更新频率cron
     * */
    private String cron;

    /**
     * 最后调用时间
     * */
    private LocalDateTime updateAt;

    /**
     * 最后通过接口调用方式的调用时间
     * */
    private LocalDateTime lastActiveTime;

    /**
     * 是否启用：1是0否
     * */
    private Integer status;
}

  • ApiActiveService: 调用缓存接口相关逻辑类，主要功能为：
    • 获取需要调用/长时间为调用的缓存接口
    • 通过反序列的方式对单个/多个需缓存的接口进行调用
    • 对长期未使用的缓存接口取消对应的定时任务 
      /**
 * @author yuqingxin
 * */
@Log4j2
@Service
public class ApiActiveService {

    //超时时间
    private final Integer timeout = 60*60*24*3;

    final ApiScheduleMapper apiScheduleMapper;

    final ApplicationContext applicationContext;

    final ThreadPoolTaskScheduler threadPoolTaskScheduler;

    final Executor threadPool;

    final Map<String, ScheduledFuture<?>> scheduledFutureMap;

    final ArgumentsUtil argumentsUtil;

    public ApiActiveService(ApiScheduleMapper apiScheduleMapper,
                            ApplicationContext applicationContext,
                            ThreadPoolTaskScheduler threadPoolTaskScheduler,
                            Executor threadPool,
                            Map<String, ScheduledFuture<?>> scheduledFutureMap,
                            ArgumentsUtil argumentsUtil){
        this.apiScheduleMapper = apiScheduleMapper;
        this.applicationContext = applicationContext;
        this.threadPoolTaskScheduler = threadPoolTaskScheduler;
        this.threadPool = threadPool;
        this.scheduledFutureMap = scheduledFutureMap;
        this.argumentsUtil = argumentsUtil;
    }

    /**
     * 获取需要更新的Api
     * */
    public List<ApiScheduleEntity> getApiScheduleList(){
        LambdaQueryWrapper<ApiScheduleEntity> aL =  new LambdaQueryWrapper<>();
        aL.eq(ApiScheduleEntity::getStatus,1);
        return apiScheduleMapper.selectList(aL);
    }

    /**
     * 获取长时间未使用的Api
     * @param timeout 多长时间未使用  秒
     * */
    public List<ApiScheduleEntity> getLongTimeUnUseApiList(Integer timeout){
        LambdaQueryWrapper<ApiScheduleEntity> aL =  new LambdaQueryWrapper<>();
        aL.eq(ApiScheduleEntity::getStatus,1)
                .le(ApiScheduleEntity::getLastActiveTime, LocalDateTime.now().minusSeconds(timeout));
        return apiScheduleMapper.selectList(aL);
    }

    /**
     * 调用单个Api方法
     * */
    public void  runApiOne(ApiScheduleEntity apiSchedule){
        // 类名
        String className = apiSchedule.getClassName();
        // 方法名
        String methodName = apiSchedule.getMethodName();
        // 参数值
        String argumentsString = apiSchedule.getArguments();

        // 参数类型
        String argumentsType = apiSchedule.getArgumentsType();
        Class<?>[] parameterTypes = argumentsUtil.getClassArray(argumentsType);
        Object[] arguments = argumentsUtil.getObjectArray(argumentsString,parameterTypes);
        try {
            // 获取类对象
            Class<?> apiClass = Class.forName(className);
            // 获取方法对象
            Method method = apiClass.getMethod(methodName, parameterTypes);
            // 获取该类的Bean对象
            Object instance = applicationContext.getBean(apiClass);
            // 调用方法
            Object result = method.invoke(instance, arguments);
            // 处理方法返回值
            log.info("Result: " + result);
        } catch (Exception e) {
            log.error("RunApiMethod Error: {}：{}::{}",className,methodName,argumentsString);
            e.printStackTrace();
        }
    }


    /**
     * 批量调用需要更新缓存的Api
     * */
    public Boolean runApiMethod(){
        List<ApiScheduleEntity> list = getApiScheduleList();
        for (ApiScheduleEntity api : list) {
            runApiOne(api);
        }
        return true;
    }

    /**
     * 添加单个Api定时任务
     * */
    public void addApiScheduledTask(ApiScheduleEntity apiSchedule){
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                runApiOne(apiSchedule);
            }
        };
        ScheduledFuture<?> scheduledFuture =  threadPoolTaskScheduler.schedule(timerTask,new CronTrigger(apiSchedule.getCron()));
        //将该实例存入到缓存map中
        if (null != scheduledFuture){
            threadPool.execute(()->{
                String key = apiSchedule.getClassName() + ":" + apiSchedule.getMethodName()+ ":" +apiSchedule.getArguments();
                scheduledFutureMap.put(key,scheduledFuture);
            });
        }
    }

    /**
     * 批量取消长时间未被主动调用的Api定时更新任务
     * */
    public Boolean cancelApiScheduleTask(){
        List<ApiScheduleEntity> list = getLongTimeUnUseApiList(timeout);
        for (ApiScheduleEntity apiSchedule : list) {
            threadPool.execute(()->{
                //去除对应定时认为
                String key = apiSchedule.getClassName() + ":" +apiSchedule.getMethodName() + ":" + apiSchedule.getArguments();
                ScheduledFuture<?> scheduledFuture = scheduledFutureMap.get(key);
                if (null != scheduledFuture){
                    scheduledFuture.cancel(true);
                    scheduledFutureMap.remove(key);
                }
                //更新数据库状态
                apiSchedule.setStatus(0);
                apiScheduleMapper.updateById(apiSchedule);
            });
        }
        return true;
    }
}

 调用示例

 完整代码获取

注：如果在使用中出现不能适配的bug，麻烦方便的话请告知我-> 1073260490@qq.com 

风起东夏
关注
SpringCloud使用教程
9.冄2.7.號的博客
09-12 412
从面试开始 什么是微服务？ 微服务之间是如何独立通讯的 SpringCloud和Dubbo有哪些区别？ SpringBoot和SpringCloud，请你谈谈对他们的理解 什么是服务熔断？什么是服务降级 微服务的优缺点分别是什么？说下你在项目开发中碰到的坑 你所知道的微服务技术栈有哪些？请列举一二 eureka和zookeeper都可以提供服务注册与发现的功能，请说说两个的区别？ … 微服务概...
淘宝面试常见问题的答案来了，你看了吗？（一面及答案）
mzl_sx的博客
10-15 1364
1、redis sds优缺点、扩容收缩、扩容因子 SDS （简单动态字符串）是什么 其实，SDS 是 Redis 中实现的一种数据结构，主要用来存储字符串。 1、那 SDS 与 C 字符串相比有什么优势呢？ 1.1、常数复杂度获取字符串长度 常规 C 字符串并不记录自身的长度信息，所以为了获取一个 C 字符串的长度，程序必须遍历整个字符串，对遇到的每个字符进行计数，直到遇到代表字符串结尾的空字符为止，这个操作的复杂度为 O(N)。 而 SDS 使用结构体实现，结构体中的 len 属性直接记录
springboot实现消息转换、切面AOP和Redis缓存
11-16
springboot实现消息转换、切面AOP和Redis缓存,实现相关技术的实例，以及相关方法的使用说明
JAVA开发（通过AOP切面方式管理redis缓存）
JAVA领域优质创作者，基于分片网络查询方法专利发明者。
01-11 721
在调用查询方法时，判断redis中是否已经有，如果有则优先从redis中查询。 如果没有则在数据库中查询后并存入到Redis中一份，并给其设置过期时间。 这样在过期时间之内，查询数据会从redis中查询，过期之后会重新从数据库中查询并存入到Redis一份。再对这个数据库表进行新增、编辑、删除的操作时，将redis中存储的数据。 进行删除，这样下次查询就会查询数据库中最新的。
redis缓存切面
stackCSDN的博客
02-05 274
redis缓存自定义切面
使用java注解+切面实现redis缓存注入
chuchanhong4976的博客
10-25 561
公司有一个项目，使用dubbo提供服务，接口大部分是查询数据接口，数据需要redis缓存以减少服务器压力，如果每个接口都手动写代码实现redis缓存的话，工作量很大，因此思考只用一套代码实现redis功能注入，无需修改业务代码。 先定义一个注解： @Target(METHOD) @Ret...
一个注解实现方法返回数据写入缓存（切面、Redis实现）
weixin_47053123的博客
07-21 515
底层采用redis来进行存储,用有超时时间的set方法来存储。采用切面的方式，对方法进行动态代理，一共分为两种情况。先去缓存中读取该方法的返回值，如果为空，则执行方法。TimeUnit超时时间的单位。timeOut超时时间。不为空，直接返回缓存数据。valuekey值。.........
redis spring 切面缓存_spring使用redis缓存数据
weixin_39629679的博客
12-19 76
缓存(Caching)可以存储经常会用到的信息，这样每次需要的时候，这些信息都是立即可用的。配置缓存管理器package cn.com.sm.config;import org.springframework.cache.CacheManager;import org.springframework.cache.annotation.EnableCaching;import org.springf...
.Net Core Redis缓存预热及Canal数据同步
最新发布
m0_59178355的博客
07-26 1225
缓存预热是指在系统启动或特定时机前，将预计会被访问的数据加载到缓存中。这样做的目的是减少系统的响应时间和数据库的访问负担。在用户首次请求数据时，这些数据已经存在于缓存中，从而能够提供更快的响应速度。Canal 是一款开源的数据同步工具，由阿里巴巴开发。它主要用于从MySQL等关系型数据库中捕捉数据变更，并将这些变更实时同步到其他系统中。Canal 基于数据库的 binlog（Binary Log）机制来获取数据变更，通过解析 binlog 来实现数据的增量同步。
大型电商架构亿级流量电商详情页系统--实战 缓存同步，热点key统计 降级
asd23rsa的博客
05-15 1009
35 我们之前的三十讲，主要是在讲解redis如何支撑海量数据、高并发读写、高可用服务的架构，redis架构 redis架构，在我们的真正类似商品详情页读高并发的系统中，redis就是底层的缓存存储的支持 从这一讲开始，我们正式开始做业务系统的开发 亿级流量以上的电商网站的商品详情页的系统，商品详情页系统，大量的业务，十几个人做一两年，堆出来复杂的业务系统 几十个小时的课程，讲解复杂的业务 把整体的架构给大家讲解清楚，然后浓缩和精炼里面的业务，提取部分业务，做一些简化，把整个详情页系统的流程跑出
缓存优化
qq_42266891的博客
09-23 1478
1、了解内存缓存 1. 1、什么是缓存 在计算中，缓存是一个高速数据存储层，其中存储了数据子集，且通常是短暂性存储，这样日后再次请求此数据时，速度要比访问数据的主存储位置快。通过缓存，可以高效地重用之前检索或计算的数据。缓存本质上是以空间换时间，提高接口的响应速度。 硬件 是指一块芯片被集成到硬盘或者CPU上，作用就是充当硬盘,CPU与外界的接口之间的一个暂存器。这里的外界接口通常是指硬盘和内存，或者是CPU与内存之间。利用缓存可以减轻系统的负载，同时提高传播效率。 客户端缓存 为了实现可以快速地响应用户的
Redis缓存切面处理
iechenyb专栏
08-26 704
package com.cyb.web.example.controller; import java.util.List; import java.util.Map; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.cache.annotation.Cacheable; import org.springframework.util.StringUtils; impor.
通过切面结合Redis自定义缓存注解
ZHUSHANGLIN的博客
07-06 447
你每次用Redis做缓存的时候是不是都要写这么一大堆重复的代码? 接下来看我怎么解决这个问题,去除重复的代码,以后每次用缓存的时候只需要添加一个注解就ok了 注解的切面(对使用该注解的处理) 这里使用的是Redis集群,Redis集群搭建可以参考https://blog.csdn.net/ZHUSHANGLIN/article/details/125600520 上面使用到的ObjectMapperUtil工具类是: 注解的使用 在需要使用Redis缓存的方法上 使用@Cache_Find注解即可,这
基于定时任务刷新Redis缓存，采用Redis发布订阅实现更新本地缓存，1箭双雕
竹林幽深
08-09 727
候选人：我们的服务后端设计是采用了二级缓存，把一些热点的数据放到本地缓存，把一些非热点的数据放到 Redis 缓存，接口优先查询一级缓存，如果一级缓存没数据，接着会查询二级缓存，二级缓存不存在，才访问数据库。面试官：从你的设计看，你的数据存储到三个地方(DB、Redis、Caffeine)，如果涉及数据更新，你是怎么保证他们三者中间的一致性的呢？点击下方公众号进入关注，后台回复【1箭双雕】即可获取所有资料，具体的商用级代码已经更新，记得关注，免费领取，标记星号哟!
springboot+redis限流处理自定义标签切面技术aop
黑科技的专栏
01-03 219
springboot+redis限流处理自定义标签切面技术aop
SpringBoot持续更新
一切都是最好的安排
05-23 561
pom.xml Application.java @SpringBootApplication 标注在某个类上，表明这个类是SpringBoot的主配置类 HelloController.java 首先，在IDEA中开发Springboot应用和Eclipse里面一样，本质上都是一个maven 项目。 但是呢，IDEA 本身自带对SpringBoot支持的插件，不像Eclipse那样，要用插件还需要从第三方安装， 而且很缓慢 (国外插件源)。 所以使用IDEA自带的 SpringBoot插件来开发。 S.
spring task的详细使用
at10090的博客
10-21 955
定时任务是解决很多问题的常用手段，spring的spring task 可以看做一个轻量级的quartz框架。只需要通过少量的配置，就能启动定时任务。 1.引入相关jar包 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-web</art...
和外部系统如何对接？Spring Boot 项目调用外部接口的 3 种方式
qq_45635347的博客
06-29 1034
SpringBoot不仅继承了Spring框架原有的优秀特性，而且还通过简化配置来进一步简化了Spring应用的整个搭建和开发过程。
Spring AOP 实现 Redis 缓存切面
shpunishment的博客
10-28 1947
文章目录1. Redis缓存切面2. 测试 使用 Redis Windows 测试。 Redis Windows 安装与简单命令使用 1. Redis缓存切面 添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> <dep
Spring Boot + Mybatis + Redis：构建高效Java Web缓存系统
"本文主要探讨了使用Spring Boot、Mybatis和Redis构建现代Java Web应用程序的实践方法，特别是如何实现Mybatis的二级缓存功能。通过这个教程，开发者将学习到如何利用Spring Boot的便捷特性快速搭建项目，以及如何...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值