上一篇：使用Nacos作为分布式配置中心

下一篇：使用责任链模式处理多种用户相同登录入口登录的问题

关于Redis

Redis应该是在现在任何一个微服务系统中都必不可少的一个中间件了——它可以用于缓存、Token（会话状态）存储，以及一些业务逻辑相关的使用。

虽然单体Redis的搭建并不是特别困难，但是要搭建Redis的高可用集群，如果不使用Docker，还是有一定难度的。既然上次使用Docker搭建SkyWalking十分简单，那这次我们也用Docker来搭建Redis高可用集群。

当然，这仅仅是一个比赛用的项目，不会上线部署到生产环境，目的也仅仅是搭建一个最简单的Redis高可用集群，所以肯定会有一些问题没有考虑到。

关于Redis Sentinel

Redis Sentinel是Redis官方推荐的Redis高可用解决方案，它可以监控Redis集群，在Master宕掉之后能进行自动切换。

很显然，不可能只用一个Redis Sentinel去监控整个Redis集群——那样假如Redis Sentinel宕机了，就会引发单点故障，所以如果要实现高可用，Redis Sentinel也要做成集群的形式。

Reference

https://www.cnblogs.com/duanxz/p/4701831.html

https://testerhome.com/topics/13091

https://www.bilibili.com/video/av36042649?p=118

在Ubuntu 16.04 LTS上安装docker-compose

如果要启动一主两从的Redis高可用集群，加上Redis Sentinel，一共有6个容器。为了方便管理，我打算在虚拟机里启动这些Docker容器。

虽然Ubuntu安装Docker并没有什么坑，但是安装docker-compose，坑就大了，并且在寻找解决方案的过程中，发现踩了这个坑的人还真不少。

Ubuntu如果直接使用apt-get install docker-compose，安装的docker-compose是不能使用的。要安装的话，只能从GitHub下载：

（以下命令都在root用户下运行，不是root用户记得加sudo）

curl -L https://github.com/docker/compose/releases/download/1.22.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

没有curl命令的话，需要先安装：

apt-get install curl

因为在GitHub，下载速度比较慢，大概需要下载15分钟。

下载好之后如果是用docker-compose命令不能运行，显示No such file or directory的话，就需要把下载好的docker-compose拷贝到/usr/bin目录中去：

mv ./docker-compose /usr/bin/docker-compose
docker-compose --version

如果可以输出版本号信息，就代表安装成功了。

docker-compose搭建Redis集群

本来我采用了 https://www.bilibili.com/video/av36042649?p=118 视频中的方法，但是不知道为什么只能启动一个Master和一个Slave，有一个Slave怎么也启动不起来，无奈之下更换了 https://testerhome.com/topics/13091 的方法，一次成功，感谢作者。

Dockerfile

FROM redis
COPY redis.conf /etc/redis.conf
RUN redis-server /etc/redis.conf

主要是把自定义的redis.conf添加到镜像中。

redis.conf

daemonize yes
pidfile /var/run/redis.pid
port 6379
timeout 0
loglevel notice
logfile stdout
databases 16
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb
dir ./
slave-serve-stale-data yes
slave-read-only no
slave-priority 100
appendonly yes
appendfsync everysec
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
lua-time-limit 5000
slowlog-log-slower-than 10000
slowlog-max-len 128
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
list-max-ziplist-entries 512
list-max-ziplist-value 64
set-max-intset-entries 512
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
activerehashing yes
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit slave 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60

docker-compose.yml

在这个文件中，配置了Master节点和两个Slave节点的信息：

version: '2'
services:
    remaster:
        build:
            context: .
            dockerfile: Dockerfile
        container_name: master
        ports:
          - "6379:6379"
        restart: always
        expose:
            - 6379
    slave6380:
        image: redis
        container_name: slave01
        ports:
          - "6380:6379"
        restart: always
        expose:
            - 6379
        command: /bin/bash -c "sleep 2 && redis-server --port 6380 --slaveof remaster 6379"
        depends_on:
          - remaster
    slave6381:
        image: redis
        container_name: slave02
        ports:
          - "6381:6379"
        restart: always
        expose:
            - 6379
        command: /bin/bash -c "sleep 2 && redis-server --port 6381 --slaveof remaster 6379"
        depends_on:
          - remaster

启动：

docker-compose up -d

使用docker ps命令就能查看到启动好的三个Redis的信息了。

docker-compose搭建Redis Sentinel集群

