多级缓存架构开发 三 ( 使用redis作为二级缓存 )

最新推荐文章于 2024-05-06 23:31:17 发布
最新推荐文章于 2024-05-06 23:31:17 发布
阅读量2.7k 收藏 7
点赞数
分类专栏： 缓存 文章标签： redis

1.导入redis的jar包

  在父模块的pom文件下添加

    <dependencyManagement>
        <dependencies>

            <dependency>
                <groupId>org.springframework.data</groupId>
                <artifactId>spring-data-redis</artifactId>
                <version>${spring.data.redis.version}</version>
            </dependency>

        </dependencies>
    </dependencyManagement>

在子模块的pom文件中添加

    <dependencies>

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

    </dependencies>

2.开发二级缓存具体实现类

package org.github.roger.cache.redis;

import com.alibaba.fastjson.JSON;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.github.roger.cache.AbstractValueAdaptingCache;
import org.github.roger.concurrent.RedisDistriLock;
import org.github.roger.concurrent.ThreadTaskUtils;
import org.github.roger.settings.SecondaryCacheSetting;
import org.github.roger.support.AwaitThreadContainer;
import org.github.roger.support.NullValue;
import org.github.roger.utils.RedisCacheKey;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;

import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

@Slf4j
@Getter
public class RedisCache  extends AbstractValueAdaptingCache {
    /**
     * 刷新缓存重试次数
     */
    private static final int RETRY_COUNT = 20;

    /**
     * 刷新缓存等待时间，单位毫秒
     */
    private static final long WAIT_TIME = 20;

    /**
     * 等待线程容器
     */
    private AwaitThreadContainer container = new AwaitThreadContainer();

    /**
     * redis 客户端 即缓存对象
     */
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 缓存有效时间,毫秒
     */
    private long expiration;

    /**
     * 缓存主动在失效前强制刷新缓存的时间
     * 单位：毫秒
     */
    private long preloadTime = 0;

    /**
     * 是否强制刷新（执行被缓存的方法），默认是false
     */
    private boolean forceRefresh = false;

    /**
     * 是否使用缓存名称作为 redis key 前缀
     */
    private boolean usePrefix;

    /**
     * 是否允许为NULL
     */
    private final boolean allowNullValues;

    /**
     * 非空值和null值之间的时间倍率，默认是1。allowNullValue=true才有效
     * <p>
     * 如配置缓存的有效时间是200秒，倍率这设置成10，
     * 那么当缓存value为null时，缓存的有效时间将是20秒，非空时为200秒
     * </p>
     */
    private final int magnification;

    /**
     * @param name                  缓存名称
     * @param redisTemplate         redis客户端 redis 客户端
     * @param secondaryCacheSetting 二级缓存配置{@link SecondaryCacheSetting}
     */
    public RedisCache(String name, RedisTemplate<String, Object> redisTemplate, SecondaryCacheSetting secondaryCacheSetting) {

        this(name, redisTemplate, secondaryCacheSetting.getTimeUnit().toMillis(secondaryCacheSetting.getExpiration()),
                secondaryCacheSetting.getTimeUnit().toMillis(secondaryCacheSetting.getPreloadTime()),
                secondaryCacheSetting.isForceRefresh(), secondaryCacheSetting.isUsePrefix(),
                secondaryCacheSetting.isAllowNullValue(), secondaryCacheSetting.getMagnification());
    }

    /**
     * @param name            缓存名称
     * @param redisTemplate   redis客户端   redis 客户端
     * @param expiration      key的有效时间
     * @param preloadTime     缓存主动在失效前强制刷新缓存的时间
     * @param forceRefresh    是否强制刷新（执行被缓存的方法），默认是false
     * @param usePrefix       是否使用缓存名称作为前缀
     * @param allowNullValues 是否允许存NULL值，模式允许
     * @param magnification   非空值和null值之间的时间倍率
     */
    public RedisCache(String name, RedisTemplate<String, Object> redisTemplate, long expiration, long preloadTime,
                      boolean forceRefresh, boolean usePrefix, boolean allowNullValues, int magnification) {
        super(name);

        Assert.notNull(redisTemplate, "RedisTemplate 不能为NULL");
        this.redisTemplate = redisTemplate;
        this.expiration = expiration;
        this.preloadTime = preloadTime;
        this.forceRefresh = forceRefresh;
        this.usePrefix = usePrefix;
        this.allowNullValues = allowNullValues;
        this.magnification = magnification;
    }

