redis-cluster spring

pom.xml

<!-- Redis 相关依赖  -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.8.1.RELEASE</version>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>

<spring.version>4.2.6.RELEASE</spring.version>

redis.properties

redis.host=127.0.0.1  
redis.port=6379   
redis.password=  
redis.maxIdle=100  
redis.maxActive=300  
redis.maxWait=1000   
redis.timeout=100000  
redis.maxTotal=1000  
redis.minIdle=8  
redis.testOnBorrow=true 
  
#rediscluster  
spring.redis.cluster.nodes=127.0.0.1:7000,127.0.0.1:7001,127.0.0.1:7002,127.0.0.1:7003,127.0.0.1:7004,127.0.0.1:7005
spring.redis.cluster.max-redirects=3  
#rediscluster 

application-context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:ehcache="http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:cache="http://www.springframework.org/schema/cache"
    xsi:schemaLocation="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/tx 
     http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
     http://www.springframework.org/schema/aop
     http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
     http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring   
     http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring/ehcache-spring-1.1.xsd
     http://www.springframework.org/schema/cache   
     http://www.springframework.org/schema/cache/spring-cache-4.0.xsd">
    <!-- 数据库配置文件 -->
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>file:./sealConfig/redis.properties</value>
            </list>
        </property>
    </bean>


    <!-- 事务配置 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" abstract="false" lazy-init="default" autowire="default">
        <property name="dataSource">
            <ref bean="dataSource" />
        </property>
    </bean>


    <!-- 数据源配置 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClassName}" />
        <property name="jdbcUrl" value="${jdbc.url}" />
        <property name="user" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
        <property name="autoCommitOnClose" value="true" />
        <property name="initialPoolSize" value="${cpool.initialPoolSize}" />
        <property name="minPoolSize" value="${cpool.minPoolSize}" />
        <property name="maxPoolSize" value="${cpool.maxPoolSize}" />
        <property name="checkoutTimeout" value="${cpool.checkoutTimeout}" />
        <property name="preferredTestQuery" value="${cpool.preferredTestQuery}" />
        <property name="idleConnectionTestPeriod" value="${cpool.idleConnectionTestPeriod}" />
        <property name="maxIdleTime" value="${cpool.maxIdleTime}" />
        <property name="maxIdleTimeExcessConnections" value="${cpool.maxIdleTimeExcessConnections}" />
        <property name="testConnectionOnCheckin" value="${cpool.testConnectionOnCheckin}" />
        <property name="acquireIncrement" value="${cpool.acquireIncrement}" />
        <property name="acquireRetryDelay" value="${cpool.acquireRetryDelay}"/>
        <property name="acquireRetryAttempts" value="${cpool.acquireRetryAttempts}"/>
    </bean>


    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource" />
    </bean>

    <bean id="smartDao" class="cfca.seal.dao.SmartDao">
        <property name="jdbcTemplate" ref="jdbcTemplate" />
    </bean>
    
    <!-- jedis 配置 -->
    <!-- 引入配置文件 -->  
  
    <!-- jedis 配置-->  
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig" >  
        <!--最大空闲数-->  
        <property name="maxIdle" value="${redis.maxIdle}" />  
        <!--最大建立连接等待时间-->  
        <property name="maxWaitMillis" value="${redis.maxWait}" />  
        <!--是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个-->  
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />  
        <property name="maxTotal" value="${redis.maxTotal}" />  
        <property name="minIdle" value="${redis.minIdle}" />  
    </bean> 
    <!--配置文件加载-->  
    <bean id="resourcePropertySource" class="org.springframework.core.io.support.ResourcePropertySource">  
        <constructor-arg name="name" value="jdbc.properties"/>  
        <constructor-arg name="resource" value="file:./sealConfig/jdbc.properties"/>  
    </bean>  
    <!--redisCluster配置-->  
    <bean id="redisClusterConfiguration" class="org.springframework.data.redis.connection.RedisClusterConfiguration">  
        <constructor-arg name="propertySource" ref="resourcePropertySource"/>  
    </bean>  
      <!-- redis服务器中心 -->  
    <bean id="connectionFactory"  class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >  
       <constructor-arg ref="redisClusterConfiguration"/>  
        <constructor-arg ref="poolConfig"/>         
        <property name="timeout" value="${redis.timeout}" ></property>  
    </bean > 
 
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >
          <property name="connectionFactory" ref="connectionFactory" />
          <property name="keySerializer" >
              <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
          </property>
          <property name="valueSerializer" >
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />  
           <!-- <bean class="org.springframework.data.redis.serializer.JacksonJsonRedisSerializer" />  -->
          </property>
            <property name="hashKeySerializer">  
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>  
        </property>  
        <property name="hashValueSerializer">  
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>  
        </property> 
        </bean >
    <!-- 数据库缓存管理器 -->
    <cache:annotation-driven cache-manager="cacheManager"/>
    <!-- spring自己的缓存管理器，这里定义了缓存位置名称 ，即注解中的value -->    
     <bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">    
         <property name="caches">    
            <set>    
                <!-- 这里可以配置多个redis -->  
               <bean class="xxx.RedisCache">    
                     <property name="redisTemplate" ref="redisTemplate" />    
                     <property name="name" value="defaultCache"/>    
                </bean>    
            </set>    
         </property>    
     </bean>
   </beans>

