canal客户端canal-spring-boot-starter

canal使用
canal官网介绍

1.开启mysql的bin-log

windows

[mysqld]
# 设置mysql的安装目录[根据本地情况进行修改]
basedir=D:/mysql/mysql-5.7.24-winx64
#Path to the database root
datadir=D:/mysql/mysql-5.7.24-winx64/data
#设置3306端口
port = 3306
# 允许最大连接数
max_connections=200
# 服务端使用的字符集默认为8比特编码的latin1字符集
character-set-server=utf8
# 创建新表时将使用的默认存储引擎
default-storage-engine=INNODB
sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES
# Server Id.数据库服务器id，这个id用来在主从服务器中标记唯一mysql服务器
# 开启binlog日志
log-bin = D:/mysql/mysql-5.7.24-winx64/mysql-bin/mysql-bin.log
expire-logs-days = 14
max-binlog-size = 500M
server-id = 1
[mysql]
# 设置mysql客户端默认字符集
default-character-set=utf8
max_allowed_packet=20M

重启服务

net stop mysql
net start mysql

centos7

虚拟机搭建mysql8

注意点：
1.mysql8密码加密方式有点不一样，不清楚的百度，这个设计远程连接问题
2.创建用canal，分配权限
3.binlog日志配置和windows一样的，expire-logs-days = 14
max-binlog-size = 500M
server-id = 1
create user '创建用canal'@'%' identified by 'canal';
GRANT SHOW VIEW, SELECT, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'canal'@'%';

2.下载canal

1.下载地址

2.参数配置,使用默认的不用配置，配置一下数据库账号密码

1.canal.properties
这里面配置实例
默认有一个example，需要增加实例的可以配置（实例，我的理解就是一个mysql服务器）可不配
canal.destinations = example

vim example/instance.properties
# 没有改变的就没有贴出来，注意mysql的用户名和密码
canal.instance.master.address=192.168.58.131:3306
# 默认监听的数据库
canal.instance.defaultDatabaseName=open_md

3.启动

bin/start.sh
# 可以去logs下面查看是否启动成功

4.简单demo

// 这个在网上抄袭的
class Test1 {
@Test
void contextLoads() {
// 创建链接
这个ip是你虚拟机的ip
CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("192.168.58.131",11111), "example", "", "");
int batchSize = 1000;
int emptyCount = 0;
try {
connector.connect();
//注意这个相当于一个白名单，那些表需要被监听，这里设置或股改服务端的设置，规则database.tableName
//connector.subscribe(".*\..*");
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;
printEntry(message.getEntries());
}
connector.ack(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("================&gt; 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("-------&gt; before");
printColumn(rowData.getBeforeColumnsList());
System.out.println("-------&gt; after");
printColumn(rowData.getAfterColumnsList());
}
}
}
}
private static void printColumn(List<Column> columns) {
for (Column column : columns) {
System.out.println(column.getName() + " : " + column.getValue() + "
update=" + column.getUpdated());
}
}
}

canal-spring-boot-starter

quickstart

1.引入依赖

<dependency>
<groupId>com.git</groupId>
<artifactId>canal-spring-boot-starter</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>

2.配置yml文件

com:
git:
canal:
username: canal
password: canal
destination: example
filter: "open_md.o_user"
hostname: 127.0.0.1
sleep-time: 10000

配置说明
1.username就是canal服务端的账号，如果没有设置可不填，在instance.里面设置04-29日改
2.password就是canal服务端的密码，如果没有设置可不填
3.destination这个就是canal实例的名称，这个必须在canal服务端配置好，默认自带example
4.filter过滤规则，如果在客户端配置了这个，服务端的过滤配置会被覆盖，表示监听那些标，规则database.tableName
5.hostname canal服务端ip
6.port这里没有配置，默认11111，canal服务端的端口
7.sleep-time，线程休眠时间，暂时采用sleep策略，单位ms，相当于每隔这个时间消费一次数据

3.编写业务代码

