redis数据结构缓存运用
- - 企业架构 - ITeye博客之前redis已经描述了redis 的基本作用与用处， 这一篇主要讲述redis运用场景以及分片,和spring整合. redis 存储数据结构大致5种，String 普通键值对，用的比较多. HASH针对 key 唯一标识 hashmap 键值对运用也比较多 list set 当然是集合运用 sortedSet 排序集合使用.
redis数据结构缓存运用
标签：
redis
数据结构
缓存
| 发表时间：2016-09-02 15:48 | 作者：代码家的乐趣
出处：http://www.iteye.com
之前redis已经描述了redis 的基本作用与用处， 这一篇主要讲述redis运用场景以及分片,和spring整合。redis 存储数据结构大致5种，String 普通键值对，用的比较多。HASH针对 key 唯一标识 hashmap 键值对运用也比较多 list set 当然是集合运用 sortedSet 排序集合使用。
首先看redis 和spring 配置整合
可能开发中redis 服务器一般不止一台 在list 下注入就行。
相信很多时候我们在写代码的时候数据结构运用的恰当能够，帮我审很多事，并且解决很多问题,redis 也一样。自己封装了一下常用的redis 使用工具类
这里主要是针对String类型 封装的方法 ，其他类型基本大致一直。可以对照着网站去理解,
这里的json输出， 序列化 是用的阿里巴巴fastjson,也可以Google gson, protobuf 在序列化方面是比较快的。找时间试一试。
http://redisdoc.com/index.html
已有 0 人发表留言，猛击->> 这里<<-参与讨论
ITeye推荐
首先看redis 和spring 配置整合
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">
<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="order" value="2" />
<property name="ignoreUnresolvablePlaceholders" value="true" />
<property name="locations">
<list>
<value>classpath:demo-provider-module.properties</value>
</list>
</property>
</bean>
<!-- redis连接池的配置 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxTotal" value="2048" />
<property name="maxIdle" value="200" />
<property name="numTestsPerEvictionRun" value="1024"/>
<property name="timeBetweenEvictionRunsMillis" value="30000" />
<property name="minEvictableIdleTimeMillis" value="-1" />
<property name="softMinEvictableIdleTimeMillis" value="10000" />
<property name="maxWaitMillis" value="1500"/>
<property name="testOnBorrow" value="true" />
<property name="testWhileIdle" value="true"/>
<property name="testOnReturn" value="false"/>
<property name="jmxEnabled" value="true"/>
<property name="jmxNamePrefix" value="youyuan"/>
<property name="blockWhenExhausted" value="false"/>
</bean>
<!-- redis的连接池pool，不是必选项：timeout/password -->
<bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">
<constructor-arg index="0" ref="jedisPoolConfig"/>
<constructor-arg index="1">
<list>
<bean name="master" class="redis.clients.jedis.JedisShardInfo">
<constructor-arg index="0" value="${redis1.server.host}"/>
<constructor-arg index="1" value="${redis1.server.port}" type="int"/><!-- 指定参数类型否则可能回报错 -->
<constructor-arg index="2" value="${redis1.server.timeout}" type="int"/>
</bean>
</list>
</constructor-arg>
</bean>
</beans>
可能开发中redis 服务器一般不止一台 在list 下注入就行。
相信很多时候我们在写代码的时候数据结构运用的恰当能够，帮我审很多事，并且解决很多问题,redis 也一样。自己封装了一下常用的redis 使用工具类
package demo.dcn.cache; import java.util.ArrayList; import java.util.List; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; import com.alibaba.fastjson.TypeReference; import com.google.protobuf.Internal.ProtobufList; /** * Redis序列化及反序列化工具类 * @author [email protected] */ public class JedisUtil { /** * 把对象转换成json 文本 * @param object * @return */ public static String toJson(Object object){ return JSON.toJSONString(object); } /** * 单独的T 代表一个类型 而 Class<T>代表这个类型所对应的类 * 把JSON文本parse为JavaBean * @param json * @param clazz * @return */ public static <T> T toObject(String json,Class<T> clazz){ return JSON.parseObject(json, clazz); } /** * 泛型解析方法 * * @param json * @param typeReference * @return */ public static <T> T toObject(String json,TypeReference<T> typeReference){ return JSON.parseObject(json, typeReference); } /** * 把json 文本转换成对象集合形式 * @param json * @param T * @return */ public static <T> List<T> parseArray(String json,Class<T> T){ return JSON.parseArray(json, T); } /** * 解析数组json 转换成对象集合方式 * @param jsons * @param clazz * @return */ public static <T> List<T> toObjects(List<String> jsons, Class<T> clazz){ List<T> list = new ArrayList<T>(); for (String json : jsons) { T obj = toObject(json, clazz); if(null != obj) { list.add(obj); } } return list; } /** * 把把JSON文本parse为JSONObject javamap或者JSONArray Javalist * @param json * @return */ public static Object parseObject(String json){ return JSON.parse(json); } /** * 把JSON文本parse成JSONObject * @param json * @return */ public static JSONObject parJsonObject(String json){ return JSONObject.parseObject(json); } /** * 把JSON文本parse成JSONArray * @param text * @return */ public static final JSONArray parseArray(String text){ return JSONArray.parseArray(text); } /** * 将JavaBean序列化为带格式的JSON文本 * @param object * @param prettyFormat * @return */ public static final String toJSONString(Object object, boolean prettyFormat){ return JSON.toJSONString(object, prettyFormat); } /** * 将JavaBean转换为JSONObject或者JSONArray * @param javaObject * @return */ public static final Object toJSON(Object javaObject){ return JSON.toJSON(javaObject); } }
package demo.dcn.cache; import redis.clients.jedis.ShardedJedis; /** * 自定义分片jedis * @author [email protected] */ public class SelfShardedJedis { private ShardedJedis shardedJedis;//分片 private Boolean isReturn;//是否归还连接池 public SelfShardedJedis(ShardedJedis shardedJedis, Boolean isReturn) { super(); this.shardedJedis = shardedJedis; this.isReturn = isReturn; } public SelfShardedJedis() { super(); } /** * @return the shardedJedis */ public ShardedJedis getShardedJedis() { return shardedJedis; } /** * @param shardedJedis the shardedJedis to set */ public void setShardedJedis(ShardedJedis shardedJedis) { this.shardedJedis = shardedJedis; } /** * @return the isReturn */ public Boolean getIsReturn() { return isReturn; } /** * @param isReturn the isReturn to set */ public void setIsReturn(Boolean isReturn) { this.isReturn = isReturn; } }
package demo.dcn.cache;
import java.util.Set;
import javax.annotation.Resource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
public class RedisClientBase implements RedisClient {
private final Logger logger = LoggerFactory.getLogger(RedisClientBase.class);
private static final String NX ="NX";//redis 设置key不存在时候起作用
private static final String XX = "XX";//redis 设置key存在 ，才能对键进行操作
private static final String EX ="EX";//redis 设置键固定时间秒
private static final String PX ="PX";//redis 设置键固定时间毫秒
@Resource
private ShardedJedisPool shardedJedisPool;//连接池
public static final int MAX_SCAN_COUNT = 200;
private static RedisClient redisclient;
public RedisClientBase(ShardedJedisPool shardedJedisPool) {
super();
this.shardedJedisPool = shardedJedisPool;
}
public RedisClientBase() {
redisclient = this;
}
public static RedisClient getInstance() {
return redisclient;
}
/**
* 获取一个分片 jedis 客户端
*
* @return
*/
public SelfShardedJedis getShardedJedis(){
ShardedJedis shards = shardedJedisPool.getResource();
SelfShardedJedis selfShardedJedis = new SelfShardedJedis(shards, false);
return selfShardedJedis;
}
/**
* 关闭 jedis 切片池
* @param jedis
* @param broken
*/
@SuppressWarnings({ "null", "deprecation" })
public void closeRedisThread(SelfShardedJedis jedis, boolean broken){
try{
if(jedis!=null||jedis.getIsReturn()){
return;
}
if(broken){
shardedJedisPool.returnBrokenResource(jedis.getShardedJedis());
jedis.setIsReturn(true);
}else{
shardedJedisPool.returnResource(jedis.getShardedJedis());
jedis.setIsReturn(true);
}
}catch(Exception e){
logger.error(e.getMessage(),e);
}
}
/**setnx 的值设为 value ，当且仅当 key 不存在。 若给定的 key 已经存在，则 setNotExists 不做任何动作。
* 保存
* @param key
* @param obj
* @return
* 设置成功，返回 1 ;设置失败，返回 0 。
*/
public Long setNotExists(String key,byte[] obj){
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try{
shardedJedis = getShardedJedis();
return shardedJedis.getShardedJedis().setnx(key.getBytes(), obj);//保存成二进制
}catch(Exception e){
logger.error(e.getMessage(), e);
broken = true;
}finally{
closeRedisThread(shardedJedis, broken);
}
return 0L;
}
/**
* 将 key 的值设为 value ，且设置过期时间，当且仅当 key 不存在。 若给定的 key 已经存在，则 setNotExists 不做任何动作。 * Set the string value as value of the key. The string
* can't be longer than 1073741824 bytes (1 GB).
* @param key
* @param value
* @param nxxx
* @param expx
* @param time
* @return
*/
public String set(String key,String value, String nxxx, String expx, long time){
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try{
shardedJedis = getShardedJedis();
return shardedJedis.getShardedJedis().set(key, value, nxxx, expx, time);
}catch(Exception e){
logger.error(e.getMessage(), e);
broken = true;
} finally {
closeRedisThread(shardedJedis, broken);
}
return null;
}
/**
* 通过key 获取字符串数据
* @param key
* @return
*/
public String getString(String key){
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try{
shardedJedis = getShardedJedis();
return shardedJedis.getShardedJedis().get(key);
}catch(Exception e){
logger.error(e.getMessage(), e);
broken = true;
}finally {
closeRedisThread(shardedJedis, broken);
}
return null;
}
/**
* 设置key过期时间
* @param key
* @param obj
* @param expireTime
* @return
*/
public String setExpire(String key, byte[] obj, int expireTime) {
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = getShardedJedis();
return shardedJedis.getShardedJedis().setex(key.getBytes(), expireTime, obj);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
} finally {
closeRedisThread(shardedJedis, broken);
}
return null;
}
/**
* 设置key过期时间
* @param key
* @param expireTime
* @return
*/
public Long expire(String key, int expireTime) {
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = getShardedJedis();
return shardedJedis.getShardedJedis().expire(key, expireTime);
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
} finally {
closeRedisThread(shardedJedis, broken);
}
return null;
}
/**
* 移除有序集 key 中，指定排名(rank)区间内的所有成员。
* <p/>
* 区间分别以下标参数 start 和 stop 指出，包含 start 和 stop 在内。 下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示有序集第一个成员，以 1 表示有序集第二个成员，以此类推。 你也可以使用负数下标，以 -1
* 表示最后一个成员， -2 表示倒数第二个成员，以此类推
*
* @param key
* @param start
* @param stop
* @return
*/
public Long zremrangeByRank(String key, long start, long stop) {
long result = 0L;
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = getShardedJedis();
result = shardedJedis.getShardedJedis().zremrangeByRank(key, start, start);
} catch (Exception e) {
broken = true;
logger.error(e.getMessage(), e);
} finally {
closeRedisThread(shardedJedis, broken);
}
return result;
}
/**
* 返回有序集 key 中，指定区间内的成员 其中成员的位置按 score 值递减(从大到小)来排列
*
* @param key
* @param start
* @param stop
* @return
*/
public Set<String> zrevrange(String key, long start, long stop) {
Set<String> result = null;
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = getShardedJedis();
result = shardedJedis.getShardedJedis().zrevrange(key, start, start);
} catch (Exception e) {
broken = true;
logger.error(e.getMessage(), e);
} finally {
closeRedisThread(shardedJedis, broken);
}
return result;
}
/**
* 删除key
* @param key
* @return
*/
public Long del(String key) {
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = getShardedJedis();
return shardedJedis.getShardedJedis().del(key);
} catch (Exception e) {
broken = true;
logger.error(e.getMessage(), e);
} finally {
closeRedisThread(shardedJedis, broken);
}
return null;
}
/**
* 计数器
*
* @param key
* @param seconds 过期时间长度，单位：秒；值为0或负数表示不过期。
* @param roll 时间是否滚动
*/
public Long incr(String key, int seconds, boolean roll) {
long b = 0;
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = getShardedJedis();
b = shardedJedis.getShardedJedis().incr(key.getBytes());
if (seconds > 0) {
if (b == 1) {// 第一次进入，设置过期时间
shardedJedis.getShardedJedis().expire(key.getBytes(), seconds);
}
if (roll && b > 1) {// 时间滚动
shardedJedis.getShardedJedis().expire(key.getBytes(), seconds);
}
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
} finally {
if (broken && shardedJedis != null) {
shardedJedis.getShardedJedis().del(key);
}
closeRedisThread(shardedJedis, broken);
}
return b;
}
/**
* 判断key 是否存在
* @param key
* @return若
*/
public Boolean exists(String key) {
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = getShardedJedis();
return shardedJedis.getShardedJedis().exists(key.getBytes());
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
} finally {
closeRedisThread(shardedJedis, broken);
}
return false;
}
/**
* 通过key 获取 jedis
* @param key
* @return
*/
public Jedis getShard(String key) {
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = getShardedJedis();
if (shardedJedis != null) {
return shardedJedis.getShardedJedis().getShard(key);
}
} catch (Exception e) {
e.printStackTrace();
logger.error(e.getMessage(), e);
broken = true;
} finally {
closeRedisThread(shardedJedis, broken);
}
return null;
}
/**
* 获取JedisShardInfo
*
* @param key
* @return JedisShareInfo
*/
public JedisShardInfo getShardInfo(String key) {
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = getShardedJedis();
if (shardedJedis != null) {
return shardedJedis.getShardedJedis().getShardInfo(key);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
} finally {
closeRedisThread(shardedJedis, broken);
}
return null;
}
/**
* 保存字符串键值对
* @param key
* @param value
* @return
*/
public String set(String key, String value) {
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = getShardedJedis();
if (shardedJedis != null) {
return shardedJedis.getShardedJedis().set(key, value);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
} finally {
closeRedisThread(shardedJedis, broken);
}
return null;
}
/**
* 获取key的类型
* @param key
* @return
*/
public String type(String key) {
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = getShardedJedis();
if (shardedJedis != null) {
return shardedJedis.getShardedJedis().type(key);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
} finally {
closeRedisThread(shardedJedis, broken);
}
return null;
}
/**
* 获取key 剩余时间 当 key 不存在时，返回 -2 。
* 当 key 存在但没有设置剩余生存时间时，返回 -1 。
* 否则，以秒为单位，返回 key 的剩余生存时间。
* @param key
* @return
*/
public Long ttl(String key) {
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = getShardedJedis();
if (shardedJedis != null) {
return shardedJedis.getShardedJedis().ttl(key);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
} finally {
closeRedisThread(shardedJedis, broken);
}
return null;
}
/**
* 为key 设定一个新值，并返回旧值
* 返回给定 key 的旧值。
* 当 key 没有旧值时，也即是， key 不存在时，返回 nil 。 不是字符串类型返回错误
* @param key
* @param value
* @return
*/
public String getSet(String key, String value) {
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = getShardedJedis();
if (shardedJedis != null) {
return shardedJedis.getShardedJedis().getSet(key, value);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
} finally {
closeRedisThread(shardedJedis, broken);
}
return null;
}
/**
* 当key 不存在时候 保存key String类型 存在不做什么操作返回0
* @param key
* @param value
* @return
*/
public Long setnx(String key, String value) {
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = getShardedJedis();
if (shardedJedis != null) {
return shardedJedis.getShardedJedis().setnx(key, value);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
} finally {
closeRedisThread(shardedJedis, broken);
}
return null;
}
/**
* 设置key 存在修改,不存在保存
* @param key
* @param seconds
* @param value
* @return
*/
public String setex(String key, int seconds, String value) {
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = getShardedJedis();
if (shardedJedis != null) {
return shardedJedis.getShardedJedis().setex(key, seconds, value);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
} finally {
closeRedisThread(shardedJedis, broken);
}
return null;
}
/**
* 对指定的key 进行减少 如果key 不存在 key值会被初始化0 然后减少
* @param key
* @param integer
* @return
*/
public Long decrBy(String key, long integer) {
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = getShardedJedis();
if (shardedJedis != null) {
return shardedJedis.getShardedJedis().decrBy(key, integer);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
} finally {
closeRedisThread(shardedJedis, broken);
}
return null;
}
/**
* 如果key 按指定增量增加 key 不存在 创造key 初始化为0 incr 自增为1
* @param key
* @param integer
* @return
*/
public Long incrBy(String key, long integer) {
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = getShardedJedis();
if (shardedJedis != null) {
return shardedJedis.getShardedJedis().incrBy(key, integer);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
} finally {
closeRedisThread(shardedJedis, broken);
}
return null;
}
/**
* 为已经存在的key追加新值，返回 长度 如果key 不存在，直接设置key为value
* @param key
* @param value
* @return
*/
public Long append(String key, String value) {
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = getShardedJedis();
if (shardedJedis != null) {
return shardedJedis.getShardedJedis().append(key, value);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
} finally {
closeRedisThread(shardedJedis, broken);
}
return null;
}
/**
* 截取字符串
* @param key
* @param start
* @param end
* @return
*/
public String substr(String key, int start, int end) {
SelfShardedJedis shardedJedis = null;
boolean broken = false;
try {
shardedJedis = getShardedJedis();
if (shardedJedis != null) {
return shardedJedis.getShardedJedis().substr(key, start, end);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
broken = true;
} finally {
closeRedisThread(shardedJedis, broken);
}
return null;
}
}
这里主要是针对String类型 封装的方法 ，其他类型基本大致一直。可以对照着网站去理解,
这里的json输出， 序列化 是用的阿里巴巴fastjson,也可以Google gson, protobuf 在序列化方面是比较快的。找时间试一试。
http://redisdoc.com/index.html
已有 0 人发表留言，猛击->> 这里<<-参与讨论
ITeye推荐
相关 [redis 数据结构 缓存] 推荐：
十五分钟介绍 Redis数据结构
- chao - NoSQLFan下面是一个对Redis官方文档《A fifteen minute introduction to Redis data types》一文的翻译，如其题目所言，此文目的在于让一个初学者能通过15分钟的简单学习对Redis的数据结构有一个了解. Redis是一种面向“键/值”对类型数据的分布式NoSQL数据库系统，特点是高性能，持久存储，适应高并发的应用场景.
Redis中5种数据结构的使用场景介绍
- - 企业架构 - ITeye博客这篇文章主要介绍了Redis中5种数据结构的使用场景介绍,本文对Redis中的5种数据类型String、Hash、List、Set、Sorted Set做了讲解,需要的朋友可以参考下. 一、redis 数据结构使用场景. 原来看过 redisbook 这本书，对 redis 的基本功能都已经熟悉了，从上周开始看 redis 的源码.
redis spring缓存配置
- - CSDN博客推荐文章使用redis做缓存的思路是在spring的项目中配置拦截器，在service层做切面，在findXXX或者getXXX等方法上进行拦截判断是否缓存即可. 1.环境：spring 3.1.2 + spring data redis 1.0.0+ jedis 2.1.0. 2.spring配置文件配置：.
Redis 缓存失效机制
- - 文章 – 伯乐在线Redis缓存失效的故事要从EXPIRE这个命令说起，EXPIRE允许用户为某个key指定超时时间，当超过这个时间之后key对应的值会被清除，这篇文章主要在分析Redis源码的基础上站在Redis设计者的角度去思考Redis缓存失效的相关问题. Redis缓存失效机制是为应对缓存应用的一种很常见的场景而设计的，讲个场景：.
Spring Boot使用redis做数据缓存
- - ITeye博客SysUser.class)); //请注意这里. 3 redis服务器配置. /**
*此处的dao操作使用的是spring data jpa,使用@Cacheable可以在任意方法上，*比如@Service或者@Controller的方法上
*/
public interface SysUserRepo1 extends CustomRepository {.
使用Redis作为一个LRU缓存
- - 并发编程网 - ifeve.com原文链接 译者：flychao88. 当用Redis作为一个LRU存储时，有些时候是比较方便的，在你增添新的数据时会自动驱逐旧的数据. 这种行为在开发者论坛是非常有名的，因为这是流行的memcached系统的默认行为. LRU实际上只是支持驱逐的方式之一. 这页包含更多一般的Redis maxmemory指令的话题用于限制内存使用到一个定额，同时它也深入的涵盖了Redis所使用的LRU算法，实际上是精确LRU的近似值.
Spring AOP + Redis缓存数据库查询
- - 编程语言 - ITeye博客我们希望能够将数据库查询结果缓存到Redis中，这样在第二次做同样的查询时便可以直接从redis取结果，从而减少数据库读写次数. 必须要做到与业务逻辑代码完全分离. 从缓存中读出的数据必须与数据库中的数据一致. 如何为一个数据库查询结果生成一个唯一的标识. Key)，能唯一确定一个查询结果，同一个查询结果，一定能映射到同一个.
spring + redis 实现数据的缓存
- - ImportNew（目的不是加快查询的速度，而是减少数据库的负担）. 注意：jdies和commons-pool两个jar的版本是有对应关系的，注意引入jar包是要配对使用，否则将会报错. 因为commons-pooljar的目录根据版本的变化，目录结构会变. 前面的版本是org.apache.pool，而后面的版本是org.apache.pool2….
[转]缓存大量小文件？Redis是首选！
- - 小鸥的博客现在有3KW的数据，单条数据都很小的，如果按key-value来看的话，key就是32位的MD5字符串，value按平均算大概是100字节左右. 现在需要将这些数据做缓存以在高并发的时候依然可以快速响应. 因为这些数据基本没有冷热数据之分，所以需要将全部数据都放到缓存中. 1、直接生成静态文件，利用nginx对静态文件的高效做静态缓存.