Spring cache Redis Key生成策略

時間 2019-11-07

標籤 spring cache redis key 生成策略欄目 Spring 简体版

原文原文鏈接

最近使用Spring cache，發現使用默認生成的key策略只使用了方法入參做爲key，很不靈活，用到真實的項目中也不太靠譜，因而本身實現它的key生成策略。html

參考官方文檔：http://docs.spring.io/spring/docs/current/spring-framework-reference/html/cache.htmljava

spring 默認的key生成實現是git

org.springframework.cache.interceptor.SimpleKeyGenerator

感興趣的同窗本身看下，具體我就不描述了。redis

自定義生成策略須要實現下面的接口：接口對應方法參數，須要調用的目標對象實例，目標方法，目標方法入參spring

public interface KeyGenerator {

	/**
	 * Generate a key for the given method and its parameters.
	 * @param target the target instance
	 * @param method the method being called
	 * @param params the method parameters (with any var-args expanded)
	 * @return a generated key
	 */
	Object generate(Object target, Method method, Object... params);

}

下面展現我實現的方式apache

import java.io.Serializable;
import java.lang.reflect.Method;

import org.springframework.cache.interceptor.KeyGenerator;

/**
 * 實現spring cache的默認緩存實現策略
 * @author lisuo
 *
 */
public class DefaultKeyGenerator implements Serializable,KeyGenerator {

	/**
	 * 
	 */
	private static final long serialVersionUID = 5944569667769217577L;

	@Override
	public Object generate(Object target, Method method, Object... params) {
		return new DefaultKey(target, method, params);
	}
}

這裏必需要知道的是，spring cache在判斷是否命中數據時，是基於底層的緩存實現判斷是否命中key的。緩存

下面結合redis展現個人實現：app

import java.io.Serializable;
import java.lang.reflect.Method;

import org.apache.commons.lang3.ArrayUtils;


/**
 * Spring cache key 生成策略
 * @author lisuo
 */
public class DefaultKey implements Serializable{
	
	private static final long serialVersionUID = -8536541050699277557L;
	
	/** 調用目標對象全類名 */
	protected String targetClassName;
	/** 調用目標方法名稱 */
	protected String methodName;
	/** 調用目標參數 */
	protected Object[] params;
	
	public DefaultKey(Object target, Method method, Object[] elements) {
		this.targetClassName = target.getClass().getName();
		this.methodName = generatorMethodName(method);
		if(ArrayUtils.isNotEmpty(elements)){
			this.params = new Object[elements.length];
			for(int i =0;i<elements.length;i++){
				Object ele = elements[i];
				this.params[i] = ele;
			}
		}
	}
	
	private String generatorMethodName(Method method){
		StringBuilder builder = new StringBuilder(method.getName());
		Class<?>[] types = method.getParameterTypes();
		if(ArrayUtils.isNotEmpty(types)){
			builder.append("(");
			for(Class<?> type:types){
				String name = type.getName();
				builder.append(name+",");
			}
			builder.delete(builder.length()-1, builder.length());
			builder.append(")");
		}
		return builder.toString();
	}
	
}

上面只是緩存應用的實現，具體咱們看下Redis底層緩存管理器的實現ide

首先是CacheManager函數

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Set;

import org.apache.commons.collections.CollectionUtils;
import org.springframework.cache.Cache;
import org.springframework.cache.support.AbstractCacheManager;
import org.springframework.util.Assert;

import com.study.demo.util.RedisUtil;

/**
 * Redis緩存管理器,實現Spring Cache接口
 * @author lisuo
 *
 */
public class RedisCacheManager extends AbstractCacheManager {
	
	private RedisUtil rcache;
	
	//緩存前綴
	private String cachePrefix;
	
	//儲存緩存名稱的set集合key名稱
	private String cacheNameSet;
	
	public RedisCacheManager(RedisUtil rcache,String cachePrefix,String cacheNameSet) {
		Assert.notNull(rcache, "Cache must not be null");
		Assert.notNull(cachePrefix, "CachePrefix must not be null");
		Assert.notNull(cacheNameSet, "CacheNameSet must not be null");
		this.rcache = rcache;
		this.cachePrefix = cachePrefix;
		this.cacheNameSet = cacheNameSet;
	}
	
	@Override
	protected Collection<? extends Cache> loadCaches() {
		List<Cache> caches = new ArrayList<>();
		Set<String> names = rcache.smembers(cacheNameSet);
		if(CollectionUtils.isNotEmpty(names)){
			for (String name:names) {
				RedisCache cache = new RedisCache(cachePrefix+name, rcache);
				caches.add(cache);
			}
		}
		return caches;
	}
	
	
	@Override
	protected Cache getMissingCache(String name) {
		String  cacheName = cachePrefix+name;
		rcache.sadd(cacheNameSet, cacheName);
		RedisCache cache = new RedisCache(cacheName, rcache);
		return cache;
	}
	
}

Cache的實現

import java.util.concurrent.Callable;

import org.springframework.cache.support.AbstractValueAdaptingCache;
import org.springframework.util.Assert;

import com.study.demo.util.RedisUtil;

/**
 * 緩存實現
 * 這個結構的緩存是不支持數據過時的
 * @author lisuo
 *
 */