    @Override
    public boolean isAllowNullValues() {
        return this.allowNullValues;
    }

    @Override
    public RedisTemplate<String, Object> getRealCache() {
        return this.redisTemplate;
    }

    /**
     * 获取 RedisCacheKey
     *
     * @param key 缓存key
     * @return RedisCacheKey
     */
    public RedisCacheKey getRedisCacheKey(Object key) {
        return new RedisCacheKey(key, redisTemplate.getKeySerializer())
                .cacheName(getName()).usePrefix(usePrefix);
    }

    @Override
    public Object get(Object key) {

        RedisCacheKey redisCacheKey = getRedisCacheKey(key);

        log.debug("redis缓存 key= {} 查询redis缓存", redisCacheKey.getKey());
        return redisTemplate.opsForValue().get(redisCacheKey.getKey());
    }

    @Override
    public <T> T get(Object key, Callable<T> valueLoader) {
        RedisCacheKey redisCacheKey = getRedisCacheKey(key);
        log.debug("redis缓存 key= {} 查询redis缓存如果没有命中，从数据库获取数据", redisCacheKey.getKey());
        // 先获取缓存，如果有直接返回
        Object result = redisTemplate.opsForValue().get(redisCacheKey.getKey());
        if (result != null || redisTemplate.hasKey(redisCacheKey.getKey())) {
            // 刷新缓存
            refreshCache(redisCacheKey, valueLoader, result);
            return (T) fromStoreValue(result);
        }
        // 执行缓存方法
        return executeCacheMethod(redisCacheKey, valueLoader);
    }

    /**
     * 刷新缓存数据
     */
    private <T> void refreshCache(RedisCacheKey redisCacheKey, Callable<T> valueLoader, Object result) {
        Long ttl = redisTemplate.getExpire(redisCacheKey.getKey());
        Long preload = preloadTime;
        // 允许缓存NULL值，则自动刷新时间也要除以倍数
        boolean flag = isAllowNullValues() && (result instanceof NullValue || result == null);
        if (flag) {
            preload = preload / getMagnification();
        }
        if (null != ttl && ttl > 0 && TimeUnit.SECONDS.toMillis(ttl) <= preload) {
            // 判断是否需要强制刷新在开启刷新线程
            if (!isForceRefresh()) {
                log.debug("redis缓存 key={} 软刷新缓存模式", redisCacheKey.getKey());
                softRefresh(redisCacheKey);
            } else {
                log.debug("redis缓存 key={} 强刷新缓存模式", redisCacheKey.getKey());
                forceRefresh(redisCacheKey, valueLoader);
            }
        }
    }

