feature(ipLookupV2,AsnLookup) GAL-196 V1.1.1 IP/ASN定为空支持输入流为InputStream.

5 files changed, 519 insertions, 258 deletions

diff --git a/pom.xml b/pom.xml
index 87ae9de..d469732 100644
--- a/pom.xml
+++ b/pom.xml
@@ -7,7 +7,7 @@
     <artifactId>galaxy</artifactId>
     <packaging>jar</packaging>
     <name>galaxy</name>
-    <version>1.1.0</version>
+    <version>1.1.1</version>
     <description>galaxy tools for common</description>
     <url>http://www.zdjizhi.com/galaxy-tool</url>
 
diff --git a/src/main/java/com/zdjizhi/utils/AsnLookup.java b/src/main/java/com/zdjizhi/utils/AsnLookup.java
index 8207c35..d1d45b8 100644
--- a/src/main/java/com/zdjizhi/utils/AsnLookup.java
+++ b/src/main/java/com/zdjizhi/utils/AsnLookup.java
@@ -9,6 +9,7 @@ import org.slf4j.LoggerFactory;
 
 import java.io.File;
 import java.io.IOException;
+import java.io.InputStream;
 import java.net.InetAddress;
 import java.net.URL;
 
@@ -34,14 +35,13 @@ public class AsnLookup {
     private final static String DEFAULT_DB_ASN_PRIVATE_V4 = "asn_private_v4.mmdb";
     private final static String DEFAULT_DB_ASN_PRIVATE_V6 = "asn_private_v6.mmdb";
 
+    private static GalaxyDataBaseReader publicDatabaseReader;
+    private static GalaxyDataBaseReader publicV4DatabaseReader;
+    private static GalaxyDataBaseReader publicV6DatabaseReader;
 
-    private static GalaxyDataBaseReader asnLocationPublicReader;
-    private static GalaxyDataBaseReader asnLocationPublicReaderV4;
-    private static GalaxyDataBaseReader asnLocationPublicReaderV6;
-
-    private static GalaxyDataBaseReader asnLocationPrivateReader;
-    private static GalaxyDataBaseReader asnLocationPrivateReaderV4;
-    private static GalaxyDataBaseReader asnLocationPrivateReaderV6;
+    private static GalaxyDataBaseReader privateDatabaseReader;
+    private static GalaxyDataBaseReader privateV4DatabaseReader;
+    private static GalaxyDataBaseReader privateV6DatabaseReader;
 
 
     synchronized void init(AsnLookup.Builder builder) {
@@ -49,12 +49,12 @@ public class AsnLookup {
 
             if (builder.isDefaultDB) {
 
-                File asnDbPublicFile =  new File(System.getProperty("user.dir") + File.separator + DEFAULT_DATABASE_PATH + File.separator
+                File publicDatabaseFile =  new File(System.getProperty("user.dir") + File.separator + DEFAULT_DATABASE_PATH + File.separator
                         + DEFAULT_DB_ASN_PUBLIC);
-                if (!asnDbPublicFile.exists()) {
-                    URL url = IpLookup.class.getResource("/"+ DEFAULT_DATABASE_PATH + "/" + DEFAULT_DB_ASN_PUBLIC);
+                if (!publicDatabaseFile.exists()) {
+                    URL url = AsnLookup.class.getResource("/"+ DEFAULT_DATABASE_PATH + "/" + DEFAULT_DB_ASN_PUBLIC);
                     if (url != null) {
-                        asnDbPublicFile =  new File(url.getPath());
+                        publicDatabaseFile =  new File(url.getPath());
                     }
 
                 }
@@ -63,7 +63,7 @@ public class AsnLookup {
                 File asnDbPublicV4File =  new File(System.getProperty("user.dir") + File.separator + DEFAULT_DATABASE_PATH + File.separator
                         + DEFAULT_DB_ASN_PUBLIC_V4);
                 if (!asnDbPublicV4File.exists()) {
-                    URL url = IpLookup.class.getResource("/"+ DEFAULT_DATABASE_PATH + "/" + DEFAULT_DB_ASN_PUBLIC_V4);
+                    URL url = AsnLookup.class.getResource("/"+ DEFAULT_DATABASE_PATH + "/" + DEFAULT_DB_ASN_PUBLIC_V4);
                     if (url != null) {
                         asnDbPublicV4File =  new File(url.getPath());
                     }
@@ -73,7 +73,7 @@ public class AsnLookup {
                 File asnDbPublicV6File =  new File(System.getProperty("user.dir") + File.separator + DEFAULT_DATABASE_PATH + File.separator
                         + DEFAULT_DB_ASN_PUBLIC_V6);
                 if (!asnDbPublicV6File.exists()) {
-                    URL url = IpLookup.class.getResource("/"+ DEFAULT_DATABASE_PATH + "/" + DEFAULT_DB_ASN_PUBLIC_V6);
+                    URL url = AsnLookup.class.getResource("/"+ DEFAULT_DATABASE_PATH + "/" + DEFAULT_DB_ASN_PUBLIC_V6);
                     if (url != null) {
                         asnDbPublicV6File =  new File(url.getPath());
                     }
@@ -82,7 +82,7 @@ public class AsnLookup {
                 File asnDbPrivateFile =  new File(System.getProperty("user.dir") + File.separator + DEFAULT_DATABASE_PATH + File.separator
                         + DEFAULT_DB_ASN_PRIVATE);
                 if (!asnDbPrivateFile.exists()) {
-                    URL url = IpLookup.class.getResource("/"+ DEFAULT_DATABASE_PATH + "/" + DEFAULT_DB_ASN_PRIVATE);
+                    URL url = AsnLookup.class.getResource("/"+ DEFAULT_DATABASE_PATH + "/" + DEFAULT_DB_ASN_PRIVATE);
                     if (url != null) {
                         asnDbPrivateFile =  new File(url.getPath());
                     }
@@ -92,7 +92,7 @@ public class AsnLookup {
                 File asnDbPrivateV4File =  new File(System.getProperty("user.dir") + File.separator + DEFAULT_DATABASE_PATH + File.separator
                         + DEFAULT_DB_ASN_PRIVATE_V4);
                 if (!asnDbPrivateV4File.exists()) {
-                    URL url = IpLookup.class.getResource("/"+ DEFAULT_DATABASE_PATH + "/" + DEFAULT_DB_ASN_PRIVATE_V4);
+                    URL url = AsnLookup.class.getResource("/"+ DEFAULT_DATABASE_PATH + "/" + DEFAULT_DB_ASN_PRIVATE_V4);
                     if (url != null) {
                         asnDbPrivateV4File =  new File(url.getPath());
                     }
@@ -103,64 +103,61 @@ public class AsnLookup {
                 File asnDbPrivateV6File =  new File(System.getProperty("user.dir") + File.separator + DEFAULT_DATABASE_PATH + File.separator
                         + DEFAULT_DB_ASN_PRIVATE_V6);
                 if (!asnDbPrivateV6File.exists()) {
-                    URL url = IpLookup.class.getResource("/"+ DEFAULT_DATABASE_PATH + "/" + DEFAULT_DB_ASN_PRIVATE_V6);
+                    URL url = AsnLookup.class.getResource("/"+ DEFAULT_DATABASE_PATH + "/" + DEFAULT_DB_ASN_PRIVATE_V6);
                     if (url != null) {
                         asnDbPrivateV6File =  new File(url.getPath());
                     }
                 }
 
-                if (asnDbPublicFile.exists()) {
-                    asnLocationPublicReader = new GalaxyDataBaseReader.Builder(asnDbPublicFile).withCache(new CHMCache()).build();
-                }
-                if (asnDbPublicV4File.exists()) {
-                    asnLocationPublicReaderV4 = new GalaxyDataBaseReader.Builder(asnDbPublicV4File).withCache(new CHMCache()).build();
-                }
-
-                if (asnDbPublicV6File.exists()) {
-                    asnLocationPublicReaderV6 = new GalaxyDataBaseReader.Builder(asnDbPublicV6File).withCache(new CHMCache()).build();
-                }
-                if (asnDbPrivateFile.exists()) {
-                    asnLocationPrivateReader = new GalaxyDataBaseReader.Builder(asnDbPrivateFile).withCache(new CHMCache()).build();
-                }
-                if (asnDbPrivateV4File.exists()) {
-                    asnLocationPrivateReaderV4 = new GalaxyDataBaseReader.Builder(asnDbPrivateV4File).withCache(new CHMCache()).build();
-                }
-
-                if (asnDbPrivateV6File.exists()) {
-                    asnLocationPrivateReaderV6 = new GalaxyDataBaseReader.Builder(asnDbPrivateV6File).withCache(new CHMCache()).build();
-                }
+                publicDatabaseReader = buildDataReader(publicDatabaseFile);
+                publicV4DatabaseReader = buildDataReader(asnDbPublicV4File);
+                publicV6DatabaseReader = buildDataReader(asnDbPublicV6File);
+                privateDatabaseReader = buildDataReader(asnDbPrivateFile);
+                privateV4DatabaseReader = buildDataReader(asnDbPrivateV4File);
+                privateV6DatabaseReader = buildDataReader(asnDbPrivateV6File);
 
             } else {
 
-
-                if (StringUtil.isNotBlank(builder.asnDatabasePublicFile)) {
-                    asnLocationPublicReader = new GalaxyDataBaseReader.Builder(new File(builder.asnDatabasePublicFile)).withCache(new CHMCache()).build();
+                if (StringUtil.isNotBlank(builder.publicAsnDatabaseFile)) {
+                    publicDatabaseReader = buildDataReader(new File(builder.publicAsnDatabaseFile));
+                 } else if (builder.publicAsnDatabaseStream != null) {
+                    publicDatabaseReader = buildDataReader(builder.publicAsnDatabaseStream);
                 }
-                if (StringUtil.isNotBlank(builder.asnDatabasePublicFileV4)) {
-                    asnLocationPublicReaderV4 = new GalaxyDataBaseReader.Builder(new File(builder.asnDatabasePublicFileV4)).withCache(new CHMCache()).build();
+
+                if (StringUtil.isNotBlank(builder.publicAsnV4DatabaseFile)) {
+                    publicV4DatabaseReader = buildDataReader((new File(builder.publicAsnV4DatabaseFile)));
+                } else if (builder.publicAsnV4DatabaseStream != null) {
+                    publicV4DatabaseReader = buildDataReader(builder.publicAsnV4DatabaseStream);
                 }
 
-                if (StringUtil.isNotBlank(builder.asnDatabasePublicFileV6)) {
-                    asnLocationPublicReaderV6 = new GalaxyDataBaseReader.Builder(new File(builder.asnDatabasePublicFileV6)).withCache(new CHMCache()).build();
+                if (StringUtil.isNotBlank(builder.publicAsnV6DatabaseFile)) {
+                    publicV6DatabaseReader = buildDataReader(new File(builder.publicAsnV6DatabaseFile));
+                } else if (builder.publicAsnV6DatabaseStream != null) {
+                    publicV6DatabaseReader = buildDataReader(builder.publicAsnV6DatabaseStream);
                 }
 
-                if (StringUtil.isNotBlank(builder.asnDatabasePrivateFile)) {
-                    asnLocationPrivateReader = new GalaxyDataBaseReader.Builder(new File(builder.asnDatabasePrivateFile)).withCache(new CHMCache()).build();
+                if (StringUtil.isNotBlank(builder.privateAsnDatabaseFile)) {
+                    privateDatabaseReader = buildDataReader(new File(builder.privateAsnDatabaseFile));
+                } else if (builder.privateAsnDatabaseStream != null) {
+                    privateDatabaseReader = buildDataReader(builder.privateAsnDatabaseStream);
                 }
 
-                if (StringUtil.isNotBlank(builder.asnDatabasePrivateFileV4)) {
-                    asnLocationPrivateReaderV4 = new GalaxyDataBaseReader.Builder(new File(builder.asnDatabasePrivateFileV4)).withCache(new CHMCache()).build();
+                if (StringUtil.isNotBlank(builder.privateAsnV4DatabaseFile)) {
+                    privateV4DatabaseReader = buildDataReader(new File(builder.privateAsnV4DatabaseFile));
+                } else if (builder.privateAsnV4DatabaseStream != null) {
+                    privateV4DatabaseReader = buildDataReader(builder.privateAsnV4DatabaseStream);
                 }
 
-                if (StringUtil.isNotBlank(builder.asnDatabasePrivateFileV6)) {
-                    asnLocationPrivateReaderV6 = new GalaxyDataBaseReader.Builder(new File(builder.asnDatabasePrivateFileV6)).withCache(new CHMCache()).build();
+                if (StringUtil.isNotBlank(builder.privateAsnV6DatabaseFile)) {
+                    privateV6DatabaseReader = buildDataReader(new File(builder.privateAsnV6DatabaseFile));
+                } else if (builder.privateAsnV6DatabaseStream != null) {
+                    privateV6DatabaseReader = buildDataReader(builder.privateAsnV6DatabaseStream);
                 }
             }
 
         } catch (Exception e) {
             e.printStackTrace();
-            logger.warn("Unknow mmdb dat file , please check your dat path!");
-
+            logger.error("Unsupported GeoIP2 *.mmdb database: expected either File path or Stream.");
         }
 
 
@@ -171,7 +168,21 @@ public class AsnLookup {
     private AsnLookup(AsnLookup.Builder builder) {
         init(builder);
     }
+    private GalaxyDataBaseReader buildDataReader(File database) throws IOException {
+        if (database.exists()) {
+            return new GalaxyDataBaseReader.Builder(database).withCache(new CHMCache()).build();
+        } else {
+            return null;
+        }
+    }
 
+    private GalaxyDataBaseReader buildDataReader(InputStream stream) throws IOException {
+        if (stream != null) {
+            return new GalaxyDataBaseReader.Builder(stream).withCache(new CHMCache()).build();
+        } else {
+            return null;
+        }
+    }
 
     /**
      * 加载mmdb数据字典文件，内部生成mmdb动态库。
@@ -188,12 +199,21 @@ public class AsnLookup {
      * </p>
      */
     public static final class Builder {
-        String asnDatabasePublicFile;
-        String asnDatabasePublicFileV4;
-        String asnDatabasePublicFileV6;
-        String asnDatabasePrivateFile;
-        String asnDatabasePrivateFileV4;
-        String asnDatabasePrivateFileV6;
+        String publicAsnDatabaseFile;
+        String publicAsnV4DatabaseFile;
+        String publicAsnV6DatabaseFile;
+
+        InputStream publicAsnDatabaseStream;
+        InputStream publicAsnV4DatabaseStream;
+        InputStream publicAsnV6DatabaseStream;
+
+        String privateAsnDatabaseFile;
+        String privateAsnV4DatabaseFile;
+        String privateAsnV6DatabaseFile;
+
+        InputStream privateAsnDatabaseStream;
+        InputStream privateAsnV4DatabaseStream;
+        InputStream privateAsnV6DatabaseStream;
         boolean isDefaultDB;
 
 
@@ -207,67 +227,129 @@ public class AsnLookup {
 
         /**
          *
-         * @param asnDatabasePublicFile 加载IPv4与IPv6 ASN库
+         * @param publicAsnDatabaseFile  加载ASN database文件,不区分IPv4/6
+         * @return
+         */
+        public Builder loadDataFile(String publicAsnDatabaseFile) {
+            this.publicAsnDatabaseFile = publicAsnDatabaseFile;
+            return this;
+        }
+
+        /**
+         *
+         * @param publicAsnDatabaseStream 加载ASN database流,不区分IPv4/6
+         * @return
+         */
+        public Builder loadDataFile(InputStream publicAsnDatabaseStream) {
+            this.publicAsnDatabaseStream = publicAsnDatabaseStream;
+            return this;
+        }
+
+        /**
+         *
+         * @param publicAsnV4DatabaseFile  加载ASN IPv4 database文件
          * @return
          */
-        public Builder loadDataFile(String asnDatabasePublicFile) {
-            this.asnDatabasePublicFile = asnDatabasePublicFile;
+        public Builder loadDataFileV4(String publicAsnV4DatabaseFile) {
+            this.publicAsnV4DatabaseFile = publicAsnV4DatabaseFile;
             return this;
         }
 
         /**
          *
-         * @param asnDatabasePublicFileV4 加载IPv4 ASN库
+         * @param publicAsnV4DatabaseStream 加载ASN IPv4 database流
          * @return
          */
-        public Builder loadDataFileV4(String asnDatabasePublicFileV4) {
-            this.asnDatabasePublicFileV4 = asnDatabasePublicFileV4;
+        public Builder loadDataFileV4(InputStream publicAsnV4DatabaseStream) {
+            this.publicAsnV4DatabaseStream = publicAsnV4DatabaseStream;
             return this;
         }
 
+
+
         /**
          *
-         * @param asnDatabasePublicFileV6 加载IPv6 ASN库
+         * @param publicAsnV6DatabaseFile 加载ASN IPv6 database文件
          * @return
          */
-        public Builder loadDataFileV6(String asnDatabasePublicFileV6) {
-            this.asnDatabasePublicFileV6 = asnDatabasePublicFileV6;
+        public Builder loadDataFileV6(String publicAsnV6DatabaseFile) {
+            this.publicAsnV6DatabaseFile = publicAsnV6DatabaseFile;
             return this;
         }
 
         /**
          *
-         * @param asnDatabasePrivateFile 加载IPv4与IPv6 用户自定义ASN库
+         * @param publicAsnV6DatabaseStream 加载ASN IPv6 database流
          * @return
          */
-        public Builder loadDataFilePrivate(String asnDatabasePrivateFile) {
-            this.asnDatabasePrivateFile = asnDatabasePrivateFile;
+        public Builder loadDataFileV6(InputStream publicAsnV6DatabaseStream) {
+            this.publicAsnV6DatabaseStream = publicAsnV6DatabaseStream;
             return this;
         }
 
         /**
          *
-         * @param asnDatabasePrivateFileV4 加载IPv4 用户自定义ASN库
+         * @param privateAsnDatabaseFile 加载ASN database文件,不区分IPv4/6
          * @return
          */
-        public Builder loadDataFilePrivateV4(String asnDatabasePrivateFileV4) {
-            this.asnDatabasePrivateFileV4 = asnDatabasePrivateFileV4;
+        public Builder loadDataFilePrivate(String privateAsnDatabaseFile) {
+            this.privateAsnDatabaseFile = privateAsnDatabaseFile;
             return this;
         }
 
         /**
          *
-         * @param asnDatabasePrivateFileV6 加载IPv6 用户自定义ASN库
+         * @param privateAsnDatabaseStream 加载ASN database流,不区分IPv4/6
          * @return
          */
-        public Builder loadDataFilePrivateV6(String asnDatabasePrivateFileV6) {
-            this.asnDatabasePrivateFileV6 = asnDatabasePrivateFileV6;
+        public Builder loadDataFilePrivate(InputStream privateAsnDatabaseStream) {
+            this.privateAsnDatabaseStream = privateAsnDatabaseStream;
             return this;
         }
 
 
 
         /**
+         *
+         * @param privateAsnV4DatabaseFile 加载ASN IPv4 database文件
+         * @return
+         */
+        public Builder loadDataFilePrivateV4(String privateAsnV4DatabaseFile) {
+            this.privateAsnV4DatabaseFile = privateAsnV4DatabaseFile;
+            return this;
+        }
+
+        /**
+         *
+         * @param privateAsnV4DatabaseStream 加载ASN IPv4 database流
+         * @return
+         */
+        public Builder loadDataFilePrivateV4(InputStream privateAsnV4DatabaseStream) {
+            this.privateAsnV4DatabaseStream = privateAsnV4DatabaseStream;
+            return this;
+        }
+
+        /**
+         *
+         * @param privateAsnV6DatabaseFile 加载ASN IPv6 database文件
+         * @return
+         */
+        public Builder loadDataFilePrivateV6(String privateAsnV6DatabaseFile) {
+            this.privateAsnV6DatabaseFile = privateAsnV6DatabaseFile;
+            return this;
+        }
+        /**
+         *
+         * @param privateAsnV6DatabaseStream 加载ASN IPv6 database流
+         * @return
+         */
+        public Builder loadDataFilePrivateV6(InputStream privateAsnV6DatabaseStream) {
+            this.privateAsnV6DatabaseStream = privateAsnV6DatabaseStream;
+            return this;
+        }
+
+
+        /**
          * 构建对象
          * @return
          * @throws IOException
@@ -281,7 +363,6 @@ public class AsnLookup {
     }
 
 
-
     public String asnLookup(String ip) {
 
         LocationResponseV2 response = getResponse(ip);
@@ -337,16 +418,16 @@ public class AsnLookup {
     private GalaxyDataBaseReader getAsnDataBaseReaderV4(String service) {
 
         if (service.equalsIgnoreCase(ServiceEnum.PRIVATE.name())) {
-            if (StringUtil.isNotEmpty(asnLocationPrivateReaderV4)) {
-                return asnLocationPrivateReaderV4;
+            if (StringUtil.isNotEmpty(privateV4DatabaseReader)) {
+                return privateV4DatabaseReader;
             } else  {
-                return asnLocationPrivateReader;
+                return privateDatabaseReader;
             }
         } else  {
-            if (StringUtil.isNotEmpty(asnLocationPublicReaderV4)) {
-                return asnLocationPublicReaderV4;
+            if (StringUtil.isNotEmpty(publicV4DatabaseReader)) {
+                return publicV4DatabaseReader;
             } else{
-                return asnLocationPublicReader;
+                return publicDatabaseReader;
             }
         }
     }
@@ -354,16 +435,16 @@ public class AsnLookup {
     private GalaxyDataBaseReader getAsnDataBaseReaderV6(String service) {
 
         if (service.equalsIgnoreCase(ServiceEnum.PRIVATE.name())) {
-            if (StringUtil.isNotEmpty(asnLocationPrivateReaderV6)) {
-                return asnLocationPrivateReaderV6;
+            if (StringUtil.isNotEmpty(privateV6DatabaseReader)) {
+                return privateV6DatabaseReader;
             } else  {
-                return asnLocationPrivateReader;
+                return privateDatabaseReader;
             }
         } else  {
-            if (StringUtil.isNotEmpty(asnLocationPublicReaderV6)) {
-                return asnLocationPublicReaderV6;
+            if (StringUtil.isNotEmpty(publicV6DatabaseReader)) {
+                return publicV6DatabaseReader;
             } else{
-                return asnLocationPublicReader;
+                return publicDatabaseReader;
             }
         }
     }
diff --git a/src/main/java/com/zdjizhi/utils/IpLookupV2.java b/src/main/java/com/zdjizhi/utils/IpLookupV2.java
index 8302e64..c816891 100644
--- a/src/main/java/com/zdjizhi/utils/IpLookupV2.java
+++ b/src/main/java/com/zdjizhi/utils/IpLookupV2.java
@@ -7,6 +7,7 @@ import com.zdjizhi.domain.LocationResponseV2;
 
 import java.io.File;
 import java.io.IOException;
+import java.io.InputStream;
 import java.net.InetAddress;
 import java.net.URL;
 import java.util.Optional;
@@ -33,26 +34,26 @@ public final class IpLookupV2 extends AbstractIpLookup{
 
     private AsnLookup asnLookup;
 
-    private static GalaxyDataBaseReader ipLocationPublicReader;
-    private static GalaxyDataBaseReader ipLocationPublicReaderV4;
-    private static GalaxyDataBaseReader ipLocationPublicReaderV6;
+    private static GalaxyDataBaseReader publicDatabaseReader;
+    private static GalaxyDataBaseReader publicV4DatabaseReader;
+    private static GalaxyDataBaseReader publicV6DatabaseReader;
 
-    private static GalaxyDataBaseReader ipLocationPrivateReader;
-    private static GalaxyDataBaseReader ipLocationPrivateReaderV4;
-    private static GalaxyDataBaseReader ipLocationPrivateReaderV6;
+    private static GalaxyDataBaseReader privateDatabaseReader;
+    private static GalaxyDataBaseReader privateV4DatabaseReader;
+    private static GalaxyDataBaseReader privateV6DatabaseReader;
 
     synchronized void init(Builder builder) {
         try {
 
             if (builder.isDefaultDB) {
 
-                File dbPublicFile = new File(System.getProperty("user.dir") + File.separator + DEFAULT_DATABASE_PATH + File.separator
+                File publicDatabaseFile = new File(System.getProperty("user.dir") + File.separator + DEFAULT_DATABASE_PATH + File.separator
                         + DEFAULT_DB_IP_PUBLIC);
 
-                if (!dbPublicFile.exists()) {
+                if (!publicDatabaseFile.exists()) {
                     URL url = IpLookupV2.class.getResource("/"+ DEFAULT_DATABASE_PATH + "/" + DEFAULT_DB_IP_PUBLIC);
                     if (url != null) {
-                        dbPublicFile =  new File(url.getPath());
+                        publicDatabaseFile =  new File(url.getPath());
                     }
                 }
 
@@ -105,76 +106,73 @@ public final class IpLookupV2 extends AbstractIpLookup{
                     }
                 }
 
-                if (dbPublicFile.exists()) {
-                    ipLocationPublicReader = new GalaxyDataBaseReader.Builder(dbPublicFile).withCache(new CHMCache()).build();
-                }
-                if (dbPublicV4File.exists()) {
-                    ipLocationPublicReaderV4 = new GalaxyDataBaseReader.Builder(dbPublicV4File).withCache(new CHMCache()).build();
-                }
-
-                if (dbPublicV6File.exists()) {
-                    ipLocationPublicReaderV6 = new GalaxyDataBaseReader.Builder(dbPublicV6File).withCache(new CHMCache()).build();
-                }
-
-                if (dbPrivateFile.exists()) {
-                    ipLocationPrivateReader = new GalaxyDataBaseReader.Builder(dbPrivateFile).withCache(new CHMCache()).build();
-                }
-
-                if (dbPrivateV4File.exists()) {
-                    ipLocationPrivateReaderV4 = new GalaxyDataBaseReader.Builder(dbPrivateV4File).withCache(new CHMCache()).build();
-                }
-
-                if (dbPrivateV6File.exists()) {
-                    ipLocationPrivateReaderV6 = new GalaxyDataBaseReader.Builder(dbPrivateV6File).withCache(new CHMCache()).build();
-                }
 
+                publicDatabaseReader = buildDataReader(publicDatabaseFile);
+                publicV4DatabaseReader = buildDataReader(dbPublicV4File);
+                publicV6DatabaseReader = buildDataReader(dbPublicV6File);
+                privateDatabaseReader = buildDataReader(dbPrivateFile);
+                privateV4DatabaseReader = buildDataReader(dbPrivateV4File);
+                privateV6DatabaseReader = buildDataReader(dbPrivateV6File);
 
                 asnLookup =  new AsnLookup.Builder(true).build();
 
             } else {
 
-
-                if (StringUtil.isNotBlank(builder.ipDatabasePublicFile)) {
-                    ipLocationPublicReader = new GalaxyDataBaseReader.Builder(new File(builder.ipDatabasePublicFile)).withCache(new CHMCache()).build();
-
+                if (StringUtil.isNotBlank(builder.publicDatabaseFile)) {
+                    publicDatabaseReader = buildDataReader(new File(builder.publicDatabaseFile));
+                } else if (builder.publicDatabaseStream != null) {
+                    publicDatabaseReader = buildDataReader(builder.publicDatabaseStream);
                 }
 
-                if (StringUtil.isNotBlank(builder.ipDatabasePublicFileV4)) {
-                    ipLocationPublicReaderV4 = new GalaxyDataBaseReader.Builder(new File(builder.ipDatabasePublicFileV4)).withCache(new CHMCache()).build();
+                if (StringUtil.isNotBlank(builder.publicV4DatabaseFile)) {
+                    publicV4DatabaseReader = buildDataReader(new File(builder.publicV4DatabaseFile));
+                } else if (builder.publicV4DatabaseStream != null) {
+                    publicV4DatabaseReader = buildDataReader(builder.publicV4DatabaseStream);
                 }
 
-                if (StringUtil.isNotBlank(builder.ipDatabasePublicFileV6)) {
-                    ipLocationPublicReaderV6 = new GalaxyDataBaseReader.Builder(new File(builder.ipDatabasePublicFileV6)).withCache(new CHMCache()).build();
+                if (StringUtil.isNotBlank(builder.publicV6DatabaseFile)) {
+                    publicV6DatabaseReader = buildDataReader(new File(builder.publicV6DatabaseFile));
+                } else if (builder.publicV6DatabaseStream != null) {
+                    publicV6DatabaseReader = buildDataReader(builder.publicV6DatabaseStream);
                 }
 
-                if (StringUtil.isNotBlank(builder.ipDatabasePrivateFile)) {
-                    ipLocationPrivateReader = new GalaxyDataBaseReader.Builder(new File(builder.ipDatabasePrivateFile)).withCache(new CHMCache()).build();
+                if (StringUtil.isNotBlank(builder.privateDatabaseFile)) {
+                    privateDatabaseReader = buildDataReader(new File(builder.privateDatabaseFile));
+                } else if (builder.privateDatabaseStream != null) {
+                    privateDatabaseReader = buildDataReader(builder.privateDatabaseStream);
+
                 }
 
-                if (StringUtil.isNotBlank(builder.ipDatabasePrivateFileV4)) {
-                    ipLocationPrivateReaderV4 = new GalaxyDataBaseReader.Builder(new File(builder.ipDatabasePrivateFileV4)).withCache(new CHMCache()).build();
+                if (StringUtil.isNotBlank(builder.privateV4DatabaseFile)) {
+                    privateV4DatabaseReader = buildDataReader(new File(builder.privateV4DatabaseFile));
+                } else if (builder.privateV4DatabaseStream != null) {
+                    privateV4DatabaseReader = buildDataReader(builder.privateV4DatabaseStream);
                 }
 
-                if (StringUtil.isNotBlank(builder.ipDatabasePrivateFileV6)) {
-                    ipLocationPrivateReaderV6 = new GalaxyDataBaseReader.Builder(new File(builder.ipDatabasePrivateFileV6)).withCache(new CHMCache()).build();
+                if (StringUtil.isNotBlank(builder.privateV6DatabaseFile)) {
+                    privateV6DatabaseReader = buildDataReader(new File(builder.privateV6DatabaseFile));
+                } else if (builder.privateV6DatabaseStream != null) {
+                    privateV6DatabaseReader = buildDataReader(builder.privateV6DatabaseStream);
                 }
 
                 asnLookup =  new AsnLookup.Builder(false)
-                        .loadDataFile(builder.asnDatabasePublicFile)
-                        .loadDataFileV4(builder.asnDatabasePublicFileV4)
-                        .loadDataFileV6(builder.asnDatabasePublicFileV6)
-                        .loadDataFilePrivate(builder.asnDatabasePrivateFile)
-                        .loadDataFilePrivateV4(builder.asnDatabasePrivateFileV4)
-                        .loadDataFilePrivateV6(builder.asnDatabasePrivateFileV6)
+                        .loadDataFile(builder.publicAsnDatabaseFile)
+                        .loadDataFile(builder.publicAsnDatabaseStream)
+                        .loadDataFileV4(builder.publicAsnV4DatabaseFile)
+                        .loadDataFileV4(builder.publicAsnV4DatabaseStream)
+                        .loadDataFileV6(builder.publicAsnV6DatabaseFile)
+                        .loadDataFileV6(builder.publicAsnV6DatabaseStream)
+                        .loadDataFilePrivate(builder.privateAsnDatabaseFile)
+                        .loadDataFilePrivate(builder.privateAsnDatabaseStream)
+                        .loadDataFilePrivateV4(builder.privateAsnV4DatabaseFile)
+                        .loadDataFilePrivateV4(builder.privateAsnV4DatabaseStream)
+                        .loadDataFilePrivateV6(builder.privateAsnV6DatabaseFile)
+                        .loadDataFilePrivateV6(builder.privateAsnV6DatabaseStream)
                         .build();
-
-
             }
 
         } catch (Exception e) {
-
-            logger.error("IpLookup init data error, please check your file path!");
-
+            logger.error("Unsupported GeoIP2 *.mmdb database: expected either File path or Stream.");
         }
 
 
@@ -185,6 +183,22 @@ public final class IpLookupV2 extends AbstractIpLookup{
         init(builder);
     }
 
+    private GalaxyDataBaseReader buildDataReader(File database) throws IOException {
+        if (database.exists()) {
+            return new GalaxyDataBaseReader.Builder(database).withCache(new CHMCache()).build();
+        } else {
+            return null;
+        }
+    }
+
+    private GalaxyDataBaseReader buildDataReader(InputStream stream) throws IOException {
+        if (stream != null) {
+            return new GalaxyDataBaseReader.Builder(stream).withCache(new CHMCache()).build();
+        } else {
+            return null;
+        }
+    }
+
 
 
     /**
@@ -202,21 +216,37 @@ public final class IpLookupV2 extends AbstractIpLookup{
      * </p>
      */
     public static final class Builder {
-        String ipDatabasePublicFile;
-        String ipDatabasePublicFileV4;
-        String ipDatabasePublicFileV6;
+        String publicDatabaseFile;
+        String publicV4DatabaseFile;
+        String publicV6DatabaseFile;
+
+        InputStream publicDatabaseStream;
+        InputStream publicV4DatabaseStream;
+        InputStream publicV6DatabaseStream;
+
+        String privateDatabaseFile;
+        String privateV4DatabaseFile;
+        String privateV6DatabaseFile;
 
-        String ipDatabasePrivateFile;
-        String ipDatabasePrivateFileV4;
-        String ipDatabasePrivateFileV6;
+        InputStream privateDatabaseStream;
+        InputStream privateV4DatabaseStream;
+        InputStream privateV6DatabaseStream;
 
-        String asnDatabasePublicFile;
-        String asnDatabasePublicFileV4;
-        String asnDatabasePublicFileV6;
+        String publicAsnDatabaseFile;
+        String publicAsnV4DatabaseFile;
+        String publicAsnV6DatabaseFile;
 
-        String asnDatabasePrivateFile;
-        String asnDatabasePrivateFileV4;
-        String asnDatabasePrivateFileV6;
+        InputStream publicAsnDatabaseStream;
+        InputStream publicAsnV4DatabaseStream;
+        InputStream publicAsnV6DatabaseStream;
+
+        String privateAsnDatabaseFile;
+        String privateAsnV4DatabaseFile;
+        String privateAsnV6DatabaseFile;
+
+        InputStream privateAsnDatabaseStream;
+        InputStream privateAsnV4DatabaseStream;
+        InputStream privateAsnV6DatabaseStream;
 
         boolean isDefaultDB;
 
@@ -229,62 +259,120 @@ public final class IpLookupV2 extends AbstractIpLookup{
         }
 
         /**
+         * @param publicDatabaseFile 加载GeoIP2 database 文件，不区分IPv4/6
+         * @return
+         */
+        public Builder loadDataFile(String publicDatabaseFile) {
+            this.publicDatabaseFile = publicDatabaseFile;
+            return this;
+        }
+
+        /**
+         * @param publicDatabaseStream 加载GeoIP2流，不区分IPv4/6
+         * @return
+         */
+        public Builder loadDataFile(InputStream publicDatabaseStream) {
+            this.publicDatabaseStream = publicDatabaseStream;
+            return this;
+        }
+
+        /**
          *
-         * @param ipDatabasePublicFile 加载IPv4与IPV6 mmdb库文件
+         * @param publicV4DatabaseFile 加载第三方内置GeoIP2 IPv4 database 文件
+         * @return
+         */
+        public Builder loadDataFileV4(String publicV4DatabaseFile) {
+            this.publicV4DatabaseFile = publicV4DatabaseFile;
+            return this;
+        }
+
+        /**
+         * @param publicV4DatabaseStream 加载第三方内置GeoIP2 IPv4流
          * @return
          */
-        public Builder loadDataFile(String ipDatabasePublicFile) {
-            this.ipDatabasePublicFile = ipDatabasePublicFile;
+        public Builder loadDataFileV4(InputStream publicV4DatabaseStream) {
+            this.publicV4DatabaseStream = publicV4DatabaseStream;
             return this;
         }
 
+
         /**
          *
-         * @param ipDatabasePublicFileV4 加载IPv4 mmdb库文件
+         * @param publicV6DatabaseFile 加载第三方内置GeoIP2 IPv6 database 文件
+         * @return
+         */
+        public Builder loadDataFileV6(String publicV6DatabaseFile) {
+            this.publicV6DatabaseFile = publicV6DatabaseFile;
+            return this;
+        }
+
+        /**
+         * @param publicV6DatabaseStream 加载第三方内置GeoIP2 IPv6流
          * @return
          */
-        public Builder loadDataFileV4(String ipDatabasePublicFileV4) {
-            this.ipDatabasePublicFileV4 = ipDatabasePublicFileV4;
+        public Builder loadDataFileV6(InputStream publicV6DatabaseStream) {
+            this.publicV6DatabaseStream = publicV6DatabaseStream;
             return this;
         }
 
+
         /**
          *
-         * @param ipDatabasePublicFileV6 加载IPv6 mmdb库文件
+         * @param privateDatabaseFile 加载自定义GeoIP2 database 文件，不区分IPv4/6
          * @return
          */
-        public Builder loadDataFileV6(String ipDatabasePublicFileV6) {
-            this.ipDatabasePublicFileV6 = ipDatabasePublicFileV6;
+        public Builder loadDataFilePrivate(String privateDatabaseFile) {
+            this.privateDatabaseFile = privateDatabaseFile;
             return this;
         }
 
         /**
          *
-         * @param ipDatabasePrivateFile 加载用户自定义IPv4与IPv6 mmdb库文件
+         * @param privateDatabaseStream 加载自定义GeoIP2 流，不区分IPv4/6
          * @return
          */
-        public Builder loadDataFilePrivate(String ipDatabasePrivateFile) {
-            this.ipDatabasePrivateFile = ipDatabasePrivateFile;
+        public Builder loadDataFilePrivate(InputStream privateDatabaseStream) {
+            this.privateDatabaseStream = privateDatabaseStream;
             return this;
         }
 
         /**
          *
-         * @param ipDatabasePrivateFileV4 加载用户自定义IPv4 mmdb库文件
+         * @param privateV4DatabaseFile 加载自定义GeoIP2 IPv4 database 文件
          * @return
          */
-        public Builder loadDataFilePrivateV4(String ipDatabasePrivateFileV4) {
-            this.ipDatabasePrivateFileV4 = ipDatabasePrivateFileV4;
+        public Builder loadDataFilePrivateV4(String privateV4DatabaseFile) {
+            this.privateV4DatabaseFile = privateV4DatabaseFile;
             return this;
         }
 
         /**
          *
-         * @param ipDatabasePrivateFileV6 加载用户自定义IPv6 mmdb库文件
+         * @param privateV4DatabaseStream 加载自定义GeoIP2 IPv4 流
          * @return
          */
-        public Builder loadDataFilePrivateV6(String ipDatabasePrivateFileV6) {
-            this.ipDatabasePrivateFileV6 = ipDatabasePrivateFileV6;
+        public Builder loadDataFilePrivateV4(InputStream privateV4DatabaseStream) {
+            this.privateV4DatabaseStream = privateV4DatabaseStream;
+            return this;
+        }
+
+        /**
+         *
+         * @param privateV6DatabaseFile 加载自定义GeoIP2 IPv6 database 文件
+         * @return
+         */
+        public Builder loadDataFilePrivateV6(String privateV6DatabaseFile) {
+            this.privateV6DatabaseFile = privateV6DatabaseFile;
+            return this;
+        }
+
+        /**
+         *
+         * @param privateV6DatabaseStream 加载自定义GeoIP2 IPv6流
+         * @return
+         */
+        public Builder loadDataFilePrivateV6(InputStream privateV6DatabaseStream) {
+            this.privateV6DatabaseStream = privateV6DatabaseStream;
             return this;
         }
 
@@ -292,65 +380,125 @@ public final class IpLookupV2 extends AbstractIpLookup{
 
         /**
          *
-         * @param asnDatabasePublicFile 加载asn IPv4与IPv6库
+         * @param publicAsnDatabaseFile 加载ASN database文件,不区分IPv4/6
+         * @return
+         */
+        public Builder loadAsnDataFile(String publicAsnDatabaseFile) {
+            this.publicAsnDatabaseFile = publicAsnDatabaseFile;
+            return this;
+        }
+
+        /**
+         *
+         * @param publicAsnDatabaseStream 加载ASN database流,不区分IPv4/6
          * @return
          */
-        public Builder loadAsnDataFile(String asnDatabasePublicFile) {
-            this.asnDatabasePublicFile = asnDatabasePublicFile;
+        public Builder loadAsnDataFile(InputStream publicAsnDatabaseStream) {
+            this.publicAsnDatabaseStream = publicAsnDatabaseStream;
             return this;
         }
 
 
         /**
          *
-         * @param asnDatabasePublicFileV4 加载asn IPv4 mmdb库文件
+         * @param publicAsnV4DatabaseFile 加载ASN IPv4 database文件
+         * @return
+         */
+        public Builder loadAsnDataFileV4(String publicAsnV4DatabaseFile) {
+            this.publicAsnV4DatabaseFile = publicAsnV4DatabaseFile;
+            return this;
+        }
+
+        /**
+         *
+         * @param publicAsnV4DatabaseStream 加载ASN IPv4 database流
          * @return
          */
-        public Builder loadAsnDataFileV4(String asnDatabasePublicFileV4) {
-            this.asnDatabasePublicFileV4 = asnDatabasePublicFileV4;
+        public Builder loadAsnDataFileV4(InputStream publicAsnV4DatabaseStream) {
+            this.publicAsnV4DatabaseStream = publicAsnV4DatabaseStream;
             return this;
         }
 
 
         /**
          *
-         * @param asnDatabasePublicFileV6 加载asn IPv6 mmdb库文件
+         * @param publicAsnV6DatabaseFile 加载ASN IPv6 database文件
          * @return
          */
-        public Builder loadAsnDataFileV6(String asnDatabasePublicFileV6) {
-            this.asnDatabasePublicFileV6 = asnDatabasePublicFileV6;
+        public Builder loadAsnDataFileV6(String publicAsnV6DatabaseFile) {
+            this.publicAsnV6DatabaseFile = publicAsnV6DatabaseFile;
+            return this;
+        }
+
+        /**
+         *
+         * @param publicAsnV6DatabaseStream 加载ASN IPv6 database流
+         * @return
+         */
+        public Builder loadAsnDataFileV6(InputStream publicAsnV6DatabaseStream) {
+            this.publicAsnV6DatabaseStream = publicAsnV6DatabaseStream;
             return this;
         }
 
 
         /**
          *
-         * @param asnDatabasePrivateFile 加载asn用户自定义 IPv4与IPv6库
+         * @param privateAsnDatabaseFile 加载ASN database文件,不区分IPv4/6
          * @return
          */
-        public Builder loadAsnDataFilePrivate(String asnDatabasePrivateFile) {
-            this.asnDatabasePrivateFile = asnDatabasePrivateFile;
+        public Builder loadAsnDataFilePrivate(String privateAsnDatabaseFile) {
+            this.privateAsnDatabaseFile = privateAsnDatabaseFile;
             return this;
         }
 
         /**
          *
-         * @param asnDatabasePrivateFileV4 加载asn用户自定义 IPv4 mmdb库文件
+         * @param privateAsnDatabaseStream 加载ASN database流,不区分IPv4/6
          * @return
          */
-        public Builder loadAsnDataFilePrivateV4(String asnDatabasePrivateFileV4) {
-            this.asnDatabasePrivateFileV4 = asnDatabasePrivateFileV4;
+        public Builder loadAsnDataFilePrivate(InputStream privateAsnDatabaseStream) {
+            this.privateAsnDatabaseStream = privateAsnDatabaseStream;
             return this;
         }
 
+        /**
+         *
+         * @param privateAsnV4DatabaseFile 加载ASN IPv4 database文件
+         * @return
+         */
+        public Builder loadAsnDataFilePrivateV4(String privateAsnV4DatabaseFile) {
+            this.privateAsnV4DatabaseFile = privateAsnV4DatabaseFile;
+            return this;
+        }
 
         /**
          *
-         * @param asnDatabasePrivateFileV6 加载用户自定义asn IPv6 mmdb库文件
+         * @param privateAsnV4DatabaseStream 加载ASN IPv4 database流
          * @return
          */
-        public Builder loadAsnDataFilePrivateV6(String asnDatabasePrivateFileV6) {
-            this.asnDatabasePrivateFileV6 = asnDatabasePrivateFileV6;
+        public Builder loadAsnDataFilePrivateV4(InputStream privateAsnV4DatabaseStream) {
+            this.privateAsnV4DatabaseStream = privateAsnV4DatabaseStream;
+            return this;
+        }
+
+
+        /**
+         *
+         * @param privateAsnV6DatabaseFile 加载ASN IPv6 database文件
+         * @return
+         */
+        public Builder loadAsnDataFilePrivateV6(String privateAsnV6DatabaseFile) {
+            this.privateAsnV6DatabaseFile = privateAsnV6DatabaseFile;
+            return this;
+        }
+
+        /**
+         *
+         * @param privateAsnV6DatabaseStream 加载ASN IPv6 database流
+         * @return
+         */
+        public Builder loadAsnDataFilePrivateV6(InputStream privateAsnV6DatabaseStream) {
+            this.privateAsnV6DatabaseStream = privateAsnV6DatabaseStream;
             return this;
         }
 
@@ -370,7 +518,7 @@ public final class IpLookupV2 extends AbstractIpLookup{
 
         LocationResponseV2 response = getResponse(ip);
         if (StringUtil.isEmpty(response)) {
-            return  UNKNOWN;
+            return UNKNOWN;
         }
         if (response.isPrivateIP()) {
             return PRIVATE_IP;
@@ -597,16 +745,16 @@ public final class IpLookupV2 extends AbstractIpLookup{
     private GalaxyDataBaseReader getIpDataBaseReaderV4(String service) {
 
         if (service.equalsIgnoreCase(ServiceEnum.PRIVATE.name())) {
-            if (StringUtil.isNotEmpty(ipLocationPrivateReaderV4)) {
-                return ipLocationPrivateReaderV4;
+            if (StringUtil.isNotEmpty(privateV4DatabaseReader)) {
+                return privateV4DatabaseReader;
             } else {
-                return ipLocationPrivateReader;
+                return privateDatabaseReader;
             }
         } else  {
-            if (StringUtil.isNotEmpty(ipLocationPublicReaderV4)) {
-                return ipLocationPublicReaderV4;
+            if (StringUtil.isNotEmpty(publicV4DatabaseReader)) {
+                return publicV4DatabaseReader;
             } else {
-                return ipLocationPublicReader;
+                return publicDatabaseReader;
             }
         }
 
@@ -615,16 +763,16 @@ public final class IpLookupV2 extends AbstractIpLookup{
     private GalaxyDataBaseReader getIpDataBaseReaderV6(String service) {
 
         if (service.equalsIgnoreCase(ServiceEnum.PRIVATE.name())) {
-            if (StringUtil.isNotEmpty(ipLocationPrivateReaderV6)) {
-                return ipLocationPrivateReaderV6;
+            if (StringUtil.isNotEmpty(privateV6DatabaseReader)) {
+                return privateV6DatabaseReader;
             } else {
-                return ipLocationPrivateReader;
+                return privateDatabaseReader;
             }
         } else  {
-            if (StringUtil.isNotEmpty(ipLocationPublicReaderV6)) {
-                return ipLocationPublicReaderV6;
+            if (StringUtil.isNotEmpty(publicV6DatabaseReader)) {
+                return publicV6DatabaseReader;
             } else {
-                return ipLocationPublicReader;
+                return publicDatabaseReader;
             }
         }
 
diff --git a/src/test/java/com/zdjizhi/test/IPBenchMarkTest.java b/src/test/java/com/zdjizhi/test/IPBenchMarkTest.java
index 67ff5e2..02702a5 100644
--- a/src/test/java/com/zdjizhi/test/IPBenchMarkTest.java
+++ b/src/test/java/com/zdjizhi/test/IPBenchMarkTest.java
@@ -5,6 +5,9 @@ import com.zdjizhi.utils.IpLookup;
 import com.zdjizhi.utils.IpLookupV2;
 import org.apache.log4j.Logger;
 
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.net.InetAddress;
 import java.util.Random;
@@ -18,23 +21,38 @@ public class IPBenchMarkTest {
     private final static int SEED = 5;
 
 
-    private static IpLookupV2 ipLookupV2 =  new IpLookupV2.Builder(false)
-            .loadDataFileV4("dat/ip_v4_built_in.mmdb")
-            .loadDataFilePrivateV6("dat/ip_v4_user_defined.mmdb")
-            .loadDataFileV6("dat/ip_v6_built_in.mmdb")
-            .loadDataFilePrivateV6("dat/ip_v6_user_defined.mmdb")
-            .loadAsnDataFile("dat/asn_v4.mmdb")
-            .loadAsnDataFileV6("dat/asn_v6.mmdb")
-            .build();
+    private IpLookupV2 ipLookup =  getIpLookupByDatabase();
 
-    private static IpLookup ipLookup =  new IpLookup.Builder(false)
-            .loadDataFileV4("dat/ip_v4_built_in.mmdb")
-            .loadDataFilePrivateV6("dat/ip_v4_user_defined.mmdb")
-            .loadDataFileV6("dat/ip_v6_built_in.mmdb")
-            .loadDataFilePrivateV6("dat/ip_v6_user_defined.mmdb")
-            .loadAsnDataFile("dat/asn_v4.mmdb")
-            .loadAsnDataFileV6("dat/asn_v6.mmdb")
-            .build();
+    private IpLookupV2 ipLookupA = getIpLookupByStream();
+
+
+    private IpLookupV2 getIpLookupByDatabase() {
+        return new IpLookupV2.Builder(false)
+                .loadDataFileV4("dat/ip_v4_built_in.mmdb")
+                .loadDataFilePrivateV6("dat/ip_v4_user_defined.mmdb")
+                .loadDataFileV6("dat/ip_v6_built_in.mmdb")
+                .loadDataFilePrivateV6("dat/ip_v6_user_defined.mmdb")
+                .loadAsnDataFile("dat/asn_v4.mmdb")
+                .loadAsnDataFileV6("dat/asn_v6.mmdb")
+                .build();
+    }
+
+    private IpLookupV2 getIpLookupByStream() {
+        IpLookupV2 ipLookupV2 = null;
+        try {
+            ipLookupV2 = new IpLookupV2.Builder(false)
+                    .loadDataFileV4(new FileInputStream(new File("dat/ip_v4_built_in.mmdb")))
+                    .loadDataFilePrivateV4(new FileInputStream(new File("dat/ip_v4_user_defined.mmdb")))
+                    .loadDataFileV6(new FileInputStream(new File("dat/ip_v6_built_in.mmdb")))
+                    .loadDataFilePrivateV6(new FileInputStream(new File("dat/ip_v6_user_defined.mmdb")))
+                    .loadAsnDataFile("dat/asn_v4.mmdb")
+                    .loadAsnDataFileV6("dat/asn_v6.mmdb")
+                    .build();
+        }catch (FileNotFoundException e) {
+            logger.error(" File is not found:", e);
+        }
+        return ipLookupV2;
+    }
 
     private static AsnLookup asnLookup =  new AsnLookup.Builder(false)
             .loadDataFileV4("dat/asn_v4.mmdb")
@@ -43,18 +61,18 @@ public class IPBenchMarkTest {
 
     public static void main(String[] args) throws IOException{
         for(int i=0; i< SEED; i++) {
-            benchMark(COUNT, i);
+            new IPBenchMarkTest().benchMark(COUNT, i);
         }
     }
 
-    private static void benchMark(int count, int seed) throws IOException {
+    private void benchMark(int count, int seed) throws IOException {
         Random random = new Random(seed);
         long startTime = System.nanoTime();
         byte[] address = new byte[4];
         for (int i = 0; i < count; i++) {
             random.nextBytes(address);
             InetAddress ip = InetAddress.getByAddress(address);
-            String ipInfo = ipLookupV2.infoLookupToJson(ip.getHostAddress());
+            String ipInfo = ipLookup.infoLookupToCSV(ip.getHostAddress());
             if (TRACE) {
                 if (i % 50000 == 0) {
                     logger.info(i + " " + ip);
diff --git a/src/test/java/com/zdjizhi/test/IpLookupV2Test.java b/src/test/java/com/zdjizhi/test/IpLookupV2Test.java
index b07ea04..88c7de5 100644
--- a/src/test/java/com/zdjizhi/test/IpLookupV2Test.java
+++ b/src/test/java/com/zdjizhi/test/IpLookupV2Test.java
@@ -7,21 +7,48 @@ import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+
 
 public class IpLookupV2Test {
     Logger logger  = Logger.getLogger(IpLookupV2Test.class);
     @Rule
     public ExpectedException expectedEx = ExpectedException.none();
 
-    IpLookupV2 ipLookup =  new IpLookupV2.Builder(false)
-         .loadDataFileV4("dat/ip_v4_built_in.mmdb")
-         .loadDataFilePrivateV6("dat/ip_v4_user_defined.mmdb")
-         .loadDataFileV6("dat/ip_v6_built_in.mmdb")
-         .loadDataFilePrivateV6("dat/ip_v6_user_defined.mmdb")
-         .loadAsnDataFile("dat/asn_v4.mmdb")
-         .loadAsnDataFileV6("dat/asn_v6.mmdb")
-         .build();
+    IpLookupV2 ipLookupA =  getIpLookupByDatabase();
+
+    IpLookupV2 ipLookup = getIpLookupByStream();
+
+
+    private IpLookupV2 getIpLookupByDatabase() {
+        return new IpLookupV2.Builder(false)
+                .loadDataFileV4("dat/ip_v4_built_in.mmdb")
+                .loadDataFilePrivateV6("dat/ip_v4_user_defined.mmdb")
+                .loadDataFileV6("dat/ip_v6_built_in.mmdb")
+                .loadDataFilePrivateV6("dat/ip_v6_user_defined.mmdb")
+                .loadAsnDataFile("dat/asn_v4.mmdb")
+                .loadAsnDataFileV6("dat/asn_v6.mmdb")
+                .build();
+    }
 
+    private IpLookupV2 getIpLookupByStream() {
+        IpLookupV2 ipLookupV2 = null;
+        try {
+            ipLookupV2 = new IpLookupV2.Builder(false)
+                    .loadDataFileV4(new FileInputStream(new File("dat/ip_v4_built_in.mmdb")))
+                    .loadDataFilePrivateV4(new FileInputStream(new File("dat/ip_v4_user_defined.mmdb")))
+                    .loadDataFileV6(new FileInputStream(new File("dat/ip_v6_built_in.mmdb")))
+                    .loadDataFilePrivateV6(new FileInputStream(new File("dat/ip_v6_user_defined.mmdb")))
+                    .loadAsnDataFile(new FileInputStream(new File("dat/asn_v4.mmdb")))
+                    .loadAsnDataFileV6(new FileInputStream(new File("dat/asn_v6.mmdb")))
+                    .build();
+        }catch (FileNotFoundException e) {
+          logger.error(" File is not found:", e);
+        }
+        return ipLookupV2;
+    }
     @Test
     public void testPrivateIP() {
         Assert.assertEquals(ipLookup.countryLookup("192.168.10.123"), "Private IP");
@@ -29,41 +56,29 @@ public class IpLookupV2Test {
 
     @Test(expected=IllegalArgumentException.class)
     public void testIpLookupIllegalArguments(){
-        ipLookup.countryLookup("");
-        ipLookup.countryLookup("123");
-
+        ipLookup.countryLookup("116.178.179.336");
     }
 
     @Test
-    public void testIpLookup() {
-        logger.info(ipLookup.locationLookupDetail("116.178.179.36"));
-        logger.info(ipLookup.countryLookup("192.168.10.1"));
-        logger.info(ipLookup.administrativeAreaLookupDetail("1.1.1.1"));
-        logger.info(ipLookup.locationLookupDetail("220.158.208.254"));
-        logger.info(ipLookup.administrativeAreaLookupDetail("220.158.208.254"));
-        logger.info(ipLookup.locationLookupDetail("220.158.208.254"));
-        logger.info( ipLookup.provinceLookup("217.71.108.0"));
-        logger.info(ipLookup.cityLookup("217.71.108.0"));
-        logger.info(ipLookup.cityLookupDetail("217.71.108.0"));
+    public void testIpLookupOutput() {
+        logger.info(ipLookup.countryLookup("120.221.155.223"));
+        logger.info(ipLookup.provinceLookup("120.221.155.223"));
         logger.info(ipLookup.cityLookup("120.221.155.223"));
-        logger.info(ipLookup.countryLookup("2001:4860:4860::8888 "));
-        logger.info(ipLookup.latLngLookup("217.71.108.0"));
         logger.info(ipLookup.cityLookupDetail("120.221.155.223"));
+        logger.info(ipLookup.administrativeAreaLookupDetail("120.221.155.223"));
+        logger.info(ipLookup.locationLookupDetail("120.221.155.223"));
+        logger.info(ipLookup.latLngLookup("120.221.155.223"));
         logger.info(ipLookup.cityLatLngLookup("120.221.155.223"));
-        logger.info(ipLookup.cityLookupDetail("202.106.0.20"));
-        logger.info(ipLookup.ispLookup("123.139.226.221"));
-        logger.info(ipLookup.organizationLookup("123.139.226.221"));
-        logger.info(ipLookup.ispLookup("116.178.179.36"));
-        logger.info(ipLookup.organizationLookup("116.178.179.36"));
-        logger.info(ipLookup.infoLookupToJson("192.168.10.1"));
+        logger.info(ipLookup.ispLookup("120.221.155.223"));
+        logger.info(ipLookup.organizationLookup("120.221.155.223"));
+        logger.info(ipLookup.asnLookup("120.221.155.223"));
         logger.info(ipLookup.infoLookupToCSV("120.221.155.223"));
         logger.info(ipLookup.infoLookupToJson("120.221.155.223"));
-
     }
 
 
  @Test
- public void testAsnLookup() {
+ public void testAsnLookupOutput() {
 
   logger.info(ipLookup.asnLookup("120.221.155.223"));
   logger.info(ipLookup.asnLookup("203.187.160.135"));
@@ -71,8 +86,7 @@ public class IpLookupV2Test {
   logger.info(ipLookup.asnLookupInfo("116.128.133.102"));
   logger.info(ipLookup.asnLookupDetail("116.128.133.102"));
   logger.info(ipLookup.asnLookup("2001:4860:4860::8888"));
-  logger.info(ipLookup.asnLookup("0.1.1.1"));
-
+  logger.info(ipLookup.asnLookup("1.1.1.1"));
 
  }