阿里云API网关调用示例

文档

阿里云API网关文档

错误代码表

如何获取错误信息

java

SDK调用

maven

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<dependency>
<groupId>com.aliyun.api.gateway</groupId>
<artifactId>sdk-core-java</artifactId>
<version>1.1.0</version>
</dependency>
<dependency>
<groupId>com.monitorjbl</groupId>
<artifactId>xlsx-streamer</artifactId>
<version>1.2.0</version>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.2</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.28</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.12</version>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-core</artifactId>
<version>1.1.2</version>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.1.3</version>
</dependency>

api层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
import com.alibaba.cloudapi.sdk.client.ApacheHttpClient;
import com.alibaba.cloudapi.sdk.enums.HttpMethod;
import com.alibaba.cloudapi.sdk.enums.Scheme;
import com.alibaba.cloudapi.sdk.model.ApiRequest;
import com.alibaba.cloudapi.sdk.model.ApiCallback;
import com.alibaba.cloudapi.sdk.model.ApiResponse;
import com.alibaba.cloudapi.sdk.model.HttpClientBuilderParams;

import javax.net.ssl.*;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.X509Certificate;


public class HttpApiClient extends ApacheHttpClient{

/**
* 初始化请求参数
* @param isHttps 是否为https请求
* @param host
* @param appKey
* @param appSecret
*/
public HttpApiClient(boolean isHttps, String host, String appKey, String appSecret){
// HTTP/HTTPS Client init
HttpClientBuilderParams httpParam = new HttpClientBuilderParams();
httpParam.setHost(host);
httpParam.setAppKey(appKey);
httpParam.setAppSecret(appSecret);
if(isHttps){
initHttpsClient(httpParam);
} else {
initHttpClient(httpParam);
}
super.init(httpParam);
}

/**
* 初始化HTTP请求参数
* @param httpParam
*/
private void initHttpClient(HttpClientBuilderParams httpParam){
httpParam.setScheme(Scheme.HTTP);
}

/**
* 初始化HTTPS请求参数
* @param httpsParam
*/
private void initHttpsClient(HttpClientBuilderParams httpsParam){
httpsParam.setScheme(Scheme.HTTPS);
/**
* HTTPS request use DO_NOT_VERIFY mode only for demo
* Suggest verify for security
*/
X509TrustManager xtm = new X509TrustManager() {
@Override
public void checkClientTrusted(X509Certificate[] chain, String authType) {
}

@Override
public void checkServerTrusted(X509Certificate[] chain, String authType) {
}

@Override
public X509Certificate[] getAcceptedIssuers() {
X509Certificate[] x509Certificates = new X509Certificate[0];
return x509Certificates;
}
};

SSLContext sslContext = null;
try {
sslContext = SSLContext.getInstance("SSL");
sslContext.init(null, new TrustManager[]{xtm}, new SecureRandom());
} catch (NoSuchAlgorithmException e) {
throw new RuntimeException(e);
} catch (KeyManagementException e) {
throw new RuntimeException(e);
}
HostnameVerifier DO_NOT_VERIFY = new HostnameVerifier() {
@Override
public boolean verify(String hostname, SSLSession session) {
return true;
}
};

httpsParam.setSslSocketFactory(sslContext.getSocketFactory());
httpsParam.setX509TrustManager(xtm);
httpsParam.setHostnameVerifier(DO_NOT_VERIFY);
}

/**
* 同步接口
* @param body
* @return
*/
public ApiResponse send(byte[] body) {
String path = "/test/send.json";
ApiRequest request = new ApiRequest(HttpMethod.POST_BODY , path, body);
return sendSyncRequest(request);
}

/**
* 异步接口
* @param body
* @param apiCallback
*/
public void sendAnsy(byte[] body, ApiCallback apiCallback) {
String path = "/test/send.json";
ApiRequest request = new ApiRequest(HttpMethod.POST_BODY , path, body);
sendAsyncRequest(request, apiCallback);
}
}

服务层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
import com.alibaba.cloudapi.sdk.constant.SdkConstant;
import com.alibaba.cloudapi.sdk.model.ApiCallback;
import com.alibaba.cloudapi.sdk.model.ApiRequest;
import com.alibaba.cloudapi.sdk.model.ApiResponse;
import com.alibaba.fastjson.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