RedisCache.java

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


import org.springframework.cache.Cache;
import org.springframework.cache.support.SimpleValueWrapper;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;




public class RedisCache implements Cache {


private RedisTemplate<String, Object> redisTemplate;
private String name;


public RedisTemplate<String, Object> getRedisTemplate() {
return redisTemplate;
}


public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
this.redisTemplate = redisTemplate;
}


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


@Override
public String getName() {
// TODO Auto-generated method stub
return this.name;
}


@Override
public Object getNativeCache() {
// TODO Auto-generated method stub
return this.redisTemplate;
}


@Override
public ValueWrapper get(Object key) {
// TODO Auto-generated method stub
final String keyf = (String) key;
Object object = null;
object = redisTemplate.execute(new RedisCallback<Object>() {
public Object doInRedis(RedisConnection connection)
throws DataAccessException {


byte[] key = keyf.getBytes();
byte[] value = connection.get(key);
if (value == null) {
return null;
}
return toObject(value);


}
});
return (object != null ? new SimpleValueWrapper(object) : null);
}


@Override
public void put(Object key, Object value) {
// TODO Auto-generated method stub
final String keyf = (String) key;
final Object valuef = value;
final long liveTime = 86400;


redisTemplate.execute(new RedisCallback<Long>() {
public Long doInRedis(RedisConnection connection)
throws DataAccessException {
byte[] keyb = keyf.getBytes();
byte[] valueb = toByteArray(valuef);
connection.set(keyb, valueb);
if (liveTime > 0) {
connection.expire(keyb, liveTime);
}
return 1L;
}
});
}


/**
* 描述 : <Object转byte[]>. <br>
* <p>
* <使用方法说明>
* </p>
* 
* @param obj
* @return
*/
private byte[] toByteArray(Object obj) {
byte[] bytes = null;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try {
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(obj);
oos.flush();
bytes = bos.toByteArray();
oos.close();
bos.close();
} catch (IOException ex) {
ex.printStackTrace();
}
return bytes;
}


/**
* 描述 : <byte[]转Object>. <br>
* <p>
* <使用方法说明>
* </p>
* 
* @param bytes
* @return
*/
private Object toObject(byte[] bytes) {
Object obj = null;
try {
ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bis);
obj = ois.readObject();
ois.close();
bis.close();
} catch (IOException ex) {
ex.printStackTrace();
} catch (ClassNotFoundException ex) {
ex.printStackTrace();
}
return obj;
}


@Override
public void evict(Object key) {
// TODO Auto-generated method stub
final String keyf = (String) key;
redisTemplate.execute(new RedisCallback<Long>() {
public Long doInRedis(RedisConnection connection)
throws DataAccessException {
return connection.del(keyf.getBytes());
}
});
}


@Override
public void clear() {
// TODO Auto-generated method stub
redisTemplate.execute(new RedisCallback<String>() {
public String doInRedis(RedisConnection connection)
throws DataAccessException {
connection.flushDb();
return "ok";
}
});
}


    @Override
    public <T> T get(Object arg0, Class<T> arg1) {
        // TODO Auto-generated method stub
        return null;
    }


    @Override
    public ValueWrapper putIfAbsent(Object arg0, Object arg1) {
        // TODO Auto-generated method stub
        return null;
    }

}

标签注入：

@CacheEvict(value = { "defaultCache"}, allEntries = true)

@Cacheable(value="defaultCache",key="'getSealById_'+#id")