Redis学习总结和相关资料

在Java中，熟悉使用Redis主要分为3步：

一.了解Redis

redis

redis是在memcache之后编写的，大家经常把这两者做比较，如果说它是个key-value store 的话但是它具有丰富的数据类型，我想暂时把它叫做缓存数据流中心，就像现在物流中心那样，order、package、store、classification、distribute、end。现在还很流行的LAMP PHP架构 不知道和 redis+mysql 或者 redis + mongodb的性能比较（听群里的人说mongodb分片不稳定）。

先说说reidis的特性

1. 支持持久化

redis的本地持久化支持两种方式：RDB和AOF。RDB 在redis.conf配置文件里配置持久化触发器，AOF指的是redis没增加一条记录都会保存到持久化文件中（保存的是这条记录的生成命令），如果不是用redis做DB用的话还会不要开AOF ，数据太庞大了，重启恢复的时候是一个巨大的工程！

2.丰富的数据类型

redis 支持 String 、Lists、sets、sorted sets、hashes 多种数据类型,新浪微博会使用redis做nosql主要也是它具有这些类型，时间排序、职能排序、我的微博、发给我的这些功能List 和 sorted set 的强大操作功能息息相关

3.高性能

这点跟memcache很想象，内存操作的级别是毫秒级的比硬盘操作秒级操作自然高效不少，较少了磁头寻道、数据读取、页面交换这些高开销的操作！这也是NOSQL冒出来的原因吧，应该是高性能

是基于RDBMS的衍生产品，虽然RDBMS也具有缓存结构，但是始终在app层面不是我们想要的那么操控的。

4.replication

redis提供主从复制方案，跟mysql一样增量复制而且复制的实现都很相似，这个复制跟AOF有点类似复制的是新增记录命令，主库新增记录将新增脚本发送给从库，从库根据脚本生成记录，这个过程非常快，就看网络了，一般主从都是在同一个局域网，所以可以说redis的主从近似及时同步，同事它还支持一主多从，动态添加从库，从库数量没有限制。 主从库搭建，我觉得还是采用网状模式，如果使用链式（master-slave-slave-slave-slave·····）如果第一个slave出现宕机重启，首先从master
接收 数据恢复脚本，这个是阻塞的，如果主库数据几TB的情况恢复过程得花上一段时间，在这个过程中其他的slave就无法和主库同步了。

5.更新快

这点好像从我接触到redis到目前为止 已经发了大版本就4个，小版本没算过。redis作者是个非常积极的人，无论是邮件提问还是论坛发帖，他都能及时耐心的为你解答，维护度很高。有人维护的话，让我们用的也省心和放心。目前作者对redis 的主导开发方向是redis的集群方向。

所以如果希望简单就用ehcache，如果开发任务比较复杂，希望得到比较多的支持什么的就redis

二.安装Redis

Windows下，我喜欢用解压版的，有4个exe文件，直接双击redis-server.exe就起来了。

Linux下，我也喜欢用解压版的，直接shell启动。

几个exe程序的功能：　　　　

redis-benchmark.exe：性能测试，用以模拟同时由N个客户端发送M个 SETs/GETs 查询 (类似于 Apache 的ab 工具).

　redis-check-aof.exe：更新日志检查

　　redis-check-dump.exe：本地数据库检查

　　redis-cli.exe：客户端

　　redis-server.exe：服务端　　

原来是5个exe文件，差点不会数数了。

三.使用Jedis或SpringDataRedis操作Redis

我自己写的3个例子，更多例子请查看下方的“参考资料”

[java] view
plain copy

package cn.fansunion.redis;

import hprose.io.HproseFormatter;

import java.io.IOException;

import java.util.Locale;

import java.util.ResourceBundle;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.JedisPoolConfig;

//简单的Redis例子，用到了Hprose序列化