Redis Sentinel也是要部署成集群形式的，同样使用docker-compose来搭建。

这次因为一共有三个Redis，所以启动了三个Redis Sentinel，实际上数量比这个多或者比这个少也没有太大的问题。

docker-compose.yml

version: '2'
services:
  sentinel1:
    image: redis
    container_name: redis-sentinel-1
    ports:
      - 26379:26379
    command: redis-sentinel /usr/local/etc/redis/sentinel.conf
    volumes:
      - ./sentinel1.conf:/usr/local/etc/redis/sentinel.conf

  sentinel2:
    image: redis
    container_name: redis-sentinel-2
    ports:
      - 26380:26379
    command: redis-sentinel /usr/local/etc/redis/sentinel.conf
    volumes:
      - ./sentinel2.conf:/usr/local/etc/redis/sentinel.conf

  sentinel3:
    image: redis
    container_name: redis-sentinel-3
    ports:
      - 26381:26379
    command: redis-sentinel /usr/local/etc/redis/sentinel.conf
    volumes:
      - ./sentinel3.conf:/usr/local/etc/redis/sentinel.conf

其中volumes指定了每一个Redis Sentinel的配置文件，并将它们映射到容器中。这三个配置文件的内容其实是相同的。

Redis Sentinel的默认端口是26379。

sentinel.conf

前面docker-compose.yml中出现的sentinel1.conf、sentinel2.conf和sentinel3.conf的内容其实都是一样的，采用的是 https://www.bilibili.com/video/av36042649?p=118 中的配置方案：

port 26379
dir "/tmp"
sentinel myid 634b81133a6b7bb6c56e1eb2e6c107a41de5f816
sentinel deny-scripts-reconfig yes
sentinel monitor mymaster 172.16.103.136 6379 2
sentinel config-epoch mymaster 0
sentinel leader-epoch mymaster 0
# Generated by CONFIG REWRITE
sentinel known-replica mymaster 172.16.103.136 6381
sentinel known-replica mymaster 172.16.103.136 6380
sentinel known-sentinel mymaster 172.16.103.136 26379 34130f5bcda76cfbe8e3f84a07c1ed65404bbd4b
sentinel known-sentinel mymaster 172.16.103.136 26379 3c13257691001f533ce8886384e555eb8e496b44
sentinel current-epoch 0

使用docker-compose up -d启动，再使用docker-ps检查，可以发现三个Redis Sentinel也启动好了。

Spring Cloud创建Redis存储服务

本来想单独开一篇写这个的，但是看了看代码量不是很多，就都写在这里了。

这个服务大体上采用的是 https://www.bilibili.com/video/av36042649?p=119 的方案，但是因为技术栈几乎完全不同，所以代码的区别还是比较大的。

使用可视化工具检查Redis集群的运行状况

首先用Medis连接Redis Sentinel：

image

连接成功，在Terminal里使用PING命令检查是否正常：

image

返回PONG就说明正常了。Redis Sentinel似乎也是用这个命令检查Master节点是否存活的。

注意：Medis对Redis Sentinel的支持其实很有限——它似乎不能识别Redis集群，比如我添加一个Key，就显示不出来，但是如果直接连接Master节点的话，就没问题了。。。如果大家知道什么在macOS下比较好用的Redis可视化工具，欢迎推荐。

依赖

pom.xml：

<dependencies>
        <!-- 公共API模块 -->
        <dependency>
            <groupId>com.timeline</groupId>
            <artifactId>timeline-api</artifactId>
        </dependency>

        <!-- 公共工具类模块 -->
        <dependency>
            <groupId>com.timeline</groupId>
            <artifactId>timeline-common</artifactId>
        </dependency>

        <!-- Dubbo -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-dubbo</artifactId>
        </dependency>

        <!-- Spring Boot -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- Nacos Discovery -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- Nacos Config -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>

        <!-- Alibaba Spring Context Support -->
        <dependency>
            <groupId>com.alibaba.spring</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>

        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>

        <!-- Redis 相关依赖 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
    </dependencies>

其实也就是那么几个依赖，比如公共API、工具模块、服务注册、服务配置、Spring Boot、Lombok等等。但是这里比其他的服务提供者多了两个Redis的依赖：

        <!-- Redis 相关依赖 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

Spring Boot的Redis模块底层实现还是用的jedis。

配置

bootstrap.yml：

spring:
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848
        name: timeline-service-redis
        file-extension: yml
        group: TIMELINE_DEV
