pr查询

curl  -H "token:您申请接口的token" -H "timestamp:1676766665" -H "sign:aedc77b7476278c8e780446ae4af6720" -H "content-type:application/json" -d {} http://i.zlapi.top/api/v1/normal/PRchaxun/query

        

<?php
$url = "http://i.zlapi.top/api/v1/normal/PRchaxun/query";
$params = [
    ];

$paramsStr = http_build_query($params);
$headers =  [
    "token" => "您申请接口的token", # 在个人中心->我的数据,接口名称上方查看
    "timestamp" => "1676766665", # 当前时间戳 :误差范围必须小于 5 分钟
    "sign" => "aedc77b7476278c8e780446ae4af6720", # token和 timestamp 拼接之后的 md5，32 位小写
    "content-type" => "application/json", # 请求内容类型
    ];

$content = httpRequest($url, $paramsStr,1,$headers);
$result = json_decode($content, true);
if ($result) {
    var_dump($result); // 参考返回参数说明、json返回示例

} else {
    // 请求异常处理
}


function httpRequest($url, $dataStr = "", $isPost = 0,$headers=[])
{
    $httpInfo = [];
    $ch = curl_init();

    curl_setopt($ch, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
    curl_setopt($ch, CURLOPT_USERAGENT, "Mozilla/5.0 (Macintosh; Intel Mac OS) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/536.3");
    curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 30);
    curl_setopt($ch, CURLOPT_TIMEOUT, 30);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    // 请求头
    if (!empty($headers)) {
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    }

    if ($isPost) {
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $dataStr);
        curl_setopt($ch, CURLOPT_URL, $url);
    } else {
        curl_setopt($ch, CURLOPT_URL, $url . "?" . $dataStr);
    }

    $response = curl_exec($ch);
    if ($response === false) {
        return false;
    }
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    $httpInfo = array_merge($httpInfo, curl_getinfo($ch));
    curl_close($ch);
    return $response;
}

#!/usr/bin/python3
# -*- coding: utf-8 -*-
import requests
import json
headers ={
    "token" : "您申请接口的token", # 在个人中心->我的数据,接口名称上方查看
    "timestamp" : "1676766665", # 当前时间戳 :误差范围必须小于 5 分钟
    "sign" : "aedc77b7476278c8e780446ae4af6720", # token和 timestamp 拼接之后的 md5，32 位小写
    "content-type" : "application/json", # 请求内容类型
    }
url = "http://i.zlapi.top/api/v1/normal/PRchaxun/query"
params = {
    }
resp = requests.post(url,params,headers=headers)
resp_json = json.loads(resp.text)
print(resp_json)
# 参考返回参数说明、json返回示例

package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strings"
    "time"
)

func main() {
    // 接口请求地址
    url := "http://i.zlapi.top/api/v1/normal/PRchaxun/query"

    // 接口请求参数
    params := map[string]string{
        }

    // 请求头设置
    headers := map[string]string{
            "token":"您申请接口的token", // 在个人中心->我的数据,接口名称上方查看
            "timestamp":"1676766665", // 当前时间戳 :误差范围必须小于 5 分钟
            "sign":"aedc77b7476278c8e780446ae4af6720", // token和 timestamp 拼接之后的 md5，32 位小写
            "content-type":"application/json", // 请求内容类型
            }

    response, err := HttpRequest("POST", url, params, headers, 15)
    if err != nil {
        fmt.Println("请求异常：", err.Error())
    } else {
        fmt.Println("请求结果：", response)
    }
    // 具体返回示例值，参考返回参数说明、json返回示例
}

