redis spring 哨兵 配置

Sentinel的工作方式: 

1)：每个Sentinel以每秒钟一次的频率向它所知的Master，Slave以及其他 Sentinel 实例发送一个 PING 命令 
2)：如果一个实例（instance）距离最后一次有效回复 PING 命令的时间超过 down-after-milliseconds 选项所指定的值， 则这个实例会被 Sentinel 标记为主观下线。 
3)：如果一个Master被标记为主观下线，则正在监视这个Master的所有 Sentinel 要以每秒一次的频率确认Master的确进入了主观下线状态。 
4)：当有足够数量的 Sentinel（大于等于配置文件指定的值）在指定的时间范围内确认Master的确进入了主观下线状态， 则Master会被标记为客观下线 
5)：在一般情况下， 每个 Sentinel 会以每 10 秒一次的频率向它已知的所有Master，Slave发送 INFO 命令 
6)：当Master被 Sentinel 标记为客观下线时，Sentinel 向下线的 Master 的所有 Slave 发送 INFO 命令的频率会从 10 秒一次改为每秒一次 
7)：若没有足够数量的 Sentinel 同意 Master 已经下线， Master 的客观下线状态就会被移除。 
若 Master 重新向 Sentinel 的 PING 命令返回有效回复， Master 的主观下线状态就会被移除。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
		http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
	
	<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
		<!-- redis最大连接数最好设置为200，不然会出现很多报错 -->
		<property name="maxTotal" value="200"></property>
		<property name="maxIdle" value="200"></property>
		<property name="minIdle" value="6"></property>
		<!-- 在抛出异常之前，调用的线程将会阻塞maxWaitMillis时长。默认值为true。推荐在生产环境下设置为true；测试环境下设置为false。 -->
		<property name="blockWhenExhausted" value="false"></property>
		<property name="maxWaitMillis" value="1000"></property>
	</bean>
	<bean id="sentinelConfiguration" class="org.springframework.data.redis.connection.RedisSentinelConfiguration">
		<property name="master">
			<bean class="org.springframework.data.redis.connection.RedisNode">
				<property name="name" value="mymaster"></property>
			</bean>
		</property>
		<property name="sentinels">
			<set>
				<bean class="org.springframework.data.redis.connection.RedisNode">
					<constructor-arg name="host" value="10.153.29.54"></constructor-arg>
					<constructor-arg name="port" value="16379"></constructor-arg>
				</bean>
				<bean class="org.springframework.data.redis.connection.RedisNode">
					<constructor-arg name="host" value="10.153.29.54"></constructor-arg>
					<constructor-arg name="port" value="26379"></constructor-arg>
				</bean>
				<bean class="org.springframework.data.redis.connection.RedisNode">
					<constructor-arg name="host" value="10.153.29.55"></constructor-arg>
					<constructor-arg name="port" value="16379"></constructor-arg>
				</bean>
			</set>
		</property>
	</bean>
	
	<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
		destroy-method="destroy">
		<property name="timeout" value="15000" />
		<property name="database" value="0" />
		<property name="password" value="" />
		<property name="usePool" value="true" />
		<property name="poolConfig" ref="jedisPoolConfig" />
		<constructor-arg name="sentinelConfig" ref="sentinelConfiguration"></constructor-arg>
	</bean>

	<!-- redis template definition p表示对该bean里面的属性进行注入，格式为p:属性名=注入的对象 效果与在bean里面使用<property>标签一样 -->
	<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" p:connection-factory-ref="jedisConnectionFactory">
		<property name="defaultSerializer">
			<bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		</property>
	</bean>
	<!-- 对string操作的封装 -->
	<bean id="stringRedisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate"
		p:connection-factory-ref="jedisConnectionFactory" >
		<property name="defaultSerializer">
			<bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		</property>
	</bean>
	
	
</beans>

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.hash.HashMapper;
import org.springframework.stereotype.Service;
/**
 * 
 * @author baoy
 *
 */
@Service
public class RedisRepositoryImpl implements RedisRepository {
	//private static final Logger logger = LoggerFactory.getLogger(RedisRepositoryImpl.class);
	@Autowired
	private StringRedisTemplate stringRedisTemplate;
	//@Autowired
	//private RedisTemplate redisTemplate;
	
	private String keyPrefix = "";
	public void setKeyPrefix(String keyPrefix) {
		if (keyPrefix == null || "".equals(keyPrefix)) {
			this.keyPrefix = "";
		} else {
			this.keyPrefix = keyPrefix;
		}
	}

	/**
	 * <pre>
	 * 命令：ttl key
	 * 说明：以秒为单位，返回给定 key的剩余生存时间(TTL, time to live)。
	 * </pre>
	 * @param key
	 * @return
	 */
	public long ttl(String key) {
		return stringRedisTemplate.getExpire(keyPrefix+key);
	}