public class RedisCache extends AbstractValueAdaptingCache{
	
	private final String name;
	
	private RedisUtil rcache;
	
	public RedisCache(String name,RedisUtil rcache) {
		super(true);
		Assert.notNull(name, "Name must not be null");
		Assert.notNull(rcache, "Cache must not be null");
		this.name = name;
		this.rcache = rcache;
	}

	@Override
	public final String getName() {
		return this.name;
	}

	@Override
	public Object getNativeCache() {
		return this.rcache;
	}

	@Override
	public ValueWrapper get(Object key) {
		String v = rcache.hget(name, ObjStringConverUtil.objToString(key));
		if(v!=null){
			Object value = ObjStringConverUtil.stringToObj(v);
			ValueWrapper valueWrapper = toValueWrapper(value);
			return valueWrapper;
		}
		return null;
	}
	
	@SuppressWarnings("unchecked")
	@Override
	public <T> T get(Object key, Callable<T> valueLoader) {
		Object v = this.lookup(key);
		if(v!=null){
			return (T) v;
		}
		else {
			T value;
			try {
				value = valueLoader.call();
			}
			catch (Exception ex) {
				throw new ValueRetrievalException(key, valueLoader, ex);
			}
			put(key, value);
			return value;
		}
		
	}

	@Override
	public void put(Object key, Object value) {
		rcache.hset(name, ObjStringConverUtil.objToString(key), ObjStringConverUtil.objToString(value));
	}

	@Override
	public ValueWrapper putIfAbsent(Object key, Object value) {
		String k = ObjStringConverUtil.objToString(key);
		Boolean hexists = rcache.hexists(name, k);
		if(hexists){
			String v = rcache.hget(name, k);
			if(v!=null){
				ValueWrapper valueWrapper = toValueWrapper(ObjStringConverUtil.stringToObj(v));
				return valueWrapper;
			}
		}
		String val = ObjStringConverUtil.objToString(value);
		rcache.hset(name, k, val);
		return toValueWrapper(value);
	}

	@Override
	public void evict(Object key) {
		String k = ObjStringConverUtil.objToString(key);
		rcache.hdel(name, k);
	}

	@Override
	public void clear() {
		rcache.del(name);
	}

	@Override
	protected Object lookup(Object key) {
		String v = rcache.hget(name, ObjStringConverUtil.objToString(key));
		if(v!=null){
			Object value = ObjStringConverUtil.stringToObj(v);
			return value;
		}
		return null;
	}

}

對象轉換字符工具類

import java.io.Serializable;

import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.SerializationUtils;

/**
 * 對象字符串互轉工具類
 * 序列化+Base64實現
 * @author lisuo
 *
 */
public class ObjStringConverUtil {
	
	/**
	 * 對象轉字符串
	 * @param obj
	 * @return
	 */
	public static String objToString(Object obj){
		byte[] bs = SerializationUtils.serialize((Serializable) obj);
		return Base64.encodeBase64String(bs);
	}
	
	/**
	 * 字符串轉對象
	 * @param str
	 * @return
	 */
	public static Object stringToObj(String str){
		byte[] bs = Base64.decodeBase64(str);
		Object obj = SerializationUtils.deserialize(bs);
		return obj;
	}
}

Redis操做工具類

關於Redis的工具類代碼比較多

具體使用介紹參看：https://my.oschina.net/lis1314/blog/881704

package com.study.demo.util;

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

import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.jedis.BitPosParams;
import redis.clients.jedis.GeoCoordinate;
import redis.clients.jedis.GeoRadiusResponse;
import redis.clients.jedis.GeoUnit;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisCommands;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.ScanParams;
import redis.clients.jedis.ScanResult;
import redis.clients.jedis.SortingParams;
import redis.clients.jedis.Tuple;
import redis.clients.jedis.params.geo.GeoRadiusParam;
import redis.clients.jedis.params.sortedset.ZAddParams;
import redis.clients.jedis.params.sortedset.ZIncrByParams;

/**
 * Jedis 操做工具類
 * 
 * @version 基於Jedis 2.9.0
 * @author lisuo
 *
 */
public class RedisUtil implements JedisCommands {

	// jedis鏈接池
	private JedisPool jedisPool;

	// jedis集羣
	private JedisCluster jedisCluster;

	// 是否爲集羣,默認不是集羣
	private boolean isCluster = false;

	/**
	 * 鏈接池構建方式
	 * @param jedisPool  jedis鏈接池
	 */
	public RedisUtil(JedisPool jedisPool) {
		this.jedisPool = jedisPool;
	}

	/**
	 * 集羣構建方式
	 * @param jedisCluster jedis集羣實例
	 */
	public RedisUtil(JedisCluster jedisCluster) {
		this.jedisCluster = jedisCluster;
		isCluster = true;
	}

	// -----------------------------------實現腳本命令-----------------------------------
	public Object eval(String script, int keyCount, String... params) {
		if (isCluster) {
			return jedisCluster.eval(script, keyCount, params);
		} else {
			Jedis jedis = jedisPool.getResource();
			try {
				return jedis.eval(script, keyCount, params);
			} finally {
				jedis.close();
			}
		}
	}