public class TestApiService {

private static Logger log = LoggerFactory.getLogger(TestApiService.class);

private final HttpApiClient httpApiClient;

/**
* 初始化请求参数
* @param isHttps 是否为https请求
* @param host
* @param appKey
* @param appSecret
*/
public TestApiService(boolean isHttps, String host, String appKey, String appSecret){
this.httpApiClient = new HttpApiClient(isHttps, host, appKey, appSecret);
}

/**
* 同步接口
* @return
*/
public JSONObject send(){
String body = "{}";

ApiResponse response = this.httpApiClient.send(body.getBytes(SdkConstant.CLOUDAPI_ENCODING));
JSONObject result = JSONObject.parseObject(new String(response.getBody()));
return result;
}

/**
* 异步接口
*/
public void sendAnsy(){
String body = "{}";
this.httpApiClient.sendAnsy(body.getBytes(SdkConstant.CLOUDAPI_ENCODING), new ApiCallback() {
@Override
public void onFailure(ApiRequest request, Exception e) {
log.error(e.getMessage(),e);
}

@Override
public void onResponse(ApiRequest request, ApiResponse response) {
JSONObject result = JSONObject.parseObject(new String(response.getBody()));
log.info(result.toJSONString());
}
});
}

public static void main(String[] args) {
boolean isHttps = false;
String host = "";
String appKey = "";
String appSecret = "";
TestApiService service = new TestApiService(isHttps, host, appKey, appSecret);
service.sendAnsy();
}
}

手动请求调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
import java.nio.charset.StandardCharsets;
import java.util.Date;
import java.util.Map;
import java.util.TreeMap;
import java.util.UUID;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

import org.apache.commons.codec.binary.Base64;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.io.IOUtils;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClients;

public class TestHttpClient {
private static final String HTTP_METHOD = "POST";
private static final String ACCEPT_VALUE = "application/json;charset=utf-8";
private static final String CONTENT_TYPE_VALUE = "application/json;charset=utf-8";
private static final String HmacSHA256 = "HmacSHA256";

public static void main(String[] args) throws Exception {
test();
}

private static void test() throws Exception {
String appKey = "";
String appSecret = "";
String host = "";
String url = "";
String body = "";

// 计算签名
Date date = new Date();
String uuid = UUID.randomUUID().toString();
String sign = getSign(appKey, appSecret, date, url, body, uuid);

HttpClient httpClient = HttpClients.createDefault();
HttpPost post = new HttpPost(host + url);
// 设置请求header
post.setHeader("date", String.valueOf(date.getTime()));
post.setHeader("accept", ACCEPT_VALUE);
post.setHeader("content-type", CONTENT_TYPE_VALUE);
post.setHeader("x-ca-key", appKey);
post.setHeader("x-ca-signature", sign);
post.setHeader("x-ca-timestamp", String.valueOf(date.getTime()));
post.setHeader("x-ca-nonce", uuid);
post.setHeader("content-md5", getBaseMD5(body));
post.setHeader("x-ca-signature-headers", "x-ca-nonce,x-ca-timestamp,x-ca-key");

StringEntity entity = new StringEntity(body, StandardCharsets.UTF_8);
post.setEntity(entity);

System.out.println("entity:" + entity);

HttpResponse response = httpClient.execute(post);

System.out.println("response:" + response);
System.out.println("Content: " + IOUtils.toString(response.getEntity().getContent()));
}

/**
* 获取验签值
*/
private static String getSign(String appKey, String appSecret, Date date, String url, String body, String uuid) throws Exception {
String contentMD5 = getBaseMD5(body);
String formatDate = String.valueOf(date.getTime());
String headers = getSignHeaders(appKey, date, uuid);

StringBuilder builder = new StringBuilder();
builder.append(HTTP_METHOD).append("\n");
builder.append(ACCEPT_VALUE).append("\n");
builder.append(contentMD5).append("\n");
builder.append(CONTENT_TYPE_VALUE).append("\n");
builder.append(formatDate).append("\n");
builder.append(headers);
builder.append(url);

String stringToSign = builder.toString();

Mac hmacSha256 = Mac.getInstance(HmacSHA256);
byte[] keyBytes = appSecret.getBytes(StandardCharsets.UTF_8);
hmacSha256.init(new SecretKeySpec(keyBytes, 0, keyBytes.length, HmacSHA256));
byte[] value = hmacSha256.doFinal(stringToSign.getBytes(StandardCharsets.UTF_8));
return Base64.encodeBase64String(value);
}

/**
* 输入内容md5后再base64
*/
private static String getBaseMD5(String body) {
byte[] md5Bytes = DigestUtils.md5(body.getBytes(StandardCharsets.UTF_8));
final Base64 base64 = new Base64();
return new String(base64.encode(md5Bytes));
}

/**
* 组装需要进行sign验签的header
*/
private static String getSignHeaders(String appKey, Date date, String uuid) {
long timestamp = date.getTime();
Map<String, String> map = new TreeMap<>();
map.put("x-ca-key", appKey);
map.put("x-ca-nonce", uuid);
map.put("x-ca-timestamp", String.valueOf(timestamp));

StringBuilder builder = new StringBuilder();
for (String key : map.keySet()) {
String value = map.getOrDefault(key, "");
String header = String.format("%s:%s\n", key, value);
builder.append(header);
}
return builder.toString();
}
}
>