update guava to 18.0, magriate compute map by package level implement

2026-11-04 00:30:15 +08:00 · 2015-04-23 22:15:57 +08:00
parent bdf3b0c861
commit 6a0733bbab
14 changed files with 633 additions and 502 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
@@ -1,5 +1,6 @@
 package com.alibaba.otter.canal.meta;

+import com.google.common.collect.MigrateMap;
 import java.io.File;
 import java.io.IOException;
 import java.nio.charset.Charset;
@@ -69,28 +70,36 @@ public class FileMixedMetaManager extends MemoryMetaManager implements CanalMeta
            throw new CanalMetaManagerException("dir[" + dataDir.getPath() + "] can not read/write");
        }

-        dataFileCaches = new MapMaker().makeComputingMap(new Function<String, File>() {
+        dataFileCaches = MigrateMap.makeComputingMap(new Function<String, File>()
+        {

-            public File apply(String destination) {
+            public File apply(String destination)
+            {
                return getDataFile(destination);
            }
        });

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

-            public List<ClientIdentity> apply(String destination) {
+            public List<ClientIdentity> apply(String destination)
+            {
                return loadClientIdentity(destination);
            }
        });

-        cursors = new MapMaker().makeComputingMap(new Function<ClientIdentity, Position>() {
+        cursors = MigrateMap.makeComputingMap(new Function<ClientIdentity, Position>()
+        {

-            public Position apply(ClientIdentity clientIdentity) {
+            public Position apply(ClientIdentity clientIdentity)
+            {
                Position position = loadCursor(clientIdentity.getDestination(), clientIdentity);
-                if (position == null) {
+                if (position == null)
+                {
                    return nullCursor; // 返回一个空对象标识，避免出现异常
-                } else {
+                } else
+                {
                    return position;
                }
            }
--- a/meta/src/main/java/com/alibaba/otter/canal/meta/MemoryMetaManager.java
+++ b/meta/src/main/java/com/alibaba/otter/canal/meta/MemoryMetaManager.java
@@ -1,5 +1,6 @@
 package com.alibaba.otter.canal.meta;

+import com.google.common.collect.MigrateMap;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
@@ -31,9 +32,11 @@ public class MemoryMetaManager extends AbstractCanalLifeCycle implements CanalMe
    public void start() {
        super.start();

-        batches = new MapMaker().makeComputingMap(new Function<ClientIdentity, MemoryClientIdentityBatch>() {
+        batches = MigrateMap.makeComputingMap(new Function<ClientIdentity, MemoryClientIdentityBatch>()
+        {

-            public MemoryClientIdentityBatch apply(ClientIdentity clientIdentity) {
+            public MemoryClientIdentityBatch apply(ClientIdentity clientIdentity)
+            {
                return MemoryClientIdentityBatch.create(clientIdentity);
            }

@@ -41,9 +44,11 @@ public class MemoryMetaManager extends AbstractCanalLifeCycle implements CanalMe

        cursors = new MapMaker().makeMap();

-        destinations = new MapMaker().makeComputingMap(new Function<String, List<ClientIdentity>>() {
+        destinations = MigrateMap.makeComputingMap(new Function<String, List<ClientIdentity>>()
+        {

-            public List<ClientIdentity> apply(String destination) {
+            public List<ClientIdentity> apply(String destination)
+            {
                return Lists.newArrayList();
            }
        });
--- 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,68 +1,79 @@
 package com.alibaba.otter.canal.meta;

-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-
-import org.springframework.util.Assert;
-
 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.MapMaker;
+import com.google.common.collect.MigrateMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import org.springframework.util.Assert;

 /**
 * 组合memory + zookeeper的使用模式
- * 
+ *
 * @author jianghang 2012-7-11 下午03:58:00
 * @version 1.0.0
 */

-public class MixedMetaManager extends MemoryMetaManager implements CanalMetaManager {
+public class MixedMetaManager extends MemoryMetaManager implements CanalMetaManager
+{

-    private ExecutorService      executor;
+    private ExecutorService executor;
    private ZooKeeperMetaManager zooKeeperMetaManager;
    @SuppressWarnings("serial")
-    private final Position       nullCursor = new Position() {
-                                            };
+    private final Position nullCursor = new Position()
+    {
+    };

-    public void start() {
+    public void start()
+    {
        super.start();
        Assert.notNull(zooKeeperMetaManager);
-        if (!zooKeeperMetaManager.isStart()) {
+        if (!zooKeeperMetaManager.isStart())
+        {
            zooKeeperMetaManager.start();
        }

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

-            public List<ClientIdentity> apply(String destination) {
+            public List<ClientIdentity> apply(String destination)
+            {
                return zooKeeperMetaManager.listAllSubscribeInfo(destination);
            }
        });

-        cursors = new MapMaker().makeComputingMap(new Function<ClientIdentity, Position>() {
+        cursors = MigrateMap.makeComputingMap(new Function<ClientIdentity, Position>()
+        {

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

-        batches = new MapMaker().makeComputingMap(new Function<ClientIdentity, MemoryClientIdentityBatch>() {
+        batches = MigrateMap.makeComputingMap(new Function<ClientIdentity, MemoryClientIdentityBatch>()
+        {

-            public MemoryClientIdentityBatch apply(ClientIdentity clientIdentity) {
+            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()) {
+                for (Map.Entry<Long, PositionRange> entry : positionRanges.entrySet())
+                {
                    batches.addPositionRange(entry.getValue(), entry.getKey()); // 添加记录到指定batchId
                }
                return batches;
@@ -70,10 +81,12 @@ public class MixedMetaManager extends MemoryMetaManager implements CanalMetaMana
        });
    }

-    public void stop() {
+    public void stop()
+    {
        super.stop();

-        if (zooKeeperMetaManager.isStart()) {
+        if (zooKeeperMetaManager.isStart())
+        {
            zooKeeperMetaManager.stop();
        }

@@ -82,58 +95,73 @@ public class MixedMetaManager extends MemoryMetaManager implements CanalMetaMana
        batches.clear();
    }

-    public void subscribe(final ClientIdentity clientIdentity) throws CanalMetaManagerException {
+    public void subscribe(final ClientIdentity clientIdentity) throws CanalMetaManagerException
+    {
        super.subscribe(clientIdentity);

-        executor.submit(new Runnable() {
+        executor.submit(new Runnable()
+        {

-            public void run() {
+            public void run()
+            {
                zooKeeperMetaManager.subscribe(clientIdentity);
            }
        });
    }

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

-        executor.submit(new Runnable() {
+        executor.submit(new Runnable()
+        {

-            public void run() {
+            public void run()
+            {
                zooKeeperMetaManager.unsubscribe(clientIdentity);
            }
        });
    }

    public void updateCursor(final ClientIdentity clientIdentity, final Position position)
-                                                                                          throws CanalMetaManagerException {
+            throws CanalMetaManagerException
+    {
        super.updateCursor(clientIdentity, position);

        // 异步刷新
-        executor.submit(new Runnable() {
+        executor.submit(new Runnable()
+        {

-            public void run() {
+            public void run()
+            {
                zooKeeperMetaManager.updateCursor(clientIdentity, position);
            }
        });
    }

    @Override
-    public Position getCursor(ClientIdentity clientIdentity) throws CanalMetaManagerException {
+    public Position getCursor(ClientIdentity clientIdentity) throws CanalMetaManagerException
+    {
        Position position = super.getCursor(clientIdentity);
-        if (position == nullCursor) {
+        if (position == nullCursor)
+        {
            return null;
-        } else {
+        } else
+        {
            return position;
        }
    }

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

-            public void run() {
+            public void run()
+            {
                zooKeeperMetaManager.addBatch(clientIdentity, positionRange, batchId);
            }
        });
@@ -141,24 +169,30 @@ public class MixedMetaManager extends MemoryMetaManager implements CanalMetaMana
    }

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

-            public void run() {
+            public void run()
+            {
                zooKeeperMetaManager.addBatch(clientIdentity, positionRange, batchId);
            }
        });
    }

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

-            public void run() {
+            public void run()
+            {
                zooKeeperMetaManager.removeBatch(clientIdentity, batchId);
            }
        });
@@ -166,20 +200,24 @@ public class MixedMetaManager extends MemoryMetaManager implements CanalMetaMana
        return positionRange;
    }

-    public void clearAllBatchs(final ClientIdentity clientIdentity) throws CanalMetaManagerException {
+    public void clearAllBatchs(final ClientIdentity clientIdentity) throws CanalMetaManagerException
+    {
        super.clearAllBatchs(clientIdentity);

        // 异步刷新
-        executor.submit(new Runnable() {
+        executor.submit(new Runnable()
+        {

-            public void run() {
+            public void run()
+            {
                zooKeeperMetaManager.clearAllBatchs(clientIdentity);
            }
        });
    }

    // =============== setter / getter ================
-    public void setZooKeeperMetaManager(ZooKeeperMetaManager zooKeeperMetaManager) {
+    public void setZooKeeperMetaManager(ZooKeeperMetaManager zooKeeperMetaManager)
+    {
        this.zooKeeperMetaManager = zooKeeperMetaManager;
    }
 }
--- a/meta/src/main/java/com/alibaba/otter/canal/meta/PeriodMixedMetaManager.java
+++ b/meta/src/main/java/com/alibaba/otter/canal/meta/PeriodMixedMetaManager.java
@@ -1,5 +1,6 @@
 package com.alibaba.otter.canal.meta;

+import com.google.common.collect.MigrateMap;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
@@ -52,32 +53,40 @@ public class PeriodMixedMetaManager extends MemoryMetaManager implements CanalMe
        }

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

-            public List<ClientIdentity> apply(String destination) {
+            public List<ClientIdentity> apply(String destination)
+            {
                return zooKeeperMetaManager.listAllSubscribeInfo(destination);
            }
        });

-        cursors = new MapMaker().makeComputingMap(new Function<ClientIdentity, Position>() {
+        cursors = MigrateMap.makeComputingMap(new Function<ClientIdentity, Position>()
+        {

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

-        batches = new MapMaker().makeComputingMap(new Function<ClientIdentity, MemoryClientIdentityBatch>() {
-
-            public MemoryClientIdentityBatch apply(ClientIdentity clientIdentity) {
+        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()) {
+                for (Map.Entry<Long, PositionRange> entry : positionRanges.entrySet())
+                {
                    batches.addPositionRange(entry.getValue(), entry.getKey()); // 添加记录到指定batchId
                }
                return batches;