	/**
	 * <pre>
	 * 命令：keys pattern
	 * 说明：查找所有符合给定模式 pattern的 key
	 * </pre>
	 */
	public Set<String> keys(String pattern) {
		return stringRedisTemplate.keys(pattern);
	}

	/**
	 * <pre>
	 * 命令：del key
	 * 说明：删除一个key
	 * </pre>
	 * @param key
	 */
	public void del(String key) {
		stringRedisTemplate.delete(keyPrefix+key);
	}

	//****************String

	/**
	 * <pre>
	 * 命令：set key value
	 * 说明：将key的值设置为value
	 * </pre>
	 * @param key
	 * @param value
	 */
	public void set(String key, String value) {
		stringRedisTemplate.opsForValue().set(keyPrefix+key, value);
	}
	/**
	 * <pre>
	 * 命令：SET key value EX seconds
	 * 说明：设置key值的同时，为该key设置超时时间（秒）
	 * </pre>
	 * @param key
	 * @param value
	 * @param timeout
	 */
	public void set(String key, String value, long timeout) {
		stringRedisTemplate.opsForValue().set(keyPrefix+key, value, timeout, TimeUnit.SECONDS);
	}
	/**
	 * <pre>
	 * 命令：setNx key value
	 * 含义：与set的区别是，如果不存在时，写入；存在时，不覆盖
	 * </pre>
	 * @param key
	 * @param value
	 */
	public boolean setNx(String key, String value) {
		return stringRedisTemplate.opsForValue().setIfAbsent(keyPrefix+key, value);
	}
	/**
	 * <pre>
	 * 命令：GET key
	 * 说明：获取key值
	 * </pre>
	 * @param key
	 * @return value
	 */
	public String get(String key) {
		return stringRedisTemplate.opsForValue().get(keyPrefix+key);
	}

	//****************Hash
	/**
	 * <pre>
	 * 命令：hSet key field value
	 * 含义：
	 * 1、将哈希表 key中的域 field的值设为 value
	 * 2、覆盖旧有field的value
	 * </pre>
	 * @param key
	 * @param field
	 * @param value
	 */
	public void hSet(String key, String field, Object value) {
		stringRedisTemplate.opsForHash().put(keyPrefix+key, field, value);
	}
	/**
	 * <pre>
	 * 命令：hSetNx key field value
	 * 含义：与hSet的区别是，如果不存在时，写入；存在时，不覆盖
	 * </pre>
	 * @param key
	 * @param field
	 * @param value
	 */
	public boolean hSetNx(String key, String field, Object value) {
		return stringRedisTemplate.opsForHash().putIfAbsent(keyPrefix+key, field, value);
	}
	/**
	 * <pre>
	 * 命令：HGET key field
	 * 说明：返回哈希表 key中给定域 field的值
	 * </pre>
	 * @param key
	 * @param field
	 * @return
	 */
	public String hGet(String key, String field) {
		return (String) stringRedisTemplate.opsForHash().get(keyPrefix+key, field);
	}
	/**
	 * <pre>
	 * 命令：hGetAll key
	 * 说明：获取指定key先所有的key/value的键值对
	 * </pre>
	 * @param key
	 * @return
	 */
	public Map hGetAll(String key) {
		return (Map) stringRedisTemplate.opsForHash().entries(keyPrefix+key);
	}
	/**
	 * <pre>
	 * 命令：hDel key field [field ...]
	 * 说明：删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
	 * </pre>
	 * @param key
	 * @param fields
	 */
	public void hDel(String key, Object... fields) {
		stringRedisTemplate.opsForHash().delete(keyPrefix+key, fields);
	}

	//****************List
	/**
	 * <pre>
	 * 命令：lPush key value
	 * 说明：
	 * 1.将一个值 value插入到列表 key的最左边
	 * 2.当该列表key不存在时，则创建
	 * </pre>
	 * @param key
	 * @param value
	 * @return 执行 lPush命令后，列表的长度
	 */
	public long lPush(String key, String value) { 
		return stringRedisTemplate.opsForList().leftPush(keyPrefix+key, value);
	}

	/**
	 * <pre>
	 * 命令：lPop key
	 * 说明：移除该列表key最左边的元素
	 * </pre>
	 * @param key
	 * @return 列表key的最左边元素。
	 */
	public String lPop(String key) {
		return stringRedisTemplate.opsForList().leftPop(keyPrefix+key);
	}
	
	public List<String> range(String key,int start,int end){
		return stringRedisTemplate.opsForList().range(keyPrefix+key, start, end);
	}
	
	public long llen(String key){
		return stringRedisTemplate.opsForList().size(keyPrefix+key);
	}