// http请求发送
func HttpRequest(method, rawUrl string, bodyMaps, headers map[string]string, timeout time.Duration) (result string, err error) {
    var (
        request  *http.Request
        response *http.Response
        res      []byte
    )
    if timeout <= 0 {
        timeout = 5
    }
    client := &http.Client{
        Timeout: timeout * time.Second,
    }

    // 请求的 body 内容
    data := url.Values{}
    for key, value := range bodyMaps {
        data.Set(key, value)
    }

    jsons := data.Encode()

    if request, err = http.NewRequest(method, rawUrl, strings.NewReader(jsons)); err != nil {
        return
    }

    if method == "GET" {
        request.URL.RawQuery = jsons
    }

    // 增加header头信息
    for key, val := range headers {
        request.Header.Set(key, val)
    }

    // 处理返回结果
    if response, err = client.Do(request); err != nil {
        return "", err
    }

    defer response.Body.Close()

    if res, err = io.ReadAll(response.Body); err != nil {
        return "", err
    }
    return string(res), nil
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.IO;
using Xfrog.Net;
using System.Diagnostics;
using System.Web;

namespace ConsoleAPI
{
    class Program
    {
        static void Main(string[] args)
        {
            string url = "http://i.zlapi.top/api/v1/normal/PRchaxun/query";

            var parameters = new Dictionary<string, string>();

            

            string result = sendPost(url, parameters, "post");

            JsonObject newObj = new JsonObject(result);
            String errorCode = newObj["error_code"].Value;

            if (errorCode == "0")
            {
                Debug.WriteLine("成功");
                Debug.WriteLine(newObj);
            }
            else
            {
                //Debug.WriteLine("请求异常");
                Debug.WriteLine(newObj["error_code"].Value+":"+newObj["reason"].Value);
            }
        }

        // <summary>
        // Http (GET/POST)
        // </summary>
        // <param name="url">请求URL</param>
        // <param name="parameters">请求参数</param>
        // <param name="method">请求方法</param>
        // <returns>响应内容</returns>
        static string sendPost(string url, IDictionary<string, string> parameters, string method)
        {
            if (method.ToLower() == "post")
            {
                HttpWebRequest req = null;
                HttpWebResponse rsp = null;
                System.IO.Stream reqStream = null;
                try
                {
                    req = (HttpWebRequest)WebRequest.Create(url);
                    req.Method = method;
                    req.KeepAlive = false;
                    req.ProtocolVersion = HttpVersion.Version10;
                    req.Timeout = 60000;
                    // 添加自定义Header
                     req.Headers.Add("token" , "您申请接口的token"); // 在个人中心->我的数据,接口名称上方查看
                     req.Headers.Add("timestamp" , "1676766665"); // 当前时间戳 :误差范围必须小于 5 分钟
                     req.Headers.Add("sign" , "aedc77b7476278c8e780446ae4af6720"); // token和 timestamp 拼接之后的 md5，32 位小写
                     req.Headers.Add("content-type" , "application/json"); // 请求内容类型
                    
                    byte[] postData = Encoding.UTF8.GetBytes(BuildQuery(parameters, "utf8"));
                    reqStream = req.GetRequestStream();
                    reqStream.Write(postData, 0, postData.Length);
                    rsp = (HttpWebResponse)req.GetResponse();
                    Encoding encoding = Encoding.GetEncoding(rsp.CharacterSet);
                    return GetResponseAsString(rsp, encoding);
                }
                catch (Exception ex)
                {
                    return ex.Message;
                }
                finally
                {
                    if (reqStream != null) reqStream.Close();
                    if (rsp != null) rsp.Close();
                }
            }
            else
            {
                //创建请求
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url + "?" + BuildQuery(parameters, "utf8"));

                //GET请求
                request.Method = "GET";
                request.ReadWriteTimeout = 5000;
                request.ContentType = "text/html;charset=UTF-8";
                HttpWebResponse response = (HttpWebResponse)request.GetResponse();
                Stream myResponseStream = response.GetResponseStream();
                StreamReader myStreamReader = new StreamReader(myResponseStream, Encoding.GetEncoding("utf-8"));

                //返回内容
                string retString = myStreamReader.ReadToEnd();
                return retString;
            }
        }

        // <summary>
        // 组装普通文本请求参数。
        // </summary>
        // <param name="parameters">Key-Value形式请求参数字典</param>
        // <returns>URL编码后的请求数据</returns>
        static string BuildQuery(IDictionary<string, string> parameters, string encode)
        {
            StringBuilder postData = new StringBuilder();
            bool hasParam = false;
            IEnumerator<KeyValuePair<string, string>> dem = parameters.GetEnumerator();
            while (dem.MoveNext())
            {
                string name = dem.Current.Key;
                string value = dem.Current.Value;
                // 忽略参数名或参数值为空的参数
                if (!string.IsNullOrEmpty(name))//&& !string.IsNullOrEmpty(value)
                {
                    if (hasParam)
                    {
                        postData.Append("&");
                    }
                    postData.Append(name);
                    postData.Append("=");
                    if (encode == "gb2312")
                    {
                        postData.Append(HttpUtility.UrlEncode(value, Encoding.GetEncoding("gb2312")));
                    }
                    else if (encode == "utf8")
                    {
                        postData.Append(HttpUtility.UrlEncode(value, Encoding.UTF8));
                    }
                    else
                    {
                        postData.Append(value);
                    }
                    hasParam = true;
                }
            }
            return postData.ToString();
        }

        // <summary>
        // 把响应流转换为文本。
        // </summary>
        // <param name="rsp">响应流对象</param>
        // <param name="encoding">编码方式</param>
        // <returns>响应文本</returns>
        static string GetResponseAsString(HttpWebResponse rsp, Encoding encoding)
        {
            System.IO.Stream stream = null;
            StreamReader reader = null;
            try
            {
                // 以字符流的方式读取HTTP响应
                stream = rsp.GetResponseStream();
                reader = new StreamReader(stream, encoding);
                return reader.ReadToEnd();
            }
            finally
            {
                // 释放资源
                if (reader != null) reader.Close();
                if (stream != null) stream.Close();
                if (rsp != null) rsp.Close();
            }
        }
    }
}

