一、简介

canal [kə'næl]，译意为水道/管道/沟渠，主要用途是基于 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

  1. sudo docker run -p 3306:3306 --name mysql \
  2. -v /mydata/mysql/log:/var/log/mysql \
  3. -v /mydata/mysql/data:/var/lib/mysql \
  4. -v /mydata/mysql/conf:/etc/mysql \
  5. -e MYSQL_ROOT_PASSWORD=root \
  6. -d mysql:5.7

2. Docker配置MySQL

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

添加如下配置：

  1. [client]
  2. default-character-set=utf8
  3. [mysql]
  4. default-character-set=utf8
  5. [mysqld]
  6. init_connect='SET collation_connection = utf8_unicode_ci'
  7. init_connect='SET NAMES utf8'
  8. character-set-server=utf8
  9. collation-server=utf8_unicode_ci
  10. skip-character-set-client-handshake
  11. skip-name-resolve
  12. # 开启binlog日志：目录为docker里的目录
  13. log-bin=/var/lib/mysql/mysql-bin
  14. # server_id 需保证唯一，不能和 canal 的 slaveId 重复
  15. server-id=123456
  16. binlog_format=row
  17. # test数据库开启，不设置则所有库开启
  18. binlog-do-db=test

3. 重新启动mysql

  1. docker restart mysql

4. 创建用户并赋权限

查看mysql的 id：

  1. docker ps

进入docker容器：

  1. docker exec -it 7d /bin/bash

连接到mysql：

  1. mysql -u root -p

创建用户并赋予权限：

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

刷新：

  1. flush privileges;

5. Win10连接mysql创建user表

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

6. 创建redis

  1. docker run -p 6379:6379 --name redis \
  2. -v /mydata/redis/data:/data \
  3. -v /mydata/redis/conf/redis.conf:/etc/redis/redis.conf \
  4. -d redis redis-server /etc/redis/redis.conf

六、安装canal

1. 启动容器

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

查看三个容器：

  1. docker ps

2. 配置canal

进入容器：

  1. docker exec -it 56 /bin/bash

切换目录：

  1. cd canal-server/conf/example

修改两个地方：

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

  1. canal.instance.master.address=192.168.84.138:3306
  3. canal.instance.filter.regex=test\..*

3. 查看日志

我们查看一下canal的日志，看是否启动成功！

首先进入容器：

  1. docker exec -it 56 /bin/bash

切换目录：

  1. cd canal-server/logs/example/

查看日志：

  1. cat example.log

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

4. 查看canal.properties

  1. cd /canal-server/conf
  1. cat canal.properties

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

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

七、简单测试

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

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter</artifactId>
  4. </dependency>
  5. <dependency>
  6.     <groupId>org.springframework.boot</groupId>
  7.     <artifactId>spring-boot-starter-test</artifactId>
  8.     <scope>test</scope>
  9.     <exclusions>
  10.         <exclusion>
  11.             <groupId>org.junit.vintage</groupId>
  12.             <artifactId>junit-vintage-engine</artifactId>
  13.         </exclusion>
  14.     </exclusions>
  15. </dependency>
  16. <dependency>
  17.     <groupId>com.alibaba.otter</groupId>
  18.     <artifactId>canal.client</artifactId>
  19.     <version>1.1.0</version>
  20. </dependency>
  21. <dependency>
  22.    <groupId>org.springframework.boot</groupId>
  23.    <artifactId>spring-boot-starter-data-redis</artifactId>
  24. </dependency>
  25. <dependency>
  26.     <groupId>com.fasterxml.jackson.core</groupId>
  27.     <artifactId>jackson-core</artifactId>
  28.     <version>2.8.6</version>
  29. </dependency>
  30. <dependency>
  31.     <groupId>com.fasterxml.jackson.module</groupId>
  32.     <artifactId>jackson-module-jaxb-annotations</artifactId>
  33.     <version>2.8.6</version>
  34. </dependency>

2. 编写测试文件

来自官方例子：

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

例子地址

  1. import com.alibaba.otter.canal.client.CanalConnector;
  2. import com.alibaba.otter.canal.protocol.Message;
  3. import com.alibaba.otter.canal.protocol.CanalEntry.Column;
  4. import com.alibaba.otter.canal.protocol.CanalEntry.Entry;
  5. import com.alibaba.otter.canal.protocol.CanalEntry.EntryType;
  6. import com.alibaba.otter.canal.protocol.CanalEntry.EventType;
  7. import com.alibaba.otter.canal.protocol.CanalEntry.RowChange;
  8. import com.alibaba.otter.canal.protocol.CanalEntry.RowData;
  9. import com.alibaba.otter.canal.client.*;
  10. import org.springframework.context.annotation.Bean;
  11. import org.springframework.context.annotation.Configuration;
  13. /**
  14.  * @author wangzhenjun
  15.  * @date 2022/6/29 9:31
  16.  */
  17. @Configuration
  18. public class SimpleCanalClientExample {
  20. //    private static String REDIS_DATABASE = "mall";
  21. //    private static String REDIS_KEY_ADMIN = "ums:admin";
  23.     @Bean
  24.     public void canalSync() {
  25.         // 创建链接,第一个参数是canal的ip，第二个参数是canal的端口号，
  26.         // 第三个参数是canal虚拟的模块名称，canal是创建的数据库账号密码
  27.         CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("192.168.84.138",
  28.                 11111), "example", "canal", "canal");
  29.         int batchSize = 1000;
  30.         int emptyCount = 0;
  31.         try {
  32.             connector.connect();
  33.             // 对应上面的配置只对test库进行获取binlog文件
  34.             connector.subscribe("test\\..*");
  35.             connector.rollback();
  36.             int totalEmptyCount = 120;
  37.             while (emptyCount < totalEmptyCount) {
  38.                 Message message = connector.getWithoutAck(batchSize); // 获取指定数量的数据
  39.                 long batchId = message.getId();
  40.                 int size = message.getEntries().size();
  41.                 if (batchId == -1 || size == 0) {
  42.                     emptyCount++;
  43.                     System.out.println("empty count : " + emptyCount);
  44.                     try {
  45.                         Thread.sleep(1000);
  46.                     } catch (InterruptedException e) {
  47.                     }
  48.                 } else {
  49.                     emptyCount = 0;
  50.                     // System.out.printf("message[batchId=%s,size=%s] \n", batchId, size);
  51.                     printEntry(message.getEntries());
  52.                 }
  54.                 connector.ack(batchId); // 提交确认
  55.                 // connector.rollback(batchId); // 处理失败, 回滚数据
  56.             }
  58.             System.out.println("empty too many times, exit");
  59.         } finally {
  60.             connector.disconnect();
  61.         }
  62.     }
  64.     private void printEntry(List<Entry> entrys) {
  65.         for (Entry entry : entrys) {
  66.             if (entry.getEntryType() == EntryType.TRANSACTIONBEGIN || entry.getEntryType() == EntryType.TRANSACTIONEND) {
  67.                 continue;
  68.             }
  70.             RowChange rowChage = null;
  71.             try {
  72.                 rowChage = RowChange.parseFrom(entry.getStoreValue());
  73.             } catch (Exception e) {
  74.                 throw new RuntimeException("ERROR ## parser of eromanga-event has an error , data:" + entry.toString(),
  75.                         e);
  76.             }
  78.             EventType eventType = rowChage.getEventType();
  79.             System.out.println(String.format("================&gt; binlog[%s:%s] , name[%s,%s] , eventType : %s",
  80.                     entry.getHeader().getLogfileName(), entry.getHeader().getLogfileOffset(),
  81.                     entry.getHeader().getSchemaName(), entry.getHeader().getTableName(),
  82.                     eventType));
  84.             for (RowData rowData : rowChage.getRowDatasList()) {
  85.                 if (eventType == EventType.DELETE) {
  86.                     printColumn(rowData.getBeforeColumnsList());
  87.                 } else if (eventType == EventType.INSERT) {
  88.                     printColumn(rowData.getAfterColumnsList());
  89.                 } else {
  90.                     System.out.println("-------&gt; before");
  91.                     printColumn(rowData.getBeforeColumnsList());
  92.                     System.out.println("-------&gt; after");
  93.                     printColumn(rowData.getAfterColumnsList());
  94.                 }
  95.             }
  96.         }
  97.     }
  99.     private void printColumn(List<Column> columns) {
  100.         for (Column column : columns) {
  101.             System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
  102.         }
  103.     }
  104. }