	/**
	 * <pre>
	 * 命令：rPush key value
	 * 说明：向list最右边插入元素value
	 * </pre>
	 * @param key
	 * @param value
	 * @return 执行 rPush命令后，列表的长度
	 */
	public long rPush(String key, String value) { 
		return stringRedisTemplate.opsForList().rightPush(keyPrefix+key, value);
	}

	/**
	 * <pre>
	 * 命令：rPop key
	 * 说明：移除并返回列表 key的最右边元素
	 * </pre>
	 * @param key
	 * @return 列表key的最右边元素。
	 */
	public String rPop(String key) {
		return stringRedisTemplate.opsForList().rightPop(keyPrefix+key);
	}

	//****************Set
	/**
	 * <pre>
	 * 命令：sAdd key value
	 * 说明：
	 * 1.将一个 value元素加入到集合 key当中
	 * 2.已经存在于集合的 value元素将被忽略。
	 * </pre>
	 * @param key
	 * @param value
	 */
	public Long sAdd(String key, String value) {
		return stringRedisTemplate.opsForSet().add(keyPrefix+key, value);
	}
	/**
	 * <pre>
	 * 命令：sMembers key
	 * 说明：返回集合 key 中的所有成员。
	 * </pre>
	 * @param key
	 * @return
	 */
	public Set<String> sMembers(String key) {
		return stringRedisTemplate.opsForSet().members(keyPrefix+key);
	}
	/**
	 * <pre>
	 * 命令：sRem key v1[v2 v3…]。
	 * 说明：删除key中指定的values
	 * </pre>
	 * @param key
	 * @param values
	 * @return 返回被删除的元素的数量，如果没有被删除的元素，则返回0
	 */
	public Long sRem(String key, Object... values) {
		return stringRedisTemplate.opsForSet().remove(keyPrefix+key, values);
	}
	//****************SortedSet
	/**
	 * <pre>
	 * 命令：zAdd key score member
	 * 说明：将一个 member元素及其 score值加入到有序集 key当中。
	 * <pre>
	 * @param key
	 * @param score
	 * @param value
	 */
	public void zAdd(String key, double score, String value) {
		stringRedisTemplate.opsForZSet().add(keyPrefix+key, value, score);
	}
	/**
	 * <pre>
	 * 命令：zRange key start stop
	 * 说明：返回有序集 key中，指定区间内的成员。
	 * </pre>
	 * @param key
	 * @param start
	 * @param stop
	 * @return
	 */
	public Set<String> zRange(String key, double start, double stop) {
		return stringRedisTemplate.opsForZSet().rangeByScore(keyPrefix+key, start, stop);
	}
	//=====obj2map map2obj
	/**
	 * 对象转map。可应用于多个对象（一个类中的属性是另外一个类）
	 * @param t
	 * @param mapper
	 * @return
	 */
	public <T> Map obj2map(T t, HashMapper<T, String, String> mapper) {
		return mapper.toHash(t);
	}
	/**
	 * map转对象。只应用于单个对象
	 * @param map
	 * @param mapper
	 * @return
	 */
	public <T> T map2obj(Map map, HashMapper<T, String, String> mapper) {
		return mapper.fromHash(map);
	}
}

import java.util.List;
import java.util.Map;
import java.util.Set;

import org.springframework.data.redis.hash.HashMapper;
/**
 * 
 * @author baoy
 *
 */
public interface RedisRepository {
	/**
	 * <pre>
	 * 命令：ttl key
	 * 说明：以秒为单位，返回给定 key的剩余生存时间(TTL, time to live)。
	 * </pre>
	 * @param key
	 * @return
	 */
	long ttl(String key);

	/**
	 * <pre>
	 * 命令：keys pattern
	 * 说明：查找所有符合给定模式 pattern的 key
	 * </pre>
	 */
	Set<String> keys(String pattern);

	/**
	 * <pre>
	 * 命令：del key
	 * 说明：删除一个key
	 * </pre>
	 * @param key
	 */
	void del(String key);

	//****************String

	/**
	 * <pre>
	 * 命令：set key value
	 * 说明：将key的值设置为value
	 * </pre>
	 * @param key
	 * @param value
	 */
	void set(String key, String value);
	/**
	 * <pre>
	 * 命令：SET key value EX seconds
	 * 说明：设置key值的同时，为该key设置超时时间（秒）
	 * </pre>
	 * @param key
	 * @param value
	 * @param timeout
	 */
	void set(String key, String value, long timeout);
	/**
	 * <pre>
	 * 命令：setNx key value
	 * 含义：与set的区别是，如果不存在时，写入；存在时，不覆盖
	 * </pre>
	 * @param key
	 * @param value
	 */
	boolean setNx(String key, String  value); 
	/**
	 * <pre>
	 * 命令：GET key
	 * 说明：获取key值
	 * </pre>
	 * @param key
	 * @return value
	 */
	String get(String key);

