服务器之家：专注于服务器技术及软件下载分享
分类导航

Mysql|Sql Server|Oracle|Redis|MongoDB|PostgreSQL|Sqlite|DB2|mariadb|Access|数据库技术|

服务器之家 - 数据库 - Redis - Redis主从实现读写分离

Redis主从实现读写分离

2019-10-31 16:27KeySilenceM Redis

这篇文章主要为大家详细介绍了Redis主从实现读写分离的相关资料 ,具有一定的参考价值，感兴趣的小伙伴们可以参考一下

前言

大家在工作中可能会遇到这样的需求，即Redis读写分离，目的是为了压力分散化。下面我将为大家介绍借助AWS的ELB实现读写分离，以写主读从为例。

实现

引用库文件

?
1
2
3
4
5
6
<!-- redis客户端 -->
<dependency>
 <groupId>redis.clients</groupId>
 <artifactId>jedis</artifactId>
 <version>2.6.2</version>
</dependency>

方式一，借助切面

JedisPoolSelector

此类的目的是为读和写分别配置不同的注解，用来区分是主还是从。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.silence.spring.redis.readwriteseparation;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
/**
 * Created by keysilence on 16/10/26.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface JedisPoolSelector {
 
  String value();
 
}

JedisPoolAspect

此类的目的是针对主和从的注解，进行动态链接池调配，即主的使用主链接池，从的使用从连接池。

 

?
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
package com.silence.spring.redis.readwriteseparation;
 
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import redis.clients.jedis.JedisPool;
 
import javax.annotation.PostConstruct;
import java.lang.reflect.Method;
import java.util.Date;
 
/**
 * Created by keysilence on 16/10/26.
 */
@Aspect
public class JedisPoolAspect implements ApplicationContextAware {
 
  private ApplicationContext ctx;
 
  @PostConstruct
  public void init() {
    System.out.println("jedis pool aspectj started @" + new Date());
  }
 
  @Pointcut("execution(* com.silence.spring.redis.readwriteseparation.util.*.*(..))")
  private void allMethod() {
 
  }
 
  @Before("allMethod()")
  public void before(JoinPoint point)
  {
    Object target = point.getTarget();
    String method = point.getSignature().getName();
 
    Class classz = target.getClass();
 
    Class<?>[] parameterTypes = ((MethodSignature) point.getSignature())
        .getMethod().getParameterTypes();
    try {
      Method m = classz.getMethod(method, parameterTypes);
      if (m != null && m.isAnnotationPresent(JedisPoolSelector.class)) {
        JedisPoolSelector data = m
            .getAnnotation(JedisPoolSelector.class);
        JedisPool jedisPool = (JedisPool) ctx.getBean(data.value());
        DynamicJedisPoolHolder.putJedisPool(jedisPool);
      }
 
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
 
  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    this.ctx = applicationContext;
  }
 
}

DynamicJedisPoolHolder

此类目的是存储当前使用的JedisPool，即上面类赋值后的结果保存。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.silence.spring.redis.readwriteseparation;
 
import redis.clients.jedis.JedisPool;
 
/**
 * Created by keysilence on 16/10/26.
 */
public class DynamicJedisPoolHolder {
 
  public static final ThreadLocal<JedisPool> holder = new ThreadLocal<JedisPool>();
 
  public static void putJedisPool(JedisPool jedisPool) {
    holder.set(jedisPool);
  }
 
  public static JedisPool getJedisPool() {
    return holder.get();
  }
 
}

RedisUtils

此类目的是对Redis具体的调用，里面包含使用主还是从的方式调用。

 

?
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
package com.silence.spring.redis.readwriteseparation.util;
 
import com.silence.spring.redis.readwriteseparation.DynamicJedisPoolHolder;
import com.silence.spring.redis.readwriteseparation.JedisPoolSelector;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
/**
 * Created by keysilence on 16/10/26.
 */
public class RedisUtils {
  private static Logger logger = LoggerFactory.getLogger(RedisUtils.class);
 
  @JedisPoolSelector("master")
  public String setString(final String key, final String value) {
 
    String ret = DynamicJedisPoolHolder.getJedisPool().getResource().set(key, value);
    System.out.println("key:" + key + ",value:" + value + ",ret:" + ret);
 
    return ret;
  }
 
  @JedisPoolSelector("slave")
  public String get(final String key) {
 
    String ret = DynamicJedisPoolHolder.getJedisPool().getResource().get(key);
    System.out.println("key:" + key + ",ret:" + ret);
 
    return ret;
  }
 
}

spring-datasource.xml

 

?
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
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
 