3. 启动项目

4. 插入一条数据

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

总结：

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

八、实战redis同步缓存

1. 编写redis序列化配置类

  1. import org.springframework.context.annotation.Bean;
  2. import org.springframework.context.annotation.Configuration;
  3. import org.springframework.data.redis.connection.RedisConnectionFactory;
  4. import org.springframework.data.redis.core.RedisTemplate;
  5. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  6. import org.springframework.data.redis.serializer.StringRedisSerializer;
  8. /**
  9.  * @author wangzhenjun
  10.  * @date 2022/6/30 9:24
  11.  */
  12. @Configuration
  13. public class RedisConfig {
  15.     @Bean
  16.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
  17.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
  18.         redisTemplate.setConnectionFactory(connectionFactory);
  19.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  20.         redisTemplate.setKeySerializer(stringRedisSerializer);
  21.         redisTemplate.setHashKeySerializer(stringRedisSerializer);
  22.         Jackson2JsonRedisSerializer<?> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
  23.         redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
  24.         redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
  25.         redisTemplate.afterPropertiesSet();
  26.         return redisTemplate;
  27.     }
  29. }

2. 添加redis增删改方法

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

  1. int totalEmptyCount = 120;
  1. import java.net.InetSocketAddress;
  2. import java.util.List;
  4. import com.alibaba.fastjson.JSONObject;
  5. import com.alibaba.otter.canal.client.CanalConnector;
  6. import com.alibaba.otter.canal.protocol.Message;
  7. import com.alibaba.otter.canal.protocol.CanalEntry.Column;
  8. import com.alibaba.otter.canal.protocol.CanalEntry.Entry;
  9. import com.alibaba.otter.canal.protocol.CanalEntry.EntryType;
  10. import com.alibaba.otter.canal.protocol.CanalEntry.EventType;
  11. import com.alibaba.otter.canal.protocol.CanalEntry.RowChange;
  12. import com.alibaba.otter.canal.protocol.CanalEntry.RowData;
  13. import com.alibaba.otter.canal.client.*;
  14. import org.springframework.beans.factory.annotation.Autowired;
  15. import org.springframework.context.annotation.Bean;
  16. import org.springframework.context.annotation.Configuration;
  17. import org.springframework.data.redis.core.RedisTemplate;
  19. /**
  20.  * @author wangzhenjun
  21.  * @date 2022/6/29 9:31
  22.  */
  23. @Configuration
  24. public class SimpleCanalClientExample {
  26.     @Autowired
  27.     private RedisTemplate redisTemplate;
  29.     private static final String KEY = "user:info";
  31.     @Bean
  32.     public void canalSync() {
  33.         // 创建链接,第一个参数是canal的ip，第二个参数是canal的端口号，
  34.         // 第三个参数是canal虚拟的模块名称，canal是创建的数据库账号密码
  35.         CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("192.168.84.138",
  36.                 11111), "example", "canal", "canal");
  37.         int batchSize = 1000;
  38.         int emptyCount = 0;
  39.         try {
  40.             connector.connect();
  41.             // 对应上面的配置只对test库进行获取binlog文件
  42.             connector.subscribe("test\\..*");
  43.             connector.rollback();
  44.             int totalEmptyCount = 120;
  45.             while (emptyCount < totalEmptyCount) {
  46.                 Message message = connector.getWithoutAck(batchSize); // 获取指定数量的数据
  47.                 long batchId = message.getId();
  48.                 int size = message.getEntries().size();
  49.                 if (batchId == -1 || size == 0) {
  50.                     emptyCount++;
  51.                     System.out.println("empty count : " + emptyCount);
  52.                     try {
  53.                         Thread.sleep(1000);
  54.                     } catch (InterruptedException e) {
  55.                     }
  56.                 } else {
  57.                     emptyCount = 0;
  58.                     // System.out.printf("message[batchId=%s,size=%s] \n", batchId, size);
  59.                     printEntry(message.getEntries());
  60.                 }
  62.                 connector.ack(batchId); // 提交确认
  63.                 // connector.rollback(batchId); // 处理失败, 回滚数据
  64.             }
  66.             System.out.println("empty too many times, exit");
  67.         } finally {
  68.             connector.disconnect();
  69.         }
  70.     }
  72.     private void printEntry(List<Entry> entrys) {
  73.         for (Entry entry : entrys) {
  74.             if (entry.getEntryType() == EntryType.TRANSACTIONBEGIN || entry.getEntryType() == EntryType.TRANSACTIONEND) {
  75.                 continue;
  76.             }
  78.             RowChange rowChage = null;
  79.             try {
  80.                 rowChage = RowChange.parseFrom(entry.getStoreValue());
  81.             } catch (Exception e) {
  82.                 throw new RuntimeException("ERROR ## parser of eromanga-event has an error , data:" + entry.toString(),
  83.                         e);
  84.             }
  86.             EventType eventType = rowChage.getEventType();
  87.             System.out.println(String.format("================&gt; binlog[%s:%s] , name[%s,%s] , eventType : %s",
  88.                     entry.getHeader().getLogfileName(), entry.getHeader().getLogfileOffset(),
  89.                     entry.getHeader().getSchemaName(), entry.getHeader().getTableName(),
  90.                     eventType));
  92.             for (RowData rowData : rowChage.getRowDatasList()) {
  93.                 if (eventType == EventType.DELETE) {
  94.                     printColumn(rowData.getBeforeColumnsList());
  95.                     // 同步到redis
  96.                     delete(rowData.getBeforeColumnsList());
  97.                 } else if (eventType == EventType.INSERT) {
  98.                     printColumn(rowData.getAfterColumnsList());
  99.                     // 同步到redis
  100.                     insertOrUpdate(rowData.getAfterColumnsList());
  101.                 } else {
  102.                     System.out.println("-------&gt; before");
  103.                     printColumn(rowData.getBeforeColumnsList());
  104.                     System.out.println("-------&gt; after");
  105.                     printColumn(rowData.getAfterColumnsList());
  106.                     // 同步到redis
  107.                     insertOrUpdate(rowData.getAfterColumnsList());
  108.                 }
  109.             }
  110.         }
  111.     }
  113.     private void printColumn(List<Column> columns) {
  114.         for (Column column : columns) {
  115.             System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
  116.         }
  117.     }
  119.     /**
  120.      * 更新或者添加触发同步到redis
  121.      * @param columns
  122.      */
  123.     private void insertOrUpdate (List<Column> columns) {
  124.         if (columns.size() > 0) {
  125.             JSONObject json = new JSONObject();
  126.             for (Column column : columns) {
  127.                 json.put(column.getName(), column.getValue());
  128.             }
  129.             redisTemplate.opsForHash().put(KEY,columns.get(0).getValue(),json.toJSONString());
  130.         }
  131.     }
  133.     /**
  134.      * 删除触发同步到redis
  135.      * @param columns
  136.      */
  137.     private void delete (List<Column> columns) {
  138.         if (columns.size() > 0) {
  139.             redisTemplate.opsForHash().delete(KEY, columns.get(0).getValue());
  140.         }
  142.     }
  143. }

