# zop-example

**Repository Path**: chocotan/zop-example

## Basic Information

- **Project Name**: zop-example
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2018-06-04
- **Last Updated**: 2020-12-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

本文仅供参考，异常处理、编码问题请自行修改

JAVA8可以直接使用 https://github.com/chocotan/ztosdk 
## JAVA8
```java

import java.io.*;
import java.math.BigInteger;
import java.net.*;
import java.nio.Buffer;
import java.nio.charset.Charset;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;

class Main {
    public static void main(String[] args) throws IOException, NoSuchAlgorithmException {

        // TODO 请自行进行异常处理和关闭资源
        String companyId = "your_company_id";
        String key = "your_key";
        Map<String, String> parameters = new HashMap<>();
        parameters.put("data", "['728350000001']");
        parameters.put("company_id", companyId);
        parameters.put("msg_type", "NEW_TRACES");

        String strToDigest = paramsToQueryString(parameters) + key;
        MessageDigest md = MessageDigest.getInstance("MD5");
        md.update(strToDigest.getBytes(Charset.forName("UTF-8")));

        String dataDigest = Base64.getEncoder().encodeToString(md.digest());
        URL url = new URL("http://japi.zto.cn/traceInterfaceNewTraces");
        HttpURLConnection con = (HttpURLConnection) url.openConnection();
        con.setRequestMethod("POST");
        con.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=utf-8");
        con.setDoOutput(true);
        con.setConnectTimeout(5000);
        con.setReadTimeout(5000);
        con.setRequestProperty("x-datadigest", dataDigest);
        con.setRequestProperty("x-companyid", companyId);
        DataOutputStream out = new DataOutputStream(con.getOutputStream());
        out.write(paramsToQueryStringUrlencoded(parameters).getBytes(Charset.forName("UTF-8")));
        out.flush();
        out.close();
        BufferedReader in = new BufferedReader(
                new InputStreamReader(con.getInputStream()));
        String inputLine;
        StringBuffer content = new StringBuffer();
        while ((inputLine = in.readLine()) != null) {
            content.append(inputLine);
        }
        in.close();

        System.out.println(content.toString());

    }

    public static String paramsToQueryString(Map<String, String> params) {
        return params.entrySet().stream().map(e -> e.getKey() + "=" + e.getValue()).collect(Collectors.joining("&"));
    }


    public static String paramsToQueryStringUrlencoded(Map<String, String> params) {
        return params.entrySet().stream().map(e -> {
            try {
                return e.getKey() + "=" + URLEncoder.encode(e.getValue(), "UTF-8");
            } catch (UnsupportedEncodingException e1) {
                return e.getValue();
            }
        }).collect(Collectors.joining("&"));
    }
}
```

## PHP
```php

$url = 'http://japi.zto.cn/traceInterfaceNewTraces';
$company_id = 'your_companyid';
$key = 'your_key';
$data = array('data' => '["728350000001"]', 'company_id' => $company_id,
              'msg_type'=>'NEW_TRACES');
$str_to_digest = "";
foreach ($data as $k=>$v) {
  $str_to_digest =$str_to_digest.$k."=".$v."&";
}
$str_to_digest = substr($str_to_digest, 0, -1).$key;
$data_digest = base64_encode(md5($str_to_digest,TRUE));

$options = array(
    'http' => array(
        'header'  => "Content-type: application/x-www-form-urlencoded; charset=utf-8\r\n".
        "x-companyid: ".$company_id."\r\n".
        "x-datadigest: ".$data_digest."\r\n",
        'method'  => 'POST',
        'content' => http_build_query($data)
    )
);

$context  = stream_context_create($options);
$result = file_get_contents($url, false, $context);
echo $result;

```

## PYTHON3
```python
from urllib.parse import urlencode
from urllib.request import Request, urlopen
import hashlib
import base64

company_id='your_company_id'
digest_key='your_key'
url = 'http://japi.zto.cn/traceInterfaceNewTraces'
post_fields = {'company_id': company_id,'data':'["728350000001"]','msg_type':'NEW_TRACES'}

str_to_digest = ''
for key, value in post_fields.items():
  str_to_digest+=(key+'='+value+'&')
str_to_digest = str_to_digest[:-1] + digest_key

m = hashlib.md5()
m.update(str_to_digest.encode("UTF-8"))

data_digest=base64.b64encode(m.digest())

request = Request(url, urlencode(post_fields).encode())
request.add_header('x-companyid',company_id)
request.add_header('x-datadigest',data_digest)
json = urlopen(request).read().decode()
print(json)

```

## NODEJS