@CanalListener(databaseName = "open_md",tableName = "o_user")
public void consumerUser(User user, CanalEntry.EventType eventType){
log.info("user={}，操作类型={}",JSON.toJSONString(user),eventType.name());
boolean b = userRepository.existsById(user.getId());
switch (eventType){
case INSERT:
case UPDATE:
System.out.println("=========正在添加或者修改文档===========");
userRepository.save(user);
break;
case DELETE:
System.out.println("=========正在删除文档===========");
if(b){
userRepository.delete(user);
}
break;
default:
System.out.println("=========操作类型不匹配===========");
System.out.println(user);
}
}

上述代码是在一个正常的server里面的业务代码，该类有添加@Service注解，被spring管控
说明：
1.consumerUser是一个消费者，个人业务代码方法规则，方法返回参数不限，方法名不限，方法参数有限制，至少两个参数
2.方法第一个参数类型不限(推荐和数据库对应一致的po对象)，第二个参数类型固定为CanalEntry.EventType，这个参数代表数据发生了增删改的那些操作。
3.消费方法必须加@CanalListener注解，不然不会自动执行里面的代码
@CanalListener参数说明
-> id每个实例的id，暂时可以不用配置
-> databaseName,必填会根据这个决定业务方法执行那些库的操作
-> tableName 必填数据库的表名，和上面结合一起决定监听个表
-> handler 选填，如何业务代码第一个参数是和数据库对应一致（实体类必须符合驼峰命名规范）可不配，如果是自定义参数，必修配置handle，实现RowDataHandler接口，并且自定义handle必须被spring管控

4.启动项目，会看到业务代码的执行

项目源码介绍

1.项目依赖

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-autoconfigure</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.1</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency>
<dependency>
<groupId>com.alibaba.otter</groupId>
<artifactId>canal.client</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring</artifactId>
</exclusion>
</exclusions>
<version>1.1.4</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>

2.项目的类说明

CanalFactory canal连接类，实现了DisposableBean接口，会在生命周期结束的时候关掉连接
CanalListener CanalListener注解
CanalListenerConsumer 动态代理工具类
CanalMessageListener 消费接口，
CanalProperties 配置类，对应于yml里面的配置
CanalService 获取和消费canal数据的类
CanalSpringListener 事件派发，在项目启动之后派发消息启动CanalService里面onmessage方法
DefalutRowDataHandler 默认RowDataHandler实现类
RowDataHandler 数据转换接口
StringUtils 内部的工具类，不对外开放

核心类代码说明

@EnableConfigurationProperties({CanalProperties.class})
@Import({CanalFactory.class, CanalSpringListener.class, DefalutRowDataHandler.class})
public class CanalService implements BeanPostProcessor,ApplicationListener<CanalSpringListener> {
private static final Logger logger = LoggerFactory.getLogger(CanalService.class);
@Autowired
private CanalFactory canalFactory;
private List<CanalMessageListener> canalMessageListeners = new CopyOnWriteArrayList<>();
private Map<String, CanalMessageListener> canalMessageListenerMap = new ConcurrentHashMap<>();
public void process() {
CanalConnector canalConnector = canalFactory.getCanalConnector();
new Thread(()->{
int failCount = 0;
while(true){
int batchSize = canalFactory.getCanalProperties().getBatchSize();
Message message = canalConnector.getWithoutAck(batchSize); // 获取指定数量的数据
long batchId = message.getId();
int size = message.getEntries().size();
if (batchId == -1 || size == 0) {
try {
//logger.info("当前线程：{}，进行休眠",Thread.currentThread().getName());
Thread.currentThread().sleep(canalFactory.getCanalProperties().getSleepTime());
} catch (InterruptedException e) {
logger.error("threadName={},sleep error",Thread.currentThread().getName());
}
} else {
try{
onMessage(message);
}catch (Exception e){
if(failCount<=3){
logger.info("消费失败，回滚，batchId={}",message.getId());
failCount++;
canalConnector.rollback();
}else{
failCount = 0;
logger.error("消费失败次数过多，停止消费，停止回滚，batchId={}",message.getId());
}
}
//consumer(message.getEntries());
}
canalConnector.ack(batchId); // 提交确认
}
}).start();
}
private void onMessage(Message message) throws InvocationTargetException, IllegalAccessException {
List<CanalEntry.Entry> entries = message.getEntries();
for (CanalEntry.Entry entry : entries) {
String key = entry.getHeader().getSchemaName()+entry.getHeader().getTableName();
CanalMessageListener listener = canalMessageListenerMap.get(key);
if(listener!=null){
listener.onMessage(entry);
}
}
}
@Override
public void onApplicationEvent(CanalSpringListener event) {
logger.info("开始消费canal数据");
process();
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
Class<?> targetClass = bean.getClass();
//判断有没有@CanalListener注解
List<Method> collect = Arrays.stream(targetClass.getMethods()).filter(s -> s.isAnnotationPresent(CanalListener.class)).collect(Collectors.toList());
if (collect==null||collect.size()<=0)return bean;
// Non-empty set of methods
collect.forEach(m->processJmsListener(m.getAnnotation(CanalListener.class), m, bean));
logger.info("正在为{}类注册CanalListener监听器,需要注册的数量为{}",beanName,collect.size());
return bean;
}
private void processJmsListener(CanalListener canalListener, Method method, Object bean) {
try{
if(StringUtils.isEmpty(canalListener.databaseName()) || StringUtils.isEmpty(canalListener.tableName()))return;
Class<?>[] parameterTypes = method.getParameterTypes();
if(parameterTypes!=null && parameterTypes.length>=2){
//第二个方法参数必须是类型
if(CanalEntry.EventType.class != parameterTypes[1])return;
logger.info("添加CanalListener监听器定义class=,{},method={}",bean.getClass().getName(),method.getName());
CanalMessageListener canalMessageListener = CanalListenerConsumer.getObject(bean, method, canalListener);
canalMessageListenerMap.put(canalListener.databaseName()+canalListener.tableName(),canalMessageListener);
canalMessageListeners.add(canalMessageListener);
}
}catch (Exception e){
logger.error("监听器创建失败");
}
}
}

