操作 redis-jedis--spring-哨兵 2

redis教程

Redis命令大全
Redis入门教程：特性及数据类型的操作 
Redis命令：strings数据类型及操作 
Redis详解：hashes数据类型及操作 
Redis详解：lists数据类型及操作 
Redis详解：sets数据类型及操作 
Redis命令：sorted sets数据类型及操作 
Redis常用命令手册：键值相关命令 
Redis常用命令手册：服务器相关命令 

Jedis存储Java对象--Java序列化为byte数组方式

在Jedis开发中，我们很多时候希望直接把一个对象放到Redis中，然后在需要的时候取出来。Redis的key和value都支持二进制安全的字符串，存储Java对象不是问题，下面我们看一下如何来实现。
1、要存储的对象

现在写一个很土的Java Bean，包含两个字段，id和name，类名叫做Person。为了实现序列化需求，该类实现Serializable接口。

package com.ljq.test;

import java.io.Serializable;

@SuppressWarnings("serial")
public class Person implements Serializable {
private int id;
private String name;

public Person() {
}

public Person(int id, String name) {
super();
this.id = id;
this.name = name;
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

}

2、序列化、反序列化

写一个序列化工具类，来提供对象的序列化和反序列化的工作。代码如下：

package com.ljq.test;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializeUtil {
/**
* 序列化
*
* @param object
* @return
*/
public static byte[]
1231a
serialize(Object object) {
ObjectOutputStream oos = null;
ByteArrayOutputStream baos = null;
try {
// 序列化
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
oos.writeObject(object);
byte[] bytes = baos.toByteArray();
return bytes;
} catch (Exception e) {

}
return null;
}

/**
* 反序列化
*
* @param bytes
* @return
*/
public static Object unserialize(byte[] bytes) {
ByteArrayInputStream bais = null;
try {
// 反序列化
bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bais);
return ois.readObject();
} catch (Exception e) {

}
return null;
}
}

3、单元测试

使用junit对Jedis进行单元测试。代码如下：

package com.ljq.test;

import org.junit.Before;
import org.junit.Test;

import redis.clients.jedis.Jedis;

public class PersonRedisTest {
private static Jedis jedis=null;

/**
* 初始化Jedis对象
*
* @throws Exception
*/
@Before
public void before() throws Exception {
jedis=new Jedis("127.0.0.1", 6379);
}

/**
* 序列化写对象, 将Person对象写入Redis中
*
* 我们到命令行窗口中读取该对象，看看有没有写入成功：
* redis 127.0.0.1:6379> get person:100
* "\xac\xed\x00\x05sr\x00\x15alanland.redis.Person\x05\xf4\x8d9A\xf4`\xb0\x02\x00\x02I\x00\x02idL\x00\x04namet\x00\x12Ljava/lang/String;xp\x00\x00\x00dt\x00\x04alan"
* 可以取到序列化之后的值。
*/
@Test
public void setObject() {
jedis.set("person:100".getBytes(), SerializeUtil.serialize(new Person(100, "zhangsan")));
jedis.set("person:101".getBytes(), SerializeUtil.serialize(new Person(101, "bruce")));
}

/**
* 反序列化取对象, 用Jedis获取对象
*
*/
@Test
public void getObject() {
byte[] data100= jedis.get(("person:100").getBytes());
Person person100 = (Person) SerializeUtil.unserialize(data100);
System.out.println(String.format("person:100->id=%s,name=%s", person100.getId(), person100.getName()));

byte[] data101= jedis.get(("person:101").getBytes());
Person person101 = (Person) SerializeUtil.unserialize(data101);
System.out.println(String.format("person:101->id=%s,name=%s", person101.getId(), person101.getName()));
}
}

为redis分配一个新的端口

为redis分配一个8888端口，操作步骤如下：

1、$REDIS_HOME/redis.conf重新复制一份，重命名为redis8888.conf。

2、打开redis8888.conf配置文件，找到port 6379这行，把6379改为8888。

3、把redis8888.conf移到$REDIS_HOME/redis-svrs/taobaoAny目录下(taobaoAny为自己新建)。

4、启动redis服务：redis-server /home/redis/redis-2.4.15/redis-svrs/taobaoAny/redis8888.conf &

5、通过“ps -x | grep redis”查看进程，在输出的信息中会看到/home/redis/redis-2.4.15/redis-svrs/taobaoAny/redis8888.conf

6、redis-cli -p 8888, 测试端口是否创建成功。

Jedis连接池的使用

