• Docker安装canal、mysql进行简单测试与实现redis和mysql缓存一致性

    一、简介

    canal [k’nl]，译意为水道/管道/沟渠，主要用途是基于 MySQL 数据库增量日志解析，提供增量数据订阅和消费。
    早期阿里巴巴因为杭州和美国双机房部署，存在跨机房同步的业务需求，实现方式主要是基于业务 trigger 获取增量变更。从 2010 年开始，业务逐步尝试数据库日志解析获取增量变更进行同步，由此衍生出了大量的数据库增量订阅和消费业务。

    Canal 是用 Java 开发的基于数据库增量日志解析，提供增量数据订阅&消费的中间件。
    目前，Canal 主要支持了 MySQL 的 Binlog 解析，解析完成后才利用 Canal Client 来处理获得
    的相关数据。（数据库同步需要阿里的 Otter 中间件，基于 Canal）。

    当前的 canal 支持源端 MySQL 版本包括 5.1.x , 5.5.x , 5.6.x , 5.7.x , 8.0.x。

    canal github地址
    在这里插入图片描述

    二、MySQL 的 Binlog

    1. Binlog介绍

    MySQL 的二进制日志可以说 MySQL 最重要的日志了，它记录了所有的 DDL 和 DML(除
    了数据查询语句)语句，以事件形式记录，还包含语句所执行的消耗的时间，MySQL 的二进 制日志是事务安全型的。
    一般来说开启二进制日志大概会有 1%的性能损耗。二进制有两个最重要的使用场景：

    • MySQL Replication 在 Master 端开启 Binlog，Master 把它的二进制日志传递给 Slaves
      来达到 Master-Slave 数据一致的目的，这就是我们常用的主从复制。

    • 就是数据恢复了，通过使用 MySQL Binlog 工具来使恢复数据，生产上要开启，不然真的要删库跑路了 。

    2. Binlog 的分类

    MySQL Binlog 的格式有三种，分别是 STATEMENT,MIXED,ROW。在配置文件中可以选择配
    置 binlog_format= statement|mixed|row。

    • statement：语句级，binlog 会记录每次一执行写操作的语句。比如
      update user set create_date=now()
      优点：节省空间。
      缺点：有可能造成数据不一致。
    • row：行级， binlog 会记录每次操作后每行记录的变化。
      优点：保持数据的绝对一致性
      缺点：占用较大空间
    • mixed：statement 的升级版，一定程度上解决了，因为一些情况而造成的 statement
      模式不一致问题，默认还是 statement，一些会产生不一致的情况还是会选择row。

    综合对比
    Canal 想做监控分析，选择 row 格式比较合适。

    三、工作原理

    1. MySQL主备复制原理

    • MySQL master 将数据变更写入二进制日志( binary log, 其中记录叫做二进制日志事件binary log events，可以通过 show binlog events 进行查看)
    • MySQL slave 将 master 的 binary log events 拷贝到它的中继日志(relay log)
    • MySQL slave 重放 relay log 中事件，将数据变更反映它自己的数据
      在这里插入图片描述

    2. canal 工作原理

    • canal 模拟 MySQL slave 的交互协议，伪装自己为 MySQL slave ，向 MySQL master 发送dump 协议
    • MySQL master 收到 dump 请求，开始推送 binary log 给 slave (即 canal )
    • canal 解析 binary log 对象(原始为 byte 流)

    总结：

    我们可以把canal理解为从机，拿到数据然后进行后续操作，可以同步到redis上，再也不需要进行延迟双删来保证mysql和redis的数据一致性了，而且还不会出现各种各样的问题！

    四、canal使用场景

    场景一： 阿里 Otter 中间件的一部分
    Otter 是阿里用于进行异地数据库之间的同步框架，Canal 是其中一部分。

    otter github地址
    在这里插入图片描述
    场景二：保证缓存和数据库一致性（我们今天要测试的）

    在这里插入图片描述

    场景三：实时数据分析

    抓取业务表的新增变化数据，用于制作实时统计

    五、安装mysql、redis

    1. 安装mysql

    sudo docker run -p 3306:3306 --name mysql 
