文档章节

基于spring+redis读写分离实践

Zero零_度
 Zero零_度
发布于 2016/08/29 15:52
字数 1214
阅读 731
收藏 0

明:本文为博主原创文章,未经博主允许不得转载。

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

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
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);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

本文转载自:http://blog.csdn.net/xujieyang4j/article/details/50816614

Zero零_度
粉丝 69
博文 1267
码字总数 263854
作品 0
程序员
私信 提问
mycat实现mysql读写分离实践

mycat是一个的数据库中间件,基于阿里开源的cobar产品而研发,由几个有志之士的牛人共同完成并开源。提供高可用性数据分片集群,自动故障切换,高可用性 ,支持读写分离,支持Mysql双主多从,...

rock912
2016/01/28
10.1K
21
Mycat学习实战-Mycat基本功能

Mycat学习实战-Mycat基本功能 Mycat学习实战-Mycat基本功能 1. Mycat高可用-读写分离 2. Mycat高可用-多主切换 3 注解 1. Mycat高可用-读写分离 1.1 读写分离配置参数 Schema.dataHost 参数b...

ygqygq2
2017/10/19
0
0
Java通用数据访问层 Fastser-DAL 1.0.2 发布

Fastser-DAL是Java通用数据访问组件,基于mybatis、spring jdbc、hibernate等ORM框架开发,同时支持基于多数据源的读写分离、主备切换、故障转移,自动恢复、负载均衡、缓存等。 Fastser-DA...

冶卫军
2014/12/24
6.7K
31
分析型数据仓库中读写分离的实现

作者:张广强 和以 MySQL 为代表的传统事务型数据库相比,数据仓库有一个很大的特点,就是主要面向批量写和查询进行优化,可以不支持更新、事务这些高级特性。一些商用的数据仓库分析系统,例...

小数点
2017/11/27
0
0
分析型数据仓库中读写分离的实现

本文作者为神策数据(ID:SensorsDataCrop)资深研发工程师张广强,版权归神策数据所有。 和以 MySQL 为代表的传统事务型数据库相比,数据仓库有一个很大的特点,就是主要面向批量写和查询进...

dev_csdn
2017/11/24
0
0

没有更多内容

加载失败,请刷新页面

加载更多

移动深度学习:人工智能的深水区

人工智能技术经历6年的快速发展,重新定义了很多行业的用户体验,而这仅是开始。 随着5G商用大规模落地,以及智能手机硬件性能越来越强、AIoT设备的快速普及,基于云-边缘-端算法和算力结构的...

博文视点Bv
13分钟前
1
0
vim 分屏 操作

$vim -On file file2 #大写O垂直分屏打开文件 $vim -on file file2 #小写水平打开 # n 表示分屏数,直接n等于文件个数 如果n小于文件,按顺序打开前面的n个,如果大于,打开空编辑页面 分屏快...

突突突酱
16分钟前
1
0
MySQL/Mariadb设置中文字符集(linux)

编辑/etc/my.cnf,添加以下设置 [mysql]default-character-set=utf8[mysqld]character_set_server=utf8[mysqld.safe]default-character-set=utf8[client]default-chara...

编程老陆
18分钟前
2
0
关于linux常用的挂载命令

挂载:就把一块磁盘(可以是光盘,U盘)绑定到一个空目录下面 一般情况下会挂载到mnt目录下面 挂载光盘(把光盘挂载到/mnt/cdrom这个目录中) mount -t iso9660 /dev/cdrom /mnt/cdrom 退出当前目录...

chenhongjiang
20分钟前
2
0
如何分享brain内容外部共享?几个需要知道的TheBrain问答

TheBrain(点击下载)是一款与众不同的思维导图软件,其所有信息通过一个又一个的节点进行联系,最终形成一个杂而不乱的网状结构。从头开始设计,让您捕获您的想法和信息在一个网络的联想,匹...

mnrssj
20分钟前
1
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部