	public Object eval(String script, List<String> keys, List<String> args) {
		if (isCluster) {
			return jedisCluster.eval(script, keys, args);
		} else {
			Jedis jedis = jedisPool.getResource();
			try {
				return jedis.eval(script, keys, args);
			} finally {
				jedis.close();
			}
		}
	}

	public Object evalsha(String sha1, int keyCount, String... params) {
		if (isCluster) {
			return jedisCluster.evalsha(sha1, keyCount, params);
		} else {
			Jedis jedis = jedisPool.getResource();
			try {
				return jedis.evalsha(sha1, keyCount, params);
			} finally {
				jedis.close();
			}
		}
	}

	/**
	 * 獲取JedisCommands實例
	 * @return JedisCommands
	 */
	private JedisCommands getJedisCommands() {
		if (isCluster) {
			return jedisCluster;
		} else {
			return jedisPool.getResource();
		}
	}

	/**
	 * Callback 回調接口
	 * @param <T>
	 */
	public interface Callback<T> {
		/**
		 * 回調函數
		 * @param commands
		 * @return
		 */
		public T call(JedisCommands commands);
	}

	/**
	 * 執行Redis 命令
	 * @param callback 回調接口
	 * @return
	 */
	public <T> T execute(Callback<T> callback) {
		JedisCommands jedisCommands = getJedisCommands();
		try {
			return callback.call(jedisCommands);
		} finally {
			// 非集羣下釋放資源,集羣源碼中已實現釋放資源
			if (!isCluster) {
				((Jedis) jedisCommands).close();
			}
		}
	}