-v /mydata/mysql/log:/var/log/mysql 
-v /mydata/mysql/data:/var/lib/mysql 
-v /mydata/mysql/conf:/etc/mysql 
-e MYSQL_ROOT_PASSWORD=root 
-d mysql:5.7

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    2. Docker配置MySQL

    vim /mydata/mysql/conf/my.cnf # 创建并进入编辑

    • 1

    添加如下配置：

    [client]
default-character-set=utf8
[mysql]
default-character-set=utf8
[mysqld]
init_connect='SET collation_connection = utf8_unicode_ci'
init_connect='SET NAMES utf8'
character-set-server=utf8
collation-server=utf8_unicode_ci
skip-character-set-client-handshake
skip-name-resolve
# 开启binlog日志：目录为docker里的目录
log-bin=/var/lib/mysql/mysql-bin
# server_id 需保证唯一，不能和 canal 的 slaveId 重复
server-id=123456
binlog_format=row
# test数据库开启，不设置则所有库开启
binlog-do-db=test

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    3. 重新启动mysql

    docker restart mysql

    • 1

    4. 创建用户并赋权限

    查看mysql的 id：

    docker ps

    • 1

    进入docker容器：

    docker exec -it 7d /bin/bash

    • 1

    连接到mysql：

    mysql -u root -p

    • 1

    创建用户并赋予权限：

    GRANT SELECT, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'canal'@'%' IDENTIFIED BY 'canal' ;

    • 1

    刷新：

    flush privileges;

    • 1

    在这里插入图片描述

    5. Win10连接mysql创建user表

    CREATE TABLE `user`  (
  `id` int(10) NOT NULL AUTO_INCREMENT,
  `name` varchar(25) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `sex` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 8 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    6. 创建redis

    docker run -p 6379:6379 --name redis 
-v /mydata/redis/data:/data 
-v /mydata/redis/conf/redis.conf:/etc/redis/redis.conf 
-d redis redis-server /etc/redis/redis.conf

    • 1
    • 2
    • 3
    • 4

    六、安装canal

    1. 启动容器

    docker run -it --name canal -p 11111:11111 -d canal/canal-server:v1.1.5

    • 1

    查看三个容器：

    docker ps

    • 1

    在这里插入图片描述

    2. 配置canal

    进入容器：

    docker exec -it 56 /bin/bash

    • 1

    切换目录：

    cd canal-server/conf/example

    • 1

    修改两个地方：

    第一个是mysql的地址，第二个是我们创建数据库名字（可以使用默认带的，就是全部的库都进行收集binlog日志）

    canal.instance.master.address=192.168.84.138:3306

canal.instance.filter.regex=test..*

    • 1
    • 2
    • 3

    在这里插入图片描述

    3. 查看日志

    我们查看一下canal的日志，看是否启动成功！
    首先进入容器：

    docker exec -it 56 /bin/bash

    • 1

    切换目录：

    cd canal-server/logs/example/

    • 1

    查看日志：

    cat example.log

    • 1

    无报错，刚刚新建的表这里也可以检测到！

    在这里插入图片描述

    4. 查看canal.properties

    cd /canal-server/conf


cat canal.properties

    • 1
    • 2
    • 3
    • 4

    我们可以看到有很多个模式，可以把canal收集到的binlog发送到三大MQ中，或者tcp。

    本次以tcp为准测试，如果大家有需求可以进行发送到MQ，往下滑都有对应的配置！

    在这里插入图片描述

    七、简单测试

    1. 新建springboot项目，导入依赖

    
    org.springframework.boot
    spring-boot-starter


    org.springframework.boot
    spring-boot-starter-test
    test
    
        
            org.junit.vintage
            junit-vintage-engine
        
    


    com.alibaba.otter
    canal.client
    1.1.0


   org.springframework.boot
   spring-boot-starter-data-redis


    com.fasterxml.jackson.core
    jackson-core
    2.8.6


    com.fasterxml.jackson.module
    jackson-module-jaxb-annotations
    2.8.6


    • 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

    2. 编写测试文件

    来自官方例子：

    我把statis关键字删除了，方便和redis进行整合

    例子地址

    import com.alibaba.otter.canal.client.CanalConnector;
import com.alibaba.otter.canal.protocol.Message;
import com.alibaba.otter.canal.protocol.CanalEntry.Column;
import com.alibaba.otter.canal.protocol.CanalEntry.Entry;
import com.alibaba.otter.canal.protocol.CanalEntry.EntryType;
import com.alibaba.otter.canal.protocol.CanalEntry.EventType;
import com.alibaba.otter.canal.protocol.CanalEntry.RowChange;
import com.alibaba.otter.canal.protocol.CanalEntry.RowData;
import com.alibaba.otter.canal.client.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


/**
 * @author wangzhenjun
 * @date 2022/6/29 9:31
 */
@Configuration
public class SimpleCanalClientExample {

//    private static String REDIS_DATABASE = "mall";
//    private static String REDIS_KEY_ADMIN = "ums:admin";

    @Bean
    public void canalSync() {
        // 创建链接,第一个参数是canal的ip，第二个参数是canal的端口号，
        // 第三个参数是canal虚拟的模块名称，canal是创建的数据库账号密码
        CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("192.168.84.138",
                11111), "example", "canal", "canal");
        int batchSize = 1000;
        int emptyCount = 0;
        try {
            connector.connect();
            // 对应上面的配置只对test库进行获取binlog文件
            connector.subscribe("test\..*");
            connector.rollback();
            int totalEmptyCount = 120;
            while (emptyCount < totalEmptyCount) {
                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) {
                    }
                } else {
                    emptyCount = 0;
                    // System.out.printf("message[batchId=%s,size=%s] 
", batchId, size);
                    printEntry(message.getEntries());
                }

                connector.ack(batchId); // 提交确认
                // connector.rollback(batchId); // 处理失败, 回滚数据
            }

            System.out.println("empty too many times, exit");
        } finally {
            connector.disconnect();
        }
    }

    private void printEntry(List 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());
                } else if (eventType == EventType.INSERT) {
                    printColumn(rowData.getAfterColumnsList());
                } else {
                    System.out.println("-------> before");
                    printColumn(rowData.getBeforeColumnsList());
                    System.out.println("-------> after");
                    printColumn(rowData.getAfterColumnsList());
                }
            }
        }
    }
	
    private void printColumn(List columns) {
        for (Column column : columns) {
            System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
        }
    }
}

    • 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

    在这里插入图片描述

    3. 启动项目

    在这里插入图片描述

    4. 插入一条数据

    INSERT INTO user VALUES (1,'小红','女');

    • 1

    在这里插入图片描述

    总结：
    我们测试是可以获取到binlog日志的，下面我们进入实战：实现redis缓存同步

    八、实战redis同步缓存

    1. 编写redis序列化配置类

    import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @author wangzhenjun
 * @date 2022/6/30 9:24
 */
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

}

    • 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

    2. 添加redis增删改方法

    主要添加了同步到redis的两个方法，这里是2分钟就会停止监听，大家可以按自己的来调整：

    int totalEmptyCount = 120;