public class MyDemo {

private static String HOST = "127.0.0.1";

private static int PORT = 6379;

private static int MAX_ACTIVE = 20;

private static int MAX_IDLE = 5;

private static int MAX_WAIT = 1000;

private static int TIME_OUT = 2000;// 毫秒

private static boolean TEST_ON_BORROW = true;// 当调用borrow

// object方法时，是否进行有效性检查

private static boolean TEST_ON_RETURN = true;// 当调用return object时，是否进行有效性检查

private static JedisPool pool;

static {

initPool();

}

private static void setValueFromBundle() {

ResourceBundle bundle = ResourceBundle.getBundle("redis",

Locale.getDefault(), MyDemo.class.getClassLoader());

if (bundle == null) {

throw new IllegalArgumentException(

"[redis.properties] is not found!");

}

HOST = bundle.getString("redis.host");

PORT = Integer.parseInt(bundle.getString("redis.port"));

MAX_ACTIVE = Integer.valueOf(bundle.getString("redis.maxActive"));

MAX_IDLE = Integer.valueOf(bundle.getString("redis.maxIdle"));

MAX_WAIT = Integer.valueOf(bundle.getString("redis.maxWait"));

TIME_OUT = Integer.valueOf(bundle.getString("redis.timeOut"));

TEST_ON_BORROW = Boolean.valueOf(bundle

.getString("redis.testOnBorrow"));

TEST_ON_RETURN = Boolean.valueOf(bundle

.getString("redis.testOnReturn"));

}

private static void initPool() {

JedisPoolConfig config = new JedisPoolConfig();

try {

setValueFromBundle();

} catch (Exception e) {

System.out.println("redis bundle resource get error");

}

config.setMaxActive(MAX_ACTIVE);

config.setMaxIdle(MAX_IDLE);

config.setMaxIdle(MAX_WAIT);

config.setTestOnBorrow(TEST_ON_BORROW);

config.setTestOnReturn(TEST_ON_RETURN);

pool = new JedisPool(config, HOST, PORT, TIME_OUT);

}

public static void put(String key, Object value) {

Jedis jedis = null;

try {

jedis = pool.getResource();

jedis.set(key.getBytes(), HproseFormatter.serialize(value)

.toByteArray());

} catch (IOException e) {

e.printStackTrace();

pool.returnBrokenResource(jedis);

} finally {

pool.returnResource(jedis);

}

}

public static void delete(String key) {

Jedis jedis = null;

try {

jedis = pool.getResource();

jedis.del(key.getBytes());

} catch (Exception e) {

e.printStackTrace();

pool.returnBrokenResource(jedis);

} finally {

pool.returnResource(jedis);

}

}

public static Object get(String key) {

Object result = null;

Jedis jedis = null;

try {

jedis = pool.getResource();

if (key != null) {

byte[] bt = jedis.get(key.getBytes());

if (bt != null) {

result = HproseFormatter.unserialize(jedis.get(key

.getBytes()));

}

}

} catch (IOException e) {

e.printStackTrace();

pool.returnBrokenResource(jedis);

} finally {

pool.returnResource(jedis);

}

return result;

}

public static void main(String[] args) {

String name = "小雷FansUnion";

String key = "name";

MyDemo.put(key, name);

Object nameObject = MyDemo.get(key);

if (nameObject != null) {

String n = (String) nameObject;

System.out.println(n);

}

MyDemo.delete(key);

Object nullObject = MyDemo.get(name);

if (nullObject == null) {

System.out.println("The name object has been deleted.");

}

}

}

[java] view
plain copy

package cn.fansunion.redis;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.JedisPoolConfig;

import redis.clients.jedis.JedisShardInfo;

import redis.clients.jedis.ShardedJedis;

import redis.clients.jedis.ShardedJedisPool;

import redis.clients.jedis.SortingParams;

//根据网上代码，略微改造的例子

