Java Entry类代码示例

import com.alibaba.otter.canal.protocol.CanalEntry.Entry; //导入依赖的package包/类
private Event buildEvent() {
    Event event = new Event();
    event.setLogIdentity(new LogIdentity());

    Header.Builder headBuilder = Header.newBuilder();
    headBuilder.setEventLength(1000L);
    headBuilder.setExecuteTime(new Date().getTime());
    headBuilder.setLogfileName("mysql-bin.000001");
    headBuilder.setLogfileOffset(1000L);
    headBuilder.setSchemaName("test");
    headBuilder.setTableName("ljh");

    Entry.Builder entryBuilder = Entry.newBuilder();
    entryBuilder.setHeader(headBuilder.build());
    entryBuilder.setEntryType(EntryType.ROWDATA);

    RowChange.Builder rowChangeBuilder = RowChange.newBuilder();
    RowData.Builder rowDataBuilder = RowData.newBuilder();
    rowChangeBuilder.addRowDatas(rowDataBuilder.build());

    entryBuilder.setStoreValue(rowChangeBuilder.build().toByteString());
    Entry entry = entryBuilder.build();
    event.setEntry(entry);
    return event;
}
 

import com.alibaba.otter.canal.protocol.CanalEntry.Entry; //导入依赖的package包/类
private void publishCanalEvent(Entry entry) {
    EventType eventType = entry.getHeader().getEventType();
    switch (eventType) {
        case INSERT:
            applicationContext.publishEvent(new InsertCanalEvent(entry));
            break;
        case UPDATE:
            applicationContext.publishEvent(new UpdateCanalEvent(entry));
            break;
        case DELETE:
            applicationContext.publishEvent(new DeleteCanalEvent(entry));
            break;
        default:
            break;
    }
}
 

import com.alibaba.otter.canal.protocol.CanalEntry.Entry; //导入依赖的package包/类
@Override
public void onApplicationEvent(EVENT event) {
    Entry entry = event.getEntry();
    String database = entry.getHeader().getSchemaName();
    String table = entry.getHeader().getTableName();
    IndexTypeModel indexTypeModel = mappingService.getIndexType(new DatabaseTableModel(database, table));
    if (indexTypeModel == null) {
        return;
    }
    String index = indexTypeModel.getIndex();
    String type = indexTypeModel.getType();
    RowChange change;
    try {
        change = RowChange.parseFrom(entry.getStoreValue());
    } catch (InvalidProtocolBufferException e) {
        logger.error("canalEntry_parser_error,根据CanalEntry获取RowChange失败！", e);
        return;
    }
    change.getRowDatasList().forEach(rowData -> doSync(database, table, index, type, rowData));
}
 

import com.alibaba.otter.canal.protocol.CanalEntry.Entry; //导入依赖的package包/类
private void printSummary(Message message, long batchId, int size) {
    long memsize = 0;
    for (Entry entry : message.getEntries()) {
        memsize += entry.getHeader().getEventLength();
    }

    String startPosition = null;
    String endPosition = null;
    if (!CollectionUtils.isEmpty(message.getEntries())) {
        startPosition = buildPositionForDump(message.getEntries().get(0));
        endPosition = buildPositionForDump(message.getEntries().get(message.getEntries().size() - 1));
    }

    SimpleDateFormat format = new SimpleDateFormat(DATE_FORMAT);
    logger.info(context_format, new Object[] { batchId, size, memsize, format.format(new Date()), startPosition,
            endPosition });
}
 

import com.alibaba.otter.canal.protocol.CanalEntry.Entry; //导入依赖的package包/类
private Message receiveMessages() throws IOException {
    Packet p = Packet.parseFrom(readNextPacket());
    switch (p.getType()) {
        case MESSAGES: {
            if (!p.getCompression().equals(Compression.NONE)) {
                throw new CanalClientException("compression is not supported in this connector");
            }

            Messages messages = Messages.parseFrom(p.getBody());
            Message result = new Message(messages.getBatchId());
            for (ByteString byteString : messages.getMessagesList()) {
                result.addEntry(Entry.parseFrom(byteString));
            }
            return result;
        }
        case ACK: {
            Ack ack = Ack.parseFrom(p.getBody());
            throw new CanalClientException("something goes wrong with reason: " + ack.getErrorMessage());
        }
        default: {
            throw new CanalClientException("unexpected packet type: " + p.getType());
        }
    }
}
 

import com.alibaba.otter.canal.protocol.CanalEntry.Entry; //导入依赖的package包/类
public void stop() {
    super.stop();
    for (Map.Entry<String, CanalInstance> entry : canalInstances.entrySet()) {
        try {
            CanalInstance instance = entry.getValue();
            if (instance.isStart()) {
                try {
                    String destination = entry.getKey();
                    MDC.put("destination", destination);
                    entry.getValue().stop();
                    logger.info("stop CanalInstances[{}] successfully", destination);
                } finally {
                    MDC.remove("destination");
                }
            }
        } catch (Exception e) {
            logger.error(String.format("stop CanalInstance[%s] has an error", entry.getKey()), e);
        }
    }
}
 