  <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
    <!-- 池中最大链接数 -->
    <property name="maxTotal" value="100"/>
    <!-- 池中最大空闲链接数 -->
    <property name="maxIdle" value="50"/>
    <!-- 池中最小空闲链接数 -->
    <property name="minIdle" value="20"/>
    <!-- 当池中链接耗尽，调用者最大阻塞时间，超出此时间将跑出异常。（单位：毫秒；默认为-1，表示永不超时） -->
    <property name="maxWaitMillis" value="1000"/>
    <!-- 参考：http://biasedbit.com/redis-jedispool-configuration/ -->
    <!-- 调用者获取链接时，是否检测当前链接有效性。无效则从链接池中移除，并尝试继续获取。（默认为false） -->
    <property name="testOnBorrow" value="true" />
    <!-- 向链接池中归还链接时，是否检测链接有效性。（默认为false） -->
    <property name="testOnReturn" value="true" />
    <!-- 调用者获取链接时，是否检测空闲超时。如果超时，则会被移除（默认为false） -->
    <property name="testWhileIdle" value="true" />
    <!-- 空闲链接检测线程一次运行检测多少条链接 -->
    <property name="numTestsPerEvictionRun" value="10" />
    <!-- 空闲链接检测线程检测周期。如果为负值，表示不运行检测线程。（单位：毫秒，默认为-1） -->
    <property name="timeBetweenEvictionRunsMillis" value="60000" />
    <!-- 链接获取方式。队列：false；栈：true -->
    <!--<property name="lifo" value="false" />-->
  </bean>
 
  <bean id="master" class="redis.clients.jedis.JedisPool">
    <constructor-arg index="0" ref="poolConfig"/>
    <constructor-arg index="1" value="192.168.100.110" type="java.lang.String"/>
    <constructor-arg index="2" value="6379" type="int"/>
  </bean>
 
  <bean id="slave" class="redis.clients.jedis.JedisPool">
    <constructor-arg index="0" ref="poolConfig"/>
    <!-- 此处Host配置成ELB地址 -->
    <constructor-arg index="1" value="192.168.100.110" type="java.lang.String"/>
    <constructor-arg index="2" value="6380" type="int"/>
  </bean>
 
  <bean id="redisUtils" class="com.silence.spring.redis.readwriteseparation.util.RedisUtils">
  </bean>
 
  <bean id="jedisPoolAspect" class="com.silence.spring.redis.readwriteseparation.JedisPoolAspect" />
 
  <aop:aspectj-autoproxy proxy-target-class="true"/>
 
</beans>

Test

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.silence.spring.redis.readwriteseparation;
 
import com.silence.spring.redis.readwriteseparation.util.RedisUtils;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
/**
 * Created by keysilence on 16/10/26.
 */
public class Test {
 
  public static void main(String[] args) {
 
    ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-datasource.xml");
 
    System.out.println(ctx);
 
    RedisUtils redisUtils = (RedisUtils) ctx.getBean("redisUtils");
    redisUtils.setString("aaa", "111");
 
    System.out.println(redisUtils.get("aaa"));
  }
 
}

方式二，依赖注入

与方式一类似，但是需要写死具体使用主的池还是从的池，思路如下：
放弃注解的方式，直接将主和从的两个链接池注入到具体实现类中。

RedisUtils

?
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
package com.silence.spring.redis.readwriteseparation.util;
 
import com.silence.spring.redis.readwriteseparation.DynamicJedisPoolHolder;
import com.silence.spring.redis.readwriteseparation.JedisPoolSelector;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.JedisPool;
 
/**
 * Created by keysilence on 16/10/26.
 */
public class RedisUtils {
  private static Logger logger = LoggerFactory.getLogger(RedisUtils.class);
 
  private JedisPool masterJedisPool;
 
  private JedisPool slaveJedisPool;
 
  public void setMasterJedisPool(JedisPool masterJedisPool) {
    this.masterJedisPool = masterJedisPool;
  }
 
  public void setSlaveJedisPool(JedisPool slaveJedisPool) {
    this.slaveJedisPool = slaveJedisPool;
  }
 
  public String setString(final String key, final String value) {
 
    String ret = masterJedisPool.getResource().set(key, value);
    System.out.println("key:" + key + ",value:" + value + ",ret:" + ret);
 
    return ret;
  }
 
  public String get(final String key) {
 
    String ret = slaveJedisPool.getResource().get(key);
    System.out.println("key:" + key + ",ret:" + ret);
 
    return ret;
  }
 
}

spring-datasource.xml

 

?
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
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
 