public class RedisClient {

private static final int PORT = 6379;

private static final String HOST = "127.0.0.1";

private Jedis jedis;// 非切片客户端连接

private JedisPool jedisPool;// 非切片连接池

private ShardedJedis shardedJedis;// 切片额客户端连接

private ShardedJedisPool shardedJedisPool;// 切片连接池

public RedisClient() {

initialPool();

initialShardedPool();

shardedJedis = shardedJedisPool.getResource();

jedis = jedisPool.getResource();

}

/**

* 初始化非切片池

*/

private void initialPool() {

// 池基本配置

JedisPoolConfig config = new JedisPoolConfig();

config.setMaxActive(20);

config.setMaxIdle(5);

config.setMaxWait(1000l);

config.setTestOnBorrow(false);

jedisPool = new JedisPool(config, HOST, PORT);

}

/**

* 初始化切片池

*/

private void initialShardedPool() {

// 池基本配置

JedisPoolConfig config = new JedisPoolConfig();

config.setMaxActive(20);

config.setMaxIdle(5);

config.setMaxWait(1000l);

config.setTestOnBorrow(false);

// slave链接

List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();

shards.add(new JedisShardInfo(HOST, 6379, "master"));

// 构造池

shardedJedisPool = new ShardedJedisPool(config, shards);

}

public static void main(String[] args) {

RedisClient redisClient = new RedisClient();

redisClient.show();

}

public void show() {

keyOperate();

stringOperate();

listOperate();

setOperate();

sortedSetOperate();

hashOperate();

jedisPool.returnResource(jedis);

shardedJedisPool.returnResource(shardedJedis);

}

private static void pn(Object o){

System.out.println(o);

}

private static void pn(){

System.out.println();

}

private void keyOperate() {

pn("======================key==========================");

// 清空数据

pn("清空库中所有数据：" + jedis.flushDB());

// 判断key否存在

pn("判断key999键是否存在：" + shardedJedis.exists("key999"));

pn("新增key001,value001键值对："

+ shardedJedis.set("key001", "value001"));

pn("判断key001是否存在：" + shardedJedis.exists("key001"));

// 输出系统中所有的key

pn("新增key002,value002键值对："

+ shardedJedis.set("key002", "value002"));

pn("系统中所有键如下：");

Set<String> keys = jedis.keys("*");

Iterator<String> it = keys.iterator();

while (it.hasNext()) {

String key = it.next();

pn(key);

}

// 删除某个key,若key不存在，则忽略该命令。

pn("系统中删除key002: " + jedis.del("key002"));

pn("判断key002是否存在：" + shardedJedis.exists("key002"));

// 设置 key001的过期时间

pn("设置 key001的过期时间为5秒:" + jedis.expire("key001", 5));

try {

Thread.sleep(2000);

} catch (InterruptedException e) {

}

// 查看某个key的剩余生存时间,单位【秒】.永久生存或者不存在的都返回-1

pn("查看key001的剩余生存时间：" + jedis.ttl("key001"));

// 移除某个key的生存时间

pn("移除key001的生存时间：" + jedis.persist("key001"));

pn("查看key001的剩余生存时间：" + jedis.ttl("key001"));

// 查看key所储存的值的类型

pn("查看key所储存的值的类型：" + jedis.type("key001"));

/*

* 一些其他方法：1、修改键名：jedis.rename("key6", "key0");

* 2、将当前db的key移动到给定的db当中：jedis.move("foo", 1)

*/

}

private void stringOperate() {

System.out

.println("======================String_1==========================");

// 清空数据

pn("清空库中所有数据：" + jedis.flushDB());

pn("=============增=============");

jedis.set("key001", "value001");

jedis.set("key002", "value002");

jedis.set("key003", "value003");

pn("已新增的3个键值对如下：");

pn(jedis.get("key001"));

pn(jedis.get("key002"));

pn(jedis.get("key003"));

pn("=============删=============");

pn("删除key003键值对：" + jedis.del("key003"));

pn("获取key003键对应的值：" + jedis.get("key003"));

pn("=============改=============");

// 1、直接覆盖原来的数据

pn("直接覆盖key001原来的数据："

+ jedis.set("key001", "value001-update"));

pn("获取key001对应的新值：" + jedis.get("key001"));

// 2、直接覆盖原来的数据

pn("在key002原来值后面追加："

+ jedis.append("key002", "+appendString"));

pn("获取key002对应的新值" + jedis.get("key002"));

pn("=============增，删，查（多个）=============");

/**

* mset,mget同时新增，修改，查询多个键值对 等价于： jedis.set("name","ssss");

* jedis.set("jarorwar","xxxx");

*/

pn("一次性新增key201,key202,key203,key204及其对应值："

+ jedis.mset("key201", "value201", "key202", "value202",

"key203", "value203", "key204", "value204"));

pn("一次性获取key201,key202,key203,key204各自对应的值："

+ jedis.mget("key201", "key202", "key203", "key204"));

pn("一次性删除key201,key202："

+ jedis.del(new String[] { "key201", "key202" }));

pn("一次性获取key201,key202,key203,key204各自对应的值："

+ jedis.mget("key201", "key202", "key203", "key204"));

pn();

// jedis具备的功能shardedJedis中也可直接使用，下面测试一些前面没用过的方法

System.out

.println("======================String_2==========================");

// 清空数据

pn("清空库中所有数据：" + jedis.flushDB());

pn("=============新增键值对时防止覆盖原先值=============");

pn("原先key301不存在时，新增key301："

+ shardedJedis.setnx("key301", "value301"));

pn("原先key302不存在时，新增key302："

+ shardedJedis.setnx("key302", "value302"));

pn("当key302存在时，尝试新增key302："

+ shardedJedis.setnx("key302", "value302_new"));

pn("获取key301对应的值：" + shardedJedis.get("key301"));

pn("获取key302对应的值：" + shardedJedis.get("key302"));

pn("=============超过有效期键值对被删除=============");

// 设置key的有效期，并存储数据

pn("新增key303，并指定过期时间为2秒"

+ shardedJedis.setex("key303", 2, "key303-2second"));

pn("获取key303对应的值：" + shardedJedis.get("key303"));

try {

Thread.sleep(3000);

} catch (InterruptedException e) {

}

pn("3秒之后，获取key303对应的值：" + shardedJedis.get("key303"));

pn("=============获取原值，更新为新值一步完成=============");

pn("key302原值："

+ shardedJedis.getSet("key302", "value302-after-getset"));

pn("key302新值：" + shardedJedis.get("key302"));

pn("=============获取子串=============");

pn("获取key302对应值中的子串："

+ shardedJedis.getrange("key302", 5, 7));

}

private void listOperate() {

pn("======================list==========================");

// 清空数据

pn("清空库中所有数据：" + jedis.flushDB());

pn("=============增=============");

shardedJedis.lpush("stringlists", "vector");

shardedJedis.lpush("stringlists", "ArrayList");

shardedJedis.lpush("stringlists", "vector");

shardedJedis.lpush("stringlists", "vector");

shardedJedis.lpush("stringlists", "LinkedList");

shardedJedis.lpush("stringlists", "MapList");

shardedJedis.lpush("stringlists", "SerialList");

shardedJedis.lpush("stringlists", "HashList");

shardedJedis.lpush("numberlists", "3");

shardedJedis.lpush("numberlists", "1");

shardedJedis.lpush("numberlists", "5");

shardedJedis.lpush("numberlists", "2");

pn("所有元素-stringlists："

+ shardedJedis.lrange("stringlists", 0, -1));

pn("所有元素-numberlists："

+ shardedJedis.lrange("numberlists", 0, -1));

pn("=============删=============");

// 删除列表指定的值 ，第二个参数为删除的个数（有重复时），后add进去的值先被删，类似于出栈

pn("成功删除指定元素个数-stringlists："

+ shardedJedis.lrem("stringlists", 2, "vector"));

pn("删除指定元素之后-stringlists："

+ shardedJedis.lrange("stringlists", 0, -1));

// 删除区间以外的数据

pn("删除下标0-3区间之外的元素："

+ shardedJedis.ltrim("stringlists", 0, 3));

pn("删除指定区间之外元素后-stringlists："

+ shardedJedis.lrange("stringlists", 0, -1));

// 列表元素出栈

pn("出栈元素：" + shardedJedis.lpop("stringlists"));

pn("元素出栈后-stringlists："

+ shardedJedis.lrange("stringlists", 0, -1));

pn("=============改=============");

// 修改列表中指定下标的值

shardedJedis.lset("stringlists", 0, "hello list!");

pn("下标为0的值修改后-stringlists："

+ shardedJedis.lrange("stringlists", 0, -1));

pn("=============查=============");

// 数组长度

pn("长度-stringlists：" + shardedJedis.llen("stringlists"));

pn("长度-numberlists：" + shardedJedis.llen("numberlists"));

// 排序

/*

* list中存字符串时必须指定参数为alpha，如果不使用SortingParams，而是直接使用sort("list")，

* 会出现"ERR One or more scores can't be converted into double"

*/

SortingParams sortingParameters = new SortingParams();

sortingParameters.alpha();

sortingParameters.limit(0, 3);

pn("返回排序后的结果-stringlists："

+ shardedJedis.sort("stringlists", sortingParameters));

pn("返回排序后的结果-numberlists："

+ shardedJedis.sort("numberlists"));

// 子串： start为元素下标，end也为元素下标；-1代表倒数一个元素，-2代表倒数第二个元素

pn("子串-第二个开始到结束："

+ shardedJedis.lrange("stringlists", 1, -1));

// 获取列表指定下标的值

pn("获取下标为2的元素：" + shardedJedis.lindex("stringlists", 2)

+ "\n");

}

private void setOperate() {

pn("======================set==========================");

// 清空数据

pn("清空库中所有数据：" + jedis.flushDB());

pn("=============增=============");

pn("向sets集合中加入元素element001："

+ jedis.sadd("sets", "element001"));

pn("向sets集合中加入元素element002："

+ jedis.sadd("sets", "element002"));

pn("向sets集合中加入元素element003："

+ jedis.sadd("sets", "element003"));

pn("向sets集合中加入元素element004："

+ jedis.sadd("sets", "element004"));

pn("查看sets集合中的所有元素:" + jedis.smembers("sets"));

pn();

pn("=============删=============");

pn("集合sets中删除元素element003："

+ jedis.srem("sets", "element003"));

pn("查看sets集合中的所有元素:" + jedis.smembers("sets"));

/*

* pn("sets集合中任意位置的元素出栈："+jedis.spop("sets"));//注：

* 出栈元素位置居然不定？--无实际意义

* pn("查看sets集合中的所有元素:"+jedis.smembers("sets"));

*/

pn();

pn("=============改=============");

pn();

pn("=============查=============");

pn("判断element001是否在集合sets中："

+ jedis.sismember("sets", "element001"));

pn("循环查询获取sets中的每个元素：");

Set<String> set = jedis.smembers("sets");

Iterator<String> it = set.iterator();

while (it.hasNext()) {

Object obj = it.next();

pn(obj);

}

pn();

pn("=============集合运算=============");

pn("sets1中添加元素element001："

+ jedis.sadd("sets1", "element001"));

pn("sets1中添加元素element002："

+ jedis.sadd("sets1", "element002"));

pn("sets1中添加元素element003："

+ jedis.sadd("sets1", "element003"));

pn("sets1中添加元素element002："

+ jedis.sadd("sets2", "element002"));

pn("sets1中添加元素element003："

+ jedis.sadd("sets2", "element003"));

pn("sets1中添加元素element004："

+ jedis.sadd("sets2", "element004"));

pn("查看sets1集合中的所有元素:" + jedis.smembers("sets1"));

pn("查看sets2集合中的所有元素:" + jedis.smembers("sets2"));

pn("sets1和sets2交集：" + jedis.sinter("sets1", "sets2"));

pn("sets1和sets2并集：" + jedis.sunion("sets1", "sets2"));

pn("sets1和sets2差集：" + jedis.sdiff("sets1", "sets2"));// 差集：set1中有，set2中没有的元素

}

private void sortedSetOperate() {

pn("======================zset==========================");

// 清空数据

pn(jedis.flushDB());

pn("=============增=============");

pn("zset中添加元素element001："

+ shardedJedis.zadd("zset", 7.0, "element001"));

pn("zset中添加元素element002："

+ shardedJedis.zadd("zset", 8.0, "element002"));

pn("zset中添加元素element003："

+ shardedJedis.zadd("zset", 2.0, "element003"));

pn("zset中添加元素element004："

+ shardedJedis.zadd("zset", 3.0, "element004"));

pn("zset集合中的所有元素：" + shardedJedis.zrange("zset", 0, -1));// 按照权重值排序

pn();

pn("=============删=============");

pn("zset中删除元素element002："

+ shardedJedis.zrem("zset", "element002"));

pn("zset集合中的所有元素：" + shardedJedis.zrange("zset", 0, -1));

pn();

pn("=============改=============");

pn();

pn("=============查=============");

pn("统计zset集合中的元素中个数：" + shardedJedis.zcard("zset"));

pn("统计zset集合中权重某个范围内（1.0——5.0），元素的个数："

+ shardedJedis.zcount("zset", 1.0, 5.0));

pn("查看zset集合中element004的权重："

+ shardedJedis.zscore("zset", "element004"));

pn("查看下标1到2范围内的元素值："

+ shardedJedis.zrange("zset", 1, 2));

}

private void hashOperate() {

pn("======================hash==========================");

// 清空数据

pn(jedis.flushDB());

pn("=============增=============");

pn("hashs中添加key001和value001键值对："

+ shardedJedis.hset("hashs", "key001", "value001"));

pn("hashs中添加key002和value002键值对："

+ shardedJedis.hset("hashs", "key002", "value002"));

pn("hashs中添加key003和value003键值对："

+ shardedJedis.hset("hashs", "key003", "value003"));

pn("新增key004和4的整型键值对："

+ shardedJedis.hincrBy("hashs", "key004", 4l));

pn("hashs中的所有值：" + shardedJedis.hvals("hashs"));

pn();

pn("=============删=============");

pn("hashs中删除key002键值对："

+ shardedJedis.hdel("hashs", "key002"));

pn("hashs中的所有值：" + shardedJedis.hvals("hashs"));

pn();

pn("=============改=============");

pn("key004整型键值的值增加100："

+ shardedJedis.hincrBy("hashs", "key004", 100l));

pn("hashs中的所有值：" + shardedJedis.hvals("hashs"));

pn();

pn("=============查=============");

pn("判断key003是否存在："

+ shardedJedis.hexists("hashs", "key003"));

pn("获取key004对应的值："

+ shardedJedis.hget("hashs", "key004"));

pn("批量获取key001和key003对应的值："

+ shardedJedis.hmget("hashs", "key001", "key003"));

pn("获取hashs中所有的key：" + shardedJedis.hkeys("hashs"));

pn("获取hashs中所有的value：" + shardedJedis.hvals("hashs"));

pn();

}

}

