update version to 5.16.3

Author: lilinjun1884

pom.xml

@@ -3,7 +3,7 @@
   <modelVersion>4.0.0</modelVersion>  
   <groupId>com.aliyun.openservices</groupId>  
   <artifactId>tablestore</artifactId>  
-  <version>5.16.2</version>
+  <version>5.16.3</version>
   <packaging>jar</packaging>  
   <name>AliCloud TableStore SDK for Java</name>  
   <url>http://www.aliyun.com</url>  

src/main/java/com/alicloud/openservices/tablestore/core/Constants.java

@@ -5,7 +5,7 @@
 public class Constants {
     // ALL HTTP HEADERS SHOULD BE DEFINED IN LOWERCASE
     // request headers
-    public static final String USER_AGENT = "ots-java-sdk 5.16.1";
+    public static final String USER_AGENT = "ots-java-sdk 5.16.3";
     public static final String OTS_HEADER_API_VERSION = "x-ots-apiversion";
     public static final String OTS_HEADER_ACCESS_KEY_ID = "x-ots-accesskeyid";
     public static final String OTS_HEADER_OTS_CONTENT_MD5 = "x-ots-contentmd5";

src/main/java/com/alicloud/openservices/tablestore/core/http/CachedDnsResolver.java

@@ -2,6 +2,9 @@
 
 import java.net.InetAddress;
 import java.net.UnknownHostException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;
 
 import com.google.common.cache.Cache;
@@ -17,6 +20,7 @@
 
 public class CachedDnsResolver extends SystemDefaultDnsResolver {
     private final Logger logger = LoggerFactory.getLogger(CachedDnsResolver.class);
+    private static final int SCHEDULED_CORE_POOL_SIZE = 2;
     private final Cache<String, InetAddress[]> dnsCache;
 
     public CachedDnsResolver(int maxSize, int expireAfterWriteSec, int refreshAfterWriteSec) {
@@ -29,29 +33,29 @@ public void onRemoval(RemovalNotification<String, InetAddress[]> notify) {
             }
         };
 
+        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(SCHEDULED_CORE_POOL_SIZE, new ThreadFactory() {
+            @Override
+            public Thread newThread(Runnable r) {
+                Thread thread = new Thread(r);
+                thread.setName("refresh-dns-cache-" + thread.getId());
+                return thread;
+            }
+        });
         dnsCache = CacheBuilder.newBuilder()
                 .maximumSize(maxSize)
                 .weakKeys()
                 .expireAfterWrite(expireAfterWriteSec, TimeUnit.SECONDS)
                 .refreshAfterWrite(refreshAfterWriteSec, TimeUnit.SECONDS)
                 .removalListener(rmListener)
-                .build(new CacheLoader<String, InetAddress[]>() {
+                .build(CacheLoader.asyncReloading(new CacheLoader<String, InetAddress[]>() {
                     @Override
                     public InetAddress[] load(String host) throws Exception {
                         if (logger.isDebugEnabled()) {
                             logger.debug("dns cache load, host: {}", host);
                         }
                         return CachedDnsResolver.super.resolve(host);
                     }
-
-                    @Override
-                    public ListenableFuture<InetAddress[]> reload(String host, InetAddress[] oldValue) throws Exception {
-                        if (logger.isDebugEnabled()) {
-                            logger.debug("dns cache reload, host: {}", host);
-                        }
-                        return super.reload(host, oldValue);
-                    }
-                });
+                }, scheduler));
     }
 
     public long cacheSize() {

src/test/java/com/alicloud/openservices/tablestore/core/http/CachedDnsResolverTest.java

@@ -2,9 +2,21 @@
 
 import java.net.InetAddress;
 import java.net.UnknownHostException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
 
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.RemovalListener;
+import com.google.common.cache.RemovalNotification;
 import junit.framework.TestCase;
+import org.apache.http.impl.conn.SystemDefaultDnsResolver;
 import org.junit.Assert;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 
 public class CachedDnsResolverTest extends TestCase {
@@ -30,4 +42,86 @@ public void testResolve() throws InterruptedException, UnknownHostException {
             dnsResolver.clear();
         }
     }
-}
+
+    public void testAsyncResolve() throws UnknownHostException, InterruptedException {
+        TestCachedDnsResolver resolver = new TestCachedDnsResolver(
+                100, 20, 3);
+
+        for (int i = 0; i < 10; ++i) {
+            long start = System.currentTimeMillis();
+            InetAddress[] resolve = resolver.resolve("taobao.com");
+            long end = System.currentTimeMillis();
+            System.out.println(end - start);
+
+            Thread.sleep(2000);
+        }
+    }
+}
+
+class BaseResolver extends SystemDefaultDnsResolver {
+
+    @Override
+    public InetAddress[] resolve(String host) throws UnknownHostException {
+        try {
+            Thread.sleep(5000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+        return super.resolve(host);
+    }
+}
+
+class TestCachedDnsResolver extends BaseResolver {
+    private final Logger logger = LoggerFactory.getLogger(CachedDnsResolverTest.class);
+    private final Cache<String, InetAddress[]> dnsCache;
+
+    public TestCachedDnsResolver(int maxSize, int expireAfterWriteSec, int refreshAfterWriteSec) {
+        RemovalListener<String, InetAddress[]> rmListener = new RemovalListener<String, InetAddress[]>() {
+            @Override
+            public void onRemoval(RemovalNotification<String, InetAddress[]> notify) {
+                logger.info("dns cache remove host key: {}, reason: {}", notify.getKey(), notify.getCause().name());
+            }
+        };
+
+        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2, new ThreadFactory() {
+            @Override
+            public Thread newThread(Runnable r) {
+                Thread thread = new Thread(r);
+                thread.setName("refresh-dns-cache-" + thread.getId());
+                return thread;
+            }
+        });
+        dnsCache = CacheBuilder.newBuilder()
+                .maximumSize(maxSize)
+                .weakKeys()
+                .expireAfterWrite(expireAfterWriteSec, TimeUnit.SECONDS)
+                .refreshAfterWrite(refreshAfterWriteSec, TimeUnit.SECONDS)
+                .removalListener(rmListener)
+                .build(CacheLoader.asyncReloading(new CacheLoader<String, InetAddress[]>() {
+                    @Override
+                    public InetAddress[] load(String host) throws Exception {
+                        logger.info("dns cache load, host: {}", host);
+                        return TestCachedDnsResolver.super.resolve(host);
+                    }
+                }, scheduler));
+    }
+
+
+    @Override
+    public InetAddress[] resolve(String host) throws UnknownHostException {
+        InetAddress[] cached = dnsCache.getIfPresent(host);
+        logger.info("dns resolve, host: {}, has cached: {}", host, cached!=null);
+        if (cached==null) {
+            InetAddress[] realtime = super.resolve(host);
+            if (realtime!=null) {
+                dnsCache.put(host, realtime);
+            }
+            return realtime;
+        }
+        return cached;
+    }
+
+    public void clear() {
+        dnsCache.cleanUp();
+    }
+}