Redis缓存和MySQL数据一致性方案详解

需求

在高并发的业务场景下，数据库大多数情况都是用户并发访问最薄弱的环节。所以，就需要使用redis做一个缓冲操作，让请求先访问到redis，而不是直接访问MySQL等数据库。

这个业务场景，主要是解决读数据从Redis缓存，一般都是按照下图的流程来进行业务操作。

读取缓存步骤一般没有什么问题，但是一旦涉及到数据更新：数据库和缓存更新，就容易出现缓存(Redis)和数据库（MySQL）间的数据一致性问题。

不管是先写MySQL数据库，再删除Redis缓存；还是先删除缓存，再写库，都有可能出现数据不一致的情况。举一个例子：

1.如果删除了缓存Redis，还没有来得及写库MySQL，另一个线程就来读取，发现缓存为空，则去数据库中读取数据写入缓存，此时缓存中为脏数据。

2.如果先写了库，在删除缓存前，写库的线程宕机了，没有删除掉缓存，则也会出现数据不一致情况。

因为写和读是并发的，没法保证顺序,就会出现缓存和数据库的数据不一致的问题。

如来解决？这里给出两个解决方案，先易后难，结合业务和技术代价选择使用。

 

缓存和数据库一致性解决方案

1.第一种方案：采用延时双删策略

在写库前后都进行redis.del(key)操作，并且设定合理的超时时间。

伪代码如下

public void write(String key,Object data){
 redis.delKey(key);
 db.updateData(data);
 Thread.sleep(500);
 redis.delKey(key);
 }

2.具体的步骤就是：

1）先删除缓存

2）再写数据库

3）休眠500毫秒

4）再次删除缓存

那么，这个500毫秒怎么确定的，具体该休眠多久呢？

需要评估自己的项目的读数据业务逻辑的耗时。这么做的目的，就是确保读请求结束，写请求可以删除读请求造成的缓存脏数据。

当然这种策略还要考虑redis和数据库主从同步的耗时。最后的的写数据的休眠时间：则在读数据业务逻辑的耗时基础上，加几百ms即可。比如：休眠1秒。

3.设置缓存过期时间

从理论上来说，给缓存设置过期时间，是保证最终一致性的解决方案。所有的写操作以数据库为准，只要到达缓存过期时间，则后面的读请求自然会从数据库中读取新值然后回填缓存。

4.该方案的弊端

结合双删策略+缓存超时设置，这样最差的情况就是在超时时间内数据存在不一致，而且又增加了写请求的耗时。

2、第二种方案：异步更新缓存(基于订阅binlog的同步机制)

1.技术整体思路：

MySQL binlog增量订阅消费+消息队列+增量数据更新到redis

1）读Redis：热数据基本都在Redis

2）写MySQL:增删改都是操作MySQL

3）更新Redis数据：MySQ的数据操作binlog，来更新到Redis

2.Redis更新

1）数据操作主要分为两大块：

• 一个是全量(将全部数据一次写入到redis)
• 一个是增量（实时更新）

这里说的是增量,指的是mysql的update、insert、delate变更数据。

2）读取binlog后分析 ，利用消息队列,推送更新各台的redis缓存数据。

这样一旦MySQL中产生了新的写入、更新、删除等操作，就可以把binlog相关的消息推送至Redis，Redis再根据binlog中的记录，对Redis进行更新。

其实这种机制，很类似MySQL的主从备份机制，因为MySQL的主备也是通过binlog来实现的数据一致性。

这里可以结合使用canal(阿里的一款开源框架)，通过该框架可以对MySQL的binlog进行订阅，而canal正是模仿了mysql的slave数据库的备份请求，使得Redis的数据更新达到了相同的效果。

当然，这里的消息推送工具你也可以采用别的第三方：kafka、rabbitMQ等来实现推送更新Redis。

以上就是Redis和MySQL数据一致性详解，相关的MySQL数据库主从同步一致性可以参考：高并发架构系列：数据库主从同步的3种一致性方案实现，优劣比较

 

 

用Binlog 同步缓存 我们就这么干的，不过这数据不是很猛烈的那种(不想订单数据那种猛写的)。数据量级8亿。没错真的8亿。这8亿数据都是活跃的(月活的)