  <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
    <!-- 池中最大链接数 -->
    <property name="maxTotal" value="100"/>
    <!-- 池中最大空闲链接数 -->
    <property name="maxIdle" value="50"/>
    <!-- 池中最小空闲链接数 -->
    <property name="minIdle" value="20"/>
    <!-- 当池中链接耗尽，调用者最大阻塞时间，超出此时间将跑出异常。（单位：毫秒；默认为-1，表示永不超时） -->
    <property name="maxWaitMillis" value="1000"/>
    <!-- 参考：http://biasedbit.com/redis-jedispool-configuration/ -->
    <!-- 调用者获取链接时，是否检测当前链接有效性。无效则从链接池中移除，并尝试继续获取。（默认为false） -->
    <property name="testOnBorrow" value="true" />
    <!-- 向链接池中归还链接时，是否检测链接有效性。（默认为false） -->
    <property name="testOnReturn" value="true" />
    <!-- 调用者获取链接时，是否检测空闲超时。如果超时，则会被移除（默认为false） -->
    <property name="testWhileIdle" value="true" />
    <!-- 空闲链接检测线程一次运行检测多少条链接 -->
    <property name="numTestsPerEvictionRun" value="10" />
    <!-- 空闲链接检测线程检测周期。如果为负值，表示不运行检测线程。（单位：毫秒，默认为-1） -->
    <property name="timeBetweenEvictionRunsMillis" value="60000" />
    <!-- 链接获取方式。队列：false；栈：true -->
    <!--<property name="lifo" value="false" />-->
  </bean>
 
  <bean id="masterJedisPool" class="redis.clients.jedis.JedisPool">
    <constructor-arg index="0" ref="poolConfig"/>
    <constructor-arg index="1" value="192.168.100.110" type="java.lang.String"/>
    <constructor-arg index="2" value="6379" type="int"/>
  </bean>
 
  <bean id="slaveJedisPool" class="redis.clients.jedis.JedisPool">
    <constructor-arg index="0" ref="poolConfig"/>
    <constructor-arg index="1" value="192.168.100.110" type="java.lang.String"/>
    <constructor-arg index="2" value="6380" type="int"/>
  </bean>
 
  <bean id="redisUtils" class="com.silence.spring.redis.readwriteseparation.util.RedisUtils">
    <property name="masterJedisPool" ref="masterJedisPool"/>
    <property name="slaveJedisPool" ref="slaveJedisPool"/>
  </bean>
 
</beans>

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。

  • redis
  • 读写分离
  • 主从

    • 延伸 · 阅读

    精彩推荐
    • Redisredis缓存存储Session原理机制

      redis缓存存储Session原理机制

      这篇文章主要为大家介绍了redis缓存存储Session原理机制详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪...

      程序媛张小妍9252021-11-25
    • RedisRedis Template实现分布式锁的实例代码

      Redis Template实现分布式锁的实例代码

      这篇文章主要介绍了Redis Template实现分布式锁,需要的朋友可以参考下 ...

      晴天小哥哥2592019-11-18
    • Redis《面试八股文》之 Redis十六卷

      《面试八股文》之 Redis十六卷

      redis 作为我们最常用的内存数据库，很多地方你都能够发现它的身影，比如说登录信息的存储，分布式锁的使用，其经常被我们当做缓存去使用。...

      moon聊技术8182021-07-26
    • Redis关于Redis数据库入门详细介绍

      关于Redis数据库入门详细介绍

      大家好，本篇文章主要讲的是关于Redis数据库入门详细介绍，感兴趣的同学赶快来看一看吧，对你有帮助的话记得收藏一下，方便下次浏览...

      沃尔码6982022-01-24
    • RedisRedis集群的5种使用方式，各自优缺点分析

      Redis集群的5种使用方式，各自优缺点分析

      Redis 多副本，采用主从(replication)部署结构，相较于单副本而言最大的特点就是主从实例间数据实时同步，并且提供数据持久化和备份策略。...

      优知学院4082021-08-10
    • Redis详解三分钟快速搭建分布式高可用的Redis集群

      详解三分钟快速搭建分布式高可用的Redis集群

      这篇文章主要介绍了详解三分钟快速搭建分布式高可用的Redis集群，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，...

      万猫学社4502021-07-25
    • Redis如何使用Redis锁处理并发问题详解

      如何使用Redis锁处理并发问题详解

      这篇文章主要给大家介绍了关于如何使用Redis锁处理并发问题的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Redis具有一定的参考学习...

      haofly4522019-11-26
    • RedisRedis 6.X Cluster 集群搭建

      Redis 6.X Cluster 集群搭建

      码哥带大家完成在 CentOS 7 中安装 Redis 6.x 教程。在学习 Redis Cluster 集群之前，我们需要先搭建一套集群环境。机器有限，实现目标是一台机器上搭建 6 个节...

      码哥字节15752021-04-07
    最近更新
    编辑推荐
    阅读排行
    热门标签
    16384 　 Hashes 　 Sorted-Sets 　 服务器管理命令 　 管线 　 操作 　 主键失效 　 LRU 　 机制 　 应用场景 　 redis-py 　 禁用命令 　 危险命令 　 速率限制 　 Redis简介 　 用户积分 　 Mac OS 　 集群部署 　 Redis安装 　 Redis配置 　 远程方法调用 　 数据结构 　 Redis教程 　 redis-dump 　 还原数据 　 java脚本 　 计数 　 使用场景 　 计数器模式 　 数据大小 　
    © 2019-2023 服务器之家(www.zzvips.com) 版权所有关于我们联系我们版权申明网站地图