所需jar：jedis-2.1.0.jar和commons-pool-1.5.4.jar
Jedis操作步骤如下：

1->获取Jedis实例需要从JedisPool中获取；

2->用完Jedis实例需要返还给JedisPool；

3->如果Jedis在使用过程中出错，则也需要还给JedisPool；
代码如下：

package com.ljq.utils;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
* Redis操作接口
*
* @author 林计钦
* @version 1.0 2013-6-14 上午08:54:14
*/
public class RedisAPI {
private static JedisPool pool = null;

/**
* 构建redis连接池
*
* @param ip
* @param port
* @return JedisPool
*/
public static JedisPool getPool() {
if (pool == null) {
JedisPoolConfig config = new JedisPoolConfig();
//控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；
//如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
config.setMaxActive(500);
//控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。
config.setMaxIdle(5);
//表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；
config.setMaxWait(1000 * 100);
//在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
config.setTestOnBorrow(true);
pool = new JedisPool(config, "192.168.2.191", 8888);
}
return pool;
}

/**
* 返还到连接池
*
* @param pool
* @param redis
*/
public static void returnResource(JedisPool pool, Jedis redis) {
if (redis != null) {
pool.returnResource(redis);
}
}

/**
* 获取数据
*
* @param key
* @return
*/
public static String get(String key){
String value = null;

JedisPool pool = null;
Jedis jedis = null;
try {
pool = getPool();
jedis = pool.getResource();
value = jedis.get(key);
} catch (Exception e) {
//释放redis对象
pool.returnBrokenResource(jedis);
e.printStackTrace();
} finally {
//返还到连接池
returnResource(pool, jedis);
}

return value;
}
}

代码说明：

a、获取jedis实例时，实际上可能有两类错误。

一类是pool.getReource()，得不到可用的jedis实例；

另一类是jedis.set/get时出错也会抛出异常；

为了实现区分，所以根据instance是否为null来实现，如果为空就证明instance根本就没初始化，也就不用return给pool；如果instance不为null，则证明是需要返还给pool的；
b、在instance出错时，必须调用returnBrokenResource返还给pool，否则下次通过getResource得到的instance的缓冲区可能还存在数据，出现问题！
-------------------------------------------------
JedisPool的配置参数很大程度上依赖于实际应用需求、软硬件能力。以前没用过commons-pool，所以这次花了一整天专门看这些参数的含义。。。JedisPool的配置参数大部分是由JedisPoolConfig的对应项来赋值的。
maxActive：控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted。
maxIdle：控制一个pool最多有多少个状态为idle(空闲)的jedis实例；
whenExhaustedAction：表示当pool中的jedis实例都被allocated完时，pool要采取的操作；默认有三种。

WHEN_EXHAUSTED_FAIL --> 表示无jedis实例时，直接抛出NoSuchElementException；

WHEN_EXHAUSTED_BLOCK --> 则表示阻塞住，或者达到maxWait时抛出JedisConnectionException；

WHEN_EXHAUSTED_GROW --> 则表示新建一个jedis实例，也就说设置的maxActive无用；
maxWait：表示当borrow一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；
testOnBorrow：在borrow一个jedis实例时，是否提前进行alidate操作；如果为true，则得到的jedis实例均是可用的；
testOnReturn：在return给pool时，是否提前进行validate操作；
testWhileIdle：如果为true，表示有一个idle object evitor线程对idle object进行扫描，如果validate失败，此object会被从pool中drop掉；这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义；
timeBetweenEvictionRunsMillis：表示idle object evitor两次扫描之间要sleep的毫秒数；
numTestsPerEvictionRun：表示idle object evitor每次扫描的最多的对象数；
minEvictableIdleTimeMillis：表示一个对象至少停留在idle状态的最短时间，然后才能被idle object evitor扫描并驱逐；这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义；
softMinEvictableIdleTimeMillis：在minEvictableIdleTimeMillis基础上，加入了至少minIdle个对象已经在pool里面了。如果为-1，evicted不会根据idle time驱逐任何对象。如果minEvictableIdleTimeMillis>0，则此项设置无意义，且只有在timeBetweenEvictionRunsMillis大于0时才有意义；
lifo：borrowObject返回对象时，是采用DEFAULT_LIFO（last in first out，即类似cache的最频繁使用队列），如果为False，则表示FIFO队列；
其中JedisPoolConfig对一些参数的默认设置如下：

testWhileIdle=true

minEvictableIdleTimeMills=60000

timeBetweenEvictionRunsMillis=30000

numTestsPerEvictionRun=-1