redis.properties

redis.pool.maxActive=1024

redis.pool.maxIdle=200

redis.pool.maxWait=1000

redis.pool.testOnBorrow=true

redis.pool.testOnReturn=true

#IP

redis.ip=127.0.0.1

#Port

redis.port=6379

补充说明：我在秒针工作的时候，有2个项目都用了Hprose，来做序列化。因此，我自己的代码中，也用了Hprose，需要的网上下载哦。

各种参考资料：

百度知道：java web开发缓存方案，ehcache和redis哪个更好 http://zhidao.baidu.com/link?url=v9i98VamdEEv-qvhXZ875qpAeLlk6Y1jLeeUjUa8RqH2OK8LLxKCfsdPMuVzLZHaJSacvOGnxJF6P3Ve9e0uYCCfniI7XzSdHyfuK7uEUKq
百度百科Redis：http://baike.baidu.com/link?url=t3DT1YANTECL0iYZ0y40otALPMqaPjgTkZV7CXyKhm9eMNZS5p3E2u4N7sbnbuHKixrmxFY9ZXS2QAlALsYcCq

java对redis的基本操作 http://www.cnblogs.com/edisonfeng/p/3571870.html#undefined
java之redis篇(spring-data-redis整合) http://www.cnblogs.com/tankaixiong/p/3660075.html