    /**
     * 软刷新，直接修改缓存时间
     *
     * @param redisCacheKey {@link RedisCacheKey}
     */
    private void softRefresh(RedisCacheKey redisCacheKey) {
        // 加一个分布式锁，只放一个请求去刷新缓存
        RedisDistriLock redisLock = new RedisDistriLock(redisTemplate, redisCacheKey.getKey() + "_lock");
        try {
            if (redisLock.tryLock()) {
                redisTemplate.expire(redisCacheKey.getKey(), this.expiration, TimeUnit.MILLISECONDS);
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        } finally {
            redisLock.unlock();
        }
    }

    /**
     * 硬刷新（执行被缓存的方法）
     *
     * @param redisCacheKey {@link RedisCacheKey}
     * @param valueLoader   数据加载器
     */
    private <T> void forceRefresh(RedisCacheKey redisCacheKey, Callable<T> valueLoader) {
        // 尽量少的去开启线程，因为线程池是有限的
        ThreadTaskUtils.run(() -> {
            // 加一个分布式锁，只放一个请求去刷新缓存
            RedisDistriLock redisLock = new RedisDistriLock(redisTemplate, redisCacheKey.getKey() + "_lock");
            try {
                if (redisLock.lock()) {
                    // 获取锁之后再判断一下过期时间，看是否需要加载数据
                    Long ttl = redisTemplate.getExpire(redisCacheKey.getKey());
                    if (null != ttl && ttl > 0 && TimeUnit.SECONDS.toMillis(ttl) <= preloadTime) {
                        // 加载数据并放到缓存
                        loaderAndPutValue(redisCacheKey, valueLoader, false);
                    }
                }
            } catch (Exception e) {
                log.error(e.getMessage(), e);
            } finally {
                redisLock.unlock();
            }
        });
    }

    /**
     * 加载并将数据放到redis缓存
     */
    private <T> T loaderAndPutValue(RedisCacheKey key, Callable<T> valueLoader, boolean isLoad) {
        long start = System.currentTimeMillis();

        try {
            // 加载数据
            Object result = putValue(key, valueLoader.call());
            log.debug("redis缓存 key={} 执行被缓存的方法，并将其放入缓存, 耗时：{}。数据:{}", key.getKey(), System.currentTimeMillis() - start, JSON.toJSONString(result));

            return (T) fromStoreValue(result);
        } catch (Exception e) {
            throw new LoaderCacheValueException(key.getKey(), e);
        }
    }

    private Object putValue(RedisCacheKey key, Object value) {
        Object result = toStoreValue(value);
        // redis 缓存不允许直接存NULL，如果结果返回NULL需要删除缓存
        if (result == null) {
            redisTemplate.delete(key.getKey());
            return result;
        }
        // 不允许缓存NULL值，删除缓存
        if (!isAllowNullValues() && result instanceof NullValue) {
            redisTemplate.delete(key.getKey());
            return result;
        }

        // 允许缓存NULL值
        long expirationTime = this.expiration;
        // 允许缓存NULL值且缓存为值为null时需要重新计算缓存时间
        if (isAllowNullValues() && result instanceof NullValue) {
            expirationTime = expirationTime / getMagnification();
        }
        // 将数据放到缓存
        redisTemplate.opsForValue().set(key.getKey(), result, expirationTime, TimeUnit.MILLISECONDS);
        return result;
    }


    /**
     * 同一个线程循环5次查询缓存，每次等待20毫秒，如果还是没有数据直接去执行被缓存的方法
     */
    private <T> T executeCacheMethod(RedisCacheKey redisCacheKey, Callable<T> valueLoader) {
        RedisDistriLock redisLock = new RedisDistriLock(redisTemplate, redisCacheKey.getKey() + "_sync_lock");
        // 同一个线程循环20次查询缓存，每次等待20毫秒，如果还是没有数据直接去执行被缓存的方法
        for (int i = 0; i < RETRY_COUNT; i++) {
            try {
                // 先取缓存，如果有直接返回，没有再去做拿锁操作
                Object result = redisTemplate.opsForValue().get(redisCacheKey.getKey());
                if (result != null) {
                    log.debug("redis缓存 key= {} 获取到锁后查询查询缓存命中，不需要执行被缓存的方法", redisCacheKey.getKey());
                    return (T) fromStoreValue(result);
                }

                // 获取分布式锁去后台查询数据
                if (redisLock.lock()) {
                    T t = loaderAndPutValue(redisCacheKey, valueLoader, true);
                    log.debug("redis缓存 key= {} 从数据库获取数据完毕，唤醒所有等待线程", redisCacheKey.getKey());
                    // 唤醒线程
                    container.signalAll(redisCacheKey.getKey());
                    return t;
                }
                // 线程等待
                log.debug("redis缓存 key= {} 从数据库获取数据未获取到锁，进入等待状态，等待{}毫秒", redisCacheKey.getKey(), WAIT_TIME);
                container.await(redisCacheKey.getKey(), WAIT_TIME);
            } catch (Exception e) {
                container.signalAll(redisCacheKey.getKey());
                throw new LoaderCacheValueException(redisCacheKey.getKey(), e);
            } finally {
                redisLock.unlock();
            }
        }
        log.debug("redis缓存 key={} 等待{}次，共{}毫秒，任未获取到缓存，直接去执行被缓存的方法", redisCacheKey.getKey(), RETRY_COUNT, RETRY_COUNT * WAIT_TIME, WAIT_TIME);
        return loaderAndPutValue(redisCacheKey, valueLoader, true);
    }

    @Override
    public void put(Object key, Object value) {
        RedisCacheKey redisCacheKey = getRedisCacheKey(key);
        log.debug("redis缓存 key= {} put缓存，缓存值：{}", redisCacheKey.getKey(), JSON.toJSONString(value));
        putValue(redisCacheKey, value);
    }

    /**
     * 缓存key中已经有缓存对象，则不在缓存，直接返回缓存的对象
     *  如果缓存key在缓存中不存在，则把新对象缓存，并返回null
     * @param key   缓存key
     * @param value 缓存key对应的值
     * @return
     */
    @Override
    public Object putIfAbsent(Object key, Object value) {
        log.debug("redis缓存 key= {} putIfAbsent缓存，缓存值：{}", getRedisCacheKey(key).getKey(), JSON.toJSONString(value));
        Object result = get(key);
        if (result != null) {
            return result;
        }
        put(key, value);
        return null;
    }

    @Override
    public void evict(Object key) {
        RedisCacheKey redisCacheKey = getRedisCacheKey(key);
        log.info("清除redis缓存 key= {} ", redisCacheKey.getKey());
        redisTemplate.delete(redisCacheKey.getKey());
    }

    @Override
    public void clear() {
        // 必须开启了使用缓存名称作为前缀，clear才有效
        if (usePrefix) {
            log.info("清空redis缓存 ，缓存前缀为{}", getName());
            Set<String> keys = redisTemplate.keys(getName() + "*");
            if (!CollectionUtils.isEmpty(keys)) {
                redisTemplate.delete(keys);
            }
        }
    }
}

3.分析redis缓存下，下面方法的实现原理

