API 文档

import time
import hashlib
import hmac
import requests

API_KEY = "your_api_key"
API_SECRET = "your_api_secret"
BASE_URL = "https://api.lijinbu.cn"
IMAGE_PATH = "/path/to/image.jpg"

def md5_file(path: str) -> str:
    md5 = hashlib.md5()
    with open(path, "rb") as f:
        for chunk in iter(lambda: f.read(8192), b""):
            md5.update(chunk)
    return md5.hexdigest()

def generate_signature(timestamp: str, api_key: str, api_secret: str, payload: str) -> str:
    sign_string = f"{timestamp}{api_key}{payload}"
    return hmac.new(
        api_secret.encode("utf-8"),
        sign_string.encode("utf-8"),
        hashlib.sha256,
    ).hexdigest()

# 1. 提交异步任务
timestamp = str(int(time.time()))
file_md5 = md5_file(IMAGE_PATH)
signature = generate_signature(timestamp, API_KEY, API_SECRET, file_md5)

headers = {
    "X-API-Key": API_KEY,
    "X-Timestamp": timestamp,
    "X-Signature": signature,
}
with open(IMAGE_PATH, "rb") as f:
    files = {"file": f}
    resp = requests.post(f"{BASE_URL}/v1/recognize/async",
                         headers=headers,
                         files=files).json()

request_id = resp["data"]["requestId"]

# 2. 轮询查询结果
while True:
    time.sleep(2)
    ts = str(int(time.time()))
    poll_sig = generate_signature(ts, API_KEY, API_SECRET, request_id)
    poll_headers = {
        "X-API-Key": API_KEY,
        "X-Timestamp": ts,
        "X-Signature": poll_sig,
    }
    r = requests.get(f"{BASE_URL}/v1/recognize/result/{request_id}",
                     headers=poll_headers).json()
    data = r["data"]
    status = data["status"]
    print("status:", status)
    if status == "pending":
        continue
    elif status == "success":
        print("records:", data["records"])
        print("total:", data["total"])
    else:
        print("failed:", data.get("errorMsg"))
    break

OkHttpClient client = new OkHttpClient();

File file = new File("/path/to/image.jpg");
MediaType mediaType = MediaType.parse("image/jpeg");

RequestBody body = new MultipartBody.Builder()
    .setType(MultipartBody.FORM)
    .addFormDataPart("file", file.getName(),
        RequestBody.create(file, mediaType))
    .build();

// 1. 提交异步任务
long ts = System.currentTimeMillis() / 1000;
String fileMd5 = org.apache.commons.codec.digest.DigestUtils.md5Hex(new java.io.FileInputStream(file));
String signString = ts + "your_api_key" + fileMd5;
javax.crypto.Mac mac = javax.crypto.Mac.getInstance("HmacSHA256");
mac.init(new javax.crypto.spec.SecretKeySpec("your_api_secret".getBytes("UTF-8"), "HmacSHA256"));
String signature = javax.xml.bind.DatatypeConverter.printHexBinary(
        mac.doFinal(signString.getBytes("UTF-8"))
).toLowerCase();

Request asyncReq = new Request.Builder()
    .url("https://api.lijinbu.cn/v1/recognize/async")
    .addHeader("X-API-Key", "your_api_key")
    .addHeader("X-Timestamp", String.valueOf(ts))
    .addHeader("X-Signature", signature)
    .post(body)
    .build();

String requestId;
try (Response resp = client.newCall(asyncReq).execute()) {
    String json = resp.body().string();
    // 解析 JSON 获取 requestId（略）
    requestId = "...";
}

