= cold cleanup

* using lambda if possible (we are already building in Java8) * using diamond when new generic instance * remove used improt
2026-11-04 00:30:15 +08:00 · 2020-09-17 10:48:15 +08:00
parent df60eda679
commit e7658879bc
133 changed files with 990 additions and 1558 deletions
--- a/meta/src/main/java/com/alibaba/otter/canal/meta/FileMixedMetaManager.java
+++ b/meta/src/main/java/com/alibaba/otter/canal/meta/FileMixedMetaManager.java
@@ -3,6 +3,7 @@ package com.alibaba.otter.canal.meta;
 import java.io.File;
 import java.io.IOException;
 import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
@@ -43,7 +44,7 @@ import com.google.common.collect.MigrateMap;
 public class FileMixedMetaManager extends MemoryMetaManager implements CanalMetaManager {

    private static final Logger      logger       = LoggerFactory.getLogger(FileMixedMetaManager.class);
-    private static final Charset     charset      = Charset.forName("UTF-8");
+    private static final Charset     charset      = StandardCharsets.UTF_8;
    private File                     dataDir;
    private String                   dataFileName = "meta.dat";
    private Map<String, File>        dataFileCaches;
@@ -69,58 +70,41 @@ public class FileMixedMetaManager extends MemoryMetaManager implements CanalMeta
            throw new CanalMetaManagerException("dir[" + dataDir.getPath() + "] can not read/write");
        }

-        dataFileCaches = MigrateMap.makeComputingMap(new Function<String, File>() {
-
-            public File apply(String destination) {
-                return getDataFile(destination);
-            }
-        });
+        dataFileCaches = MigrateMap.makeComputingMap(this::getDataFile);

        executor = Executors.newScheduledThreadPool(1);
