redis cluster 集群配置

<!--    使用Redis作为缓存数据服务redis 集群模式-->
    <bean id="redisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"  p:password="Aicc@123">
        <constructor-arg index="0">
            <bean class="org.springframework.data.redis.connection.RedisClusterConfiguration">
                <constructor-arg>
                    <list>
                        <value>35.22.1.86:6379</value>
                        <value>35.22.1.87:6379</value>
                        <value>35.22.1.88:6379</value>
                    </list>
                </constructor-arg>
                <property name="maxRedirects" value="5" />
            </bean>
        </constructor-arg>
        <constructor-arg index="1">
            <bean class="redis.clients.jedis.JedisPoolConfig">
                <property name="maxTotal" value="100"/>
                <property name="maxIdle" value="10"/>
                <property name="minIdle" value="1"/>
                <property name="maxWaitMillis" value="30000"/>
            </bean>
        </constructor-arg>
    </bean>

    <!-- 使用Redis作为缓存数据服务-->
<!--    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" p:use-pool="true"  p:host-name="130.1.14.82"  p:port="6380" p:password="123456" />-->
<!--         -->
    <bean id="redisTemplate" class="net.sf.liveSupport.cache.redis.SimpleRedisTemplate"
          p:connection-factory-ref="redisConnectionFactory" p:scope="xiaolinfuwu">
    </bean>

 

SimpleRedisTemplate 

package net.sf.liveSupport.cache.redis;

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

import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SessionCallback;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

public class SimpleRedisTemplate extends RedisTemplate<Object, Object> implements IRedisTemplate {
	private String scope;

	public SimpleRedisTemplate() {
		RedisSerializer<String> redisSerializer = new StringRedisSerializer();//Long类型不可以会出现异常信息;
		this.setKeySerializer(redisSerializer);
		this.setHashKeySerializer(redisSerializer);
	}
	
	public String getScope() {
		return scope + ".";
	}
	
    public void setScope(String scope) {
        this.scope = scope;
    }

	@Override
	public void set(String key, Object value) {
		this.opsForValue().set(key, value);
	}

	@Override
	public void set(String key, Object value, long ttl, TimeUnit timeUnit) {
		this.opsForValue().set(key, value, ttl, timeUnit);
	}

	@Override
	public Object get(String key) {
		return this.opsForValue().get(key);
	}

	@Override
	public List<Object> multiGet(Collection<Object> keys) {
		return this.opsForValue().multiGet(keys);
	}

	@Override
	public void multiSet(Map<? extends String, ?> map) {
		this.opsForValue().multiSet(map);
	}

	@Override
	public Boolean expire(Object key, long timeout, TimeUnit unit) {
		return super.expire(key, timeout, unit);
	}

	@Override
	public Boolean delete(Object key) {
		return super.delete(key);
	}

    @Override
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public void putToList(final String key, final Object value) {
    	this.execute(new SessionCallback<List<Object>>() {
			public List<Object> execute(RedisOperations operations) throws DataAccessException {
				List<Object> result = null;
				do {
					operations.watch(key);
					List<Object> list = (List<Object>)operations.opsForValue().get(key);
					if (list == null) {
						list = new ArrayList<Object>();
					}
					list.add(value);
					operations.multi();
					operations.opsForValue().set(key, list);
					try {
						result = operations.exec();
					} catch (Exception e) {}
				} while (result == null);
				return result;
			}
        });
	}

    @Override
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public void removeFromList(final String key, final Object value) {
		this.execute(new SessionCallback<List<Object>>() {
			
			public List<Object> execute(RedisOperations operations) throws DataAccessException {
				List<Object> result = null;
				do {
					operations.watch(key);
					List<Object> list = (List<Object>)operations.opsForValue().get(key);
					if (list == null) {
						break;
					}
					list.remove(value);
					operations.multi();
					operations.opsForValue().set(key, list);
					try {
						result = operations.exec();
					} catch (Exception e) {}
				} while (result == null);
				return result;
			}
		});
	}


    @Override
	public <T> List<T> getList(String key, Class<T> type) {
		List<T> result = (List<T>)this.opsForValue().get(key);
		return result;
	}


    @Override
	public void saveForHash(String key, Object hashKey, Object value) {
		this.opsForHash().put(key, hashKey, value);
	}


    @Override
	public void removeForHash(String key, Object... hashKeys) {
		this.opsForHash().delete(key, hashKeys);
	}


    @Override
	public Object getForHash(String key, Object hashKey) {
		return this.opsForHash().get(key, hashKey);
	}


    @Override
	public Map<Object, Object> entriesForHash(String key) {
		return this.opsForHash().entries(key);
	}


    @Override
	public void putAllForHash(String key, Map<? extends Object, ? extends Object> m) {
		this.opsForHash().putAll(key, m);
	}


    @Override
	public String getCollectionName(String collectionName, String epid) {
		return this.getScope() + collectionName;
	}
	

    @Override
	public void addKey(String key, Object value) {
		this.opsForSet().add(key, value);
	}

    @Override
	public void removeKey(String key, Object value) {
		this.opsForSet().remove(key, value);
	}

	@Override
	public Set<Object> membersForKey(Object key) {
		return this.opsForSet().members(key);
	}

	@Override
	public void destroy() {
		
	}

	@Override
	public Set<Object> keys(String key) {
		return super.keys(key);
	}


	@Override
	public <T> T execute(SessionCallback<T> action) {
		return super.execute(action);
	}

	@Override
	public void restore(Object key, byte[] value, long timeToLive, TimeUnit unit) {

	}

	@Override
	public Boolean setIfAbsent(Object key, Object value) {
		return this.opsForValue().setIfAbsent(key, value);
	}

	@Override
	public Boolean setIfAbsent(Object key, Object value, long ttl, TimeUnit timeUnit) {
		return this.opsForValue().setIfAbsent(key, value, ttl, timeUnit);
	}

	@Override
	public Object getAndSet(Object key, Object value) {
		return this.opsForValue().getAndSet(key, value);
	}


}

 

IRedisTemplate

package net.sf.liveSupport.cache.redis;

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

import org.springframework.data.redis.core.SessionCallback;

public interface IRedisTemplate {
    String getScope();

    void set(String key, Object value);

    void set(String key, Object value, long ttl, TimeUnit timeUnit);

    Object get(String key);

    List<Object> multiGet(Collection<Object> keys);

    void multiSet(Map<? extends String, ?> map);

    Boolean expire(Object key, long timeout, TimeUnit unit);

    Boolean delete(Object key);

    Long delete(Collection<Object> keys);

    void putToList(final String key, final Object value);

    void removeFromList(final String key, final Object value);

    <T> List<T> getList(String key, Class<T> type);

    void saveForHash(String key, Object hashKey, Object value);

    void removeForHash(String key, Object... hashKeys);

    Object getForHash(String key, Object hashKey);

    Map<Object, Object> entriesForHash(String key);

    void putAllForHash(String key, Map<? extends Object, ? extends Object> m);

    String getCollectionName(String collectionName, String epid);

    void addKey(String key, Object value);

    void removeKey(String key, Object value);

    Set<Object> membersForKey(Object key);

    void destroy();


    /**
     * 微众的不支持
     */
    Set<Object> keys(String key);

    /**
     * 微众的不支持
     */
    <T> T execute(SessionCallback<T> action);

    Boolean setIfAbsent(Object key, Object value);

    Boolean setIfAbsent(Object key, Object value, long ttl, TimeUnit timeUnit);

    Object getAndSet(Object key, Object value);
}