	// 實現JedisCommands,關於@Deprecated標記的方法參看Jedis API,若是報錯多是版本太高,一些方法被廢除
	@Override
	public String get(final String key) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.get(key);
			}
		});
	}

	@Override
	public String set(final String key, final String value) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.set(key, value);
			}
		});
	}

	@Override
	public Long sadd(final String key, final String... member) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.sadd(key, member);
			}
		});
	}

	@Override
	public Long srem(final String key, final String... member) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.srem(key, member);
			}
		});
	}

	@Override
	public Boolean sismember(final String key, final String member) {
		return execute(new Callback<Boolean>() {
			@Override
			public Boolean call(JedisCommands commands) {
				return commands.sismember(key, member);
			}
		});
	}

	@Override
	public String hget(final String key, final String field) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.hget(key, field);
			}
		});
	}

	@Override
	public String hmset(final String key, final Map<String, String> hash) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.hmset(key, hash);
			}
		});
	}

	@Override
	public Long hset(final String key, final String field, final String value) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.hset(key, field, value);
			}
		});
	}

	@Override
	public Long lpush(final String key, final String... string) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.lpush(key, string);
			}
		});
	}

	@Override
	public String lpop(final String key) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.lpop(key);
			}
		});
	}

	@Override
	public String set(final String key, final String value, final String nxxx, final String expx, final long time) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.set(key, value, nxxx, expx, time);
			}
		});
	}

	@Override
	public String set(final String key, final String value, final String nxxx) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.set(key, value, nxxx);
			}
		});
	}

	@Override
	public Boolean exists(final String key) {
		return execute(new Callback<Boolean>() {
			@Override
			public Boolean call(JedisCommands commands) {
				return commands.exists(key);
			}
		});
	}

	@Override
	public Long persist(final String key) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.persist(key);
			}
		});
	}

	@Override
	public String type(final String key) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.type(key);
			}
		});
	}

	@Override
	public Long expire(final String key, final int seconds) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.expire(key, seconds);
			}
		});
	}

	@Override
	public Long pexpire(final String key, final long milliseconds) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.pexpire(key, milliseconds);
			}
		});
	}

	@Override
	public Long expireAt(final String key, final long unixTime) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.expireAt(key, unixTime);
			}
		});
	}

	@Override
	public Long pexpireAt(final String key, final long millisecondsTimestamp) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.pexpireAt(key, millisecondsTimestamp);
			}
		});
	}

	@Override
	public Long ttl(final String key) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.ttl(key);
			}
		});
	}

	@Override
	public Long pttl(final String key) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.pttl(key);
			}
		});
	}

	@Override
	public Boolean setbit(final String key, final long offset, final boolean value) {
		return execute(new Callback<Boolean>() {
			@Override
			public Boolean call(JedisCommands commands) {
				return commands.setbit(key, offset, value);
			}
		});
	}

	@Override
	public Boolean setbit(final String key, final long offset, final String value) {
		return execute(new Callback<Boolean>() {
			@Override
			public Boolean call(JedisCommands commands) {
				return commands.setbit(key, offset, value);
			}
		});
	}

	@Override
	public Boolean getbit(final String key, final long offset) {
		return execute(new Callback<Boolean>() {
			@Override
			public Boolean call(JedisCommands commands) {
				return commands.getbit(key, offset);
			}
		});
	}

	@Override
	public Long setrange(final String key, final long offset, final String value) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.setrange(key, offset, value);
			}
		});
	}

	@Override
	public String getrange(final String key, final long startOffset, final long endOffset) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.getrange(key, startOffset, endOffset);
			}
		});
	}

	@Override
	public String getSet(final String key, final String value) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.getSet(key, value);
			}
		});
	}

	@Override
	public Long setnx(final String key, final String value) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.setnx(key, value);
			}
		});
	}

	@Override
	public String setex(final String key, final int seconds, final String value) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.setex(key, seconds, value);
			}
		});
	}

	@Override
	public String psetex(final String key, final long milliseconds, final String value) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.psetex(key, milliseconds, value);
			}
		});
	}

	@Override
	public Long decrBy(final String key, final long integer) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.decrBy(key, integer);
			}
		});
	}

	@Override
	public Long decr(final String key) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.decr(key);
			}
		});
	}

	@Override
	public Long incrBy(final String key, final long integer) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.incrBy(key, integer);
			}
		});
	}

	@Override
	public Double incrByFloat(final String key, final double value) {
		return execute(new Callback<Double>() {
			@Override
			public Double call(JedisCommands commands) {
				return commands.incrByFloat(key, value);
			}
		});
	}

	@Override
	public Long incr(final String key) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.incr(key);
			}
		});
	}

	@Override
	public Long append(final String key, final String value) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.append(key, value);
			}
		});
	}

	@Override
	public String substr(final String key, final int start, final int end) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.substr(key, start, end);
			}
		});
	}

	@Override
	public Long hsetnx(final String key, final String field, final String value) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.hsetnx(key, field, value);
			}
		});
	}

	@Override
	public List<String> hmget(final String key, final String... fields) {
		return execute(new Callback<List<String>>() {
			@Override
			public List<String> call(JedisCommands commands) {
				return commands.hmget(key, fields);
			}
		});
	}

	@Override
	public Long hincrBy(final String key, final String field, final long value) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.hincrBy(key, field, value);
			}
		});
	}

	@Override
	public Double hincrByFloat(final String key, final String field, final double value) {
		return execute(new Callback<Double>() {
			@Override
			public Double call(JedisCommands commands) {
				return commands.hincrByFloat(key, field, value);
			}
		});
	}

	@Override
	public Boolean hexists(final String key, final String field) {
		return execute(new Callback<Boolean>() {
			@Override
			public Boolean call(JedisCommands commands) {
				return commands.hexists(key, field);
			}
		});
	}

	@Override
	public Long hdel(final String key, final String... field) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.hdel(key, field);
			}
		});
	}

	@Override
	public Long hlen(final String key) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.hlen(key);
			}
		});
	}

	@Override
	public Set<String> hkeys(final String key) {
		return execute(new Callback<Set<String>>() {
			@Override
			public Set<String> call(JedisCommands commands) {
				return commands.hkeys(key);
			}
		});
	}

	@Override
	public List<String> hvals(final String key) {
		return execute(new Callback<List<String>>() {
			@Override
			public List<String> call(JedisCommands commands) {
				return commands.hvals(key);
			}
		});
	}

	@Override
	public Map<String, String> hgetAll(final String key) {
		return execute(new Callback<Map<String, String>>() {
			@Override
			public Map<String, String> call(JedisCommands commands) {
				return commands.hgetAll(key);
			}
		});
	}

	@Override
	public Long rpush(final String key, final String... string) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.rpush(key, string);
			}
		});
	}

	@Override
	public Long llen(final String key) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.llen(key);
			}
		});
	}

	@Override
	public List<String> lrange(final String key, final long start, final long end) {
		return execute(new Callback<List<String>>() {
			@Override
			public List<String> call(JedisCommands commands) {
				return commands.lrange(key, start, end);
			}
		});
	}

	@Override
	public String ltrim(final String key, final long start, final long end) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.ltrim(key, start, end);
			}
		});
	}

	@Override
	public String lindex(final String key, final long index) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.lindex(key, index);
			}
		});
	}

	@Override
	public String lset(final String key, final long index, final String value) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.lset(key, index, value);
			}
		});
	}

	@Override
	public Long lrem(final String key, final long count, final String value) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.lrem(key, count, value);
			}
		});
	}

	@Override
	public String rpop(final String key) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.rpop(key);
			}
		});
	}

	@Override
	public Set<String> smembers(final String key) {
		return execute(new Callback<Set<String>>() {
			@Override
			public Set<String> call(JedisCommands commands) {
				return commands.smembers(key);
			}
		});
	}

	@Override
	public String spop(final String key) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.spop(key);
			}
		});
	}

	@Override
	public Set<String> spop(final String key, final long count) {
		return execute(new Callback<Set<String>>() {
			@Override
			public Set<String> call(JedisCommands commands) {
				return commands.spop(key, count);
			}
		});
	}

	@Override
	public Long scard(final String key) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.scard(key);
			}
		});
	}

	@Override
	public String srandmember(final String key) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.srandmember(key);
			}
		});
	}

	@Override
	public List<String> srandmember(final String key, final int count) {
		return execute(new Callback<List<String>>() {
			@Override
			public List<String> call(JedisCommands commands) {
				return commands.srandmember(key, count);
			}
		});
	}

	@Override
	public Long strlen(final String key) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.strlen(key);
			}
		});
	}

	@Override
	public Long zadd(final String key, final double score, final String member) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.zadd(key, score, member);
			}
		});
	}

	@Override
	public Long zadd(final String key, final double score, final String member, final ZAddParams params) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.zadd(key, score, member, params);
			}
		});
	}

	@Override
	public Long zadd(final String key, final Map<String, Double> scoreMembers) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.zadd(key, scoreMembers);
			}
		});
	}

	@Override
	public Long zadd(final String key, final Map<String, Double> scoreMembers, final ZAddParams params) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.zadd(key, scoreMembers, params);
			}
		});
	}

	@Override
	public Set<String> zrange(final String key, final long start, final long end) {
		return execute(new Callback<Set<String>>() {
			@Override
			public Set<String> call(JedisCommands commands) {
				return commands.zrange(key, start, end);
			}
		});
	}

	@Override
	public Long zrem(final String key, final String... member) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.zrem(key, member);
			}
		});
	}

	@Override
	public Double zincrby(final String key, final double score, final String member) {
		return execute(new Callback<Double>() {
			@Override
			public Double call(JedisCommands commands) {
				return commands.zincrby(key, score, member);
			}
		});
	}

	@Override
	public Double zincrby(final String key, final double score, final String member, final ZIncrByParams params) {
		return execute(new Callback<Double>() {
			@Override
			public Double call(JedisCommands commands) {
				return commands.zincrby(key, score, member, params);
			}
		});
	}

	@Override
	public Long zrank(final String key, final String member) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.zrank(key, member);
			}
		});
	}

	@Override
	public Long zrevrank(final String key, final String member) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.zrevrank(key, member);
			}
		});
	}

	@Override
	public Set<String> zrevrange(final String key, final long start, final long end) {
		return execute(new Callback<Set<String>>() {
			@Override
			public Set<String> call(JedisCommands commands) {
				return commands.zrevrange(key, start, end);
			}
		});
	}

	@Override
	public Set<Tuple> zrangeWithScores(final String key, final long start, final long end) {
		return execute(new Callback<Set<Tuple>>() {
			@Override
			public Set<Tuple> call(JedisCommands commands) {
				return commands.zrangeWithScores(key, start, end);
			}
		});
	}

	@Override
	public Set<Tuple> zrevrangeWithScores(final String key, final long start, final long end) {
		return execute(new Callback<Set<Tuple>>() {
			@Override
			public Set<Tuple> call(JedisCommands commands) {
				return commands.zrevrangeWithScores(key, start, end);
			}
		});
	}

	@Override
	public Long zcard(final String key) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.zcard(key);
			}
		});
	}

	@Override
	public Double zscore(final String key, final String member) {
		return execute(new Callback<Double>() {
			@Override
			public Double call(JedisCommands commands) {
				return commands.zscore(key, member);
			}
		});
	}

	@Override
	public List<String> sort(final String key) {
		return execute(new Callback<List<String>>() {
			@Override
			public List<String> call(JedisCommands commands) {
				return commands.sort(key);
			}
		});
	}

	@Override
	public List<String> sort(final String key, final SortingParams sortingParameters) {
		return execute(new Callback<List<String>>() {
			@Override
			public List<String> call(JedisCommands commands) {
				return commands.sort(key, sortingParameters);
			}
		});
	}

	@Override
	public Long zcount(final String key, final double min, final double max) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.zcount(key, min, max);
			}
		});
	}

	@Override
	public Long zcount(final String key, final String min, final String max) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.zcount(key, min, max);
			}
		});
	}

	@Override
	public Set<String> zrangeByScore(final String key, final double min, final double max) {
		return execute(new Callback<Set<String>>() {
			@Override
			public Set<String> call(JedisCommands commands) {
				return commands.zrangeByScore(key, min, max);
			}
		});
	}

	@Override
	public Set<String> zrangeByScore(final String key, final String min, final String max) {
		return execute(new Callback<Set<String>>() {
			@Override
			public Set<String> call(JedisCommands commands) {
				return commands.zrangeByScore(key, min, max);
			}
		});
	}

	@Override
	public Set<String> zrevrangeByScore(final String key, final double max, final double min) {
		return execute(new Callback<Set<String>>() {
			@Override
			public Set<String> call(JedisCommands commands) {
				return commands.zrevrangeByScore(key, max, min);
			}
		});
	}

	@Override
	public Set<String> zrangeByScore(final String key, final double min, final double max, final int offset,
			final int count) {
		return execute(new Callback<Set<String>>() {
			@Override
			public Set<String> call(JedisCommands commands) {
				return commands.zrangeByScore(key, min, max, offset, count);
			}
		});
	}

	@Override
	public Set<String> zrevrangeByScore(final String key, final String max, final String min) {
		return execute(new Callback<Set<String>>() {
			@Override
			public Set<String> call(JedisCommands commands) {
				return commands.zrevrangeByScore(key, max, min);
			}
		});
	}

	@Override
	public Set<String> zrangeByScore(final String key, final String min, final String max, final int offset,
			final int count) {
		return execute(new Callback<Set<String>>() {
			@Override
			public Set<String> call(JedisCommands commands) {
				return commands.zrangeByScore(key, min, max, offset, count);
			}
		});
	}

	@Override
	public Set<String> zrevrangeByScore(final String key, final double max, final double min, final int offset,
			final int count) {
		return execute(new Callback<Set<String>>() {
			@Override
			public Set<String> call(JedisCommands commands) {
				return commands.zrevrangeByScore(key, max, min, offset, count);
			}
		});
	}

	@Override
	public Set<Tuple> zrangeByScoreWithScores(final String key, final double min, final double max) {
		return execute(new Callback<Set<Tuple>>() {
			@Override
			public Set<Tuple> call(JedisCommands commands) {
				return commands.zrangeByScoreWithScores(key, min, max);
			}
		});
	}

	@Override
	public Set<Tuple> zrevrangeByScoreWithScores(final String key, final double max, final double min) {
		return execute(new Callback<Set<Tuple>>() {
			@Override
			public Set<Tuple> call(JedisCommands commands) {
				return commands.zrevrangeByScoreWithScores(key, max, min);
			}
		});
	}

	@Override
	public Set<Tuple> zrangeByScoreWithScores(final String key, final double min, final double max, final int offset,
			final int count) {
		return execute(new Callback<Set<Tuple>>() {
			@Override
			public Set<Tuple> call(JedisCommands commands) {
				return commands.zrangeByScoreWithScores(key, min, max, offset, count);
			}
		});
	}

	@Override
	public Set<String> zrevrangeByScore(final String key, final String max, final String min, final int offset,
			final int count) {
		return execute(new Callback<Set<String>>() {
			@Override
			public Set<String> call(JedisCommands commands) {
				return commands.zrevrangeByScore(key, max, min, offset, count);
			}
		});
	}

	@Override
	public Set<Tuple> zrangeByScoreWithScores(final String key, final String min, final String max) {
		return execute(new Callback<Set<Tuple>>() {
			@Override
			public Set<Tuple> call(JedisCommands commands) {
				return commands.zrangeByScoreWithScores(key, min, max);
			}
		});
	}

	@Override
	public Set<Tuple> zrevrangeByScoreWithScores(final String key, final String max, final String min) {
		return execute(new Callback<Set<Tuple>>() {
			@Override
			public Set<Tuple> call(JedisCommands commands) {
				return commands.zrevrangeByScoreWithScores(key, max, min);
			}
		});
	}

	@Override
	public Set<Tuple> zrangeByScoreWithScores(final String key, final String min, final String max, final int offset,
			final int count) {
		return execute(new Callback<Set<Tuple>>() {
			@Override
			public Set<Tuple> call(JedisCommands commands) {
				return commands.zrangeByScoreWithScores(key, min, max, offset, count);
			}
		});
	}

	@Override
	public Set<Tuple> zrevrangeByScoreWithScores(final String key, final double max, final double min, final int offset,
			final int count) {
		return execute(new Callback<Set<Tuple>>() {
			@Override
			public Set<Tuple> call(JedisCommands commands) {
				return commands.zrevrangeByScoreWithScores(key, max, min, offset, count);
			}
		});
	}

	@Override
	public Set<Tuple> zrevrangeByScoreWithScores(final String key, final String max, final String min, final int offset,
			final int count) {
		return execute(new Callback<Set<Tuple>>() {
			@Override
			public Set<Tuple> call(JedisCommands commands) {
				return commands.zrevrangeByScoreWithScores(key, max, min, offset, count);
			}
		});
	}

	@Override
	public Long zremrangeByRank(final String key, final long start, final long end) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.zremrangeByRank(key, start, end);
			}
		});
	}

	@Override
	public Long zremrangeByScore(final String key, final double start, final double end) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.zremrangeByScore(key, start, end);
			}
		});
	}

	@Override
	public Long zremrangeByScore(final String key, final String start, final String end) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.zremrangeByScore(key, start, end);
			}
		});
	}

	@Override
	public Long zlexcount(final String key, final String min, final String max) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.zlexcount(key, min, max);
			}
		});
	}

	@Override
	public Set<String> zrangeByLex(final String key, final String min, final String max) {
		return execute(new Callback<Set<String>>() {
			@Override
			public Set<String> call(JedisCommands commands) {
				return commands.zrangeByLex(key, min, max);
			}
		});
	}

	@Override
	public Set<String> zrangeByLex(final String key, final String min, final String max, final int offset,
			final int count) {
		return execute(new Callback<Set<String>>() {
			@Override
			public Set<String> call(JedisCommands commands) {
				return commands.zrangeByLex(key, min, max, offset, count);
			}
		});
	}

	@Override
	public Set<String> zrevrangeByLex(final String key, final String max, final String min) {
		return execute(new Callback<Set<String>>() {
			@Override
			public Set<String> call(JedisCommands commands) {
				return commands.zrevrangeByLex(key, max, min);
			}
		});
	}

	@Override
	public Set<String> zrevrangeByLex(final String key, final String max, final String min, final int offset,
			final int count) {
		return execute(new Callback<Set<String>>() {
			@Override
			public Set<String> call(JedisCommands commands) {
				return commands.zrevrangeByLex(key, max, min, offset, count);
			}
		});
	}

	@Override
	public Long zremrangeByLex(final String key, final String min, final String max) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.zremrangeByLex(key, min, max);
			}
		});
	}

	@Override
	public Long linsert(final String key, final LIST_POSITION where, final String pivot, final String value) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.linsert(key, where, pivot, value);
			}
		});
	}

	@Override
	public Long lpushx(final String key, final String... string) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.lpushx(key, string);
			}
		});
	}

	@Override
	public Long rpushx(final String key, final String... string) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.rpushx(key, string);
			}
		});
	}

	@Deprecated
	@Override
	public List<String> blpop(final String arg) {
		return execute(new Callback<List<String>>() {
			@Override
			public List<String> call(JedisCommands commands) {
				return commands.blpop(arg);
			}
		});
	}

	@Override
	public List<String> blpop(final int timeout, final String key) {
		return execute(new Callback<List<String>>() {
			@Override
			public List<String> call(JedisCommands commands) {
				return commands.blpop(timeout, key);
			}
		});
	}

	@Deprecated
	@Override
	public List<String> brpop(final String arg) {
		return execute(new Callback<List<String>>() {
			@Override
			public List<String> call(JedisCommands commands) {
				return commands.brpop(arg);
			}
		});
	}

	@Override
	public List<String> brpop(final int timeout, final String key) {
		return execute(new Callback<List<String>>() {
			@Override
			public List<String> call(JedisCommands commands) {
				return commands.brpop(timeout, key);
			}
		});
	}

	@Override
	public Long del(final String key) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.del(key);
			}
		});
	}

	@Override
	public String echo(final String string) {
		return execute(new Callback<String>() {
			@Override
			public String call(JedisCommands commands) {
				return commands.echo(string);
			}
		});
	}

	@Override
	public Long move(final String key, final int dbIndex) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.move(key, dbIndex);
			}
		});
	}

	@Override
	public Long bitcount(final String key) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.bitcount(key);
			}
		});
	}

	@Override
	public Long bitcount(final String key, final long start, final long end) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.bitcount(key, start, end);
			}
		});
	}

	@Override
	public Long bitpos(final String key, final boolean value) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.bitpos(key, value);
			}
		});
	}

	@Override
	public Long bitpos(final String key, final boolean value, final BitPosParams params) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.bitpos(key, value, params);
			}
		});
	}

	@Deprecated
	@Override
	public ScanResult<Entry<String, String>> hscan(final String key, final int cursor) {
		return execute(new Callback<ScanResult<Entry<String, String>>>() {
			@Override
			public ScanResult<Entry<String, String>> call(JedisCommands commands) {
				return commands.hscan(key, cursor);
			}
		});
	}

	@Deprecated
	@Override
	public ScanResult<String> sscan(final String key, final int cursor) {
		return execute(new Callback<ScanResult<String>>() {
			@Override
			public ScanResult<String> call(JedisCommands commands) {
				return commands.sscan(key, cursor);
			}
		});
	}

	@Deprecated
	@Override
	public ScanResult<Tuple> zscan(final String key, final int cursor) {
		return execute(new Callback<ScanResult<Tuple>>() {
			@Override
			public ScanResult<Tuple> call(JedisCommands commands) {
				return commands.zscan(key, cursor);
			}
		});
	}

	@Override
	public ScanResult<Entry<String, String>> hscan(final String key, final String cursor) {
		return execute(new Callback<ScanResult<Entry<String, String>>>() {
			@Override
			public ScanResult<Entry<String, String>> call(JedisCommands commands) {
				return commands.hscan(key, cursor);
			}
		});
	}

	@Override
	public ScanResult<Entry<String, String>> hscan(final String key, final String cursor, final ScanParams params) {
		return execute(new Callback<ScanResult<Entry<String, String>>>() {
			@Override
			public ScanResult<Entry<String, String>> call(JedisCommands commands) {
				return commands.hscan(key, cursor, params);
			}
		});
	}

	@Override
	public ScanResult<String> sscan(final String key, final String cursor) {
		return execute(new Callback<ScanResult<String>>() {
			@Override
			public ScanResult<String> call(JedisCommands commands) {
				return commands.sscan(key, cursor);
			}
		});
	}

	@Override
	public ScanResult<String> sscan(final String key, final String cursor, final ScanParams params) {
		return execute(new Callback<ScanResult<String>>() {
			@Override
			public ScanResult<String> call(JedisCommands commands) {
				return commands.sscan(key, cursor, params);
			}
		});
	}

	@Override
	public ScanResult<Tuple> zscan(final String key, final String cursor) {
		return execute(new Callback<ScanResult<Tuple>>() {
			@Override
			public ScanResult<Tuple> call(JedisCommands commands) {
				return commands.zscan(key, cursor);
			}
		});
	}

	@Override
	public ScanResult<Tuple> zscan(final String key, final String cursor, final ScanParams params) {
		return execute(new Callback<ScanResult<Tuple>>() {
			@Override
			public ScanResult<Tuple> call(JedisCommands commands) {
				return commands.zscan(key, cursor, params);
			}
		});
	}

	@Override
	public Long pfadd(final String key, final String... elements) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.pfadd(key, elements);
			}
		});
	}

	@Override
	public long pfcount(final String key) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.pfcount(key);
			}
		});
	}

	@Override
	public Long geoadd(final String key, final double longitude, final double latitude, final String member) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.geoadd(key, longitude, latitude, member);
			}
		});
	}

	@Override
	public Long geoadd(final String key, final Map<String, GeoCoordinate> memberCoordinateMap) {
		return execute(new Callback<Long>() {
			@Override
			public Long call(JedisCommands commands) {
				return commands.geoadd(key, memberCoordinateMap);
			}
		});
	}

	@Override
	public Double geodist(final String key, final String member1, final String member2) {
		return execute(new Callback<Double>() {
			@Override
			public Double call(JedisCommands commands) {
				return commands.geodist(key, member1, member2);
			}
		});
	}

	@Override
	public Double geodist(final String key, final String member1, final String member2, final GeoUnit unit) {
		return execute(new Callback<Double>() {
			@Override
			public Double call(JedisCommands commands) {
				return commands.geodist(key, member1, member2, unit);
			}
		});
	}

	@Override
	public List<String> geohash(final String key, final String... members) {
		return execute(new Callback<List<String>>() {
			@Override
			public List<String> call(JedisCommands commands) {
				return commands.geohash(key, members);
			}
		});
	}

	@Override
	public List<GeoCoordinate> geopos(final String key, final String... members) {
		return execute(new Callback<List<GeoCoordinate>>() {
			@Override
			public List<GeoCoordinate> call(JedisCommands commands) {
				return commands.geopos(key, members);
			}
		});
	}

	@Override
	public List<GeoRadiusResponse> georadius(final String key, final double longitude, final double latitude,
			final double radius, final GeoUnit unit) {
		return execute(new Callback<List<GeoRadiusResponse>>() {
			@Override
			public List<GeoRadiusResponse> call(JedisCommands commands) {
				return commands.georadius(key, longitude, latitude, radius, unit);
			}
		});
	}

	@Override
	public List<GeoRadiusResponse> georadius(final String key, final double longitude, final double latitude,
			final double radius, final GeoUnit unit, final GeoRadiusParam param) {
		return execute(new Callback<List<GeoRadiusResponse>>() {
			@Override
			public List<GeoRadiusResponse> call(JedisCommands commands) {
				return commands.georadius(key, longitude, latitude, radius, unit, param);
			}
		});
	}

	@Override
	public List<GeoRadiusResponse> georadiusByMember(final String key, final String member, final double radius,
			final GeoUnit unit) {
		return execute(new Callback<List<GeoRadiusResponse>>() {
			@Override
			public List<GeoRadiusResponse> call(JedisCommands commands) {
				return commands.georadiusByMember(key, member, radius, unit);
			}
		});
	}

	@Override
	public List<GeoRadiusResponse> georadiusByMember(final String key, final String member, final double radius,
			final GeoUnit unit, final GeoRadiusParam param) {
		return execute(new Callback<List<GeoRadiusResponse>>() {
			@Override
			public List<GeoRadiusResponse> call(JedisCommands commands) {
				return commands.georadiusByMember(key, member, radius, unit, param);
			}
		});
	}

	@Override
	public List<Long> bitfield(final String key, final String... arguments) {
		return execute(new Callback<List<Long>>() {
			@Override
			public List<Long> call(JedisCommands commands) {
				return commands.bitfield(key, arguments);
			}
		});
	}

}