-        destinations = MigrateMap.makeComputingMap(new Function<String, List<ClientIdentity>>() {
+        destinations = MigrateMap.makeComputingMap(this::loadClientIdentity);

-            public List<ClientIdentity> apply(String destination) {
-                return loadClientIdentity(destination);
+        cursors = MigrateMap.makeComputingMap(clientIdentity -> {
+            Position position = loadCursor(clientIdentity.getDestination(), clientIdentity);
+            if (position == null) {
+                return nullCursor; // 返回一个空对象标识，避免出现异常
+            } else {
+                return position;
            }
        });

-        cursors = MigrateMap.makeComputingMap(new Function<ClientIdentity, Position>() {
-
-            public Position apply(ClientIdentity clientIdentity) {
-                Position position = loadCursor(clientIdentity.getDestination(), clientIdentity);
-                if (position == null) {
-                    return nullCursor; // 返回一个空对象标识，避免出现异常
-                } else {
-                    return position;
-                }
-            }
-        });
-
-        updateCursorTasks = Collections.synchronizedSet(new HashSet<ClientIdentity>());
+        updateCursorTasks = Collections.synchronizedSet(new HashSet<>());

        // 启动定时工作任务
-        executor.scheduleAtFixedRate(new Runnable() {
-
-            public void run() {
-                List<ClientIdentity> tasks = new ArrayList<ClientIdentity>(updateCursorTasks);
-                for (ClientIdentity clientIdentity : tasks) {
-                    MDC.put("destination", String.valueOf(clientIdentity.getDestination()));
-                    try {
-                        // 定时将内存中的最新值刷到file中，多次变更只刷一次
-                        if (logger.isInfoEnabled()) {
-                            LogPosition cursor = (LogPosition) getCursor(clientIdentity);
-                            logger.info("clientId:{} cursor:[{},{},{},{},{}] address[{}]", new Object[] {
-                                    clientIdentity.getClientId(), cursor.getPostion().getJournalName(),
-                                    cursor.getPostion().getPosition(), cursor.getPostion().getTimestamp(),
-                                    cursor.getPostion().getServerId(), cursor.getPostion().getGtid(),
-                                    cursor.getIdentity().getSourceAddress().toString() });
-                        }
-                        flushDataToFile(clientIdentity.getDestination());
-                        updateCursorTasks.remove(clientIdentity);
-                    } catch (Throwable e) {
-                        // ignore
-                        logger.error("period update" + clientIdentity.toString() + " curosr failed!", e);
+        executor.scheduleAtFixedRate(() -> {
+            List<ClientIdentity> tasks = new ArrayList<>(updateCursorTasks);
+            for (ClientIdentity clientIdentity : tasks) {
+                MDC.put("destination", String.valueOf(clientIdentity.getDestination()));
+                try {
+                    // 定时将内存中的最新值刷到file中，多次变更只刷一次
+                    if (logger.isInfoEnabled()) {
+                        LogPosition cursor = (LogPosition) getCursor(clientIdentity);
+                        logger.info("clientId:{} cursor:[{},{},{},{},{}] address[{}]", clientIdentity.getClientId(), cursor.getPostion().getJournalName(),
+                                cursor.getPostion().getPosition(), cursor.getPostion().getTimestamp(),
+                                cursor.getPostion().getServerId(), cursor.getPostion().getGtid(),
+                                cursor.getIdentity().getSourceAddress().toString());
                    }
+                    flushDataToFile(clientIdentity.getDestination());
+                    updateCursorTasks.remove(clientIdentity);
+                } catch (Throwable e) {
+                    // ignore
+                    logger.error("period update" + clientIdentity.toString() + " curosr failed!", e);
                }
            }
        },
@@ -142,24 +126,14 @@ public class FileMixedMetaManager extends MemoryMetaManager implements CanalMeta
        super.subscribe(clientIdentity);

        // 订阅信息频率发生比较低，不需要做定时merge处理
-        executor.submit(new Runnable() {
-
-            public void run() {
-                flushDataToFile(clientIdentity.getDestination());
-            }
-        });
+        executor.submit(() -> flushDataToFile(clientIdentity.getDestination()));
    }

    public void unsubscribe(final ClientIdentity clientIdentity) throws CanalMetaManagerException {
        super.unsubscribe(clientIdentity);

        // 订阅信息频率发生比较低，不需要做定时merge处理
-        executor.submit(new Runnable() {
-
-            public void run() {
-                flushDataToFile(clientIdentity.getDestination());
-            }
-        });
+        executor.submit(() -> flushDataToFile(clientIdentity.getDestination()));
    }

    public void updateCursor(ClientIdentity clientIdentity, Position position) throws CanalMetaManagerException {
--- a/meta/src/main/java/com/alibaba/otter/canal/meta/MemoryMetaManager.java
+++ b/meta/src/main/java/com/alibaba/otter/canal/meta/MemoryMetaManager.java
@@ -32,22 +32,11 @@ public class MemoryMetaManager extends AbstractCanalLifeCycle implements CanalMe
    public void start() {
        super.start();

-        batches = MigrateMap.makeComputingMap(new Function<ClientIdentity, MemoryClientIdentityBatch>() {
-
-            public MemoryClientIdentityBatch apply(ClientIdentity clientIdentity) {
-                return MemoryClientIdentityBatch.create(clientIdentity);
-            }
-
-        });
+        batches = MigrateMap.makeComputingMap(MemoryClientIdentityBatch::create);

        cursors = new MapMaker().makeMap();

-        destinations = MigrateMap.makeComputingMap(new Function<String, List<ClientIdentity>>() {
-
-            public List<ClientIdentity> apply(String destination) {
-                return Lists.newArrayList();
-            }
-        });
+        destinations = MigrateMap.makeComputingMap(destination -> Lists.newArrayList());
    }

    public void stop() {
--- a/meta/src/main/java/com/alibaba/otter/canal/meta/MixedMetaManager.java
+++ b/meta/src/main/java/com/alibaba/otter/canal/meta/MixedMetaManager.java
@@ -1,6 +1,5 @@
 package com.alibaba.otter.canal.meta;

-import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -11,7 +10,6 @@ import com.alibaba.otter.canal.meta.exception.CanalMetaManagerException;
 import com.alibaba.otter.canal.protocol.ClientIdentity;
 import com.alibaba.otter.canal.protocol.position.Position;
 import com.alibaba.otter.canal.protocol.position.PositionRange;
-import com.google.common.base.Function;
 import com.google.common.collect.MigrateMap;

 /**
@@ -37,36 +35,25 @@ public class MixedMetaManager extends MemoryMetaManager implements CanalMetaMana
        }

        executor = Executors.newFixedThreadPool(1);
-        destinations = MigrateMap.makeComputingMap(new Function<String, List<ClientIdentity>>() {
+        destinations = MigrateMap.makeComputingMap(destination -> zooKeeperMetaManager.listAllSubscribeInfo(destination));

-            public List<ClientIdentity> apply(String destination) {
-                return zooKeeperMetaManager.listAllSubscribeInfo(destination);
+        cursors = MigrateMap.makeComputingMap(clientIdentity -> {
+            Position position = zooKeeperMetaManager.getCursor(clientIdentity);
+            if (position == null) {
+                return nullCursor; // 返回一个空对象标识，避免出现异常
+            } else {
+                return position;
            }
        });

-        cursors = MigrateMap.makeComputingMap(new Function<ClientIdentity, Position>() {
-
-            public Position apply(ClientIdentity clientIdentity) {
-                Position position = zooKeeperMetaManager.getCursor(clientIdentity);
-                if (position == null) {
-                    return nullCursor; // 返回一个空对象标识，避免出现异常
-                } else {
-                    return position;
-                }
-            }
-        });
-
-        batches = MigrateMap.makeComputingMap(new Function<ClientIdentity, MemoryClientIdentityBatch>() {
-
-            public MemoryClientIdentityBatch apply(ClientIdentity clientIdentity) {
-                // 读取一下zookeeper信息，初始化一次
-                MemoryClientIdentityBatch batches = MemoryClientIdentityBatch.create(clientIdentity);
-                Map<Long, PositionRange> positionRanges = zooKeeperMetaManager.listAllBatchs(clientIdentity);
-                for (Map.Entry<Long, PositionRange> entry : positionRanges.entrySet()) {
-                    batches.addPositionRange(entry.getValue(), entry.getKey()); // 添加记录到指定batchId
-                }
-                return batches;
+        batches = MigrateMap.makeComputingMap(clientIdentity -> {
+            // 读取一下zookeeper信息，初始化一次
+            MemoryClientIdentityBatch batches = MemoryClientIdentityBatch.create(clientIdentity);
+            Map<Long, PositionRange> positionRanges = zooKeeperMetaManager.listAllBatchs(clientIdentity);
+            for (Map.Entry<Long, PositionRange> entry : positionRanges.entrySet()) {
+                batches.addPositionRange(entry.getValue(), entry.getKey()); // 添加记录到指定batchId
            }
+            return batches;
        });
    }

@@ -85,23 +72,13 @@ public class MixedMetaManager extends MemoryMetaManager implements CanalMetaMana
    public void subscribe(final ClientIdentity clientIdentity) throws CanalMetaManagerException {
        super.subscribe(clientIdentity);

-        executor.submit(new Runnable() {
-
-            public void run() {
-                zooKeeperMetaManager.subscribe(clientIdentity);
-            }
-        });
+        executor.submit(() -> zooKeeperMetaManager.subscribe(clientIdentity));
    }

    public void unsubscribe(final ClientIdentity clientIdentity) throws CanalMetaManagerException {
        super.unsubscribe(clientIdentity);

-        executor.submit(new Runnable() {
-
-            public void run() {
-                zooKeeperMetaManager.unsubscribe(clientIdentity);
-            }
-        });
+        executor.submit(() -> zooKeeperMetaManager.unsubscribe(clientIdentity));
    }

    public void updateCursor(final ClientIdentity clientIdentity, final Position position)
@@ -109,12 +86,7 @@ public class MixedMetaManager extends MemoryMetaManager implements CanalMetaMana
        super.updateCursor(clientIdentity, position);

        // 异步刷新
-        executor.submit(new Runnable() {
-
-            public void run() {
-                zooKeeperMetaManager.updateCursor(clientIdentity, position);
-            }
-        });
+        executor.submit(() -> zooKeeperMetaManager.updateCursor(clientIdentity, position));
    }

    @Override
@@ -131,12 +103,7 @@ public class MixedMetaManager extends MemoryMetaManager implements CanalMetaMana
                                                                                                throws CanalMetaManagerException {
        final Long batchId = super.addBatch(clientIdentity, positionRange);
        // 异步刷新
-        executor.submit(new Runnable() {
-
-            public void run() {
-                zooKeeperMetaManager.addBatch(clientIdentity, positionRange, batchId);
-            }
-        });
+        executor.submit(() -> zooKeeperMetaManager.addBatch(clientIdentity, positionRange, batchId));
        return batchId;
    }

@@ -144,23 +111,15 @@ public class MixedMetaManager extends MemoryMetaManager implements CanalMetaMana
                                                                                                                    throws CanalMetaManagerException {
        super.addBatch(clientIdentity, positionRange, batchId);
        // 异步刷新
-        executor.submit(new Runnable() {
-
-            public void run() {
-                zooKeeperMetaManager.addBatch(clientIdentity, positionRange, batchId);
-            }
-        });
+        executor.submit(() -> zooKeeperMetaManager.addBatch(clientIdentity, positionRange, batchId));
    }

    public PositionRange removeBatch(final ClientIdentity clientIdentity, final Long batchId)
                                                                                             throws CanalMetaManagerException {
        PositionRange positionRange = super.removeBatch(clientIdentity, batchId);
        // 异步刷新
-        executor.submit(new Runnable() {
-
-            public void run() {
-                zooKeeperMetaManager.removeBatch(clientIdentity, batchId);
-            }
+        executor.submit(() -> {
+            zooKeeperMetaManager.removeBatch(clientIdentity, batchId);
        });

        return positionRange;
@@ -170,12 +129,7 @@ public class MixedMetaManager extends MemoryMetaManager implements CanalMetaMana
        super.clearAllBatchs(clientIdentity);

        // 异步刷新
-        executor.submit(new Runnable() {
-
-            public void run() {
-                zooKeeperMetaManager.clearAllBatchs(clientIdentity);
-            }
-        });
+        executor.submit(() -> zooKeeperMetaManager.clearAllBatchs(clientIdentity));
    }

    // =============== setter / getter ================
--- a/meta/src/main/java/com/alibaba/otter/canal/meta/PeriodMixedMetaManager.java
+++ b/meta/src/main/java/com/alibaba/otter/canal/meta/PeriodMixedMetaManager.java
@@ -18,7 +18,6 @@ import com.alibaba.otter.canal.meta.exception.CanalMetaManagerException;
 import com.alibaba.otter.canal.protocol.ClientIdentity;
 import com.alibaba.otter.canal.protocol.position.Position;
 import com.alibaba.otter.canal.protocol.position.PositionRange;
-import com.google.common.base.Function;
 import com.google.common.collect.MigrateMap;

 /**
@@ -52,54 +51,40 @@ public class PeriodMixedMetaManager extends MemoryMetaManager implements CanalMe
        }

        executor = Executors.newScheduledThreadPool(1);
-        destinations = MigrateMap.makeComputingMap(new Function<String, List<ClientIdentity>>() {
+        destinations = MigrateMap.makeComputingMap(destination -> zooKeeperMetaManager.listAllSubscribeInfo(destination));

-            public List<ClientIdentity> apply(String destination) {
-                return zooKeeperMetaManager.listAllSubscribeInfo(destination);
+        cursors = MigrateMap.makeComputingMap(clientIdentity -> {
+            Position position = zooKeeperMetaManager.getCursor(clientIdentity);
+            if (position == null) {
+                return nullCursor; // 返回一个空对象标识，避免出现异常
+            } else {
+                return position;
            }
        });

-        cursors = MigrateMap.makeComputingMap(new Function<ClientIdentity, Position>() {
-
-            public Position apply(ClientIdentity clientIdentity) {
-                Position position = zooKeeperMetaManager.getCursor(clientIdentity);
-                if (position == null) {
-                    return nullCursor; // 返回一个空对象标识，避免出现异常
-                } else {
-                    return position;
-                }
+        batches = MigrateMap.makeComputingMap(clientIdentity -> {
+            // 读取一下zookeeper信息，初始化一次
+            MemoryClientIdentityBatch batches = MemoryClientIdentityBatch.create(clientIdentity);
+            Map<Long, PositionRange> positionRanges = zooKeeperMetaManager.listAllBatchs(clientIdentity);
+            for (Map.Entry<Long, PositionRange> entry : positionRanges.entrySet()) {
+                batches.addPositionRange(entry.getValue(), entry.getKey()); // 添加记录到指定batchId
            }
+            return batches;
        });

-        batches = MigrateMap.makeComputingMap(new Function<ClientIdentity, MemoryClientIdentityBatch>() {
-
-            public MemoryClientIdentityBatch apply(ClientIdentity clientIdentity) {
-                // 读取一下zookeeper信息，初始化一次
-                MemoryClientIdentityBatch batches = MemoryClientIdentityBatch.create(clientIdentity);
-                Map<Long, PositionRange> positionRanges = zooKeeperMetaManager.listAllBatchs(clientIdentity);
-                for (Map.Entry<Long, PositionRange> entry : positionRanges.entrySet()) {
-                    batches.addPositionRange(entry.getValue(), entry.getKey()); // 添加记录到指定batchId
-                }
-                return batches;
-            }
-        });
-
-        updateCursorTasks = Collections.synchronizedSet(new HashSet<ClientIdentity>());
+        updateCursorTasks = Collections.synchronizedSet(new HashSet<>());

        // 启动定时工作任务
-        executor.scheduleAtFixedRate(new Runnable() {
-
-            public void run() {
-                List<ClientIdentity> tasks = new ArrayList<ClientIdentity>(updateCursorTasks);
-                for (ClientIdentity clientIdentity : tasks) {
-                    try {
-                        // 定时将内存中的最新值刷到zookeeper中，多次变更只刷一次
-                        zooKeeperMetaManager.updateCursor(clientIdentity, getCursor(clientIdentity));
-                        updateCursorTasks.remove(clientIdentity);
-                    } catch (Throwable e) {
-                        // ignore
-                        logger.error("period update" + clientIdentity.toString() + " curosr failed!", e);
-                    }
+        executor.scheduleAtFixedRate(() -> {
+            List<ClientIdentity> tasks = new ArrayList<>(updateCursorTasks);
+            for (ClientIdentity clientIdentity : tasks) {
+                try {
+                    // 定时将内存中的最新值刷到zookeeper中，多次变更只刷一次
+                    zooKeeperMetaManager.updateCursor(clientIdentity, getCursor(clientIdentity));
+                    updateCursorTasks.remove(clientIdentity);
+                } catch (Throwable e) {
+                    // ignore
+                    logger.error("period update" + clientIdentity.toString() + " curosr failed!", e);
                }
            }
        }, period, period, TimeUnit.MILLISECONDS);
@@ -121,24 +106,14 @@ public class PeriodMixedMetaManager extends MemoryMetaManager implements CanalMe
        super.subscribe(clientIdentity);

        // 订阅信息频率发生比较低，不需要做定时merge处理
-        executor.submit(new Runnable() {
-
-            public void run() {
-                zooKeeperMetaManager.subscribe(clientIdentity);
-            }
-        });
+        executor.submit(() -> zooKeeperMetaManager.subscribe(clientIdentity));
    }

    public void unsubscribe(final ClientIdentity clientIdentity) throws CanalMetaManagerException {
        super.unsubscribe(clientIdentity);

        // 订阅信息频率发生比较低，不需要做定时merge处理
-        executor.submit(new Runnable() {
-
-            public void run() {
-                zooKeeperMetaManager.unsubscribe(clientIdentity);
-            }
-        });
+        executor.submit(() -> zooKeeperMetaManager.unsubscribe(clientIdentity));
    }

    public void updateCursor(ClientIdentity clientIdentity, Position position) throws CanalMetaManagerException {
--- a/meta/src/main/java/com/alibaba/otter/canal/meta/ZooKeeperMetaManager.java
+++ b/meta/src/main/java/com/alibaba/otter/canal/meta/ZooKeeperMetaManager.java
@@ -103,7 +103,7 @@ public class ZooKeeperMetaManager extends AbstractCanalLifeCycle implements Cana

    public List<ClientIdentity> listAllSubscribeInfo(String destination) throws CanalMetaManagerException {
        if (zkClientx == null) { //重新加载时可能为空
-            return new ArrayList<ClientIdentity>();
+            return new ArrayList<>();
        }
        String path = ZookeeperPathUtils.getDestinationPath(destination);
        List<String> childs = null;
@@ -114,9 +114,9 @@ public class ZooKeeperMetaManager extends AbstractCanalLifeCycle implements Cana
        }

        if (CollectionUtils.isEmpty(childs)) {
-            return new ArrayList<ClientIdentity>();
+            return new ArrayList<>();
        }
-        List<Short> clientIds = new ArrayList<Short>();
+        List<Short> clientIds = new ArrayList<>();
        for (String child : childs) {
            if (StringUtils.isNumeric(child)) {
                clientIds.add(ZookeeperPathUtils.getClientId(child));
@@ -252,7 +252,7 @@ public class ZooKeeperMetaManager extends AbstractCanalLifeCycle implements Cana
            return null;
        }
        // 找到最大的Id
-        ArrayList<Long> batchIds = new ArrayList<Long>(nodes.size());
+        ArrayList<Long> batchIds = new ArrayList<>(nodes.size());
        for (String batchIdString : nodes) {
            batchIds.add(Long.valueOf(batchIdString));
        }
@@ -279,7 +279,7 @@ public class ZooKeeperMetaManager extends AbstractCanalLifeCycle implements Cana
            return null;
        }
        // 找到最小的Id
-        ArrayList<Long> batchIds = new ArrayList<Long>(nodes.size());
+        ArrayList<Long> batchIds = new ArrayList<>(nodes.size());
        for (String batchIdString : nodes) {
            batchIds.add(Long.valueOf(batchIdString));
        }
@@ -306,7 +306,7 @@ public class ZooKeeperMetaManager extends AbstractCanalLifeCycle implements Cana
            return Maps.newHashMap();
        }
        // 找到最大的Id
-        ArrayList<Long> batchIds = new ArrayList<Long>(nodes.size());
+        ArrayList<Long> batchIds = new ArrayList<>(nodes.size());
        for (String batchIdString : nodes) {
            batchIds.add(Long.valueOf(batchIdString));
        }
--- a/meta/src/test/java/com/alibaba/otter/canal/meta/AbstractMetaManagerTest.java
+++ b/meta/src/test/java/com/alibaba/otter/canal/meta/AbstractMetaManagerTest.java
@@ -20,7 +20,7 @@ import org.junit.Test;
 public class AbstractMetaManagerTest extends AbstractZkTest {

    private static final String MYSQL_ADDRESS  = "127.0.0.1";
-    protected ClientIdentity    clientIdentity = new ClientIdentity(destination, (short) 1); ;
+    protected ClientIdentity    clientIdentity = new ClientIdentity(destination, (short) 1);

    @Test
    public void doSubscribeTest(CanalMetaManager metaManager) {
@@ -116,6 +116,6 @@ public class AbstractMetaManagerTest extends AbstractZkTest {
        LogPosition end = new LogPosition();
        end.setIdentity(new LogIdentity(new InetSocketAddress(MYSQL_ADDRESS, 3306), 1234L));
        end.setPostion(new EntryPosition("mysql-bin.000000" + (number + 1), 106L, (new Date().getTime()) + 1000 * 1000L));
-        return new PositionRange<LogPosition>(start, end);
+        return new PositionRange<>(start, end);
    }
 }