3. 测试添加

数据库插入一条：

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

控制台捕捉到信息：



我们看到redis已经有数据了，同步成功！

4. 测试更新

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

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

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



redis也同步修改了！

5. 测试删除

我们先多添加几条哈：

删除id为1的那条数据：

  1. delete from user where id = 1;

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

redis也同步删除了！

九、总结

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

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

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

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

Docker安装canal、mysql进行简单测试与实现redis和mysql缓存一致性的更多相关文章

  1. docker安装fastdfs与java客户端测试

    一.docker 安装FastDFS 1.拉取镜像 docker pull morunchang/fastdfs 2.创建并启动tracker容器 docker run -d --name=track ...

  2. YOLO2（1）配置安装win10+openvc2413+VS2013 简单测试官例

    参考官网 https://github.com/AlexeyAB/darknet#how-to-compile-on-windows https://github.com/AlexeyAB/darkn ...

  3. JAVA中JDBC连接Mysql数据库简单测试

    一.引用库 maven库:mysql:mysql-connector-java:6.0.6 二.SDK环境 JAVA JDK10 三.测试代码 package com.mysql.mysqlconne ...

  4. mysql事务简单测试

    Auth: jinDate: 20140507 一.事务控制默认情况下,MySQL是自动提交(autocommit)的,如果需要通过明确的commit和rollblack来提交和回滚事务,那么需要通过 ...

  5. Docker安装mysql5.7并且配置主从复制

    Docker安装mysql5.7并且配置主从复制 一.拉取mysql镜像 二.创建文件docker.cnf 2.1 mysql主机(192.168.21.55:3307) 2.1.1 创建文件夹 2. ...

  6. docker安装caffe

    [最近一直想要学习caffe,但是苦苦纠结于环境安装不上,真的是第一步都迈不出去,还好有docker的存在!下面,对本人如何利用docker安装caffe做以简单叙述,不属于教程,只是记录自己都做了什 ...

  7. Docker安装指定版本

    今天新增一个Docker服务器,Docker安装顺利,启动hello-world测试的时候却出现了问题: $ docker run hello-worldUnable to find image 'h ...

  8. [转]Docker学习之四：使用docker安装mysql

    本文转自:https://blog.csdn.net/qq_19348391/article/details/82998391 Docker学习之一:注册Docker Hub账号 Docker学习之二 ...

  9. 33.Docker安装Mysql及用户配置

    mysql在官方上有两个镜像 这个是一个优化过的mysql 使用这个命令 安装mysql 演示最简单的方式去安装mysql: 这种方式安装的用户名没有,密码没有 docker run -d -p 33 ...

随机推荐

  1. 一文读懂原子操作、内存屏障、锁(偏向锁、轻量级锁、重量级锁、自旋锁)、Disruptor、Go Context之上半部分

    我不想卷,我是被逼的 在做了几年前端之后,发现互联网行情比想象的差,不如赶紧学点后端知识,被裁之后也可接个私活不至于饿死.学习两周Go,如盲人摸象般不知重点,那么重点谁知道呢?肯定是使用Go的后端工程 ...

  2. MyBatis插件 - 通用mapper

    1.简单认识通用mapper 1.1.了解mapper 作用:就是为了帮助我们自动的生成sql语句 [ ps:MyBatis需要编写xxxMapper.xml,而逆向工程是根据entity实体类来进行 ...

  3. 你不知道的Python容器

    你不知道的Python容器 你不知道的Python容器 散列表 ChainMap MappingProxyType 线性表 堆 参考资料 昨天阅读了<Python Tricks: The Boo ...

  4. Linux-编译安装http-实验

    准备工作 1.关闭防火墙和SELinux 2.基础安装的系统,安装以下命令 yum install gcc make autoconf gcc-c++ glibc glibc-devel pcre p ...

  5. openstack命令创建云主机实例

    @ 目录 前言 上传centos镜像 创建实例 创建外网卡 修改安全组规则 创建云主机实例 前言 简单创建云主机实例只需要上传一个测试镜像.创建一张外网卡.创建一个实例类型.修改安全组规则即可 注:这 ...

  6. 不使用比较和条件判断实现min函数的一种方法

    不使用比较和条件判断实现min函数,参数为两个32位无符号int. 面试的时候遇到的题目,感觉很有意思. 搜了一下多数现有的解法都是仅有两种限制之一,即要么仅要求不能使用比较,要么仅要求不能使用条件判 ...

  7. opencv学习之基础

    前段时间一直在钻研深度学习中的卷积神经网络,其中的预处理环节可以说非常关键,主要就是对图片和视频进行处理.而图像处理就涉及到图形学和底层技术细节,这是一个比较精深和专业的领域,假设我们要从头开始做起, ...

  8. linux篇-公司网络故障那些事（路由器变交换机）

    首先这次网络故障是断电引起的 我给大家画个模型 三层的为八口交换机 一层的为五口打印机 笔记本代表两台无线打印机 首先八口的连接了公司采购电脑一台,业务电脑一台,其他电脑三台 第二个五口交换的连接财务 ...

  9. 值得注意的： c++动态库、静态库、弱符号__attribute__((weak))以及extern之间的关系

    先说结论: ①:动态库优先级最差,如果同时有静态库和动态库,那么首先使用的是静态库函数. ②:如果只有两个或多个动态库,那么首先使用的是最开始链接的动态库函数: ③:弱符号函数在动态库中是起任何作用的 ...

  10. 微信小程序避坑指南——echarts层级太高/层级遮挡

    问题:小程序中echarts因为小程序原生的canvas层级太高,而导致弹窗这类dom元素无法遮挡住canvas,如下图: 解决方案1:(wx:if控制dom显隐,显示canvas就重新渲染echar ...