spring整合redis3.x集群-蒲公英云

spring整合redis3.x集群

连接池数据库配置

<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:jdbc.properties</value>
                <value>classpath:redis.properties</value>
            </list>
        </property>
    </bean>
    <!--redisPool配置 -->
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!--最大连接数 -->
        <property name="maxTotal" value="${redis.maxTotal}"/>
        <!--最大空闲连接数 -->
        <property name="maxIdle" value="${redis.maxIdle}"/>
        <!--每次释放连接的最大数目 -->
        <property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}"/>
        <!--释放连接的扫描间隔(单位:毫秒) -->
        <property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}"/>
        <!--连接最小空闲时间(单位:毫秒) -->
        <property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}"/>
        <!--连接空闲多久后释放,当空闲时间大于该值并且空闲连接大于最大空闲连接时直接释放连接 -->
        <property name="softMinEvictableIdleTimeMillis" value="${redis.softMinEvictableIdleTimeMillis}"/>
        <!--获取连接时最大等待毫秒数,如果该值小于0,则阻塞不确定的时长,默认值-1 -->
        <property name="maxWaitMillis" value="${redis.maxWaitMillis}"/>
        <!--在获取连接时检查连接有效性,默认为false -->
        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
        <!--在连接空闲时检查连接有效性,默认为false -->
        <property name="testWhileIdle" value="${redis.testWhileIdle}"/>
        <!--连接耗尽是否阻塞,false代表抛异常,true代表阻塞直到超时,默认为true -->
        <property name="blockWhenExhausted" value="${redis.blockWhenExhausted}"/>
    </bean>
    <!--配置redis集群 -->
    <bean id="myJedisCuster" class="redis.clients.jedis.JedisCluster">
        <constructor-arg name="nodes">
            <!--设置集群节点 -->
            <set>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="${redis.host}"/>
                    <constructor-arg name="port" value="${redis.port1}"/>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="${redis.host}"/>
                    <constructor-arg name="port" value="${redis.port2}"/>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="${redis.host}"/>
                    <constructor-arg name="port" value="${redis.port3}"/>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="${redis.host}"/>
                    <constructor-arg name="port" value="${redis.port4}"/>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="${redis.host}"/>
                    <constructor-arg name="port" value="${redis.port5}"/>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="${redis.host}"/>
                    <constructor-arg name="port" value="${redis.port6}"/>
                </bean>
            </set>
        </constructor-arg>
        <!--设置连接超时时间 -->
        <!--<constructor-arg name="connectionTimeout" value="${redis.timeout}"/>-->
        <!--设置网络通信超时时间 -->
        <!--<constructor-arg name="soTimeout" value="${redis.soTimeout}"/>-->
        <!--设置最大重试次数 -->
        <!--<constructor-arg name="maxAttempts" value="${redis.attempts}"/>-->
        <!--设置jedisPool配置 -->
        <constructor-arg name="poolConfig" ref="jedisPoolConfig"/>
    </bean>
    <!--配置jedisClientCluster -->
    <bean id="jedisClientCluster" class="org.seckill.redis.JedisClientCluster">
        <property name="jedisCluster" ref="myJedisCuster" />
    </bean>

redis.properties

redis.maxIdle=10
redis.maxTotal=30
redis.testOnBorrow=false
redis.testWhileIdle=true
redis.numTestsPerEvictionRun=1024
redis.timeBetweenEvictionRunsMillis=30000
redis.minEvictableIdleTimeMillis=100000
redis.softMinEvictableIdleTimeMillis=10000
redis.maxWaitMillis=1500
redis.blockWhenExhausted=false
redis.timeout=6000
redis.host=127.0.0.1
redis.port1=7000
redis.port2=7001
redis.port3=7002
redis.port4=7003
redis.port5=7004
redis.port6=7005

JedisClientCluster.java