可以支撑吧，热点数据大概多少

8亿 用户数据，更新较少//@大拿213：可以支撑吧，热点数据大概多少

 

使用canal进行mysql数据同步到Redis

• 开启mysql的binlog模块

切换到mysql的安装路径，找到my.cnf(Linux)/my.ini (windows)，加入如下内容：

log-bin=mysql-bin #添加这一行就ok

binlog-format=ROW #选择row模式

server_id=1 #配置mysql replaction需要定义，不能和canal的slaveId重复

配置完成后，需要重启数据库。当重启数据库遇到问题时，耐心解决，但需要警告的是，千万别动data文件夹下的文件。当然如果你觉得你比较有“资本”，同时遇到了“mysql 1067 无法启动”的错误，你可以试着备份一下data文件夹下的内容，删除logfile文件，重启数据库即可，但本人极不推荐这样进行操作。就是由于本人之前的无知，根据一个无良博客，误删了ibdata1文件，使得本人造成了很大的损失，mysql下的所有数据库瞬间毁灭。

• 配置mysql数据库

创建canal用户，用来管理canal的访问权限。我们可以通过对canal用户访问权限的控制，进而控制canal能够获取的内容。

CREATE USER canal IDENTIFIED BY 'canal';

GRANT SELECT, REPLICATION SLAVE, REPLICATION CLIENT ON 数据库名.表名 TO 'canal'@'%';

-- GRANT ALL PRIVILEGES ON 数据库名.表名 TO 'canal'@'%' ;

FLUSH PRIVILEGES;

配置修改

vi conf/example/instance.properties

#################################################
## mysql serverId
canal.instance.mysql.slaveId = 1234
#position info，需要改成自己的数据库信息 192.126.6.107为MySQL所在机器对应的IP
canal.instance.master.address = 192.126.6.107:3306
canal.instance.master.journal.name =
canal.instance.master.position =
canal.instance.master.timestamp =
 
 
#canal.instance.standby.address =
#canal.instance.standby.journal.name =
#canal.instance.standby.position =
#canal.instance.standby.timestamp =
 

canal.instance.dbUsername = canal #改成自己的数据库信息 
canal.instance.dbPassword = canal #改成自己的数据库信息 
canal.instance.defaultDatabaseName =  #改成自己的数据库信息
canal.instance.connectionCharset = UTF-8 #改成自己的数据库信息 
 
#table regex
#监听所有用户所有表的变化
canal.instance.filter.regex = .\..
#监听canal用户下以da_dosage_开头的表的变化
#canal.instance.filter.regex = canal\\.da_dosage_.*

• 启动canal

./canal/startup.sh

• 查看启动状态

我们可以通过查看logs/canal/canal.log 和logs/example/example.log日志来判断canal是否启动成功。

canal/logs/canal/canal.log

2016-12-29 14:03:00.956 [main] INFO com.alibaba.otter.canal.deployer.CanalLauncher - ## start the canal server.

2016-12-29 14:03:01.071 [main] INFO com.alibaba.otter.canal.deployer.CanalController - ## start the canal server[192.168.1.99:11111]

2016-12-29 14:03:01.628 [main] INFO com.alibaba.otter.canal.deployer.CanalLauncher - ## the canal server is running now ......

canal/logs/example/example.log

2016-12-29 14:03:01.357 [main] INFO c.a.o.c.i.spring.support.PropertyPlaceholderConfigurer - Loading properties file from class path resource [canal.properties]

2016-12-29 14:03:01.362 [main] INFO c.a.o.c.i.spring.support.PropertyPlaceholderConfigurer - Loading properties file from class path resource [example/instance.properties]

2016-12-29 14:03:01.535 [main] INFO c.a.otter.canal.instance.spring.CanalInstanceWithSpring - start CannalInstance for 1-example

2016-12-29 14:03:01.555 [main] INFO c.a.otter.canal.instance.core.AbstractCanalInstance - start successful....

4. Java连接canal执行同步操作

 

在maven项目中中加载canal和redis依赖包.

<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.4.2</version>
</dependency>