      public <T> T get(Object key, Callable<T> valueLoader)

     3.1) 根据key值获取缓存key的方法，通过缓存key的生成类

package org.github.roger.utils;

import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;

import java.util.Arrays;

public class RedisCacheKey {

    /**
     * 前缀序列化器
     */
    private final RedisSerializer prefixSerializer1 = new StringRedisSerializer();

    /**
     * 缓存key
     */
    private final Object keyElement;

    /**
     * 缓存名称
     */
    private String cacheName;

    /**
     * 是否使用缓存前缀
     */
    private boolean usePrefix = true;

    /**
     * RedisTemplate 的key序列化器
     */
    private final RedisSerializer serializer;

    /**
     * @param keyElement 缓存key
     * @param serializer RedisSerializer
     */
    public RedisCacheKey(Object keyElement, RedisSerializer serializer) {

        Assert.notNull(keyElement, "缓存key不能为NULL");
        Assert.notNull(serializer, "key的序列化器不能为NULL");
        this.keyElement = keyElement;
        this.serializer = serializer;
    }

    /**
     * 获取缓存key
     *
     * @return String
     */
    public String getKey() {

        return new String(getKeyBytes());
    }

    /**
     * 获取key的byte数组
     *
     * @return byte[]
     */
    public byte[] getKeyBytes() {

        byte[] rawKey = serializeKeyElement();
        if (!usePrefix) {
            return rawKey;
        }
        byte[] prefix = getPrefix();

        byte[] prefixedKey = Arrays.copyOf(prefix, prefix.length + rawKey.length);
        System.arraycopy(rawKey, 0, prefixedKey, prefix.length, rawKey.length);

        return prefixedKey;
    }

    private byte[] serializeKeyElement() {

        if (serializer == null && keyElement instanceof byte[]) {
            return (byte[]) keyElement;
        }

        return serializer.serialize(keyElement);
    }

    /**
     * 获取缓存前缀，默认缓存前缀是":"
     *
     * @return byte[]
     */
    public byte[] getPrefix() {
        return prefixSerializer1.serialize((StringUtils.isEmpty(cacheName) ? cacheName.concat(":") : cacheName.concat(":")));
    }

    /**
     * 设置缓存名称
     *
     * @param cacheName cacheName
     * @return RedisCacheKey
     */
    public RedisCacheKey cacheName(String cacheName) {
        this.cacheName = cacheName;
        return this;
    }