import com.alibaba.otter.canal.protocol.CanalEntry.Entry; //导入依赖的package包/类
private Entry parseRowsQueryEvent(RowsQueryLogEvent event) {
    if (filterQueryDml) {
        return null;
    }
    // mysql5.6支持，需要设置binlog-rows-query-log-events=1，可详细打印原始DML语句
    String queryString = null;
    try {
        queryString = new String(event.getRowsQuery().getBytes(ISO_8859_1), charset.name());
        String tableName = null;
        if (useDruidDdlFilter) {
            List<DdlResult> results = DruidDdlParser.parse(queryString, null);
            if (results.size() > 0) {
                tableName = results.get(0).getTableName();
            }
        }

        return buildQueryEntry(queryString, event.getHeader(), tableName);
    } catch (UnsupportedEncodingException e) {
        throw new CanalParseException(e);
    }
}
 

import com.alibaba.otter.canal.protocol.CanalEntry.Entry; //导入依赖的package包/类
public AbstractEventParser(){
    // 初始化一下
    transactionBuffer = new EventTransactionBuffer(new TransactionFlushCallback() {

        public void flush(List<CanalEntry.Entry> transaction) throws InterruptedException {
            boolean successed = consumeTheEventAndProfilingIfNecessary(transaction);
            if (!running) {
                return;
            }

            if (!successed) {
                throw new CanalParseException("consume failed!");
            }

            LogPosition position = buildLastTransactionPosition(transaction);
            if (position != null) { // 可能position为空
                logPositionManager.persistLogPosition(AbstractEventParser.this.destination, position);
            }
        }
    });
}
 

import com.alibaba.otter.canal.protocol.CanalEntry.Entry; //导入依赖的package包/类
protected boolean consumeTheEventAndProfilingIfNecessary(List<CanalEntry.Entry> entrys) throws CanalSinkException,
                                                                                       InterruptedException {
    long startTs = -1;
    boolean enabled = getProfilingEnabled();
    if (enabled) {
        startTs = System.currentTimeMillis();
    }

    boolean result = eventSink.sink(entrys, (runningInfo == null) ? null : runningInfo.getAddress(), destination);

    if (enabled) {
        this.processingInterval = System.currentTimeMillis() - startTs;
    }

    if (consumedEventCount.incrementAndGet() < 0) {
        consumedEventCount.set(0);
    }

    return result;
}
 

import com.alibaba.otter.canal.protocol.CanalEntry.Entry; //导入依赖的package包/类
protected CanalEntry.Entry parseAndProfilingIfNecessary(EVENT bod, boolean isSeek) throws Exception {
    long startTs = -1;
    boolean enabled = getProfilingEnabled();
    if (enabled) {
        startTs = System.currentTimeMillis();
    }
    CanalEntry.Entry event = binlogParser.parse(bod, isSeek);
    if (enabled) {
        this.parsingInterval = System.currentTimeMillis() - startTs;
    }

    if (parsedEventCount.incrementAndGet() < 0) {
        parsedEventCount.set(0);
    }
    return event;
}
 

import com.alibaba.otter.canal.protocol.CanalEntry.Entry; //导入依赖的package包/类
private Entry parseAnnotateRowsEvent(AnnotateRowsEvent event) {
    if (filterQueryDml) {
        return null;
    }
    // mariaDb֧�֣���Ҫ����binlog_annotate_row_events=true������ϸ��ӡԭʼDML���
    String queryString = null;
    try {
        queryString = new String(event.getRowsQuery().getBytes(ISO_8859_1), charset.name());
        return buildQueryEntry(queryString, event.getHeader());
    } catch (UnsupportedEncodingException e) {
        throw new CanalParseException(e);
    }
}
 

import com.alibaba.otter.canal.protocol.CanalEntry.Entry; //导入依赖的package包/类
private Entry parseRowsQueryEvent(RowsQueryLogEvent event) {
    if (filterQueryDml) {
        return null;
    }
    // mysql5.6֧�֣���Ҫ����binlog-rows-query-log-events=1������ϸ��ӡԭʼDML���
    String queryString = null;
    try {
        queryString = new String(event.getRowsQuery().getBytes(ISO_8859_1), charset.name());
        return buildQueryEntry(queryString, event.getHeader());
    } catch (UnsupportedEncodingException e) {
        throw new CanalParseException(e);
    }
}
 

import com.alibaba.otter.canal.protocol.CanalEntry.Entry; //导入依赖的package包/类
private Entry parseUserVarLogEvent(UserVarLogEvent event) {
    if (filterQueryDml) {
        return null;
    }

    return buildQueryEntry(event.getQuery(), event.getHeader());
}
 

import com.alibaba.otter.canal.protocol.CanalEntry.Entry; //导入依赖的package包/类
private Entry parseIntrvarLogEvent(IntvarLogEvent event) {
    if (filterQueryDml) {
        return null;
    }

    return buildQueryEntry(event.getQuery(), event.getHeader());
}
 

import com.alibaba.otter.canal.protocol.CanalEntry.Entry; //导入依赖的package包/类
private Entry parseRandLogEvent(RandLogEvent event) {
    if (filterQueryDml) {
        return null;
    }

    return buildQueryEntry(event.getQuery(), event.getHeader());
}