import java.net.InetSocketAddress;
import java.util.List;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.otter.canal.client.CanalConnector;
import com.alibaba.otter.canal.protocol.Message;
import com.alibaba.otter.canal.protocol.CanalEntry.Column;
import com.alibaba.otter.canal.protocol.CanalEntry.Entry;
import com.alibaba.otter.canal.protocol.CanalEntry.EntryType;
import com.alibaba.otter.canal.protocol.CanalEntry.EventType;
import com.alibaba.otter.canal.protocol.CanalEntry.RowChange;
import com.alibaba.otter.canal.protocol.CanalEntry.RowData;
import com.alibaba.otter.canal.client.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;


/**
 * @author wangzhenjun
 * @date 2022/6/29 9:31
 */
@Configuration
public class SimpleCanalClientExample {

    @Autowired
    private RedisTemplate redisTemplate;

    private static final String KEY = "user:info";

    @Bean
    public void canalSync() {
        // 创建链接,第一个参数是canal的ip，第二个参数是canal的端口号，
        // 第三个参数是canal虚拟的模块名称，canal是创建的数据库账号密码
        CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("192.168.84.138",
                11111), "example", "canal", "canal");
        int batchSize = 1000;
        int emptyCount = 0;
        try {
            connector.connect();
            // 对应上面的配置只对test库进行获取binlog文件
            connector.subscribe("test\..*");
            connector.rollback();
            int totalEmptyCount = 120;
            while (emptyCount < totalEmptyCount) {
                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) {
                    }
                } else {
                    emptyCount = 0;
                    // System.out.printf("message[batchId=%s,size=%s] 
", batchId, size);
                    printEntry(message.getEntries());
                }

