重封装Ehcache与Redis模板以便于一二级缓存同步数据(二)

已于 2023-07-14 14:24:42 修改
阅读量713 收藏 1
点赞数
分类专栏： Redis跨系统消息发布订阅(一) 文章标签： redis spring java
于 2023-07-14 14:19:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014635374/article/details/131722351
版权

参考: 一级缓存二级缓存的获取与更新顺序（一) 

                                   简单封装Ehcache与RedisTemplate模版                                       

                 

                   通常使用一二级缓存时,必须保持一二级缓存数据数据与数据库中数据保持一致 ；此时可以简单封装下,一二级缓存的相关接口,便于我们同步数据操作；

                                                           Ehcache封装

package org.jd.auth.data.security.server.base;

import lombok.extern.slf4j.Slf4j;
import org.ehcache.Cache;
import org.ehcache.CacheManager;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;

import javax.annotation.Resource;
import java.util.Map;


/**
 * ehcache缓存服务组件：
 * 这样重写Ehcache缓存组件的目的在于使用一级缓存和二级缓存时,便于及时同步一二级缓存的数据
 * @Author: yh19166
 */
@Slf4j
@Component
public class SSOEhcacheService {

    @Resource
    @Qualifier("ehCacheManager")
    private CacheManager cacheManager;

    /**
     * @param cacheName 为ehcache.xml文件中配置缓存的名称
     * @return
     */
    public Cache<String, Object> getCache(String cacheName) {
        Cache cache = this.cacheManager.getCache(cacheName, String.class, Object.class);
        if (ObjectUtils.isEmpty(cache)) { // 避免了Optional对象为Optional.empty()空对象;ObjectUtils.isEmpty(方法源代码已经作了判断)
            log.error("SSOEhcacheService.getCache.cacheName[{}] is not exit", cacheName);
        }
        return cache;
    }

    /**
     * 根据cacheKey获取对应的值
     *
     * @param cacheName 配置文件中配置缓存的名称
     * @param cacheKey  缓存Key
     * @return {@link Object}
     */
    public Object get(String cacheName, String cacheKey) {
        Cache<String, Object> cache = getCache(cacheName);
        if (ObjectUtils.isEmpty(cache)) {
            log.error("SSOEhcacheService.do.get method,[{}] is not exit", cacheName);
            return null;
        }
        return cache.get(cacheKey);
    }

    /**
     * @param cacheName 配置文件中配置缓存的名称
     * @param cacheKey  缓存key
     * @param value     缓存值
     */
    public void put(String cacheName, String cacheKey, Object value) {
        Cache<String, Object> cache = getCache(cacheName);
        if (ObjectUtils.isEmpty(cache)) {
            log.error("SSOEhcacheService.do.put method,[{}] is not exit", cacheName);
            return;
        }
        cache.put(cacheKey, value);
    }

    /**
     * @param cacheName 配置文件中配置缓存的名称
     * @param value     缓存值
     */
    public void putAll(String cacheName, Map<String, Object> value) {
        Cache<String, Object> cache = getCache(cacheName);
        if (ObjectUtils.isEmpty(cache)) {
            log.error("SSOEhcacheService.do.putAll method,[{}] is not exit", cacheName);
            return;
        }
        cache.putAll(value);
    }

    /**
     * 判断缓存key是否存在
     *
     * @param cacheName 配置文件中配置缓存的名称
     * @param key       缓存key
     * @return {@link Boolean}
     */
    public boolean exist(String cacheName, String key) {
        Cache<String, Object> cache = getCache(cacheName);
        if (ObjectUtils.isEmpty(cache)) {
            log.error("SSOEhcacheService.do.exist method,[{}] is not exit", cacheName);
            return false;
        }
        return cache.containsKey(key);

    }