package org.seckill.redis;
import redis.clients.jedis.JedisCluster;
import java.util.List;
import java.util.Map;
public class JedisClientCluster implements JedisClient {
    private JedisCluster jedisCluster;
    public JedisCluster getJedisCluster() {
        return jedisCluster;
    }
    public void setJedisCluster(JedisCluster jedisCluster) {
        this.jedisCluster = jedisCluster;
    }
    @Override
    public String set(String key, String value) {
        return jedisCluster.set(key, value);
    }
    @Override
    public String get(String key) {
        return jedisCluster.get(key);
    }
    @Override
    public Boolean exists(String key) {
        return jedisCluster.exists(key);
    }
    @Override
    public Long expire(String key, int seconds) {
        return jedisCluster.expire(key, seconds);
    }
    @Override
    public Long ttl(String key) {
        return jedisCluster.ttl(key);
    }
    @Override
    public Long hset(String key, String field, String value) {
        return jedisCluster.hset(key, field, value);
    }
    @Override
    public String hget(String key, String field) {
        return jedisCluster.hget(key, field);
    }
    @Override
    public Long hdel(String key, String... field) {
        return jedisCluster.hdel(key, field);
    }
    @Override
    public Boolean hexists(String key, String field) {
        return jedisCluster.hexists(key, field);
    }
    @Override
    public Map<String, String> hgetAll(String key) {
        return jedisCluster.hgetAll(key);
    }
    @Override
    public List<String> hvals(String key) {
        return jedisCluster.hvals(key);
    }
    @Override
    public Long del(String key) {
        return jedisCluster.del(key);
    }
}

JedisClient.java

package org.seckill.redis;
import java.util.List;
import java.util.Map;
public interface JedisClient {
    /**
     * 设置一个字符串类型的值,如果记录存在则覆盖原有value
     *
     * @param key   值对应的键
     * @param value 值
     * @return 状态码, 成功则返回OK
     */
    String set(String key, String value);
    /**
     * 从redis中根据key取值
     *
     * @param key 要取得值对应的key
     * @return 取到的value值
     */
    String get(String key);
    /**
     * 判断某个键值对是否存在
     *
     * @param key 根据键判断
     * @return 判断结果
     */
    Boolean exists(String key);
    /**
     * 设置键值对的过期时间
     *
     * @param key     要设置过期时间的k键值对的键
     * @param seconds 过期时间
     * @return 影响的记录数
     */
    Long expire(String key, int seconds);
    /**
     * 查看键值对的剩余时间
     *
     * @param key 要查看的键值对的键
     * @return 剩余时间
     */
    Long ttl(String key);
    /**
     * 添加一个对应关系
     *
     * @param key   存储的键
     * @param field 存储的名字
     * @param value 存储的值
     * @return 状态码, 1成功, 0失败, 如果field已存在将更新, 返回0
     */
    Long hset(String key, String field, String value);
    /**
     * 返回hash中指定存储的值
     *
     * @param key   查找的存储的键
     * @param field 查找的存储的名字
     * @return 指定存储的值
     */
    String hget(String key, String field);
    /**
     * 从hash中删除指定的存储
     *
     * @param key   存储的键
     * @param field 存储的名字
     * @return 状态码, 1成功, 0失败
     */
    Long hdel(String key, String... field);
    /**
     * 检测hash中指定的存储是否存在
     *
     * @param key   存储的键
     * @param field 存储的额名字
     * @return 状态码, 1代表成功, 0代表失败
     */
    Boolean hexists(String key, String field);
    /**
     * 以map的形式返回hash存储的名字和值
     *
     * @param key 存储的键
     * @return 根据key查找到的存储的名字和值
     */
    Map<String, String> hgetAll(String key);
    /**
     * 获取hash中value的集合
     *
     * @param key hash中存储的键
     * @return 指定键的所有value的集合
     */
    List<String> hvals(String key);
    /**
     * 根据存储的键删除存储
     *
     * @param key 存储的键
     * @return 状态码, 1成功, 0失败
     */
    Long del(String key);
}

JunitTest测试类

package org.seckill.redis;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class JedisClientClusterTest {
    private ApplicationContext context;
    @Before
    public void setUp() {
        context = new ClassPathXmlApplicationContext(new String[]{加载你自己的spring xml配置文件});
    }
    @Test
    public void testRedisCluster(){
        JedisClientCluster jedisClientCluster = (JedisClientCluster) context.getBean("jedisClientCluster");
        jedisClientCluster.set("foo","chyw");
        String value = jedisClientCluster.get("foo");
        System.out.println(value);
    }
    @After
    public void tearDown() {
    }
}