                connector.ack(batchId); // 提交确认
                // connector.rollback(batchId); // 处理失败, 回滚数据
            }

            System.out.println("empty too many times, exit");
        } finally {
            connector.disconnect();
        }
    }

    private void printEntry(List 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());
                    // 同步到redis
                    delete(rowData.getBeforeColumnsList());
                } else if (eventType == EventType.INSERT) {
                    printColumn(rowData.getAfterColumnsList());
                    // 同步到redis
                    insertOrUpdate(rowData.getAfterColumnsList());
                } else {
                    System.out.println("-------> before");
                    printColumn(rowData.getBeforeColumnsList());
                    System.out.println("-------> after");
                    printColumn(rowData.getAfterColumnsList());
                    // 同步到redis
                    insertOrUpdate(rowData.getAfterColumnsList());
                }
            }
        }
    }

    private void printColumn(List columns) {
        for (Column column : columns) {
            System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
        }
    }

    /**
     * 更新或者添加触发同步到redis
     * @param columns
     */
    private void insertOrUpdate (List columns) {
        if (columns.size() > 0) {
            JSONObject json = new JSONObject();
            for (Column column : columns) {
                json.put(column.getName(), column.getValue());
            }
            redisTemplate.opsForHash().put(KEY,columns.get(0).getValue(),json.toJSONString());
        }
    }

    /**
     * 删除触发同步到redis
     * @param columns
     */
    private void delete (List columns) {
        if (columns.size() > 0) {
            redisTemplate.opsForHash().delete(KEY, columns.get(0).getValue());
        }
        
    }
}

    • 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

    3. 测试添加

    数据库插入一条：

    insert into user values (1,'我是测试添加','男');

    • 1

    控制台捕捉到信息：

    在这里插入图片描述
    我们看到redis已经有数据了，同步成功！

    在这里插入图片描述

    4. 测试更新

    更细我们刚刚添加的那条数据：

    update user set name = '修改了' where id = 1;

    • 1

    控制台捕捉到了更新信息：

    在这里插入图片描述
    redis也同步修改了！

    在这里插入图片描述

    5. 测试删除

    我们先多添加几条哈：
    在这里插入图片描述

    删除id为1的那条数据：

    delete from user where id = 1;

    • 1

    控制台捕捉到了删除信息：

    在这里插入图片描述

    redis也同步删除了！
    在这里插入图片描述

    九、总结

    这样就实现了一个canal的应用场景，当然也可以把binlog的数据发送到MQ来！

    小编整理了一天，看到这里给小编点个关注呗，谢谢大家的支持哦！！

    有缘人才可以看得到的哦！！！

    点击访问！小编自己的网站，里面也是有很多好的文章哦！

    最后

    深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

    因此收集整理了一份《Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

    小编已加密：aHR0cHM6Ly9kb2NzLnFxLmNvbS9kb2MvRFVrVm9aSGxQZUVsTlkwUnc==出于安全原因，我们把网站通过base64编码了，大家可以通过base64解码把网址获取下来。

  • 相关阅读:
    uboot 启动流程详细分析参考
    Java——JDBC连接池（c3p0、druid连接池及JDBCTemplate模版）
    创世纪：比特币诞生记
    linux 下MySQL本地安装mysql - u root - p 无法登入
    Linux学习笔记---编辑器Vim
    django及DRF流程源码分析
    Flink系列文档-(YY05)-Flink编程API-多流算子
    微电影的特征有哪些？
    如何使用websocket+node.js实现pc后台与小程序端实时通信
    redis 6.0.5 linux详细安装步骤和测试
  • 原文地址：https://blog.csdn.net/m0_67391521/article/details/126801704