1.CanalService类上面的注解说明
->@EnableConfigurationProperties({CanalProperties.class})开启配置自动注入，相当与导入yml的配置
->@Import({CanalFactory.class, CanalSpringListener.class, DefalutRowDataHandler.class})
手工引入这三个类被spring所管理，CanalService依赖于这三个类
2.实现接口说明
->BeanPostProcessor bean的后置处理器用于收集那些方法加了@CanalListener注解并将这些方法收集到map和list里面
->ApplicationListener 实现spring的监听器，用于接受自定义的派发事件
3.逻辑梳理
1.项目启动，spring自动读取yml文件并映射为对应的配置类
2.canalFactory会建立和canalServer的连接
3.CanalService收集所有被@CanalListener修饰的方法
->list收集方法
->map会将这些方法通过CanalListenerConsumer工具类生成CanalMessageListener代理对象，
map的key就是注解的databaseName+tableName，如果重复会被覆盖
4.项目启动完 CanalSpringListener派发事件
5.CanalService接收到消息，开始执行 process()方法

proceess()方法详解
1.创建线程
2.canal读取数据,得到message对象
3.canal消费数据
->消费失败，尝试三次重新消费，超过失败放弃数据
->消费过程
->onMessage(message);
首先获得List<CanalEntry.Entry>，遍历，CanalEntry.Entry相当于数据库的多条row对象
根据Entry对象的databaseName和tableName决定哪个消费者来处理，执行CanalMessageListener里面的onMessage方法
->消费成功会进行提交commit

CanalListenerConsumer代理方法详解
1.创建代理对象,根据注解和被注接修饰的方法
public CanalListenerConsumer(Object bean, Method method,CanalListener canalListener) {
this.bean = bean;
this.method = method;
this.canalListener = canalListener;
}
2.逻辑处理
遍历CanalEntry.Entry，得到rowData，得到行记录，将行记录转化为po对象，使用RowDataHandle接口的方法，有一个默认的实现接口
3.执业务方法，执行的就是被业务代码里面的方法

完善与发展

1.本文代码不仅完善之处也不多说

2.后续发展

• 保留直接消费message的方法
• 开启线程和线程休眠的改善
• 针对多环境开发，不同环境数据库名字可能不一样(表名）必须一样，进行处理，对@CanalListener能通过${}或者#{}读取环境里面的值，动态设置库名

参考文章：canal官网
代码已在github项目源码

最后

以上就是简单高山为你收集整理的canal客户端canal-spring-boot-starter的全部内容，希望文章能够帮你解决canal客户端canal-spring-boot-starter所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。