	//****************Hash
	/**
	 * <pre>
	 * 命令：hSet key field value
	 * 含义：
	 * 1、将哈希表 key中的域 field的值设为 value
	 * 2、覆盖旧有field的value
	 * </pre>
	 * @param key
	 * @param field
	 * @param value
	 */
	void hSet(String key, String field, Object value);
	/**
	 * <pre>
	 * 命令：hSetNx key field value
	 * 含义：与hSet的区别是，如果不存在时，写入；存在时，不覆盖
	 * </pre>
	 * @param key
	 * @param field
	 * @param value
	 */
	boolean hSetNx(String key, String field, Object value);
	/**
	 * <pre>
	 * 命令：HGET key field
	 * 说明：返回哈希表 key中给定域 field的值
	 * </pre>
	 * @param key
	 * @param field
	 * @return
	 */
	String hGet(String key, String field);
	/**
	 * <pre>
	 * 命令：hGetAll key
	 * 说明：获取指定key先所有的key/value的键值对
	 * </pre>
	 * @param key
	 * @return
	 */
	Map hGetAll(String key);
	/**
	 * <pre>
	 * 命令：hDel key field [field ...]
	 * 说明：删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
	 * </pre>
	 * @param key
	 * @param fields
	 */
	void hDel(String key, Object... fields);

	//****************List
	/**
	 * <pre>
	 * 命令：lPush key value
	 * 说明：
	 * 1.将一个值 value插入到列表 key的最左边
	 * 2.当该列表key不存在时，则创建
	 * </pre>
	 * @param key
	 * @param value
	 * @return 执行 lPush命令后，列表的长度
	 */
	long lPush(String key, String value);

	/**
	 * <pre>
	 * 命令：lPop key
	 * 说明：移除该列表key最左边的元素
	 * </pre>
	 * @param key
	 * @return 列表key的最左边元素。
	 */
	String lPop(String key);

	List<String> range(String key,int start,int end);
	
	long llen(String key);
	
	/**
	 * <pre>
	 * 命令：rPush key value
	 * 说明：向list最右边插入元素value
	 * </pre>
	 * @param key
	 * @param value
	 * @return 执行 rPush命令后，列表的长度
	 */
	long rPush(String key, String value);

	/**
	 * <pre>
	 * 命令：rPop key
	 * 说明：移除并返回列表 key的最右边元素
	 * </pre>
	 * @param key
	 * @return 列表key的最右边元素。
	 */
	String rPop(String key);

	//****************Set
	/**
	 * <pre>
	 * 命令：sAdd key value
	 * 说明：
	 * 1.将一个 value元素加入到集合 key当中
	 * 2.已经存在于集合的 value元素将被忽略。
	 * </pre>
	 * @param key
	 * @param value
	 */
	Long sAdd(String key, String value);
	/**
	 * <pre>
	 * 命令：sMembers key
	 * 说明：返回集合 key 中的所有成员。
	 * </pre>
	 * @param key
	 * @return
	 */
	Set<String> sMembers(String key);
	/**
	 * <pre>
	 * 命令：sRem key v1[v2 v3…]。
	 * 说明：删除key中指定的values
	 * </pre>
	 * @param key
	 * @param values
	 * @return 返回被删除的元素的数量，如果没有被删除的元素，则返回0
	 */
	Long sRem(String key, Object... values);
	//****************SortedSet
	/**
	 * <pre>
	 * 命令：zAdd key score member
	 * 说明：将一个 member元素及其 score值加入到有序集 key当中。
	 * <pre>
	 * @param key
	 * @param score
	 * @param value
	 */
	void zAdd(String key, double score, String value);
	/**
	 * <pre>
	 * 命令：zRange key start stop
	 * 说明：返回有序集 key中，指定区间内的成员。
	 * </pre>
	 * @param key
	 * @param start
	 * @param stop
	 * @return
	 */
	Set<String> zRange(String key, double start, double stop);
	//=====obj2map map2obj
	/**
	 * 对象转map。可应用于多个对象（一个类中的属性是另外一个类）
	 * @param t
	 * @param mapper
	 * @return
	 */
	<T> Map obj2map(T t, HashMapper<T, String, String> mapper);
	/**
	 * map转对象。只应用于单个对象
	 * @param map
	 * @param mapper
	 * @return
	 */
	<T> T map2obj(Map map, HashMapper<T, String, String> mapper);
}

捐助开发者 

在兴趣的驱动下,写一个免费的东西，有欣喜，也还有汗水，希望你喜欢我的作品，同时也能支持一下。 当然，有钱捧个钱场（支持支付宝和微信 以及扣扣群），没钱捧个人场，谢谢各位。

个人主页：http://knight-black-bob.iteye.com/

 
 
 谢谢您的赞助，我会做的更好！