海康sdk

其他 2018-11-10 18:01:15 阅读次数: 0 
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("\n");
    if (null != headers)
    {
      if (null != headers.get("Accept"))
      {
        sb.append((String)headers.get("Accept"));
        sb.append("\n");
      }
      if (null != headers.get("Content-MD5"))
      {
        sb.append((String)headers.get("Content-MD5"));
        sb.append("\n");
      }
      if (null != headers.get("Content-Type"))
      {
        sb.append((String)headers.get("Content-Type"));
        sb.append("\n");
      }
      if (null != headers.get("Date"))
      {
        sb.append((String)headers.get("Date"));
        sb.append("\n");
      }
    }
    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("\n");
          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);
    }
}

猜你喜欢

转载自www.cnblogs.com/longyi/p/9940014.html
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
BPM为企业带来的实际利益
好程序员web前端分享css常用属性缩写
Java文件下载（excel）
css样式的动态添加及显示和隐藏等零碎用法
axios全局配置以及拦截器
使用Logstash来实时同步MySQL和log日志数据到ES
C++获取当前时间（年月日、时分秒、毫秒）
Odoo产品分析 (四) -- 工具板块(11) -- 网站即时聊天(1)
Java环境配置正确，但是java、javac、java -version均返回“不是内部或外部命令，也不是可运行的程序或批处理文件”？
01 官网下载各种CentOS教程（超详细版）
每日归档
更多
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022