redis java端问题

@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));
  }
}