```javascript
var crypto = require('crypto');
var fetch = require('node-fetch');
var querystring = require('querystring');
let company_id = "your_company_id";
let key = "your_key";
let requestBody = {
  data: "['728350000001']",
  company_id: company_id,
  msg_type: "NEW_TRACES"
}

let query_string = [];
for(let k in requestBody){
  query_string.push(k+"="+requestBody[k]);
}
let str_to_digest = query_string.join("&")+key;


let data_digest = crypto.createHash('md5')
  .update(str_to_digest)
  .digest('base64');

var query_string_urlencoded = querystring.stringify(requestBody);


fetch("http://japi.zto.cn/traceInterfaceNewTraces", {
      method: 'POST',
      headers: {
        "Content-Type": "application/x-www-form-urlencoded",
        "x-companyid":company_id,
        "x-datadigest":data_digest
      },
      body: query_string_urlencoded,
    }).then(response => {
      if (response.ok) {
        response.json().then(data => {
            console.log(data);
        })
      }
    })

```

## C#
```C#
using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Web;
using System.Collections.Specialized;
using System.Linq;
using System.Text;
using System.IO;
using System.Net;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;

namespace ztotest
{
    class Program
    {
        static void Main(string[] args)
        {
            string company_id = "kfpttestCode";
            string key = "kfpttestkey==";
            string data = "{\"unionCode\":\"536178917071\",\"send_province\":\"上海市\",\"send_city\":\"上海市\",\"send_district\":\"青浦区\",\"send_address\":\"华新镇华志路123号\",\"receive_province\":\"四川省\",\"receive_city\":\"成都市\",\"receive_district\":\"武侯区\",\"receive_address\":\"610号和兴润园二期1栋2单元1003室\"}";
            var bodyNvc = new NameValueCollection();
            bodyNvc.Add("company_id", company_id);
            bodyNvc.Add("msg_type", "GETMARK");
            bodyNvc.Add("data", data);
            // 这里生成签名的body字符串的拼接顺序，要和http请求的参数顺序一致，也就是和上面bodyNvc的添加顺序一致
            string body = "company_id=" + company_id + "&msg_type=GETMARK" + "&data=" + data;
            var headersNvc = new NameValueCollection();
            headersNvc.Add("x-companyId", company_id);
            //得到签名
            string dataDigest = EncryptMD5Base64(body + key);
            headersNvc.Add("x-dataDigest", dataDigest);
            Console.WriteLine(CreatePostSysHttpResponse("http://58.40.16.120:9001/bagAddrMarkGetmark", headersNvc, bodyNvc, 5000, Encoding.UTF8, null));
        }



        /// <summary>
        /// 调用接口的方法
        /// </summary>
        /// <param name="url">调用的接口地址</param>
        /// <param name="postValues">参数集合</param>
        /// <returns></returns>
        public static string Redirect(string url, NameValueCollection postValues)
        {
            // -- 需要调用的接口 ---
            var request = (HttpWebRequest)HttpWebRequest.Create(url);
            request.Method = "POST";
            request.ContentType = "application/x-www-form-urlencoded";
            SetWebRequest(request);
            var data = EncodePars(postValues);
            WriteRequestData(request, data);
            var response = request.GetResponse() as HttpWebResponse;
            var responseStream = response.GetResponseStream();
            var encoding = new UTF8Encoding(false);
            var reader = new System.IO.StreamReader(responseStream, encoding);
            var rValue = reader.ReadToEnd();
            reader.Close();
            responseStream.Close();

            return rValue;
        }

        #region 创建POST方式的HTTP请求
        /// <summary>
        /// 创建POST方式的HTTP请求
        /// </summary>
        /// <param name="url">请求的URL</param>
        /// <param name="Hederparameters"></param>
        /// <param name="parameters">随同请求POST的参数名称及参数值字典</param>
        /// <param name="timeout">请求的超时时间</param>
        /// <param name="requestEncoding">发送HTTP请求时所用的编码</param>
        /// <param name="cookies">随同HTTP请求发送的Cookie信息，如果不需要身份验证可以为空</param>
        /// <param name="contentType">请求的发送编码方式</param>
        /// <param name="method">请求的方式GET、POST</param>
        /// <returns></returns>
        public static string CreatePostSysHttpResponse(string url, NameValueCollection Hederparameters, NameValueCollection parameters, int? timeout, Encoding requestEncoding, CookieCollection cookies, string contentType = "application/x-www-form-urlencoded", string method = "POST")
        {
            string returns = "";
            if (string.IsNullOrEmpty(url))
            {
                throw new ArgumentNullException("url");
            }
            if (requestEncoding == null)
            {
                throw new ArgumentNullException("requestEncoding");
            }
            HttpWebRequest request = null;
            //如果是发送HTTPS请求  
            if (url.StartsWith("https", StringComparison.OrdinalIgnoreCase))
            {
                ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);
                request = WebRequest.Create(url) as HttpWebRequest;
                request.ProtocolVersion = HttpVersion.Version10;
            }
            else
            {
                request = WebRequest.Create(url) as HttpWebRequest;
            }
            request.Method = method;
            request.ContentType = contentType;
            if (Hederparameters != null)
            {
                request.Headers.Add(Hederparameters);
            }
            if (timeout.HasValue)
            {
                request.Timeout = timeout.Value;
            }
            if (cookies != null)
            {
                request.CookieContainer = new CookieContainer();
                request.CookieContainer.Add(cookies);
            }
            //如果需要POST数据  
            if (!(parameters == null || parameters.Count == 0))
            {
                StringBuilder buffer = new StringBuilder();
                int i = 0;
                foreach (string key in parameters.Keys)
                {
                    if (i > 0)
                    {
                        buffer.AppendFormat("&{0}={1}", key, HttpUtility.UrlEncode(parameters[key],Encoding.UTF8));
                    }
                    else
                    {
                        buffer.AppendFormat("{0}={1}", key, HttpUtility.UrlEncode(parameters[key],Encoding.UTF8));
                    }
                    i++;
                }
                byte[] data = requestEncoding.GetBytes(buffer.ToString());
                using (Stream stream = request.GetRequestStream())
                {
                    stream.Write(data, 0, data.Length);
                }
            }
            HttpWebResponse response = request.GetResponse() as HttpWebResponse;
            Stream responseStream = response.GetResponseStream();
            System.IO.StreamReader reader = new System.IO.StreamReader(responseStream, requestEncoding);
            string ret = reader.ReadToEnd();
            reader.Close();
            responseStream.Close();
            returns = ret;
            return returns;
        }

        private static bool CheckValidationResult(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors)
        {
            return true; //总是接受  
        }
        #endregion




        #region 帮助方法
        /// <summary>
        /// 设置请求的参数信息
        /// </summary>
        /// <param name="request"></param>
        private static void SetWebRequest(HttpWebRequest request)
        {
            request.Credentials = CredentialCache.DefaultCredentials;
            request.Timeout = 10000;
        }
        /// <summary>
        /// 请求数据
        /// </summary>
        /// <param name="request"></param>
        /// <param name="data"></param>
        private static void WriteRequestData(HttpWebRequest request, byte[] data)
        {
            request.ContentLength = data.Length;
            Stream writer = request.GetRequestStream();
            writer.Write(data, 0, data.Length);
            writer.Close();
        }
        /// <summary>
        /// 编码方式
        /// </summary>
        /// <param name="Pars"></param>
        /// <returns></returns>
        private static byte[] EncodePars(NameValueCollection Pars)
        {
            return Encoding.UTF8.GetBytes(ParsToString(Pars));
        }
        /// <summary>
        /// 参数转为字符串
        /// </summary>
        /// <param name="Pars"></param>
        /// <returns></returns>
        private static String ParsToString(NameValueCollection Pars)
        {
            StringBuilder sb = new StringBuilder();
            foreach (string k in Pars.Keys)
            {
                if (sb.Length > 0)
                {
                    sb.Append("&");
                }
                sb.Append(HttpUtility.UrlEncode(k) + "=" + HttpUtility.UrlEncode(Pars[k].ToString()));
            }
            return sb.ToString();
        }
        #endregion



        /// <summary>
        /// 开放平台签名[MD5 + BASE64]
        /// </summary>
        /// <param name="encryptStr">加密的字符串(请求数据[data] + 消息密钥[key])</param>
        /// <param name="charset">编码方式, 默认UTF-8</param>
        /// <returns></returns>
        public static string EncryptMD5Base64(string encryptStr, string charset = "UTF-8")
        {
            string rValue = "";
            var m5 = new MD5CryptoServiceProvider();

            byte[] inputBye;
            byte[] outputBye;
            try
            {
                inputBye = Encoding.GetEncoding(charset).GetBytes(encryptStr);
            }
            catch (Exception)
            {
                inputBye = Encoding.UTF8.GetBytes(encryptStr);
            }
            outputBye = m5.ComputeHash(inputBye);
            rValue = Convert.ToBase64String(outputBye, 0, outputBye.Length);

            return rValue;
        }
    }
}

```