package com.hikvision.artemis.sdk.util; import java.util.Collections; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import java.util.TreeMap; import javax.crypto.Mac; import javax.crypto.spec.SecretKeySpec; import org.apache.commons.codec.binary.Base64; import org.apache.commons.lang3.StringUtils; public class SignUtil { public static String sign(String secret, String method, String path, Map<String, String> headers, Map<String, String> querys, Map<String, String> bodys, List<String> signHeaderPrefixList) { try { Mac hmacSha256 = Mac.getInstance("HmacSHA256"); byte[] keyBytes = secret.getBytes("UTF-8"); hmacSha256.init(new SecretKeySpec(keyBytes, 0, keyBytes.length, "HmacSHA256")); return new String(Base64.encodeBase64(hmacSha256 .doFinal(buildStringToSign(method, path, headers, querys, bodys, signHeaderPrefixList) .getBytes("UTF-8"))), "UTF-8"); } catch (Exception e) { throw new RuntimeException(e); } } private static String buildStringToSign(String method, String path, Map<String, String> headers, Map<String, String> querys, Map<String, String> bodys, List<String> signHeaderPrefixList) { StringBuilder sb = new StringBuilder(); sb.append(method.toUpperCase()).append(" "); if (null != headers) { if (null != headers.get("Accept")) { sb.append((String)headers.get("Accept")); sb.append(" "); } if (null != headers.get("Content-MD5")) { sb.append((String)headers.get("Content-MD5")); sb.append(" "); } if (null != headers.get("Content-Type")) { sb.append((String)headers.get("Content-Type")); sb.append(" "); } if (null != headers.get("Date")) { sb.append((String)headers.get("Date")); sb.append(" "); } } sb.append(buildHeaders(headers, signHeaderPrefixList)); sb.append(buildResource(path, querys, bodys)); return sb.toString(); } private static String buildResource(String path, Map<String, String> querys, Map<String, String> bodys) { StringBuilder sb = new StringBuilder(); if (!StringUtils.isBlank(path)) { sb.append(path); } Map<String, String> sortMap = new TreeMap(); if (null != querys) { for (Map.Entry<String, String> query : querys.entrySet()) { if (!StringUtils.isBlank((CharSequence)query.getKey())) { sortMap.put(query.getKey(), query.getValue()); } } } if (null != bodys) { for (??? = bodys.entrySet().iterator(); ???.hasNext();) { body = (Map.Entry)???.next(); if (!StringUtils.isBlank((CharSequence)body.getKey())) { sortMap.put(body.getKey(), body.getValue()); } } } Map.Entry<String, String> body; StringBuilder sbParam = new StringBuilder(); for (Map.Entry<String, String> item : sortMap.entrySet()) { if (!StringUtils.isBlank((CharSequence)item.getKey())) { if (0 < sbParam.length()) { sbParam.append("&"); } sbParam.append((String)item.getKey()); if (!StringUtils.isBlank((CharSequence)item.getValue())) { sbParam.append("=").append((String)item.getValue()); } } } if (0 < sbParam.length()) { sb.append("?"); sb.append(sbParam); } return sb.toString(); } private static String buildHeaders(Map<String, String> headers, List<String> signHeaderPrefixList) { StringBuilder sb = new StringBuilder(); if (null != signHeaderPrefixList) { signHeaderPrefixList.remove("x-ca-signature"); signHeaderPrefixList.remove("Accept"); signHeaderPrefixList.remove("Content-MD5"); signHeaderPrefixList.remove("Content-Type"); signHeaderPrefixList.remove("Date"); Collections.sort(signHeaderPrefixList); } if (null != headers) { Map<String, String> sortMap = new TreeMap(); sortMap.putAll(headers); StringBuilder signHeadersStringBuilder = new StringBuilder(); for (Map.Entry<String, String> header : sortMap.entrySet()) { if (isHeaderToSign((String)header.getKey(), signHeaderPrefixList)) { sb.append((String)header.getKey()); sb.append(":"); if (!StringUtils.isBlank((CharSequence)header.getValue())) { sb.append((String)header.getValue()); } sb.append(" "); if (0 < signHeadersStringBuilder.length()) { signHeadersStringBuilder.append(","); } signHeadersStringBuilder.append((String)header.getKey()); } } headers.put("x-ca-signature-headers", signHeadersStringBuilder.toString()); } return sb.toString(); } private static boolean isHeaderToSign(String headerName, List<String> signHeaderPrefixList) { if (StringUtils.isBlank(headerName)) { return false; } if (headerName.startsWith("x-ca-")) { return true; } if (null != signHeaderPrefixList) { for (String signHeaderPrefix : signHeaderPrefixList) { if (headerName.equalsIgnoreCase(signHeaderPrefix)) { return true; } } } return false; } }
package com.hikvision.artemis.sdk.util; import java.io.UnsupportedEncodingException; import java.net.URLEncoder; import java.security.KeyManagementException; import java.security.NoSuchAlgorithmException; import java.security.cert.X509Certificate; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import javax.net.ssl.SSLContext; import javax.net.ssl.TrustManager; import javax.net.ssl.X509TrustManager; import org.apache.commons.lang3.StringUtils; import org.apache.http.HttpResponse; import org.apache.http.client.HttpClient; import org.apache.http.client.entity.UrlEncodedFormEntity; import org.apache.http.client.methods.HttpDelete; import org.apache.http.client.methods.HttpGet; import org.apache.http.client.methods.HttpPost; import org.apache.http.client.methods.HttpPut; import org.apache.http.conn.ClientConnectionManager; import org.apache.http.conn.scheme.Scheme; import org.apache.http.conn.scheme.SchemeRegistry; import org.apache.http.conn.ssl.SSLSocketFactory; import org.apache.http.entity.ByteArrayEntity; import org.apache.http.entity.StringEntity; import org.apache.http.impl.client.DefaultHttpClient; import org.apache.http.message.BasicNameValuePair; public class HttpUtils { public static HttpResponse doGet(String host, String path, String method, Map<String, String> headers, Map<String, String> querys) throws Exception { HttpClient httpClient = wrapClient(host); HttpGet request = new HttpGet(buildUrl(host, path, querys)); for (Map.Entry<String, String> e : headers.entrySet()) { request.addHeader((String)e.getKey(), (String)e.getValue()); } return httpClient.execute(request); } public static HttpResponse doPost(String host, String path, String method, Map<String, String> headers, Map<String, String> querys, Map<String, String> bodys) throws Exception { HttpClient httpClient = wrapClient(host); HttpPost request = new HttpPost(buildUrl(host, path, querys)); for (Iterator localIterator = headers.entrySet().iterator(); localIterator.hasNext();) { e = (Map.Entry)localIterator.next(); request.addHeader((String)e.getKey(), (String)e.getValue()); } Map.Entry<String, String> e; if (bodys != null) { Object nameValuePairList = new ArrayList(); for (String key : bodys.keySet()) { ((List)nameValuePairList).add(new BasicNameValuePair(key, (String)bodys.get(key))); } UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity((List)nameValuePairList, "utf-8"); formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8"); request.setEntity(formEntity); } return httpClient.execute(request); } public static HttpResponse doPost(String host, String path, String method, Map<String, String> headers, Map<String, String> querys, String body) throws Exception { HttpClient httpClient = wrapClient(host); HttpPost request = new HttpPost(buildUrl(host, path, querys)); for (Map.Entry<String, String> e : headers.entrySet()) { request.addHeader((String)e.getKey(), (String)e.getValue()); } if (StringUtils.isNotBlank(body)) { request.setEntity(new StringEntity(body, "utf-8")); } return httpClient.execute(request); } public static HttpResponse doPost(String host, String path, String method, Map<String, String> headers, Map<String, String> querys, byte[] body) throws Exception { HttpClient httpClient = wrapClient(host); HttpPost request = new HttpPost(buildUrl(host, path, querys)); for (Map.Entry<String, String> e : headers.entrySet()) { request.addHeader((String)e.getKey(), (String)e.getValue()); } if (body != null) { request.setEntity(new ByteArrayEntity(body)); } return httpClient.execute(request); } public static HttpResponse doPut(String host, String path, String method, Map<String, String> headers, Map<String, String> querys, String body) throws Exception { HttpClient httpClient = wrapClient(host); HttpPut request = new HttpPut(buildUrl(host, path, querys)); for (Map.Entry<String, String> e : headers.entrySet()) { request.addHeader((String)e.getKey(), (String)e.getValue()); } if (StringUtils.isNotBlank(body)) { request.setEntity(new StringEntity(body, "utf-8")); } return httpClient.execute(request); } public static HttpResponse doPut(String host, String path, String method, Map<String, String> headers, Map<String, String> querys, byte[] body) throws Exception { HttpClient httpClient = wrapClient(host); HttpPut request = new HttpPut(buildUrl(host, path, querys)); for (Map.Entry<String, String> e : headers.entrySet()) { request.addHeader((String)e.getKey(), (String)e.getValue()); } if (body != null) { request.setEntity(new ByteArrayEntity(body)); } return httpClient.execute(request); } public static HttpResponse doDelete(String host, String path, String method, Map<String, String> headers, Map<String, String> querys) throws Exception { HttpClient httpClient = wrapClient(host); HttpDelete request = new HttpDelete(buildUrl(host, path, querys)); for (Map.Entry<String, String> e : headers.entrySet()) { request.addHeader((String)e.getKey(), (String)e.getValue()); } return httpClient.execute(request); } private static String buildUrl(String host, String path, Map<String, String> querys) throws UnsupportedEncodingException { StringBuilder sbUrl = new StringBuilder(); sbUrl.append(host); if (!StringUtils.isBlank(path)) { sbUrl.append(path); } if (null != querys) { StringBuilder sbQuery = new StringBuilder(); for (Map.Entry<String, String> query : querys.entrySet()) { if (0 < sbQuery.length()) { sbQuery.append("&"); } if ((StringUtils.isBlank((CharSequence)query.getKey())) && (!StringUtils.isBlank((CharSequence)query.getValue()))) { sbQuery.append((String)query.getValue()); } if (!StringUtils.isBlank((CharSequence)query.getKey())) { sbQuery.append((String)query.getKey()); if (!StringUtils.isBlank((CharSequence)query.getValue())) { sbQuery.append("="); sbQuery.append(URLEncoder.encode((String)query.getValue(), "utf-8")); } } } if (0 < sbQuery.length()) { sbUrl.append("?").append(sbQuery); } } return sbUrl.toString(); } private static HttpClient wrapClient(String host) { HttpClient httpClient = new DefaultHttpClient(); if (host.startsWith("https://")) { sslClient(httpClient); } return httpClient; } private static void sslClient(HttpClient httpClient) { try { SSLContext ctx = SSLContext.getInstance("TLS"); X509TrustManager tm = new X509TrustManager() { public X509Certificate[] getAcceptedIssuers() { return null; } public void checkClientTrusted(X509Certificate[] xcs, String str) {} public void checkServerTrusted(X509Certificate[] xcs, String str) {} }; ctx.init(null, new TrustManager[] { tm }, null); SSLSocketFactory ssf = new SSLSocketFactory(ctx); ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); ClientConnectionManager ccm = httpClient.getConnectionManager(); SchemeRegistry registry = ccm.getSchemeRegistry(); registry.register(new Scheme("https", 443, ssf)); } catch (KeyManagementException ex) { throw new RuntimeException(ex); } catch (NoSuchAlgorithmException ex) { throw new RuntimeException(ex); } } }
doget
package com.hikvision.artemis.sdk; import com.hikvision.artemis.sdk.config.ArtemisConfig; import com.hikvision.artemis.sdk.enums.Method; import com.hikvision.artemis.sdk.util.MessageDigestUtil; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import org.apache.commons.lang3.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class ArtemisHttpUtil { private static final Logger logger = LoggerFactory.getLogger(ArtemisHttpUtil.class); private static final List<String> CUSTOM_HEADERS_TO_SIGN_PREFIX = new ArrayList(); private static final String SUCC_PRE = "2"; public static String doGetArtemis(Map<String, String> path, Map<String, String> querys, String accept, String contentType) { String httpSchema = (String)path.keySet().toArray()[0]; if ((httpSchema == null) || (StringUtils.isEmpty(httpSchema))) { throw new RuntimeException("http��https��������httpSchema: " + httpSchema); } String responseStr = null; try { Map<String, String> headers = new HashMap(); if (StringUtils.isNotBlank(accept)) { headers.put("Accept", accept); } else { headers.put("Accept", "*/*"); } if (StringUtils.isNotBlank(contentType)) { headers.put("Content-Type", contentType); } else { headers.put("Content-Type", "application/text;charset=UTF-8"); } CUSTOM_HEADERS_TO_SIGN_PREFIX.clear(); Request request = new Request(Method.GET, httpSchema + ArtemisConfig.host, (String)path.get(httpSchema), ArtemisConfig.appKey, ArtemisConfig.appSecret, 2000); request.setHeaders(headers); request.setSignHeaderPrefixList(CUSTOM_HEADERS_TO_SIGN_PREFIX); request.setQuerys(querys); Response response = Client.execute(request); responseStr = getResponseResult(response); } catch (Exception e) { logger.error("the Artemis GET Request is failed[doGetArtemis]", e); } return responseStr; } public static String doPostFormArtemis(Map<String, String> path, Map<String, String> paramMap, Map<String, String> querys, String accept, String contentType) { String httpSchema = (String)path.keySet().toArray()[0]; if ((httpSchema == null) || (StringUtils.isEmpty(httpSchema))) { throw new RuntimeException("http��https��������httpSchema: " + httpSchema); } String responseStr = null; try { Map<String, String> headers = new HashMap(); if (StringUtils.isNotBlank(accept)) { headers.put("Accept", accept); } else { headers.put("Accept", "*/*"); } if (StringUtils.isNotBlank(contentType)) { headers.put("Content-Type", contentType); } else { headers.put("Content-Type", "application/x-www-form-urlencoded;charset=UTF-8"); } CUSTOM_HEADERS_TO_SIGN_PREFIX.clear(); Request request = new Request(Method.POST_FORM, httpSchema + ArtemisConfig.host, (String)path.get(httpSchema), ArtemisConfig.appKey, ArtemisConfig.appSecret, 2000); request.setHeaders(headers); request.setSignHeaderPrefixList(CUSTOM_HEADERS_TO_SIGN_PREFIX); request.setQuerys(querys); request.setBodys(paramMap); Response response = Client.execute(request); responseStr = getResponseResult(response); } catch (Exception e) { logger.error("the Artemis PostForm Request is failed[doPostFormArtemis]", e); } return responseStr; } public static String doPostStringArtemis(Map<String, String> path, String body, Map<String, String> querys, String accept, String contentType) { String httpSchema = (String)path.keySet().toArray()[0]; if ((httpSchema == null) || (StringUtils.isEmpty(httpSchema))) { throw new RuntimeException("http��https��������httpSchema: " + httpSchema); } String responseStr = null; try { Map<String, String> headers = new HashMap(); if (StringUtils.isNotBlank(accept)) { headers.put("Accept", accept); } else { headers.put("Accept", "*/*"); } if (StringUtils.isNotBlank(contentType)) { headers.put("Content-Type", contentType); } else { headers.put("Content-Type", "application/text;charset=UTF-8"); } CUSTOM_HEADERS_TO_SIGN_PREFIX.clear(); Request request = new Request(Method.POST_STRING, httpSchema + ArtemisConfig.host, (String)path.get(httpSchema), ArtemisConfig.appKey, ArtemisConfig.appSecret, 2000); request.setHeaders(headers); request.setSignHeaderPrefixList(CUSTOM_HEADERS_TO_SIGN_PREFIX); request.setQuerys(querys); request.setStringBody(body); Response response = Client.execute(request); responseStr = getResponseResult(response); } catch (Exception e) { logger.error("the Artemis PostString Request is failed[doPostStringArtemis]", e); } return responseStr; } public static String doPostBytesArtemis(Map<String, String> path, byte[] bytesBody, Map<String, String> querys, String accept, String contentType) { String httpSchema = (String)path.keySet().toArray()[0]; if ((httpSchema == null) || (StringUtils.isEmpty(httpSchema))) { throw new RuntimeException("http��https��������httpSchema: " + httpSchema); } String responseStr = null; try { Map<String, String> headers = new HashMap(); if (StringUtils.isNotBlank(accept)) { headers.put("Accept", accept); } else { headers.put("Accept", "*/*"); } if (bytesBody != null) { headers.put("Content-MD5", MessageDigestUtil.base64AndMD5(bytesBody)); } if (StringUtils.isNotBlank(contentType)) { headers.put("Content-Type", contentType); } else { headers.put("Content-Type", "application/text;charset=UTF-8"); } CUSTOM_HEADERS_TO_SIGN_PREFIX.clear(); Request request = new Request(Method.POST_BYTES, httpSchema + ArtemisConfig.host, (String)path.get(httpSchema), ArtemisConfig.appKey, ArtemisConfig.appSecret, 2000); request.setHeaders(headers); request.setSignHeaderPrefixList(CUSTOM_HEADERS_TO_SIGN_PREFIX); request.setQuerys(querys); request.setBytesBody(bytesBody); Response response = Client.execute(request); responseStr = getResponseResult(response); } catch (Exception e) { logger.error("the Artemis PostBytes Request is failed[doPostBytesArtemis]", e); } return responseStr; } public static String doPutStringArtemis(Map<String, String> path, String body, String accept, String contentType) { String httpSchema = (String)path.keySet().toArray()[0]; if ((httpSchema == null) || (StringUtils.isEmpty(httpSchema))) { throw new RuntimeException("http��https��������httpSchema: " + httpSchema); } String responseStr = null; try { Map<String, String> headers = new HashMap(); if (StringUtils.isNotBlank(accept)) { headers.put("Accept", accept); } else { headers.put("Accept", "*/*"); } if (StringUtils.isNotBlank(body)) { headers.put("Content-MD5", MessageDigestUtil.base64AndMD5(body)); } if (StringUtils.isNotBlank(contentType)) { headers.put("Content-Type", contentType); } else { headers.put("Content-Type", "application/text;charset=UTF-8"); } CUSTOM_HEADERS_TO_SIGN_PREFIX.clear(); Request request = new Request(Method.PUT_STRING, httpSchema + ArtemisConfig.host, (String)path.get(httpSchema), ArtemisConfig.appKey, ArtemisConfig.appSecret, 2000); request.setHeaders(headers); request.setSignHeaderPrefixList(CUSTOM_HEADERS_TO_SIGN_PREFIX); request.setStringBody(body); Response response = Client.execute(request); responseStr = getResponseResult(response); } catch (Exception e) { logger.error("the Artemis PutString Request is failed[doPutStringArtemis]", e); } return responseStr; } public static String doPutBytesArtemis(Map<String, String> path, byte[] bytesBody, String accept, String contentType) { String httpSchema = (String)path.keySet().toArray()[0]; if ((httpSchema == null) || (StringUtils.isEmpty(httpSchema))) { throw new RuntimeException("http��https��������httpSchema: " + httpSchema); } String responseStr = null; try { Map<String, String> headers = new HashMap(); if (StringUtils.isNotBlank(accept)) { headers.put("Accept", accept); } else { headers.put("Accept", "*/*"); } if (bytesBody != null) { headers.put("Content-MD5", MessageDigestUtil.base64AndMD5(bytesBody)); } if (StringUtils.isNotBlank(contentType)) { headers.put("Content-Type", contentType); } else { headers.put("Content-Type", "application/text;charset=UTF-8"); } CUSTOM_HEADERS_TO_SIGN_PREFIX.clear(); Request request = new Request(Method.PUT_BYTES, httpSchema + ArtemisConfig.host, (String)path.get(httpSchema), ArtemisConfig.appKey, ArtemisConfig.appSecret, 2000); request.setHeaders(headers); request.setSignHeaderPrefixList(CUSTOM_HEADERS_TO_SIGN_PREFIX); request.setBytesBody(bytesBody); Response response = Client.execute(request); responseStr = getResponseResult(response); } catch (Exception e) { logger.error("the Artemis PutBytes Request is failed[doPutBytesArtemis]", e); } return responseStr; } public static String doDeleteArtemis(Map<String, String> path, Map<String, String> querys, String accept, String contentType) { String httpSchema = (String)path.keySet().toArray()[0]; if ((httpSchema == null) || (StringUtils.isEmpty(httpSchema))) { throw new RuntimeException("http��https��������httpSchema: " + httpSchema); } String responseStr = null; try { Map<String, String> headers = new HashMap(); if (StringUtils.isNotBlank(accept)) { headers.put("Accept", accept); } else { headers.put("Accept", "*/*"); } if (StringUtils.isNotBlank(contentType)) { headers.put("Content-Type", contentType); } Request request = new Request(Method.DELETE, httpSchema + ArtemisConfig.host, (String)path.get(httpSchema), ArtemisConfig.appKey, ArtemisConfig.appSecret, 2000); request.setHeaders(headers); request.setSignHeaderPrefixList(CUSTOM_HEADERS_TO_SIGN_PREFIX); request.setQuerys(querys); Response response = Client.execute(request); responseStr = getResponseResult(response); } catch (Exception e) { logger.error("the Artemis DELETE Request is failed[doDeleteArtemis]", e); } return responseStr; } private static String getResponseResult(Response response) { String responseStr = null; int statusCode = response.getStatusCode(); if (String.valueOf(statusCode).startsWith("2")) { responseStr = response.getBody(); logger.info("the Artemis Request is Success,statusCode:" + statusCode + " SuccessMsg:" + response.getBody()); } else { String msg = response.getErrorMessage(); responseStr = response.getBody(); logger.error("the Artemis Request is Failed,statusCode:" + statusCode + " errorMsg:" + msg); } return responseStr; } }
package com.hikvision.ga; import java.util.HashMap; import java.util.Map; import com.hikvision.artemis.sdk.ArtemisHttpUtil; import com.hikvision.artemis.sdk.config.ArtemisConfig; /** * ��Class��������, ����������������������, ��������������������������������������. * ������������������: * [1] ���������������������� * https://open8200.hikvision.com/artemis-portal/document?version=4&docId=306&apiBlock=1 * [2] ����appKey������������ * https://open8200.hikvision.com/artemis-portal/document?version=4&docId=284&apiBlock=2 * @author zhangtuo * */ public class ArtemisTest { /** * ������������appKey��appSecret����static������������������. * [1 host] * ����������������open8200����,������������������,������������������,host��������.������open8200.hikvision.com * ����������������������������,host������������������ip,����1.0 ��������������9999.����2.0 ��������������443.����:10.33.25.22:9999 ����10.33.25.22:443 * [2 appKey��appSecret] * ��������������appKey��appSecret����. * * ps. ����������open8200��������������������,��������������,��������������,������������. * */ static { ArtemisConfig.host ="open8200.hikvision.com"; //artemis����������ip���� ArtemisConfig.appKey ="22425132"; //����appkey ArtemisConfig.appSecret ="mcsioUGkT5GRMZTvjwAC";//����appSecret } /** * ���������������������� * TODO ������������������/artemis */ private static final String ARTEMIS_PATH = "/artemis"; /** * [1] ������������������������������ * @return */ public static String callApiGetCameraInfos() { /** * https://open8200.hikvision.com/artemis-portal/document?version=4&docId=306&apiBlock=1 * ����API��������������,��������GET������Rest����, ������������������queryString, ����������������������: * http://ip:port/path?a=1&b=2 * ArtemisHttpUtil������������doGetArtemis��������, ����������������������������������. * ����������https, ��������������path����hashmap����,��put����key-value, querys������������. * start��������, size��������. */ String getCamsApi = ARTEMIS_PATH + "/api/common/v1/remoteCameraInfoRestService/findCameraInfoPage"; Map<String,String> querys = new HashMap<String,String>();//get�������������� querys.put("start", "0"); querys.put("size", "20"); Map<String, String> path = new HashMap<String, String>(2){ { put("https://", getCamsApi); } }; String result = ArtemisHttpUtil.doGetArtemis(path, querys,null,null); return result; } /** * [2] ����appKey������������ * @return */ public static String callApiGetSecurity() { /** * https://open8200.hikvision.com/artemis-portal/document?version=4&docId=284&apiBlock=2 * ����API��������������,��������GET������Rest����, * ����������������Parameter Path,����queryString����������. * ��������: /api/artemis/v1/agreementService/securityParam/appKey/{appKey} * {appKey}��Parameter Path * ����, doGetArtemis����������������null * * TODO ��������������appKey����������static��������������appKey */ String getSecurityApi = ARTEMIS_PATH + "/api/artemis/v1/agreementService/securityParam/appKey/22425132"; Map<String, String> path = new HashMap<String, String>(2){ { put("https://", getSecurityApi); } }; String result = ArtemisHttpUtil.doGetArtemis(path, null,null,null); return result; } public static void main(String[] args) { /** * ������������������ */ String camsResult = callApiGetCameraInfos(); /** * ����appKey������������ */ String securityResult = callApiGetSecurity(); System.out.println(camsResult); System.out.println(securityResult); } }