    /**
     * 设置是否使用缓存前缀，默认使用
     *
     * @param usePrefix usePrefix
     * @return RedisCacheKey
     */
    public RedisCacheKey usePrefix(boolean usePrefix) {
        this.usePrefix = usePrefix;
        return this;
    }

}

  3.2) 通过缓存对象 和 缓存 key 获取缓存的值

     3.2.1) 如果得到缓存对象的值 不为null 或者 缓存对象中包含 缓存key，则刷新缓存key的超时时间，即执行

              org.github.roger.cache.redis.RedisCache#refreshCache 方法

     3.2.2) 如果缓存对象中没有缓存key，则执行

        org.github.roger.cache.redis.RedisCache#executeCacheMethod 方法

Roger6650
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
云原生｜Java二级高速缓存架构设计
元年技术
01-13 882
在元年商旅业务中存在各种各样的配置信息,包括: 基础数据(城市、火车站、机场等)、全局配置(数据字典、I18N信息)、租户配置(预定、对接、服务费、供应商等),这些数据部分属于静态数据、部分属于热点数据，根据业务要求每种数据的过期时间、缓存淘汰策略都略有不同。二级缓存是支持商旅SAAS系统高并发的利器之一，有效的提升了商旅SAAS系统的性能和并发量。
Mybatis集成ehcache+redis
weixin_43710113的博客
09-25 605
Mybatis集成ehcache 为什么需要缓存 拉高程序的性能 什么样的数据需要缓存 很少被修改或根本不改的数据 业务场景比如：耗时较高的统计分析sql、电话账单查询sql等 ehcache是什么 Ehcache 是现在最流行的纯Java开源缓存框架，配置简单、结构清晰、功能强大 注1：本章介绍的是2.X版本，3.x的版本和2.x的版本API差异比较大 ehcache的特点 4....
Redis多级缓存搭建（结合案例学习）
qq_43456605的博客
04-13 754
Redis多级缓存、Canal、Nginx
1.L2Cache 分布式二级缓存框架
白云
04-19 1085
L2Cache 是一个基于内存Redis实现的满足高并发场景下的分布式二级缓存框架。
Redis之二级缓存（基于Maven Web项目java实现）
最新发布
2302_78041486的博客
05-06 2148
Cacheable配置在方法或类上，作用：本方法执行后，先去缓存看有没有数据，如果没有，从数据库中查找出来，给缓存中存一份，返回结果，本次方法执行，在缓存未过期情况下，先在缓存中查找，有的话直接返回，没有的话从数据库查找。文中第一步，不需要配置，需要在spring.xml文件中配置多配置文件.properties文件引入方式： 代码在1.4.1中。@CachePut类似于更新操作，即每次不管缓存中有没有结果，都从数据库查找结果，并将结果更新到缓存，并返回结果。2.1、解注1.4中5、6、7步的代码。
CaffeineCache+Redis 接入系统做二层缓存，SPI 思路实现（借鉴 mybatis 二级缓存、自动装配源码）
风团团
06-20 3741
现在手上有个系统写操作比较少，很多接口都是读操作，也就是写多读少，性能上遇到瓶颈了，正所谓前人栽树、后人乘凉，原先系统每次都是查数据库的，性能比较低，如果先查 redis，redis 没数据再查数据库的话，但是还可以更快，那就是使用内存查询，依次按照内存、redis、db的顺序从快到慢查询，可使系统整体的性能提升一个档次，但是仅限于读多写少的场景，写多读少的场景没必要搞这么多缓存，搞多了缓存一致性也是个问题，就好比 mysql 数据库的读多写少，我们可以用 MYISM 存储引擎。
redis多级缓存搭建资料
05-31
本资料将详细介绍如何使用Redis搭建多级缓存。 一、缓存基础知识 缓存是一种存储技术，用于临时存储经常访问的数据，以减少对慢速存储（如硬盘）的依赖。在Web应用中，缓存可以显著提升响应速度，降低延迟。多级...
Redis高级使用-缓存架构、缓存穿透、缓存雪崩
12-26
在Redis中，缓存架构可以分为多级缓存，包括Redis自身的缓存、内存缓存、磁盘缓存等。 缓存穿透是指客户端向缓存系统请求数据，但是缓存系统中没有该数据，于是缓存系统向后端系统请求数据，这样会对后端系统造成...
J2Cache 基于内存和 Redis 的两级 Java 缓存框架
04-20
第一级缓存使用内存(同时支持 Ehcache 2.x、Ehcache 3.x 和 Caffeine)，第二级缓存使用 Redis(推荐)/Memcached 。 由于大量的缓存读取会导致 L2 的网络成为整个系统的瓶颈，因此 L1 的目标是降低对 L2 的读取次数。 ...
spring boot+spring cache实现两级缓存(redis+caffeine)
08-27
在Spring Boot+Spring Cache实现两级缓存（Redis+Caffeine）中，Redis作为远程缓存，Caffeine作为应用内缓存。当应用内缓存有符合条件的数据时，就可以直接使用，而不用通过网络到Redis中去获取，这样就形成了两级...
spring-ehcache-redis两级缓存
11-13
（见下图，为了减少get这几条网络传输，我们会在每个应用服务器上增加本地的ehcache缓存作为二级缓存，即第一次get到的数据存入ehcache，后面output输出即可从本地ehcache中获取，不用再访问redis了，所以就减少了...
Redis用作二级缓存
06-04
这个主要是用作在Mybatis中的Mapping文件中的二级缓存
Caffeine 和 Redis 整合二级缓存
weixin_49648855的博客
10-08 271
/ 在缓存中实际执行查找的操作，父类的get()方法会调用这个方法// 通过key获取缓存值，如果没有找到，会调用valueLoader的call()方法// 将数据放入缓存中// 删除缓存// 清空缓存中所有数据// 获取缓存名称，一般在CacheManager创建时指定// 获取实际使用的缓存。
Springboot + Mybatis-Plus开启二级缓存
ZwLemon
07-26 1475
详细说明 Mybatis 的一级缓存和二级缓存的区别，并且使用实例讲述 springboot + mybatis-plus 开启二级缓存的用法；
二级缓存之王：Redis+Caffeine深度实践
Reische的博客
10-12 641
核心是get方法与put方法。/** * 默认key超时时间 3600s */ private long defaultExpiration = 3600;if (value!} //key在redis和缓存中均不存在 ReentrantLock lock = keyLockMap.get(key.toString());if (value!
3.L2Cache 核心原理解析
白云
07-27 1602
L2Cache 核心原理解析。
二级缓存（Spring Boot）
qq_41296669的博客
12-22 2590
开启缓存：@EnableCaching
4.L2cache 关于缓存的几个常见问题分析和处理方案
白云
06-09 4933
l2cache 分布式二级缓存组件 Gitee 源码地址 l2cache 是一个基于 Caffeine、 Redis 、 Spring Cache 实现的满足高并发场景下的分布式二级缓存解决方案。 Caffeine ：一级缓存 L1，也就是内存缓存，而内存天然支撑高并发的。 Redis ： 二级缓存 L2，也就是集中式缓存。 注意： 1、由于大量的缓存读取会导致 L2 的网络成为整个系统的瓶颈，因此 L1 的目标是降低对 L2 的读取次数。 2、L2 可以避免应用重启后导致的 L1 数据丢失的问题
十二、Redis——多级缓存
djdjdxieuej的博客
04-26 698
目录1. 传统缓存策略2. 多级缓存方案 3. JVM进程缓存3.1 初识Caffeine4. 实现进程缓存4.1 安装OpenResty4.2.Redis缓存预热4.3.缓存同步4.3.1 缓存数据同步策略4.3.2 Canal介绍 4.3.3 监听Canal总结： 存在下面的问题：•请求要经过Tomcat处理，Tomcat的性能成为整个系统的瓶颈•Redis缓存失效时，会对数据库产生冲击多级缓存就是充分利用请求处理的每个环节，分别添加缓存，减轻Tomcat压力，提升服务性能：在多级缓存架构中，Nginx
实现多级缓存架构设计方案.docx
05-17
实现多级缓存架构设计方案主要针对电商行业中的大规模应用需求，尤其针对有赞PaaS团队服务下的复杂营销活动场景。TMC（透明多级缓存）是为了解决由于商家频繁进行商品促销活动导致的缓存热点访问问题。这些问题包括...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值