Merge pull request #49 from lexiLiu/1.0.1.0

[update]

Author: jianbin2001

CHANGES.md

@@ -1,5 +1,15 @@
 # Release Notes
 
+## 1.0.1.0
+
+### update
+
+* 支持jdk版本 1.8及以上版本，不再支持jdk1.6
+* 重试支持切换域名
+* 支持设置接口维度的超时时间
+* 修改默认的连接超时时间，60s改为10s
+* 内部异常，会拼接到apiResult的msg上，eg. 原来接口超时返回`{"code":5000, "message":"http error::5000"}`，修改后返回`{"code":5000, "message":"http error:Read timed out::5000"}
+
 ## 1.0.0.17
 
 ### update

README.md

@@ -7,7 +7,7 @@
 
 
 ## 环境要求
-1. 需要配合`JDK 1.6`或其以上版本。
+1. 需要配合`JDK 1.8`或其以上版本。
 
 2. 使用`个推PUSH SDK`前，您需要先前往[个推开发者中心](https://dev.getui.com) 完成开发者接入的一些准备工作，创建应用。详细见[操作步骤](https://docs.getui.com/getui/start/devcenter/#1)
 
@@ -22,7 +22,7 @@
 <dependency>
     <groupId>com.getui.push</groupId>
     <artifactId>restful-sdk</artifactId>
-    <version>1.0.0.17</version>
+    <version>1.0.1.0</version>
 </dependency>
 ```
 