dubbo:
  application:
    name: timeline-service-redis
  registry:
    address: spring-cloud://localhost:8848

配置好bootstrap.yml之后，在Nacos里新建配置：

server: 
  port: 10700
spring: 
  application: 
    name: timeline-service-redis
  main:
    allow-bean-definition-overriding: true
  cloud: 
    nacos: 
      discovery:
        server-addr: 127.0.0.1:8848
        # 注册到TIMELINE分组
        group: TIMELINE
  redis: 
    lettuce:
      pool: 
        max-active: 8
        max-idle: 8
        max-wait: -1ms
        min-idle: 0
    sentinel: 
      master: mymaster
      nodes: 172.16.103.136:26379, 172.16.103.136:26380, 172.16.103.136:26381
# 服务健康检查
management:
  endpoints:
    web:
      exposure:
        include: "*"
dubbo:
  scan:
    base-packages: com.timeline.service.redis.service
  # 使用dubbo协议，端口从20880开始自增以防重复
  protocol:
    name: dubbo
    port: -1
  cloud:
    subscribed-services: "*"

重点关注Redis相关的配置：

  redis: 
    lettuce:
      pool: 
        max-active: 8
        max-idle: 8
        max-wait: -1ms
        min-idle: 0
    sentinel: 
      master: mymaster
      nodes: 172.16.103.136:26379, 172.16.103.136:26380, 172.16.103.136:26381

redis.lettuce.pool节点中定义了一些Redis连接池相关的信息。

redis.sentinel节点则定义了Redis Sentinel的信息——主节点的名称（sentinel.conf文件中配置）是mymaster；一共有三个Redis Sentinel节点，就是我们用docker-compose启动的那三个。

Dubbo服务接口

因为我们是使用Dubbo作为RPC框架进行服务之间的调用的，Redis服务和其他服务之间也是，所以需要在公共API模块新建一个interface作为服务接口：

package com.timeline.api.service.redis;

/**
 * Redis相关服务的公共接口
 *
 * @author Architect
 * @date 2020/3/8 2:20 上午
 */
public interface RedisService {
    /**
     * 向Redis集群中添加数据
     *
     * @param key key
     * @param value value
     * @param expire 过期时间(单位：秒)
     */
    void put(String key, Object value, long expire);

    /**
     * 从Redis集群里拿数据
     *
     * @param key 要获取的数据的key
     * @return 根据key获取到的value，此对象可能为缺省值
     */
    Object get(String key);
}

顺便提一句：本来get()方法返回值我使用的是Optional<Object>类型，因为返回值可能为空，用Optional会减少一些问题，但是在跑单元测试时我发现Optional并不能像List一样被序列化，所以需要序列化的场景，不能使用Optional，需要手动判断缺省值null。

服务提供者

package com.timeline.service.redis.service;

import com.timeline.api.service.redis.RedisService;
import org.apache.dubbo.config.annotation.Service;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * Redis相关服务的实现类
 * 提供了get()和put()两种方法，并对外暴露了Dubbo接口
 *
 * @author Architect
 * @date 2020/3/8 2:22 上午
 */
@Service
@Component
public class RedisServiceImpl implements RedisService {
    final RedisTemplate redisTemplate;

    public RedisServiceImpl(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    @Override
    public void put(String key, Object value, long expire) {
        redisTemplate.opsForValue().set(key, value, expire, TimeUnit.SECONDS);
    }

    @Override
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }
}

这里的put和get方法使用了RedisTemplate工具类。

测试

package com.timeline.service.redis.tests;

import com.timeline.api.service.redis.RedisService;
import org.apache.dubbo.config.annotation.Reference;
import org.junit.Assert;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Optional;

/**
 * Redis相关测试
 * 注意：由于要调试Dubbo，所以需要先把服务本身开起来，再跑测试
 *
 * @author Architect
 * @date 2020/3/8 2:31 上午
 */
@SpringBootTest
public class RedisTests {
    @Reference
    RedisService redisService;

    /**
     * 测试添加key
     */
    @Test
    void testPut() {
        redisService.put("test", "timeline", 300);
    }

    /**
     * 测试获取key
     */
    @Test
    void testGet() {
        Object value = redisService.get("test");
        if (value == null) {
            Assert.fail();
        }
        Assert.assertEquals("timeline", value);
    }
}

两个测试不能一起跑，否则testGet()就获取不到key导致失败，不知道是啥原因，但是在跑完testPut()之后单独跑testGet()，就可以成功。