// 2. 轮询查询结果
while (true) {
    Thread.sleep(2000);
    long pollTs = System.currentTimeMillis() / 1000;
    String pollSignString = pollTs + "your_api_key" + requestId;
    javax.crypto.Mac pollMac = javax.crypto.Mac.getInstance("HmacSHA256");
    pollMac.init(new javax.crypto.spec.SecretKeySpec("your_api_secret".getBytes("UTF-8"), "HmacSHA256"));
    String pollSignature = javax.xml.bind.DatatypeConverter.printHexBinary(
            pollMac.doFinal(pollSignString.getBytes("UTF-8"))
    ).toLowerCase();

    Request pollReq = new Request.Builder()
        .url("https://api.lijinbu.cn/v1/recognize/result/" + requestId)
        .addHeader("X-API-Key", "your_api_key")
        .addHeader("X-Timestamp", String.valueOf(pollTs))
        .addHeader("X-Signature", pollSignature)
        .get()
        .build();
    try (Response resp = client.newCall(pollReq).execute()) {
        String json = resp.body().string();
        // 解析 JSON，判断 data.status 是否为 pending/success/failed
    }
}

import axios from "axios";
import FormData from "form-data";
import fs from "fs";
import crypto from "crypto";

const API_KEY = "your_api_key";
const API_SECRET = "your_api_secret";
const BASE_URL = "https://api.lijinbu.cn";
const IMAGE_PATH = "/path/to/image.jpg";

function md5File(path) {
  const hash = crypto.createHash("md5");
  const data = fs.readFileSync(path);
  hash.update(data);
  return hash.digest("hex");
}

function generateSignature(timestamp, apiKey, apiSecret, payload) {
  const signString = `${timestamp}${apiKey}${payload}`;
  return crypto.createHmac("sha256", apiSecret).update(signString).digest("hex");
}

// 1. 提交异步任务
const ts = Math.floor(Date.now() / 1000).toString();
const fileMd5 = md5File(IMAGE_PATH);
const sig = generateSignature(ts, API_KEY, API_SECRET, fileMd5);

const form = new FormData();
form.append("file", fs.createReadStream(IMAGE_PATH));

const asyncResp = await axios.post(`${BASE_URL}/v1/recognize/async`, form, {
  headers: {
    "X-API-Key": API_KEY,
    "X-Timestamp": ts,
    "X-Signature": sig,
    ...form.getHeaders(),
  },
});

const requestId = asyncResp.data.data.requestId;

// 2. 轮询查询结果
while (true) {
  await new Promise((r) => setTimeout(r, 2000));
  const pollTs = Math.floor(Date.now() / 1000).toString();
  const pollSig = generateSignature(pollTs, API_KEY, API_SECRET, requestId);
  const pollResp = await axios.get(
    `${BASE_URL}/v1/recognize/result/${requestId}`,
    {
      headers: {
        "X-API-Key": API_KEY,
        "X-Timestamp": pollTs,
        "X-Signature": pollSig,
      },
    }
  );
  const data = pollResp.data.data;
  console.log("status:", data.status);
  if (data.status === "pending") continue;
  if (data.status === "success") {
    console.log("records:", data.records);
    console.log("total:", data.total);
  } else {
    console.log("failed:", data.errorMsg);
  }
  break;
}

const apiKey = "your_api_key"
const apiSecret = "your_api_secret"
const baseURL = "https://api.lijinbu.cn"

// 1. 提交异步任务（参考同步示例构造 multipart 请求到 /v1/recognize/async，签名 payload 为文件 MD5）
// 返回 JSON 中 data.requestId 即为异步查询 ID
requestId := "..."

// 2. 轮询查询结果
for {
    time.Sleep(2 * time.Second)

    ts := fmt.Sprintf("%d", time.Now().Unix())
    payload := requestId
    signString := ts + apiKey + payload
    mac := hmac.New(sha256.New, []byte(apiSecret))
    mac.Write([]byte(signString))
    sig := hex.EncodeToString(mac.Sum(nil))

    req, _ := http.NewRequest("GET",
        fmt.Sprintf("%s/v1/recognize/result/%s", baseURL, requestId), nil)
    req.Header.Set("X-API-Key", apiKey)
    req.Header.Set("X-Timestamp", ts)
    req.Header.Set("X-Signature", sig)

    resp, _ := http.DefaultClient.Do(req)
    body, _ := io.ReadAll(resp.Body)
    resp.Body.Close()

    fmt.Println(string(body))
    // 根据 JSON 中的 data.status 判断 pending/success/failed
}