var request = require("request");
var querystring = require("querystring");

const options = {
    url: "http://i.zlapi.top/api/v1/normal/PRchaxun/query",
    method: "POST",
    headers: {
    "token" : "您申请接口的token", # 在个人中心->我的数据,接口名称上方查看
    "timestamp" : "1676766665", # 当前时间戳 :误差范围必须小于 5 分钟
    "sign" : "aedc77b7476278c8e780446ae4af6720", # token和 timestamp 拼接之后的 md5，32 位小写
    "content-type" : "application/json", # 请求内容类型
    },
    body:  querystring.stringify({
        })
};

request(options, function (error, response, body) {
    if (!error && response.statusCode == 200) {
        console.log(body); // 请求成功，输出响应内容：参考返回参数说明、json返回示例
    } else {
        console.log("请求异常");
    }
});

import net.sf.json.JSONObject;

import java.io.*;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLEncoder;
import java.util.Map;
import java.util.HashMap;

public class ApiDemo {

    public static void main(String[] args) {

        String url = "http://i.zlapi.top/api/v1/normal/PRchaxun/query";

        Map<String, String> params = new HashMap<String, String>();
        

        String paramsStr = urlencode(params);
        System.out.println(paramsStr);
        String response = requestGet(url,paramsStr);

        // 输出请求结果
        System.out.println(response);

        try {
            // 解析请求结果，json：
            JSONObject jsonObject = JSONObject.fromObject(response);
            System.out.println(jsonObject);// 具体返回示例值，参考返回参数说明、json返回示例

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 将map型转为请求参数型
    public static String urlencode(Map<String, String> data) {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry i : data.entrySet()) {
            try {
                sb.append(i.getKey()).append("=").append(URLEncoder.encode(i.getValue() + "", "UTF-8")).append("&");
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
        return sb.toString();
    }

    /**
     * post方式的http请求
     *
     * @param httpUrl 请求地址
     * @param paramStr   请求参数
     * @return 返回结果
     */
    public static String doPost(String httpUrl, String paramStr) {
        HttpURLConnection connection = null;
        InputStream inputStream = null;
        OutputStream outputStream = null;
        BufferedReader bufferedReader = null;
        String result = null;
        try {
            URL url = new URL(httpUrl);
            // 通过远程url连接对象打开连接
            connection = (HttpURLConnection) url.openConnection();
            // 设置连接请求方式
            connection.setRequestMethod("POST");
            // 设置连接主机服务器超时时间：15000毫秒
            connection.setConnectTimeout(15000);
            // 设置读取主机服务器返回数据超时时间：60000毫秒
            connection.setReadTimeout(60000);
            // 默认值为：false，当向远程服务器传送数据/写数据时，需要设置为true
            connection.setDoOutput(true);
            connection.setRequestProperty("token", "您申请接口的token"); //在个人中心->我的数据,接口名称上方查看
            connection.setRequestProperty("timestamp", "1676766665"); //当前时间戳 :误差范围必须小于 5 分钟
            connection.setRequestProperty("sign", "aedc77b7476278c8e780446ae4af6720"); //token和 timestamp 拼接之后的 md5，32 位小写
            connection.setRequestProperty("content-type", "application/json"); //请求内容类型
            
            // 通过连接对象获取一个输出流
            outputStream = connection.getOutputStream();
            // 通过输出流对象将参数写出去/传输出去,它是通过字节数组写出的
            outputStream.write(paramStr.getBytes());
            // 通过连接对象获取一个输入流，向远程读取
            if (connection.getResponseCode() == 200) {
                inputStream = connection.getInputStream();
                // 对输入流对象进行包装:charset根据工作项目组的要求来设置
                bufferedReader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
                StringBuilder sbf = new StringBuilder();
                String temp;
                // 循环遍历一行一行读取数据
                while ((temp = bufferedReader.readLine()) != null) {
                    sbf.append(temp);
                    sbf.append(System.getProperty("line.separator"));
                }
                result = sbf.toString();
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭资源
            if (null != bufferedReader) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != outputStream) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != inputStream) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (connection != null) {
                connection.disconnect();
            }
        }
        return result;
    }
}