    /**
     * 删除指定key的缓存
     *
     * @param cacheName 配置文件中配置缓存的名称
     * @param key       缓存key
     */
    public void evict(String cacheName, String key) {
        Cache<String, Object> cache = getCache(cacheName);
        if (ObjectUtils.isEmpty(cache)) {
            log.error("SSOEhcacheService.do.evict method,[{}] is not exit", cacheName);
            return;
        }
        cache.remove(key);
    }
}

                                               RedisTemplate模版简单封装

package org.jd.auth.data.security.server.base;

import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.io.Serializable;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * Redis通常作为二级缓存
 * Redis缓存对: spring-boot-starter-data-redis的模版(RedisTemplate)的进一步封装:
 * @Author: yh19166
 */
@Slf4j
@Component
public class SSORedisService {
    @Resource
    private RedisTemplate<Serializable, Object> redisTemplate;

    /**
     * 批量删除对应的value
     *
     * @param keys
     */
    public void remove(String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 正则批量删除key 例：h?llo matches hello, hallo
     *
     * @param pattern
     */
    public void removePattern(String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (!keys.isEmpty()) {
            redisTemplate.delete(keys);
        }
    }

    /**
     * 正则获取多个缓存key 例：h?llo matches hello, hallo
     *
     * @param pattern
     */
    public Set<Serializable> patternKeys(String pattern) {
        return redisTemplate.keys(pattern);
    }

    /**
     * 正则key获取多个缓存
     *
     * @param pattern
     * @return 返回Set >-String 集合
     */
    public Set<String> patternKeysIsStr(String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        Set<String> dataSet = new HashSet<>();
        for (Serializable obj : keys) {
            dataSet.add(obj.toString());
        }
        return dataSet;
    }

    /**
     * 删除对应的value
     *
     * @param key
     */
    public void remove(String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 判断缓存中是否有对应的value
     *
     * @param key
     * @return
     */
    public boolean exists(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 设置key的过期时间 单位(秒)
     *
     * @param key
     * @param expireTime
     * @return boolean
     */
    public boolean setKeyExpire(String key, Long expireTime) {
        return redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
    }

    /**
     * 读取缓存
     *
     * @param key
     * @return
     */
    public Object getObject(String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean setObject(String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            log.warn("setObject 返回异常 " + e.getMessage());
        }
        return result;
    }

    /**
     * 写入缓存设置并设置时间 时间单位(秒)
     *
     * @param key
     * @param value
     * @return
     */
    public boolean setObjectAndExpire(String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            log.warn("setObjectAndExpire 返回异常 " + e.getMessage());
        }
        return result;
    }

    /**
     * 缓存List数据 右侧入栈
     *
     * @param key      缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public boolean setList(String key, List<Object> dataList) {
        boolean result = false;
        try {
            ListOperations<Serializable, Object> listOperation = redisTemplate.opsForList();
            if (null != dataList) {
                int size = dataList.size();
                for (int i = 0; i < size; i++) {
                    listOperation.rightPush(key, dataList.get(i));
                }
            }
            result = true;
        } catch (Exception e) {
            log.warn("setList 返回异常 " + e.getMessage());
        }
        return result;
    }

    /**
     * 缓存List数据 右侧入栈 并设置过期时间 单位（秒）
     *
     * @param key      缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public boolean setListAndExpire(String key, List<Object> dataList, Long expireTime) {
        boolean result = false;
        try {
            ListOperations<Serializable, Object> listOperation = redisTemplate.opsForList();
            if (null != dataList) {
                int size = dataList.size();
                for (int i = 0; i < size; i++) {
                    listOperation.rightPush(key, dataList.get(i));
                }
            }
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);

            result = true;
        } catch (Exception e) {
            log.warn("setListAndExpire 返回异常 " + e.getMessage());
        }
        return result;
    }

    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public List<Object> getList(String key) {
        ListOperations<Serializable, Object> listOperation = redisTemplate.opsForList();
        return listOperation.range(key, 0, -1);
    }

    /**
     * 获得缓存的list对象 出栈的方式获取数据 左侧出栈
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public List<Object> getListPop(String key) {
        List<Object> dataList = new ArrayList<>();
        ListOperations<Serializable, Object> listOperation = redisTemplate.opsForList();
        Long size = listOperation.size(key);
        for (int i = 0; i < size; i++) {
            dataList.add(listOperation.leftPop(key));
        }
        return dataList;
    }

    /**
     * 缓存Set
     *
     * @param key     缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public boolean setSet(String key, Set<Object> dataSet) {
        boolean result = false;
        try {
            BoundSetOperations<Serializable, Object> setOperation = redisTemplate.boundSetOps(key);
            Iterator<Object> it = dataSet.iterator();
            while (it.hasNext()) {
                setOperation.add(it.next());
            }
            result = true;
        } catch (Exception e) {
            log.warn("setSet 返回异常 " + e.getMessage());
        }
        return result;
    }

    /**
     * 缓存Set并设置失效时间 单位（秒）
     *
     * @param key     缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public boolean setSetAndExpire(String key, Set<Object> dataSet, Long expireTime) {
        boolean result = false;
        try {
            BoundSetOperations<Serializable, Object> setOperation = redisTemplate.boundSetOps(key);
            Iterator<Object> it = dataSet.iterator();
            while (it.hasNext()) {
                setOperation.add(it.next());
            }
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            log.warn("setSetAndExpire 返回异常 " + e.getMessage());
        }
        return result;
    }

    /**
     * 获得缓存的set
     *
     * @param key
     * @param
     * @return
     */
    public Set<Object> getSet(String key) {
        BoundSetOperations<Serializable, Object> operation = redisTemplate.boundSetOps(key);
        return operation.members();
    }

    /**
     * 获得缓存的set 已出栈方式获取
     *
     * @param key
     * @param
     * @return
     */
    public Set<Object> getSetPop(String key) {
        Set<Object> dataSet = new HashSet<>();
        BoundSetOperations<Serializable, Object> operation = redisTemplate.boundSetOps(key);
        Long size = operation.size();
        for (int i = 0; i < size; i++) {
            dataSet.add(operation.pop());
        }
        return dataSet;
    }

    /**
     * 缓存Hash（字典，哈希表）
     *
     * @param key
     * @param dataMap
     * @return
     */
    public boolean setMap(String key, Map<String, Object> dataMap) {
        boolean result = false;
        try {
            HashOperations<Serializable, Object, Object> hashOperations = redisTemplate.opsForHash();
            if (null != dataMap) {

                for (Map.Entry<String, Object> entry : dataMap.entrySet()) {

                    hashOperations.put(key, entry.getKey(), entry.getValue());
                }

            }
            result = true;
        } catch (Exception e) {
            log.warn("setMap 返回异常 " + e.getMessage());
        }
        return result;
    }

    /**
     * 缓存Hash（字典，哈希表）并设置过期时间 单位（秒）
     *
     * @param key
     * @param dataMap
     * @return
     */
    public boolean setMapAndExpire(String key, Map<String, Object> dataMap, Long expireTime) {
        boolean result = false;
        try {
            HashOperations<Serializable, Object, Object> hashOperations = redisTemplate.opsForHash();
            if (null != dataMap) {

                for (Map.Entry<String, Object> entry : dataMap.entrySet()) {

                    hashOperations.put(key, entry.getKey(), entry.getValue());
                }

            }
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            log.warn("setMapAndExpire 返回异常 " + e.getMessage());
        }
        return result;
    }

    /**
     * 缓存Hash（字典，哈希表）并设置过期时间 单位（秒） 值类型为 Map<String, String>
     *
     * @param key
     * @param dataMap
     * @return
     */
    public boolean setStrMapAndExpire(String key, Map<String, String> dataMap, Long expireTime) {
        boolean result = false;
        try {
            HashOperations<Serializable, Object, Object> hashOperations = redisTemplate.opsForHash();
            if (null != dataMap) {

                for (Map.Entry<String, String> entry : dataMap.entrySet()) {

                    hashOperations.put(key, entry.getKey(), entry.getValue());
                }

            }
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            log.warn("setMapAndExpire 返回异常 " + e.getMessage());
        }
        return result;
    }

    /**
     * 获得缓存的Hash（字典，哈希表）
     *
     * @param key
     * @param
     * @return
     */
    public Map<String, Object> getMap(String key) {
        HashOperations<Serializable, String, Object> hashOperations = redisTemplate.opsForHash();

        return hashOperations.entries(key);
    }

    /**
     * 根据key和hashKey获得缓存Hash中的值
     *
     * @param key
     * @param
     * @return String
     */
    public String getMapByHashKey(String key, String hashKey) {
        HashOperations<Serializable, String, Object> hashOperations = redisTemplate.opsForHash();
        return (String) hashOperations.get(key, hashKey);
    }

    /**
     * 缓存有序Set 默认score为添加的顺序
     *
     * @param key     缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public boolean setZSet(String key, Set<Object> dataSet) {
        boolean result = false;
        try {
            BoundZSetOperations<Serializable, Object> setOperation = redisTemplate.boundZSetOps(key);
            int size = dataSet.size();
            Iterator<Object> it = dataSet.iterator();
            while (it.hasNext()) {
                setOperation.add(it.next(), --size);
            }
            result = true;
        } catch (Exception e) {
            log.warn("setZSet 返回异常 " + e.getMessage());
        }
        return result;
    }

    /**
     * 缓存有序Set 并添加失效时间单位（秒） 默认score为添加的顺序
     *
     * @param key     缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public boolean setZSetAndExpire(String key, Set<Object> dataSet, Long expireTime) {
        boolean result = false;
        try {
            BoundZSetOperations<Serializable, Object> setOperation = redisTemplate.boundZSetOps(key);
            int size = dataSet.size();
            Iterator<Object> it = dataSet.iterator();
            while (it.hasNext()) {
                if (size > 0) {
                    setOperation.add(it.next(), size--);
                }
            }
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            log.warn("setZSetAndExpire 返回异常 " + e.getMessage());
        }
        return result;
    }

    /**
     * 缓存有序Set
     *
     * @param key
     * @return 缓存数据的对象
     */
    public Set<Object> getZSetRange(String key) {
        BoundZSetOperations<Serializable, Object> operation = redisTemplate.boundZSetOps(key);
        return operation.range(0, -1);

    }

    /**
     * 根据key 返回该key的存活时间 单位（秒）
     *
     * @param key 缓存键值
     * @return key 的存活时间 单位（秒）
     */
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 根据key 设置时间 单位（秒）
     *
     * @param key 缓存键值
     * @return boolean
     */
    public Boolean setUpExpire(String key, Long expireTime) {
        return redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
    }

    /**
     * 清空redis 所有数据
     *
     * @return 成功返回 ok
     */
    public String flushDb() {
        return (String) redisTemplate.execute(new RedisCallback<Object>() {
            @Override
            public String doInRedis(RedisConnection connection) {
                connection.flushDb();
                return "ok";
            }
        });
    }

    /**
     * @return 查看redis里有多少数据
     */
    public long dbSize() {
        return (long) redisTemplate.execute(new RedisCallback<Object>() {
            @Override
            public Long doInRedis(RedisConnection connection) {
                return connection.dbSize();
            }
        });
    }

    /**
     * 检查是否连接成功
     *
     * @return 成功则返回 PONG 失败什么都不会留下
     */
    public String ping() {
        return (String) redisTemplate.execute(new RedisCallback<Object>() {
            @Override
            public String doInRedis(RedisConnection connection) {
                return connection.ping();
            }
        });
    }

    /**
     * 生成自增长
     * @param key
     * @return {@link Long}
     */
    public Long createAutoNo(String key) {
        return redisTemplate.opsForValue().increment(key, 1);
    }
}

蜗牛杨哥
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot + shiro 配置 ehcache 缓存
快乐的小三菊的博客
05-26 2247
账号登录，第一次访问，查看控制台，有日志输出，如下所示，下面只截取了一部分的日志输出，再次访问将不再打印输出，证明缓存生效了。1、用两个浏览器分别用不同的用户登录到系统中，然后刷新界面，我们发现，无论怎么刷新，都不用有日志输出，因为此时查询的时缓存。方法，然后再刷新界面，我们发现此时后台有日志输出，即查询的数据是数据库里面的数据。方法，然后再刷新界面，我们发现此时后台有日志输出，即查询的数据是数据库里面的数据。中添加如下方法用于清除缓存，在添加或者删除权限的时候，都需要清除缓存。，并将缓存管理器添加到。
spring + ehcache + redis两级缓存
07-19
spring + ehcache + redis两级缓存
Redis用作二级缓存
06-04
这个主要是用作在Mybatis中的Mapping文件中的二级缓存
Mybatis整合Redis实现二级缓存
qq_44493832的博客
09-25 180
文章目录前言1、mybatis整合ehcache作为缓存 前言 为什么需要缓存 拉高程序的性能 什么样的数据需要缓存 很少被修改或根本不改的数据 业务场景比如：耗时较高的统计分析sql、电话账单查询sql等 ehcache是什么 Ehcache 是现在最流行的纯Java开源缓存框架，配置简单、结构清晰、功能强大 注1：本章介绍的是2.X版本，3.x的版本和2.x的版本API差异比较大 ...
sprintboot Redis配置详解
u010125432的博客
10-21 807
# REDIS (RedisProperties) # Redis数据库索引（默认为0） spring.redis.database=0 # Redis服务器地址 spring.redis.host=localhost # Redis服务器连接端口 spring.redis.port=6379 # Redis服务器连接密码（默认为空） spring.redis.password= # 连接池最大连接数（使用负值表示没有限制） spring.redis.pool.max-active=8 # 连接池最大阻塞等
spring boot+spring cache实现两级缓存(redis+caffeine)
08-27
两级缓存是指应用内缓存（一级缓存）和远程缓存（二级缓存）的组合。应用内缓存是指在应用程序内部的缓存，如Caffeine；远程缓存是指在远程服务器上的缓存，如Redis。两级缓存可以大幅度提高应用程序的处理效率。 ...
对Hibernate框架的二次封装，简化对数据库的操作
最新发布
02-02
5. 配置缓存：配置Hibernate的二级缓存，例如使用Ehcache或Redis，提升性能。 6. 查询优化：创建一个QueryHelper类，提供基于HQL或Criteria的动态查询功能。 五、实战示例 以`User`实体为例，我们可以定义`...
spring-mvc-gradle：记录，缓存，验证，Redis ..
02-12
Redis是一个开源的、内存中的数据结构存储系统，可以作为数据库、缓存和消息代理。在这个项目中，Redis可能被用作缓存服务器，存储和检索数据，以加速应用程序的响应速度。 6. **线程服务（Thread Service）和...
AdminLTE-admin 轻量级权限管理框架.rar
07-04
使用redis、Ehcache实现权限缓存。 使用thymeleaf模板,实现页面拆分,封装公共部分。 整合本地存储、七牛云实现文件oss存储。 前端项目地址：https://gitee.com/liyucc/adminlte-tab 在线体验 演示地址：...
《项目可用》CacheUtil缓存工具类.rar
07-15
在Java中，缓存可以是内存中的数据结构，如HashMap，也可以是专门的缓存库，如 Ehcache、Guava Cache 或 Redis。 2. **CacheUtil 类**：这个工具类很可能是为了简化缓存操作而设计的，它封装了缓存的增删改查等基本...
spring-ehcache-redis两级缓存
11-13
两级缓存在redis的方案上做一步优化，在缓存到远程redis的同时，缓存一份到本地进程ehcache（此处的ehcache不用做集群，避免组播带来的开销），取缓存的时候会先取本地，没有会向redis请求，这样会减少应用服务器<–>缓存服务器redis之间的网络开销。（见下图，为了减少get这几条网络传输，我们会在每个应用服务器上增加本地的ehcache缓存作为二级缓存，即第一次get到的数据存入ehcache，后面output输出即可从本地ehcache中获取，不用再访问redis了，所以就减少了以后get的网络开销。get开销只要一次，后续不需要了，除非本地缓存过期需要再get。）
Ehcache工具类
01-07
本工具类包括初始化cache 修改缓存容器配置 向指定容器中设置值 取值 删除指定的ehcache容器 删除所有容器 删除容器内所有元素 释放CacheManage 获取所有的cache名称
【SpringBoot】 集成 Ehcache
Java_Wxlin的博客
02-10 1847
EhCache 是一个纯 Java 的进程内缓存框架，具有快速、精干等特点， 是 Hibernate 中默认CacheProvider。Ehcache 是一种广泛使用的开源 Java 分布式缓存。
Ehcache封装的工具类
qq_43747119的博客
02-18 473
Ehcache封装的工具类
Spring boot start中封装Ehcache作为缓存的实践
无心小店
03-31 250
怎么封装starter不属于该篇讨论范围。本篇主要说明一下在集成ehcache中遇到的一些问题。 一、ehcache在spring boot中有两个大版本，2.x和3.x，本篇讲2.x的集成。 二、ehcache 2.x(下称eh)在一般的项目集成中都会讲到，配置spring.cache.type=ehcache,spring.cache.config=classpath:ehcache.xml这两个配置，并写一个关于配置的文件。 但是在starter中，本人并未找到如何向spring中写配置。所以就
一级缓存（默认开始sqlsession级别）和 二级缓存(testTwoCache)
19.2.04.157N的博客
09-29 499
一级缓存（默认开始sqlsession级别）和 二级缓存(testTwoCache)
看着文档学ehcache
zhengholien的java净土
08-13 9982
简介：纯java实现的缓存组件（jar包），最主要的作用还是做应用内缓存（进程内），比如hibernate就默认使用ehcache做缓存。我们可以创建多个缓存（cache），缓存中以key-value的形式存储数据，数据结构较为单一。 存储位置： heap：由GC管理的JVM堆 offheap：堆外内存（非JVM的堆） disk：持久化到硬盘，cache.destroy()方法可以
Ehcache（09）——缓存Web页面
Elim的博客
09-25 201
页面缓存 目录 1       SimplePageCachingFilter 1.1      calculateKey 1.2      可配置的初始化参数 1.2.1     cacheName 1.2.2     blockingTimeoutMillis 2       SimpleCachingHeadersPageCachingFilter 3       Sim...
如何用go语言与redis、mysql交互并写一个简单的二级缓存
weixin_42694428的博客
09-25 5056
go语言简介 首先go语言作为一门新语言，2007年开始研发，2009年11月开源，2012年初发布Go1稳定版本，截止目前还是在1.0时代，那么，这么一个“新生代语言”相比于活跃在各大公司之前的前辈，如：C，Java,python等具有哪些优势呢？ go语言的最大的优势在于高并发，go程，协程，一台pc机，即可完成百万级别的并发 go语言有自动垃圾回收机制，而且是一门底层语言 redis简介 r...
分布式缓存.docx
06-26
10. redis和ehcache的二级缓存：可以将ehcache作为一级缓存，redis作为二级缓存，当ehcache缓存失效时，可以从redis中获取数据。 11. redis雪崩效应：当redis集群中的多个节点同时出现故障或宕机时，可能会出现大量...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值