<dependency>
<groupId>com.alibaba.otter</groupId>
<artifactId>canal.client</artifactId>
<version>1.0.22</version>
</dependency>

建立canal客户端，从canal中获取数据，并将数据更新至Redis

 

public class CanalClient {
    public static void main(String args[]) {
        // 创建链接,127.0.0.1是ip，11111是canal的端口号，默认是11111，这个在conf/canal.properties文件里配置，example是canal虚拟的模块名，
        // 在canal.properties文件canal.destinations= example 这段可以自行修改。canal是创建的数据库账号密码
        CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("127.0.0.1",
                11111), "example", "canal", "canal");
        int batchSize = 1000;
        int emptyCount = 0;
        try {
            connector.connect();
            connector.subscribe(".*\\..*");
            connector.rollback();
            int totalEmtryCount = 1200;
            while (emptyCount < totalEmtryCount) {
                Message message = connector.getWithoutAck(batchSize); // 获取指定数量的数据
                long batchId = message.getId();
                int size = message.getEntries().size();
                if (batchId == -1 || size == 0) {
                    emptyCount++;
                    System.out.println("empty count : " + emptyCount);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    emptyCount = 0;
                    // System.out.printf("message[batchId=%s,size=%s] \n", batchId, size);
                    printEntry(message.getEntries());
                }
 
                connector.ack(batchId); // 提交确认
                // connector.rollback(batchId); // 处理失败, 回滚数据
            }
 
            System.out.println("empty too many times, exit");
        } finally {
            connector.disconnect();
        }
    }
 
    private static void printEntry(List<Entry> entrys) {
        for (Entry entry : entrys) {
            if (entry.getEntryType() == EntryType.TRANSACTIONBEGIN || entry.getEntryType() == EntryType.TRANSACTIONEND) {
                continue;
            }
 
            RowChange rowChage = null;
            try {
                rowChage = RowChange.parseFrom(entry.getStoreValue());
            } catch (Exception e) {
                throw new RuntimeException("ERROR ## parser of eromanga-event has an error , data:" + entry.toString(),
                        e);
            }
 
            EventType eventType = rowChage.getEventType();
            System.out.println(String.format("================> binlog[%s:%s] , name[%s,%s] , eventType : %s",
                    entry.getHeader().getLogfileName(), entry.getHeader().getLogfileOffset(),
                    entry.getHeader().getSchemaName(), entry.getHeader().getTableName(),
                    eventType));
 
            for (RowData rowData : rowChage.getRowDatasList()) {
                if (eventType == EventType.DELETE) {
                    printColumn(rowData.getBeforeColumnsList());
                    redisDelete(rowData.getBeforeColumnsList(), entry.getHeader().getTableName());
                } else if (eventType == EventType.INSERT) {
                    printColumn(rowData.getAfterColumnsList());
                    redisInsert(rowData.getAfterColumnsList(), entry.getHeader().getTableName());
                } else {
                    System.out.println("-------> before");
                    printColumn(rowData.getBeforeColumnsList());
                    System.out.println("-------> after");
                    printColumn(rowData.getAfterColumnsList());
                    redisUpdate(rowData.getAfterColumnsList(), entry.getHeader().getTableName());
                }
            }
        }
    }
 
    private static void printColumn(List<Column> columns) {
        for (Column column : columns) {
            System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
        }
    }
 
    private static void redisInsert(List<Column> columns, String tablename) {
        JSONObject json = new JSONObject();
        for (Column column : columns) {
            json.put(column.getName(), column.getValue());
        }
        if (columns.size() > 0) {
            RedisUtil.stringSet(tablename + columns.get(0).getValue(), json.toJSONString());//以表名+第一列主键为key
        }
    }
 
    private static void redisUpdate(List<Column> columns, String tablename) {
        JSONObject json = new JSONObject();
        for (Column column : columns) {
            json.put(column.getName(), column.getValue());
        }
        if (columns.size() > 0) {
            RedisUtil.stringSet(tablename + columns.get(0).getValue(), json.toJSONString());//以表名+第一列主键为key
        }
    }
 
    private static void redisDelete(List<Column> columns, String tablename) {
        JSONObject json = new JSONObject();
        for (Column column : columns) {
            json.put(column.getName(), column.getValue());
        }
        if (columns.size() > 0) {
            RedisUtil.delKey(tablename + columns.get(0).getValue());//以表名+第一列主键为key
        }
    }
}

