基于spring+redis读写分离实践

在RedisTemplate上层进行了封装，根据调用的方法，切换master/slave，但是却耦合了具体的redis客户端。

package com.xjy.study.spring.redis.rw;

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

import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;

import redis.clients.jedis.JedisShardInfo;

// 使用装饰器设计模式
// 暂时只支持jedis客户端
public class RWRedisTemplate<K, V> {

private JedisShardInfo masterJedisShardInfo;
private List<JedisShardInfo> slaveJedisShardInfos;
private RedisTemplate<K, V> delegate;
// 记录delegate最后一次的状态
private volatile boolean isMaster = true;

public RWRedisTemplate(RedisTemplate<K, V> delegate) {
this.delegate = delegate;
}

public void setMasterJedisShardInfo(JedisShardInfo masterJedisShardInfo) {
this.masterJedisShardInfo = masterJedisShardInfo;
}

public void setSlaveJedisShardInfos(List<JedisShardInfo> slaveJedisShardInfos) {
this.slaveJedisShardInfos = slaveJedisShardInfos;
}

///////////////////////////////////////////string/////////////////////////////////////////////////////
public void set(K key, V value) {
switchToMaster();
delegate.opsForValue().set(key, value);
}

public void set(K key, V value, long timeout, TimeUnit unit) {
switchToMaster();
delegate.opsForValue().set(key, value, timeout, unit);
}

public Boolean setIfAbsent(K key, V value) {
switchToMaster();
return delegate.opsForValue().setIfAbsent(key, value);
}

public void multiSet(Map<? extends K, ? extends V> m) {
switchToMaster();
delegate.opsForValue().multiSet(m);
}

public Boolean multiSetIfAbsent(Map<? extends K, ? extends V> m) {
switchToMaster();
return delegate.opsForValue().multiSetIfAbsent(m);
}

public V get(K key) {
return get(key, false);
}

public V get(K key, boolean forceToMaster) {
if(forceToMaster) {
switchToMaster();
} else{
switchToSlave();
}
return delegate.opsForValue().get(key);
}

public V getAndSet(K key, V value) {
switchToMaster();
return delegate.opsForValue().getAndSet(key, value);
}

public List<V> multiGet(Collection<K> keys) {
return multiGet(keys, false);
}

public List<V> multiGet(Collection<K> keys, boolean forceToMaster) {
if(forceToMaster) {
switchToMaster();
} else {
switchToSlave();
}
return delegate.opsForValue().multiGet(keys);
}

public Long increment(K key, long delta) {
switchToMaster();
return delegate.opsForValue().increment(key, delta);
}

public Double increment(K key, double delta) {
switchToMaster();
return delegate.opsForValue().increment(key, delta);
}

public Integer append(K key, String value) {
switchToMaster();
return delegate.opsForValue().append(key, value);
}

public String get(K key, long start, long end) {
return get(key, start, end, false);
}

public String get(K key, long start, long end, boolean forceToMaster) {
if(forceToMaster) {
switchToMaster();
} else {
switchToSlave();
}
return delegate.opsForValue().get(key, start, end);
}

public void set(K key, V value, long offset) {
switchToMaster();
delegate.opsForValue().set(key, value, offset);
}

public Long size(K key) {
switchToMaster();
return delegate.opsForValue().size(key);
}

public Boolean setBit(K key, long offset, boolean value) {
switchToMaster();
return delegate.opsForValue().setBit(key, offset, value);
}

public Boolean getBit(K key, long offset) {
return getBit(key, offset, false);
}

public Boolean getBit(K key, long offset, boolean forceToMaster) {
if(forceToMaster) {
switchToMaster();
} else {
switchToSlave();
}
return delegate.opsForValue().getBit(key, offset);
}
///////////////////////////////////////////string/////////////////////////////////////////////////////

///////////////////////////////////////////key/////////////////////////////////////////////////////
public Boolean hasKey(K key) {
switchToSlave();
return delegate.hasKey(key);
}

public void delete(K key) {
switchToMaster();
delegate.delete(key);
}

public void delete(Collection<K> key) {
switchToMaster();
delegate.delete(key);
}

public DataType type(K key) {
switchToSlave();
return delegate.type(key);
}

public Set<K> keys(K pattern) {
switchToSlave();
return delegate.keys(pattern);
}
//
//  K randomKey();
//
//  void rename(K oldKey, K newKey);
//
//  Boolean renameIfAbsent(K oldKey, K newKey);
//
//  Boolean expire(K key, long timeout, TimeUnit unit);
//
//  Boolean expireAt(K key, Date date);
//
//  Boolean persist(K key);
//
//  Boolean move(K key, int dbIndex);
//
//  byte[] dump(K key);
//
//  void restore(K key, byte[] value, long timeToLive, TimeUnit unit);
//
//  Long getExpire(K key);
//
//  Long getExpire(K key, TimeUnit timeUnit);
//
//  void watch(K keys);
//
//  void watch(Collection<K> keys);
//
//  void unwatch();
//
//  /**
//   * '
//   */
//  void multi();
//
//  void discard();
///////////////////////////////////////////key/////////////////////////////////////////////////////

private void switchToSlave() {
if(isMaster) {
JedisConnectionFactory redisConnectionFactory = switchToSlaveCnnection();
switchRedisConnectionFactory(redisConnectionFactory);
isMaster = false;
}
}

private void switchToMaster() {
if(!isMaster) {
JedisConnectionFactory redisConnectionFactory = switchToMasterConnection();
switchRedisConnectionFactory(redisConnectionFactory);
isMaster = true;
}
}

private JedisConnectionFactory switchToMasterConnection() {
JedisConnectionFactory redisConnectionFactory = (JedisConnectionFactory) delegate.getConnectionFactory();
redisConnectionFactory.setShardInfo(masterJedisShardInfo);
return redisConnectionFactory;
}

private JedisConnectionFactory switchToSlaveCnnection() {
JedisConnectionFactory redisConnectionFactory = (JedisConnectionFactory) delegate.getConnectionFactory();
int index = ThreadLocalRandom.current().nextInt(slaveJedisShardInfos.size());
JedisShardInfo jedisShardInfo = slaveJedisShardInfos.get(index);
// 设置redisConnectionFactory
redisConnectionFactory.setShardInfo(jedisShardInfo);
redisConnectionFactory.setHostName(jedisShardInfo.getHost());
redisConnectionFactory.setPort(jedisShardInfo.getPort());
redisConnectionFactory.afterPropertiesSet();
return redisConnectionFactory;
}

// 多余
private void switchRedisConnectionFactory(JedisConnectionFactory redisConnectionFactory) {
delegate.setConnectionFactory(redisConnectionFactory);
}

}

package com.xjy.study.spring.redis.rw;

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

// 使用装饰器设计模式
// 暂时只支持jedis客户端
public class RWStringRedisTemplate extends RWRedisTemplate<String, String>  {

public RWStringRedisTemplate(StringRedisTemplate delegate) {
super(delegate);
}
}