整合配置：Redis配置

package com.study.demo.configuration;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.study.demo.util.RedisUtil;

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

/**
 * Redis 配置(單點)
 * @author lisuo
 *
 */
@Configuration
public class RedisConfiguration {

	@Bean(name = "redisPool")
	public JedisPool jedisPool(@Autowired @Qualifier("redisPoolConfig") JedisPoolConfig config,
			@Value("${redis.host1}") String host, @Value("${redis.port}") int port) {
		return new JedisPool(config, host, port);
	}

	@Bean(name = "redisPoolConfig")
	public JedisPoolConfig jedisPoolConfig(@Value("${redis.pool.maxIdle}") int maxTotal,
			@Value("${redis.pool.maxIdle}") int maxIdle, @Value("${redis.pool.maxWaitMillis}") int maxWaitMillis) {
		JedisPoolConfig config = new JedisPoolConfig();
		config.setMaxTotal(maxTotal);
		config.setMaxIdle(maxIdle);
		config.setMaxWaitMillis(maxWaitMillis);
		return config;
	}

	@Bean(name = "redisUtil")
	public RedisUtil redisUtil(@Autowired @Qualifier("redisPool") JedisPool jedisPool) {
		RedisUtil config = new RedisUtil(jedisPool);
		return config;
	}

}

緩存整合配置

package com.study.demo.configuration;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Configuration;

import com.study.demo.cache.DefaultKeyGenerator;
import com.study.demo.cache.RedisCacheManager;
import com.study.demo.util.RedisUtil;

@Configuration
@EnableCaching
public class SpringCacheConfiguraction extends CachingConfigurerSupport{
	
	@Autowired
	private RedisUtil redisUtil;
	
	@Override
	public CacheManager cacheManager() {
		RedisCacheManager manager = new RedisCacheManager(redisUtil, "study:cache:", "study:cacheNameSet");
		return manager;
	}

	@Override
	public KeyGenerator keyGenerator() {
		return new DefaultKeyGenerator();
	}

	
	
}

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。