RedisUtil 工具类

public class RedisUtil {
    private static String ip = "localhost";
    private static int port = 6379;
    private static int timeout = 10000;
    private static JedisPool pool = null;
 
 
    static {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(1024);//最大连接数
        config.setMaxIdle(200);//最大空闲实例数
        config.setMaxWaitMillis(10000);//等连接池给连接的最大时间，毫秒
        config.setTestOnBorrow(true);//borrow一个实例的时候，是否提前vaildate操作
 
        pool = new JedisPool(config, ip, port, timeout);
 
    }
 
    //得到redis连接
    public static Jedis getJedis() {
        if (pool != null) {
            return pool.getResource();
        } else {
            return null;
        }
    }
 
    //关闭redis连接
    public static void close(final Jedis redis) {
        if (redis != null) {
            redis.close();
        }
    }
  
    public static boolean existKey(String key) {
        return getJedis().exists(key);
    }
 
    public static void delKey(String key) {
        getJedis().del(key);
    }
 
    public static String stringGet(String key) {
        return getJedis().get(key);
    }
 
    public static String stringSet(String key, String value) {
        return getJedis().set(key, value);
    }
 
    public static void hashSet(String key, String field, String value) {
        getJedis().hset(key, field, value);
    }
}

启动Canal Client后，可以从控制台从看到类似消息：
 
empty count : 1
empty count : 2
empty count : 3
empty count : 4
此时代表当前数据库无变更数据
 
触发数据库变更
 
mysql> use test;
Database changed
mysql> CREATE TABLE `xdual` (
    ->   `ID` int(11) NOT NULL AUTO_INCREMENT,
    ->   `X` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
    ->   PRIMARY KEY (`ID`)
    -> ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 ;
Query OK, 0 rows affected (0.06 sec)
mysql> insert into xdual(id,x) values(null,now());Query OK, 1 row affected (0.06 sec)
 
可以从控制台中看到：
 
empty count : 1
empty count : 2
empty count : 3
empty count : 4
================> binlog[mysql-bin.001946:313661577] , name[test,xdual] , eventType : INSERT
ID : 4    update=true
X : 2013-02-05 23:29:46    update=true

 application.properties

server.port=8080
#server.servlet.context-path=/demo
 
#集成jsp
spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp
 
#集成mybatis：注解的形式
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/NEEM_CDB?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.username=root
spring.datasource.password=root
 
#mybatis配置信息
mybatis.type-aliases-package=com.data.pojo
#集成mybatis：配置xml形式
mybatis.config-locations=classpath:mybatis/mybatis-config.xml
mybatis.mapper-locations=classpath:mybatis/mapper/*.xml
 
 
#集成redis
#redis数据库参数
#jedis连接池配置
redis.maxTotal=100
redis.maxIdle=5
redis.minIdle=2
redis.maxWaitMillis=30000
redis.testOnBorrow=false
redis.testOnIdle=true
redis.timeBetweenEvictionRunsMillis=60000
redis.numTestsPerEvictionRun=1000
redis.minEvictableIdleTimeMillis=3000000
redis.port=6379
redis.hostName=20.20.20.246
redis.password=123456
redis.timeout=10000
#选择redis数据库
redis.dbSelected=15
 
 
#打印sql
#logging.level.com.data.dao=debug
 
#################################################日志####################################################
#com.mycompany.mavenspringboot.controller 日志 WARN级别输出
#logging.level.com.mycompany.mavenspringboot.controller=WARN
#com.mycompany.mavenspringboot.mapper sql日志 DEBUG级别输出
#logging.level.com=DEBUG,INFO
#logging.file=logs/statistical.log
#logging.pattern.console=%d{yyyy/MM/dd-HH:mm:ss} [%thread] %-5level %logger- %msg%n
#logging.pattern.file=%d{yyyy/MM/dd-HH:mm} [%thread] %-5level %logger- %msg%n