@@ -46,7 +46,7 @@ public class TestCreatApi {
         apiConfiguration.setAppId("xxx");
         apiConfiguration.setAppKey("xxx");
         apiConfiguration.setMasterSecret("xxx");
-        // 接口调用前缀，请查看文档: 接口调用规范 -> 接口前缀, 可不填写appId
+        // 接口调用前缀，请查看文档: 接口调用规范 -> 接口前缀
         apiConfiguration.setDomain("https://restapi.getui.com/v2/");
         // 实例化ApiHelper对象，用于创建接口对象
         ApiHelper apiHelper = ApiHelper.build(apiConfiguration);
@@ -56,6 +56,24 @@ public class TestCreatApi {
 }
 ```
 
+###### 已支持的配置项说明
+| 通过代码修改 | 启动项 | 默认值 | 说明 |
+| --- | --- | --- | --- |
+| gtApiConfiguration.setSoTimeout(30000); | \-Dgt.socket.timeout=30000 | 30000 | 修改全局的套接字读超时时间，默认30s，单位ms |
+| gtApiConfiguration.setCustomSocketTimeout(PushApi.singleCidUri, 3000); | \-D/push/single/cid= | 默认为gt.socket.timeout的值 | cid单推接口设置套接字读取超时时间，单位ms |
+| gtApiConfiguration.setCustomSocketTimeout(PushApi.singleAliasUri, 3000); | \-D/push/single/alias= | 默认为gt.socket.timeout的值 | 别名单推接口设置套接字读取超时时间，单位ms |
+| gtApiConfiguration.setCustomSocketTimeout(PushApi.singleBatchCidUri, 6000); | \-D/push/single/batch/cid= | 默认为gt.socket.timeout的值 | cid批量单推接口设置套接字读取超时时间，单位ms |
+| gtApiConfiguration.setCustomSocketTimeout(PushApi.singleBatchAliasUri, 6000); | \-D/push/single/batch/alias= | 默认为gt.socket.timeout的值 | 别名批量单推接口设置套接字读取超时时间，单位ms |
+| gtApiConfiguration.setCustomSocketTimeout(PushApi.pushListMessageUri, 3000); | \-D/push/list/message= | 默认为gt.socket.timeout的值 | 保存列表推消息体接口设置套接字读取超时时间，单位ms |
+| gtApiConfiguration.setCustomSocketTimeout(PushApi.pushListCidUri, 6000); | \-D/push/list/cid= | 默认为gt.socket.timeout的值 | cid列表推接口设置套接字读取超时时间，单位ms |
+| gtApiConfiguration.setCustomSocketTimeout(PushApi.pushListAliasUri, 6000); | \-D/push/list/alias= | 默认为gt.socket.timeout的值 | 别名列表推接口设置套接字读取超时时间，单位ms |
+| gtApiConfiguration.setConnectTimeout(10000); | \-Dgt.connect.timeout=10000 | 10000 | 修改连接超时时间，默认10s，单位ms |
+| gtApiConfiguration.setMaxHttpTryTime(1); | \-Dgt.max.http.try.times=1 | 1 |设置重试次数；<br>上述配置项设为1时，如果请求失败(超时或其他异常)，sdk内部会重试1次，重试可能造成消息重复，建议客户配合消息幂等使用，详见文档：[消息覆盖https://docs.getui.com/getui/server/rest_v2/advanced/](https://docs.getui.com/getui/server/rest_v2/advanced/)；<br>用户不接受重试的，可将此值改为0|
+| gtApiConfiguration.setOpenAnalyseStableDomainSwitch(true); | \-Dgt.analyse.stable.domain.switch=true | true | 是否开启稳定域名检测 |
+| gtApiConfiguration.setMaxFailedNum(10); | \-Dgt.max.failed.num=10 | 10 | 开启稳定域名检测时生效，单位时间内失败总次数阈值，达到阈值会切换域名 |
+| gtApiConfiguration.setCheckMaxFailedNumInterval(3000); | \-Dgt.check.max.failed.num.interval=3000 | 3000 | 开启稳定域名检测时生效，修改上述阈值的单位时间，单位ms |
+| gtApiConfiguration.setContinuousFailedNum(3); | \-Dgt.continuous.failed.num=3 | 3 | 开启稳定域名检测时生效，连续失败次数达到阈值会切换域名 |
+
 ##### 使用示例：**推送API**_根据cid进行单推
 
 ```java
@@ -176,7 +194,7 @@ public class TestUserApi {
 ### 设置代理
 > 当需要使用代理进行http访问时，可以参考如下设置
 
-```java
+```
         GtApiConfiguration apiConfiguration = new GtApiConfiguration();
         //设置代理对象，参数依次为host、端口、鉴权账户、鉴权密码。其中鉴权账户密码可选
         GtHttpProxyConfig proxyConfig = new GtHttpProxyConfig("xxx",xxx,"xxx","xxx");

pom.xml

@@ -7,7 +7,7 @@
     <groupId>com.getui.push</groupId>
     <artifactId>restful-sdk</artifactId>
     <packaging>jar</packaging>
-    <version>1.0.0.17</version>
+    <version>1.0.1.0</version>
     <url>https://github.com/GetuiLaboratory/getui-pushapi-java-client-v2</url>
     <name>Getui Push API Java Client</name>
     <description>Getui's officially supported Java client library for accessing Getui APIs.</description>
@@ -80,7 +80,7 @@
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <version>4.8.2</version>
-            <scope>provided</scope>
+            <scope>test</scope>
         </dependency>
 
     </dependencies>
@@ -91,8 +91,8 @@
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>2.3.2</version>
                 <configuration>
-                    <source>1.6</source>
-                    <target>1.6</target>
+                    <source>1.8</source>
+                    <target>1.8</target>
                     <encoding>utf-8</encoding>
                 </configuration>
             </plugin>

src/main/java/com/getui/push/v2/sdk/ApiHelper.java

@@ -7,6 +7,7 @@
 import com.getui.push.v2.sdk.core.DefaultJson;
 import com.getui.push.v2.sdk.core.client.DefaultApiClient;
 import com.getui.push.v2.sdk.core.factory.GtApiProxyFactory;
+import com.getui.push.v2.sdk.core.handler.GtInterceptor;
 
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -37,6 +38,14 @@ public static ApiHelper build(GtApiConfiguration configuration) {
      * @return
      */
     public static ApiHelper build(GtApiConfiguration configuration, IJson json) {
+        return build(configuration, json, null);
+    }
+
+    /**
+     * @param configuration 配置信息类
+     * @return
+     */
+    public static ApiHelper build(GtApiConfiguration configuration, IJson json, GtInterceptor interceptor) {
         Assert.notNull(configuration, "configuration");
         configuration.check();
         String key = configuration.keyOfCache();
@@ -53,6 +62,9 @@ public static ApiHelper build(GtApiConfiguration configuration, IJson json) {
                 return apiHelper;
             }
             final DefaultApiClient defaultApiClient = DefaultApiClient.build(configuration, json);
+            if (interceptor != null) {
+                defaultApiClient.addGtInterceptor(interceptor);
+            }
             GtApiProxyFactory factory = GtApiProxyFactory.build(defaultApiClient);
             final AuthApi authApi = factory.createProxy(AuthApi.class);
             defaultApiClient.setAuthApiAndAuth(authApi);

src/main/java/com/getui/push/v2/sdk/GtApiConfiguration.java

@@ -1,11 +1,19 @@
 package com.getui.push.v2.sdk;
 
+import com.getui.push.v2.sdk.anno.method.GtDelete;
+import com.getui.push.v2.sdk.anno.method.GtGet;
+import com.getui.push.v2.sdk.anno.method.GtPost;
+import com.getui.push.v2.sdk.anno.method.GtPut;
+import com.getui.push.v2.sdk.api.PushApi;
 import com.getui.push.v2.sdk.common.Assert;
+import com.getui.push.v2.sdk.core.Configs;
 import org.apache.http.client.config.RequestConfig;
 
 import java.util.Arrays;
 import java.util.HashSet;
+import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * 应用相关配置信息
@@ -28,7 +36,7 @@ public class GtApiConfiguration {
      */
     private String masterSecret;
     /**
-     * 接口调用前缀, 可不包含{@link #appId}
+     * 接口调用前缀, 不带{@link #appId}
      * eg. https://restapi.getui.com/v2
      */
     private String domain = "https://restapi.getui.com/v2";
@@ -70,20 +78,23 @@ public class GtApiConfiguration {
      *
      * @see RequestConfig#getSocketTimeout()
      */
+    private final String SOCKET_TIMEOUT_KEY = "gt.socket.timeout";
     private int soTimeout = 30000;
     /**
      * http连接超时时间，单位ms
      *
      * @see RequestConfig#getConnectTimeout()
      */
-    private int connectTimeout = 60000;
+    private final String CONNECT_TIMEOUT_KEY = "gt.connect.timeout";
+    private int connectTimeout = 10000;
     /**
      * 从连接池中获取http连接的超时时间，单位ms
      */
     private int connectionRequestTimeout = 0;
     /**
-     * http请求失败，最大尝试次数
+     * http请求失败，最大尝试次数，默认重试1次，0表示不重试
      */
+    private final String MAX_HTTP_TRY_TIME_KEY = "gt.max.http.try.times";
     private int maxHttpTryTime = 1;
     /**
      * 保持长连接的时长，最大{@link #MAX_KEEP_ALIVE_SECONDS}
@@ -101,6 +112,33 @@ public class GtApiConfiguration {
      */
     private GtHttpProxyConfig proxyConfig;
 
+    /**
+     * 存储uri和socketTimeout，支持设置接口维度socketTimeout
+     */
+    private Map<String, Integer> uriToSocketTimeoutMap = new ConcurrentHashMap<>();
+    /**
+     * 最大失败次数，单位时间内达到此阈值，切换域名，默认10次
+     */
+    public final static String MAX_FAILED_NUM_KEY = "gt.max.failed.num";
+    private int maxFailedNum = 10;
+
+    /**
+     * 连续失败次数达到阈值，切换域名，默认3
+     */
+    public final static String CONTINUOUS_FAILED_NUM_KEY = "gt.continuous.failed.num";
+    private int continuousFailedNum = Configs.MAX_FAIL_CONTINUOUSLY;
+
+    /**
+     * 重置最大失败次数的时间间隔，默认3s
+     */
+    public final static String CHECK_MAX_FAILED_NUM_INTERVAL_KEY = "gt.check.max.failed.num.interval";
+    private long checkMaxFailedNumInterval = 3000;
+    /**
+     * 域名检测的超时时间，单位ms，默认100ms
+     */
+    public final static String HTTP_CHECK_TIMEOUT_KEY = "gt.http.check.timeout";
+    private int httpCheckTimeout = 100;
+
     /**
      * @param domain 接口调用前缀, 可不含{@link #appId}
      */
@@ -209,15 +247,15 @@ public void setCheckHealthInterval(long checkHealthInterval) {
     }
 
     public int getSoTimeout() {
-        return soTimeout;
+        return Integer.getInteger(SOCKET_TIMEOUT_KEY, soTimeout);
     }
 
     public void setSoTimeout(int soTimeout) {
         this.soTimeout = soTimeout;
     }
 
     public int getConnectTimeout() {
-        return connectTimeout;
+        return Integer.getInteger(CONNECT_TIMEOUT_KEY, connectTimeout);
     }
 
     public void setConnectTimeout(int connectTimeout) {
@@ -233,7 +271,7 @@ public void setConnectionRequestTimeout(int connectionRequestTimeout) {
     }
 
     public int getMaxHttpTryTime() {
-        return maxHttpTryTime;
+        return Integer.getInteger(MAX_HTTP_TRY_TIME_KEY, maxHttpTryTime);
     }
 
     public void setMaxHttpTryTime(int maxHttpTryTime) {
@@ -281,6 +319,38 @@ public void setProxyConfig(GtHttpProxyConfig proxyConfig) {
         this.proxyConfig = proxyConfig;
     }
 
+    public int getContinuousFailedNum() {
+        return Integer.getInteger(CONTINUOUS_FAILED_NUM_KEY, continuousFailedNum);
+    }
+
+    public void setContinuousFailedNum(int continuousFailedNum) {
+        this.continuousFailedNum = continuousFailedNum;
+    }
+
+    public int getMaxFailedNum() {
+        return Integer.getInteger(MAX_FAILED_NUM_KEY, maxFailedNum);
+    }
+
+    public void setMaxFailedNum(int maxFailedNum) {
+        this.maxFailedNum = maxFailedNum;
+    }
+
+    public long getCheckMaxFailedNumInterval() {
+        return Long.getLong(CHECK_MAX_FAILED_NUM_INTERVAL_KEY, checkMaxFailedNumInterval);
+    }
+
+    public void setCheckMaxFailedNumInterval(long checkMaxFailedNumInterval) {
+        this.checkMaxFailedNumInterval = checkMaxFailedNumInterval;
+    }
+
+    public int getHttpCheckTimeout() {
+        return Integer.getInteger(HTTP_CHECK_TIMEOUT_KEY, httpCheckTimeout);
+    }
+
+    public void setHttpCheckTimeout(int httpCheckTimeout) {
+        this.httpCheckTimeout = httpCheckTimeout;
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) {
@@ -329,4 +399,30 @@ public String prefixOfKey() {
         return String.format("%s|%s", this.getAppId(), this.getAppKey());
     }
 
+    /**
+     * 针对接口设置超时时间，可根据监控修改合理值
+     *
+     * @param uri           {@link GtGet#uri()}, {@link GtPost#uri()}, {@link GtDelete#uri()}, {@link GtPut#uri()}
+     * @param socketTimeout {@link RequestConfig#getSocketTimeout()}，单位: ms
+     */
+    public void setCustomSocketTimeout(String uri, int socketTimeout) {
+        this.uriToSocketTimeoutMap.put(uri, socketTimeout);
+    }
+
+    public void resetConnectAndSocketTimeout() {
+        setConnectTimeout(3000);
+        setCustomSocketTimeout(PushApi.singleCidUri, 3000);
+        setCustomSocketTimeout(PushApi.singleAliasUri, 3000);
+        setCustomSocketTimeout(PushApi.singleBatchCidUri, 6000);
+        setCustomSocketTimeout(PushApi.singleBatchAliasUri, 6000);
+        setCustomSocketTimeout(PushApi.singleBatchAliasUri, 6000);
+        setCustomSocketTimeout(PushApi.pushListMessageUri, 3000);
+        setCustomSocketTimeout(PushApi.pushListCidUri, 6000);
+        setCustomSocketTimeout(PushApi.pushListAliasUri, 6000);
+    }
+
+    public int getCustomSocketTimeout(String uri) {
+        return Integer.getInteger(uri, this.uriToSocketTimeoutMap.getOrDefault(uri, 0));
+    }
+
 }