提取公共代码放到StorageBase

lealone · Apr 14, 2017 · c323508 · c323508
1 parent 26e6605
commit c323508
Show file tree

Hide file tree

Showing 5 changed files with 124 additions and 164 deletions.
diff --git a/lealone-aose/src/main/java/org/lealone/aose/storage/AOStorage.java b/lealone-aose/src/main/java/org/lealone/aose/storage/AOStorage.java
@@ -18,40 +18,29 @@
 package org.lealone.aose.storage;
 
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
 
 import org.lealone.aose.storage.btree.BTreeMap;
 import org.lealone.aose.storage.rtree.RTreeMap;
 import org.lealone.common.util.DataUtils;
-import org.lealone.db.Constants;
+import org.lealone.storage.StorageBase;
-import org.lealone.storage.Storage;
 import org.lealone.storage.StorageMap;
 import org.lealone.storage.fs.FilePath;
 import org.lealone.storage.fs.FileUtils;
-import org.lealone.storage.memory.MemoryMap;
 import org.lealone.storage.type.DataType;
 
 /**
  * Adaptive optimization storage
  * 
  * @author zhh
  */
-public class AOStorage implements Storage {
+public class AOStorage extends StorageBase {
 
     public static final String SUFFIX_AO_FILE = ".db";
     public static final int SUFFIX_AO_FILE_LENGTH = SUFFIX_AO_FILE.length();
 
-    private static final String TEMP_NAME_PREFIX = "temp" + Constants.NAME_SEPARATOR;
-
-    private final ConcurrentHashMap<String, StorageMap<?, ?>> maps = new ConcurrentHashMap<>();
     private final Map<String, Object> config;
 
-    private boolean closed;
-    private int nextTemporaryMapId;
-
     AOStorage(Map<String, Object> config) {
         this.config = config;
         String storageName = (String) config.get("storageName");
@@ -67,28 +56,18 @@ public class AOStorage implements Storage {
         }
     }
 
-    public void closeMap(String name) {
+    @Override
-        maps.remove(name);
+    public <K, V> StorageMap<K, V> openMap(String name, String mapType, DataType keyType, DataType valueType,
-    }
-
-    @SuppressWarnings("unchecked")
-    public <M extends StorageMap<K, V>, K, V> M openMap(String name, StorageMapBuilder<M, K, V> builder,
             Map<String, String> parameters) {
-        M map = (M) maps.get(name);
+        if (mapType == null || mapType.equalsIgnoreCase("AOMap")) {
-        if (map == null) {
+            return openAOMap(name, keyType, valueType, parameters);
-            synchronized (this) {
+        } else if (mapType.equalsIgnoreCase("BTreeMap")) {
-                map = (M) maps.get(name);
+            return openBTreeMap(name, keyType, valueType, parameters);
-                if (map == null) {
+        } else if (mapType.equalsIgnoreCase("BufferedMap")) {
-                    HashMap<String, Object> c = new HashMap<>(config);
+            return openBufferedMap(name, keyType, valueType, parameters);
-                    if (parameters != null)
+        } else {
-                        c.putAll(parameters);
+            throw DataUtils.newIllegalArgumentException("Unknow map type: {0}", mapType);
-                    builder.name(name).config(c).aoStorage(this);
-                    map = builder.openMap();
-                    maps.put(name, map);
-                }
-            }
         }
-        return map;
     }
 
     public <K, V> BTreeMap<K, V> openBTreeMap(String name) {
@@ -126,95 +105,33 @@ public <K, V> BufferedMap<K, V> openBufferedMap(String name, DataType keyType, D
         return map;
     }
 
-    public <K, V> MemoryMap<K, V> openMemoryMap(String name, DataType keyType, DataType valueType) {
+    @SuppressWarnings("unchecked")
-        MemoryMapBuilder<K, V> builder = new MemoryMapBuilder<>();
+    private <M extends StorageMap<K, V>, K, V> M openMap(String name, StorageMapBuilder<M, K, V> builder,
-        builder.keyType(keyType);
+            Map<String, String> parameters) {
-        builder.valueType(valueType);
+        M map = (M) maps.get(name);
-        return openMap(name, builder, null);
+        if (map == null) {
-    }
+            synchronized (this) {
-
+                map = (M) maps.get(name);
-    private static class MemoryMapBuilder<K, V> extends StorageMapBuilder<MemoryMap<K, V>, K, V> {
+                if (map == null) {
-        @Override
+                    HashMap<String, Object> c = new HashMap<>(config);
-        public MemoryMap<K, V> openMap() {
+                    if (parameters != null)
-            return new MemoryMap<>(name, keyType, valueType);
+                        c.putAll(parameters);
+                    builder.name(name).config(c).aoStorage(this);
+                    map = builder.openMap();
+                    maps.put(name, map);
+                }
+            }
         }
+        return map;
     }
 
     public boolean isReadOnly() {
         return config.containsKey("readOnly");
     }
 
-    public Set<String> getMapNames() {
-        return new HashSet<String>(maps.keySet());
-    }
-
-    @Override
-    public <K, V> StorageMap<K, V> openMap(String name, String mapType, DataType keyType, DataType valueType,
-            Map<String, String> parameters) {
-        if (mapType == null || mapType.equalsIgnoreCase("AOMap")) {
-            return openAOMap(name, keyType, valueType, parameters);
-        } else if (mapType.equalsIgnoreCase("BTreeMap")) {
-            return openBTreeMap(name, keyType, valueType, parameters);
-        } else if (mapType.equalsIgnoreCase("BufferedMap")) {
-            return openBufferedMap(name, keyType, valueType, parameters);
-        } else if (mapType.equalsIgnoreCase("MemoryMap")) {
-            return openMemoryMap(name, keyType, valueType);
-        } else {
-            throw DataUtils.newIllegalArgumentException("Unknow map type: {0}", mapType);
-        }
-    }
-
-    @Override
-    public synchronized String nextTemporaryMapName() {
-        return TEMP_NAME_PREFIX + nextTemporaryMapId++;
-    }
-
-    @Override
-    public boolean hasMap(String name) {
-        return maps.containsKey(name);
-    }
-
     @Override
     public void backupTo(String fileName) {
         // TODO Auto-generated method stub
     }
 
-    @Override
-    public void flush() {
-        save();
-    }
-
-    @Override
-    public void sync() {
-        save();
-    }
-
-    public synchronized void save() {
-        for (StorageMap<?, ?> map : maps.values())
-            map.save();
-    }
-
-    public boolean isClosed() {
-        return closed;
-    }
-
-    @Override
-    public void close() {
-        close(true);
-    }
-
-    @Override
-    public void closeImmediately() {
-        close(false);
-    }
-
-    private synchronized void close(boolean closeMaps) {
-        closed = true;
-
-        for (StorageMap<?, ?> map : maps.values())
-            map.close();
-
-        maps.clear();
-    }
-
 }
diff --git a/lealone-common/src/main/java/org/lealone/storage/Storage.java b/lealone-common/src/main/java/org/lealone/storage/Storage.java
@@ -32,12 +32,12 @@ <K, V> StorageMap<K, V> openMap(String name, String mapType, DataType keyType, D
 
     void backupTo(String fileName);
 
-    void flush();
+    void save();
-
-    void sync();
 
     void close();
 
     void closeImmediately();
 
+    boolean isClosed();
+
 }
diff --git a/lealone-common/src/main/java/org/lealone/storage/StorageBase.java b/lealone-common/src/main/java/org/lealone/storage/StorageBase.java
@@ -0,0 +1,87 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lealone.storage;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.lealone.db.Constants;
+
+public abstract class StorageBase implements Storage {
+
+    protected static final String TEMP_NAME_PREFIX = "_temp_" + Constants.NAME_SEPARATOR;
+
+    protected final ConcurrentHashMap<String, StorageMap<?, ?>> maps = new ConcurrentHashMap<>();
+
+    protected boolean closed;
+
+    @Override
+    public boolean hasMap(String name) {
+        return maps.containsKey(name);
+    }
+
+    @Override
+    public String nextTemporaryMapName() {
+        int i = 0;
+        String name = null;
+        while (true) {
+            name = TEMP_NAME_PREFIX + i;
+            if (!maps.containsKey(name))
+                return name;
+        }
+    }
+
+    @Override
+    public void backupTo(String fileName) {
+    }
+
+    @Override
+    public void save() {
+        for (StorageMap<?, ?> map : maps.values())
+            map.save();
+    }
+
+    @Override
+    public void close() {
+        closeImmediately();
+    }
+
+    @Override
+    public void closeImmediately() {
+        closed = true;
+
+        for (StorageMap<?, ?> map : maps.values())
+            map.close();
+
+        maps.clear();
+    }
+
+    @Override
+    public boolean isClosed() {
+        return closed;
+    }
+
+    public Set<String> getMapNames() {
+        return new HashSet<String>(maps.keySet());
+    }
+
+    public void closeMap(String name) {
+        maps.remove(name);
+    }
+}
diff --git a/lealone-common/src/main/java/org/lealone/storage/memory/MemoryStorage.java b/lealone-common/src/main/java/org/lealone/storage/memory/MemoryStorage.java
@@ -18,15 +18,11 @@
 package org.lealone.storage.memory;
 
 import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
 
-import org.lealone.db.Constants;
+import org.lealone.storage.StorageBase;
-import org.lealone.storage.Storage;
 import org.lealone.storage.type.DataType;
 
-public class MemoryStorage implements Storage {
+public class MemoryStorage extends StorageBase {
-
-    private final ConcurrentHashMap<String, MemoryMap<?, ?>> maps = new ConcurrentHashMap<>();
 
     @SuppressWarnings("unchecked")
     @Override
@@ -46,44 +42,4 @@ public <K, V> MemoryMap<K, V> openMap(String name, String mapType, DataType keyT
         return map;
     }
 
-    @Override
-    public boolean hasMap(String name) {
-        return maps.containsKey(name);
-    }
-
-    @Override
-    public String nextTemporaryMapName() {
-        int i = 0;
-        String name = null;
-        while (true) {
-            name = "temp" + Constants.NAME_SEPARATOR + i;
-            if (!maps.containsKey(name))
-                return name;
-        }
-    }
-
-    @Override
-    public void backupTo(String fileName) {
-    }
-
-    @Override
-    public void flush() {
-    }
-
-    @Override
-    public void sync() {
-    }
-
-    @Override
-    public void close() {
-        for (MemoryMap<?, ?> map : maps.values())
-            map.close();
-        maps.clear();
-    }
-
-    @Override
-    public void closeImmediately() {
-        close();
-    }
-
 }
diff --git a/lealone-db/src/main/java/org/lealone/db/Database.java b/lealone-db/src/main/java/org/lealone/db/Database.java
@@ -1621,7 +1621,7 @@ public synchronized void flush() {
         }
         try {
             for (Storage s : getStorages()) {
-                s.flush();
+                s.save();
             }
         } catch (RuntimeException e) {
             backgroundException = DbException.convert(e);
@@ -1692,7 +1692,7 @@ public synchronized void sync() {
         }
 
         for (Storage s : getStorages()) {
-            s.sync();
+            s.save();
         }
     }
 
@@ -1973,7 +1973,7 @@ public Table getFirstUserTable() {
     public void checkpoint() {
         if (persistent) {
             for (Storage s : getStorages()) {
-                s.flush();
+                s.save();
             }
         }
         getTempFileDeleter().deleteUnused();