redis 命令 http://doc.redisfans.com/
@Autowired
private StringRedisTemplateDelegate stringRedisTemplateDelegate;
这个其实 extends RedisTemplateDelegate<String>
@Autowired
@Qualifier("basicRedisTemplateDelegate")//@Autowired 是通过byType查找,这个是通过byName
private RedisTemplateDelegate<List<Long>> redisTemplateDelegate;
这个是源码,主要的
import com.wanda.common.redis.template.RedisTemplateDelegate;
import com.wanda.common.redis.template.StringRedisTemplateDelegate;
redisTemplateDelegate.map(namespace);
redisTemplateDelegate.delete(namespace);
redisTemplateDelegate.map(namespace).putAll(map);
// 查看源码 ,应该放入数组形式
stringRedisTemplateDelegate.list(namespace).addAll(list.toArray(new String[list.size()]));
//源码主要方法
主要还是查看源码(stringRedis)
package com.wanda.common.redis.template;
import com.wanda.common.util.StringUtils;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.springframework.data.redis.core.StringRedisTemplate;
public class StringRedisTemplateDelegate extends RedisTemplateDelegate<String>
{
private static final String NAMESPACE_DELIMITER = ":";
private String namespace;
public void setStringRedisTemplate(StringRedisTemplate redisTemplate)
{
super.setRedisTemplate(redisTemplate);
}
public void set(String key, String value)
{
super.set(getNamespaceKey(key, new String[0]), value);
}
public void set(String key, String value, String[] namespaces) {
super.set(getNamespaceKey(key, namespaces), value);
}
public boolean set(String key, String value, long timeout, TimeUnit unit)
{
return super.set(getNamespaceKey(key, new String[0]), value, timeout, unit);
}
public boolean set(String key, String value, long timeout, TimeUnit unit, String[] namespaces) {
return super.set(getNamespaceKey(key, namespaces), value, timeout, unit);
}
public boolean setWithoutBaseNS(String key, String value, long timeout, TimeUnit unit, String[] namespaces) {
return super.set(getNamespaceKeyWithoutBaseNS(key, namespaces), value, timeout, unit);
}
public Boolean setIfAbsent(String key, String value)
{
return super.setIfAbsent(getNamespaceKey(key, new String[0]), value);
}
public Boolean setIfAbsent(String key, String value, String[] namespaces) {
return super.setIfAbsent(getNamespaceKey(key, namespaces), value);
}
public void multiSet(Map<? extends String, ? extends String> m)
{
super.multiSet(fillNamespace(m, new String[0]));
}
public void multiSet(Map<? extends String, ? extends String> m, String[] namespaces) {
super.multiSet(fillNamespace(m, namespaces));
}
public void multiSet(Map<? extends String, ? extends String> m, long timeout, TimeUnit unit, String[] namespaces) {
super.multiSet(fillNamespace(m, namespaces), timeout, unit);
}
public void multiSetWithoutBaseNS(Map<? extends String, ? extends String> m, String[] namespaces) {
super.multiSet(fillNamespaceWithoutBaseNS(m, namespaces));
}
public void multiSetWithoutBaseNS(Map<? extends String, ? extends String> m, long timeout, TimeUnit unit, String[] namespaces) {
super.multiSet(fillNamespaceWithoutBaseNS(m, namespaces), timeout, unit);
}
public Boolean multiSetIfAbsent(Map<? extends String, ? extends String> m)
{
return super.multiSetIfAbsent(fillNamespace(m, new String[0]));
}
public Boolean multiSetIfAbsent(Map<? extends String, ? extends String> m, String[] namespaces) {
return super.multiSetIfAbsent(fillNamespace(m, namespaces));
}
public String get(String key)
{
return ((String)super.get(getNamespaceKey(key, new String[0])));
}
public String getWithoutBaseNS(String key, String[] namespaces)
{
return ((String)super.get(getNamespaceKeyWithoutBaseNS(key, namespaces)));
}
public String get(String key, String[] namespaces) {
return ((String)super.get(getNamespaceKey(key, namespaces)));
}
public String getAndSet(String key, String value)
{
return ((String)super.getAndSet(getNamespaceKey(key, new String[0]), value));
}
public String getAndSet(String key, String value, String[] namespaces) {
return ((String)super.getAndSet(getNamespaceKey(key, namespaces), value));
}
public List<String> multiGet(Collection<String> keys)
{
return super.multiGet(fillNamespace(keys, new String[0]));
}
public List<String> multiGetWithoutBaseNS(Collection<String> keys) {
return super.multiGet(fillNamespaceWithoutBaseNS(keys, new String[0]));
}
public List<String> multiGet(Collection<String> keys, String[] namespaces) {
return super.multiGet(fillNamespace(keys, namespaces));
}
public List<String> multiGetWithoutBaseNS(Collection<String> keys, String[] namespaces) {
return super.multiGet(fillNamespaceWithoutBaseNS(keys, namespaces));
}
public Map<String, String> multiGetMap(List<String> keys)
{
return super.multiGetMap(fillNamespace(keys, new String[0]));
}
public Map<String, String> multiGetMap(List<String> keys, String[] namespaces) {
return super.multiGetMap(fillNamespace(keys, namespaces));
}
public Map<String, String> multiGetMapWithoutBaseNS(List<String> keys, String[] namespaces) {
return super.multiGetMap(fillNamespaceWithoutBaseNS(keys, namespaces));
}
public Long size(String key)
{
return super.size(getNamespaceKey(key, new String[0]));
}
public Long size(String key, String[] namespaces) {
return super.size(getNamespaceKey(key, namespaces));
}
public void delete(String key)
{
super.delete(getNamespaceKey(key, new String[0]));
}
public void delete(String key, String[] namespaces) {
super.delete(getNamespaceKey(key, namespaces));
}
public void delete(Collection<String> keys)
{
super.delete(fillNamespace(keys, new String[0]));
}
public void delete(Collection<String> keys, String[] namespaces) {
super.delete(fillNamespace(keys, namespaces));
}
public void remove(String key)
{
super.delete(getNamespaceKey(key, new String[0]));
}
public void remove(String key, String[] namespaces) {
super.delete(getNamespaceKey(key, namespaces));
}
public void remove(Collection<String> keys)
{
super.remove(fillNamespace(keys, new String[0]));
}
public void remove(Collection<String> keys, String[] namespaces) {
super.remove(fillNamespace(keys, namespaces));
}
public Boolean hasKey(String key)
{
return super.hasKey(getNamespaceKey(key, new String[0]));
}
public Boolean hasKey(String key, String[] namespaces) {
return super.hasKey(getNamespaceKey(key, namespaces));
}
public Boolean persist(String key)
{
return super.persist(getNamespaceKey(key, new String[0]));
}
public Boolean persist(String key, String[] namespaces) {
return super.persist(getNamespaceKey(key, namespaces));
}
public Boolean expire(String key, long timeout, TimeUnit unit)
{
return super.expire(getNamespaceKey(key, new String[0]), timeout, unit);
}
public Boolean expire(String key, long timeout, TimeUnit unit, String[] namespaces) {
return super.expire(getNamespaceKey(key, namespaces), timeout, unit);
}
public Boolean expireAt(String key, Date date)
{
return super.expireAt(getNamespaceKey(key, new String[0]), date);
}
public Boolean expireAt(String key, Date date, String[] namespaces) {
return super.expireAt(getNamespaceKey(key, namespaces), date);
}
public Long getExpire(String key)
{
return super.getExpire(getNamespaceKey(key, new String[0]));
}
public Long getExpire(String key, String[] namespaces) {
return super.getExpire(getNamespaceKey(key, namespaces));
}
public Long getExpire(String key, TimeUnit timeUnit)
{
return super.getExpire(getNamespaceKey(key, new String[0]), timeUnit);
}
public Long getExpire(String key, TimeUnit timeUnit, String[] namespaces) {
return super.getExpire(getNamespaceKey(key, namespaces), timeUnit);
}
public Set<String> keysInNamespaces(String[] namespaces) {
String pattern = getNamespaceKeyWithoutBaseNS("", namespaces);
pattern = pattern + "*";
return super.keys(pattern);
}
public void setNamespace(String namespace) {
this.namespace = namespace;
}
private final String getNamespaceKey(String key, String[] namespaces) {
String nsKey = "";
if (StringUtils.isNotEmpty(this.namespace)) {
nsKey = this.namespace;
}
if ((namespaces != null) && (namespaces.length > 0)) {
if (StringUtils.isNotEmpty(nsKey))
nsKey = nsKey + ":" + String.join(":", namespaces);
else {
nsKey = String.join(":", namespaces);
}
}
if (StringUtils.isNotEmpty(nsKey))
nsKey = nsKey + ":" + key;
else {
nsKey = key;
}
return nsKey;
}
private final String getNamespaceKeyWithoutBaseNS(String key, String[] namespaces) {
String nsKey = key;
if ((namespaces != null) && (namespaces.length > 0)) {
nsKey = String.join(":", namespaces) + ":" + nsKey;
}
return nsKey;
}
private final Map<String, String> fillNamespace(Map<? extends String, ? extends String> m, String[] namespaces) {
Map nsMap = new HashMap(m.size());
for (String key : m.keySet()) {
nsMap.put(getNamespaceKey(key, namespaces), m.get(key));
}
return nsMap;
}
private final Map<String, String> fillNamespaceWithoutBaseNS(Map<? extends String, ? extends String> m, String[] namespaces) {
Map nsMap = new HashMap(m.size());
for (String key : m.keySet()) {
nsMap.put(getNamespaceKeyWithoutBaseNS(key, namespaces), m.get(key));
}
return nsMap;
}
private final List<String> fillNamespace(Collection<String> keys, String[] namespaces) {
List nsKeys = new ArrayList(keys.size());
for (String key : keys) {
nsKeys.add(getNamespaceKey(key, namespaces));
}
return nsKeys;
}
private final List<String> fillNamespaceWithoutBaseNS(Collection<String> keys, String[] namespaces) {
List nsKeys = new ArrayList(keys.size());
for (String key : keys) {
nsKeys.add(getNamespaceKeyWithoutBaseNS(key, namespaces));
}
return nsKeys;
}
}
redis初始源码
package com.wanda.common.redis.template;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.DataType;
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.core.ValueOperations;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
public class RedisTemplateDelegate<V>
{
private static final Logger log = LogManager.getLogger(RedisTemplateDelegate.class);
private RedisTemplate<String, V> redisTemplate;
private ValueOperations<String, V> valueOperations;
public void setRedisTemplate(RedisTemplate<String, V> redisTemplate)
{
this.redisTemplate = redisTemplate;
this.valueOperations = redisTemplate.opsForValue();
RedisSerializer stringSerializer = new StringRedisSerializer();
this.redisTemplate.setKeySerializer(stringSerializer);
}
public void set(String key, V value) {
this.valueOperations.set(key, value);
}
public boolean set(String key, V value, long timeout, TimeUnit unit) {
try {
this.valueOperations.set(key, value, timeout, unit);
} catch (Throwable e) {
log.error("", e);
return false;
}
return true;
}
public Boolean setIfAbsent(String key, V value) {
return this.valueOperations.setIfAbsent(key, value);
}
public void multiSet(Map<? extends String, ? extends V> m) {
this.valueOperations.multiSet(m);
}
public Boolean multiSetIfAbsent(Map<? extends String, ? extends V> m) {
return this.valueOperations.multiSetIfAbsent(m);
}
public V get(String key) {
return this.valueOperations.get(key);
}
public V getAndSet(String key, V value) {
return this.valueOperations.getAndSet(key, value);
}
public List<V> multiGet(Collection<String> keys) {
return this.valueOperations.multiGet(keys);
}
public Map<String, V> multiGetMap(List<String> keys) {
int size = 0;
if ((keys == null) || ((size = keys.size()) <= 0)) {
return new HashMap();
}
Map kvMap = new HashMap();
List values = this.valueOperations.multiGet(keys);
for (int i = 0; i < size; ++i) {
kvMap.put(keys.get(i), values.get(i));
}
return kvMap;
}
public Long increment(String key, long delta) {
return this.valueOperations.increment(key, delta);
}
public Double increment(String key, double delta) {
return this.valueOperations.increment(key, delta);
}
public Integer append(String key, String value) {
return this.valueOperations.append(key, value);
}
public String get(String key, long start, long end) {
return this.valueOperations.get(key, start, end);
}
public void set(String key, V value, long offset) {
this.valueOperations.set(key, value, offset);
}
public Long size(String key) {
return this.valueOperations.size(key);
}
public Boolean setBit(String key, long offset, boolean value) {
return this.valueOperations.setBit(key, offset, value);
}
public Boolean getBit(String key, long offset) {
return this.valueOperations.getBit(key, offset);
}
public void delete(String key) {
this.redisTemplate.delete(key);
}
public void delete(Collection<String> keys) {
this.redisTemplate.delete(keys);
}
public void remove(String key) {
delete(key);
}
public void remove(Collection<String> keys) {
delete(keys);
}
public Boolean hasKey(String key) {
return this.redisTemplate.hasKey(key);
}
public Boolean persist(String key) {
return this.redisTemplate.persist(key);
}
public Boolean expire(String key, long timeout, TimeUnit unit) {
return this.redisTemplate.expire(key, timeout, unit);
}
public Boolean expireAt(String key, Date date) {
return this.redisTemplate.expireAt(key, date);
}
public Long getExpire(String key) {
return this.redisTemplate.getExpire(key);
}
public Long getExpire(String key, TimeUnit timeUnit) {
return this.redisTemplate.getExpire(key, timeUnit);
}
public Boolean move(String key, int dbIndex) {
return this.redisTemplate.move(key, dbIndex);
}
public String randomKey() {
return ((String)this.redisTemplate.randomKey());
}
public void rename(String oldKey, String newKey) {
this.redisTemplate.rename(oldKey, newKey);
}
public Boolean renameIfAbsent(String oldKey, String newKey) {
return this.redisTemplate.renameIfAbsent(oldKey, newKey);
}
public DataType type(String key) {
return this.redisTemplate.type(key);
}
public void restore(String key, byte[] value, long timeToLive, TimeUnit unit) {
this.redisTemplate.restore(key, value, timeToLive, unit);
}
public void multiSet(Map<? extends String, ? extends V> m, long timeout, TimeUnit unit)
{
transaction(new Executor(m, timeout, unit)
{
public Object run()
{
RedisTemplateDelegate.this.valueOperations.multiSet(this.val$m);
for (String key : this.val$m.keySet()) {
RedisTemplateDelegate.this.expire(key, this.val$timeout, this.val$unit);
}
return null;
}
});
}
private <T> T transaction(Executor<T> executor)
{
return this.redisTemplate.execute(new SessionCallback(executor)
{
public <OK, OV> T execute(RedisOperations<OK, OV> operations) throws DataAccessException {
try {
RedisTemplateDelegate.this.redisTemplate.multi();
Object result = this.val$executor.run();
RedisTemplateDelegate.this.redisTemplate.exec();
return result;
} catch (Throwable e) {
RedisTemplateDelegate.log.error("", e);
RedisTemplateDelegate.this.redisTemplate.discard(); }
return null;
}
});
}
public void watch(String key)
{
this.redisTemplate.watch(key);
}
public Set<String> keys(String pattern) {
return this.redisTemplate.keys(pattern);
}
public <HK, HV> HashOperations<HK, HV> hash(String key) {
return new HashOperations(this.redisTemplate.boundHashOps(key));
}
public <HK, HV> HashOperations<HK, HV> map(String key) {
return new HashOperations(this.redisTemplate.boundHashOps(key));
}
public ListOperations<V> list(String key) {
return new ListOperations(this.redisTemplate.boundListOps(key));
}
public SetOperations<V> set(String key) {
return new SetOperations(this.redisTemplate.boundSetOps(key));
}
public ZSetOperations<V> zset(String key) {
return new ZSetOperations(this.redisTemplate.boundZSetOps(key));
}
}