Java实现1688拍立淘接口（item_search_img）完整技术指南

签名步骤：1. 将所有参数（除sign外）按参数名ASCII升序排序2. 拼接为 key1value1key2value2... 格式（无连接符）3. 在字符串首尾各拼接一次 app_secret4. MD5加密，结果转大写

<dependencies>
    <!-- HTTP客户端 -->
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5.14</version>
    </dependency>
    
    <!-- JSON处理 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>2.0.43</version>
    </dependency>
    
    <!-- 图片处理（用于压缩和Base64编码） -->
    <dependency>
        <groupId>javax.imageio</groupId>
        <artifactId>imageio-core</artifactId>
        <version>3.8.2</version>
    </dependency>
    
    <!-- Lombok简化代码 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.30</version>
        <scope>provided</scope>
    </dependency></dependencies>

import java.security.MessageDigest;import java.util.Comparator;import java.util.Map;import java.util.TreeMap;/**
 * 1688 API签名工具类
 * 实现1688开放平台MD5签名算法（首尾拼接app_secret）
 */public class AlibabaApiSigner {
    
    /**
     * 生成MD5签名
     * @param params 请求参数（不含sign）
     * @param appSecret 应用密钥
     * @return 大写签名字符串（32位）
     */
    public static String generateSign(Map<String, String> params, String appSecret) {
        // 1. 使用TreeMap按ASCII升序排序
        TreeMap<String, String> sortedParams = new TreeMap<>(Comparator.naturalOrder());
        sortedParams.putAll(params);
        
        // 2. 拼接字符串：key+value（无分隔符）
        StringBuilder signBuilder = new StringBuilder();
        for (Map.Entry<String, String> entry : sortedParams.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            
            // 跳过空值、sign参数本身，以及值为null的字段
            if (value != null && !value.isEmpty() && !"sign".equals(key)) {
                signBuilder.append(key).append(value);
            }
        }
        
        // 3. 首尾拼接appSecret
        String signStr = appSecret + signBuilder.toString() + appSecret;
        
        // 4. MD5加密并转大写
        return md5(signStr).toUpperCase();
    }
    
    /**
     * MD5加密（UTF-8编码）
     */
    private static String md5(String str) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            byte[] digest = md.digest(str.getBytes("UTF-8"));
            
            StringBuilder sb = new StringBuilder();
            for (byte b : digest) {
                String hex = Integer.toHexString(b & 0xFF);
                if (hex.length() == 1) {
                    sb.append("0");
                }
                sb.append(hex);
            }
            return sb.toString();
        } catch (Exception e) {
            throw new RuntimeException("MD5加密失败: " + e.getMessage(), e);
        }
    }
    
    /**
     * 验证签名（用于调试）
     */
    public static boolean verifySign(Map<String, String> params, String appSecret, String expectedSign) {
        String generatedSign = generateSign(params, appSecret);
        return generatedSign.equals(expectedSign);
    }}

import javax.imageio.ImageIO;import java.awt.Graphics2D;import java.awt.Image;import java.awt.image.BufferedImage;import java.io.ByteArrayOutputStream;import java.io.File;import java.io.IOException;import java.net.URL;import java.util.Base64;/**
 * 图片处理工具类
 * 支持本地图片压缩、Base64编码、URL图片下载
 */public class ImageProcessor {
    
    private static final int MAX_SIZE = 5 * 1024 * 1024; // 5MB限制
    private static final int TARGET_WIDTH = 800; // 目标宽度
    
    /**
     * 本地图片转Base64（自动压缩）
     * @param filePath 本地图片路径
     * @return Base64编码字符串（不含data:image前缀）
     */
    public static String localImageToBase64(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            throw new IOException("图片文件不存在: " + filePath);
        }
        
        // 读取图片
        BufferedImage originalImage = ImageIO.read(file);
        if (originalImage == null) {
            throw new IOException("无法读取图片格式: " + filePath);
        }
        
        // 智能压缩
        BufferedImage compressedImage = compressImage(originalImage);
        
        // 转为Base64
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        String format = getImageFormat(filePath);
        ImageIO.write(compressedImage, format, baos);
        byte[] imageBytes = baos.toByteArray();
        
        // 检查大小
        if (imageBytes.length > MAX_SIZE) {
            throw new IOException("图片压缩后仍超过5MB限制");
        }
        
        return Base64.getEncoder().encodeToString(imageBytes);
    }
    
    /**
     * 从URL下载图片并转Base64
     */
    public static String urlImageToBase64(String imageUrl) throws IOException {
        URL url = new URL(imageUrl);
        BufferedImage image = ImageIO.read(url);
        if (image == null) {
            throw new IOException("无法从URL读取图片");
        }
        
        BufferedImage compressed = compressImage(image);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ImageIO.write(compressed, "jpg", baos);
        
        return Base64.getEncoder().encodeToString(baos.toByteArray());
    }
    
    /**
     * 等比压缩图片
     */
    private static BufferedImage compressImage(BufferedImage original) {
        int originalWidth = original.getWidth();
        int originalHeight = original.getHeight();
        
        // 如果图片小于目标尺寸，不压缩
        if (originalWidth <= TARGET_WIDTH) {
            return original;
        }
        
        // 计算等比缩放后的高度
        int targetHeight = (int) ((double) originalHeight / originalWidth * TARGET_WIDTH);
        
        Image scaledImage = original.getScaledInstance(TARGET_WIDTH, targetHeight, Image.SCALE_SMOOTH);
        BufferedImage bufferedImage = new BufferedImage(TARGET_WIDTH, targetHeight, BufferedImage.TYPE_INT_RGB);
        
        Graphics2D g2d = bufferedImage.createGraphics();
        g2d.drawImage(scaledImage, 0, 0, null);
        g2d.dispose();
        
        return bufferedImage;
    }
    
    /**
     * 获取图片格式
     */
    private static String getImageFormat(String filePath) {
        String ext = filePath.substring(filePath.lastIndexOf(".") + 1).toLowerCase();
        return switch (ext) {
            case "jpg", "jpeg" -> "jpg";
            case "png" -> "png";
            case "gif" -> "gif";
            default -> "jpg";
        };
    }}

import com.alibaba.fastjson.JSON;import com.alibaba.fastjson.JSONArray;import com.alibaba.fastjson.JSONObject;import org.apache.http.client.methods.CloseableHttpResponse;import org.apache.http.client.methods.HttpPost;import org.apache.http.entity.StringEntity;import org.apache.http.impl.client.CloseableHttpClient;import org.apache.http.impl.client.HttpClients;import org.apache.http.util.EntityUtils;import java.io.IOException;import java.net.URLEncoder;import java.text.SimpleDateFormat;import java.util.*;/**
 * 1688拍立淘API客户端
 * 支持图片URL和本地图片两种方式搜索
 */public class ItemSearchImgClient {
    
    private final String appKey;
    private final String appSecret;
    private final String apiUrl;
    
    // 1688开放平台网关地址
    private static final String GATEWAY_URL = "https://gw.open.1688.com/openapi/param2/2/portals.open/";
    
    public ItemSearchImgClient(String appKey, String appSecret) {
        this.appKey = appKey;
        this.appSecret = appSecret;
        this.apiUrl = GATEWAY_URL + "api.itemSearchImg/" + appKey;
    }
    
    /**
     * 使用图片URL搜索
     * @param imageUrl 公网可访问的图片URL（推荐阿里CDN地址）
     * @param searchParam 搜索参数
     * @return 搜索结果
     */
    public SearchResult searchByImageUrl(String imageUrl, SearchParam searchParam) throws Exception {
        Map<String, String> params = buildBaseParams(searchParam);
        params.put("imgUrl", imageUrl); // 注意：部分版本使用imgid或image_url
        
        return executeSearch(params);
    }
    
    /**
     * 使用本地图片搜索（Base64编码）
     * @param imageBase64 图片Base64编码（不含data:image前缀）
     * @param searchParam 搜索参数
     * @return 搜索结果
     */
    public SearchResult searchByImageBase64(String imageBase64, SearchParam searchParam) throws Exception {
        Map<String, String> params = buildBaseParams(searchParam);
        params.put("image", imageBase64);
        
        return executeSearch(params);
    }
    
    /**
     * 构建基础参数
     */
    private Map<String, String> buildBaseParams(SearchParam param) {
        Map<String, String> params = new HashMap<>();
        
        // 系统级参数
        params.put("app_key", appKey);
        params.put("method", "portals.open.api.itemSearchImg");
        params.put("format", "json");
        params.put("v", "1.0");
        params.put("timestamp", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        
        // 业务级参数
        if (param.getPage() != null) {
            params.put("page", String.valueOf(param.getPage()));
        }
        if (param.getPageSize() != null) {
            params.put("pageSize", String.valueOf(param.getPageSize()));
        }
        if (param.getSort() != null) {
            params.put("sort", param.getSort());
        }
        if (param.getCatId() != null) {
            params.put("catId", param.getCatId());
        }
        if (param.getPriceStart() != null) {
            params.put("priceStart", param.getPriceStart());
        }
        if (param.getPriceEnd() != null) {
            params.put("priceEnd", param.getPriceEnd());
        }
        
        return params;
    }
    
    /**
     * 执行搜索请求
     */
    private SearchResult executeSearch(Map<String, String> params) throws Exception {
        // 生成签名
        String sign = AlibabaApiSigner.generateSign(params, appSecret);
        params.put("sign", sign);
        
        // 发送POST请求
        String response = sendPostRequest(apiUrl, params);
        
        // 解析响应
        return parseResponse(response);
    }
    
    /**
     * 发送HTTP POST请求（表单格式）
     */
    private String sendPostRequest(String url, Map<String, String> params) throws IOException {
        CloseableHttpClient client = HttpClients.createDefault();
        HttpPost post = new HttpPost(url);
        
        // 构建表单参数
        List<String> formParams = new ArrayList<>();
        for (Map.Entry<String, String> entry : params.entrySet()) {
            formParams.add(entry.getKey() + "=" + URLEncoder.encode(entry.getValue(), "UTF-8"));
        }
        String formData = String.join("&", formParams);
        
        post.setEntity(new StringEntity(formData, "application/x-www-form-urlencoded", "UTF-8"));
        post.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=UTF-8");
        
        try (CloseableHttpResponse response = client.execute(post)) {
            return EntityUtils.toString(response.getEntity(), "UTF-8");
        }
    }
    
    /**
     * 解析API响应
     */
    private SearchResult parseResponse(String response) {
        JSONObject json = JSON.parseObject(response);
        
        // 检查错误
        if (json.containsKey("error_response")) {
            JSONObject error = json.getJSONObject("error_response");
            String code = error.getString("code");
            String msg = error.getString("msg");
            throw new RuntimeException(String.format("API调用失败: %s (错误码: %s)", msg, code));
        }
        
        // 提取结果
        JSONObject result = json.getJSONObject("item_search_img_response");
        if (result == null) {
            result = json.getJSONObject("result");
        }
        
        SearchResult searchResult = new SearchResult();
        
        // 分页信息
        searchResult.setPage(result.getIntValue("page", 1));
        searchResult.setPageSize(result.getIntValue("pageSize", 20));
        searchResult.setTotalResults(result.getIntValue("totalResults", 0));
        searchResult.setRealTotalResults(result.getIntValue("realTotalResults", 0));
        searchResult.setPageCount(result.getIntValue("pagecount", 0));
        
        // 商品列表
        JSONArray items = result.getJSONArray("items");
        if (items == null && result.containsKey("item")) {
            items = result.getJSONArray("item");
        }
        
        List<ProductItem> productList = new ArrayList<>();
        if (items != null) {
            for (int i = 0; i < items.size(); i++) {
                JSONObject item = items.getJSONObject(i);
                ProductItem product = parseProductItem(item);
                productList.add(product);
            }
        }
        
        searchResult.setItems(productList);
        return searchResult;
    }
    
    /**
     * 解析单个商品
     */
    private ProductItem parseProductItem(JSONObject item) {
        ProductItem product = new ProductItem();
        
        // 基础信息
        product.setProductId(item.getString("productId"));
        product.setOfferId(item.getString("offerId"));
        product.setTitle(item.getString("title"));
        product.setPicUrl(item.getString("picUrl"));
        product.setDetailUrl(item.getString("detailUrl"));
        
        // 价格信息（兼容单值和区间两种格式）[^20^]
        if (item.containsKey("price")) {
            Object priceObj = item.get("price");
            if (priceObj instanceof Number) {
                product.setPrice(item.getDoubleValue("price"));
                product.setMinPrice(product.getPrice());
                product.setMaxPrice(product.getPrice());
            } else if (priceObj instanceof JSONObject) {
                JSONObject priceJson = (JSONObject) priceObj;
                product.setMinPrice(priceJson.getDoubleValue("min_price"));
                product.setMaxPrice(priceJson.getDoubleValue("max_price"));
                product.setPrice(product.getMinPrice());
            }
        }
        
        // 销量信息
        if (item.containsKey("sales")) {
            product.setSales(item.getIntValue("sales"));
        }
        if (item.containsKey("transaction")) {
            JSONObject trans = item.getJSONObject("transaction");
            product.setSalesCount(trans.getIntValue("sales_count"));
            product.setTurnover(trans.getDoubleValue("turnover"));
        }
        
        // 起订量（MOQ）[^20^]
        product.setMoq(item.getIntValue("moq", 1));
        
        // 相似度（0-100或0-1）[^20^]
        double similarity = item.getDoubleValue("similarity", 0);
        if (similarity <= 1) similarity *= 100; // 统一转为百分比
        product.setSimilarity(similarity);
        
        // 供应商信息
        product.setSupplierId(item.getString("supplierId"));
        product.setSupplierName(item.getString("supplierName"));
        product.setShopName(item.getString("shopName"));
        product.setLocation(item.getString("location"));
        product.setCreditLevel(item.getString("creditLevel"));
        
        // 类目信息
        product.setCatId(item.getString("catId"));
        product.setCatName(item.getString("catName"));
        
        return product;
    }}

import lombok.Data;import java.util.List;/**
 * 搜索参数
 */@Datapublic class SearchParam {
    private Integer page = 1;           // 页码，默认1
    private Integer pageSize = 20;      // 每页数量，默认20，最大100
    private String sort;                // 排序：default(综合), sales(销量), price_up(价格升), price_down(价格降)
    private String catId;               // 类目ID过滤
    private String priceStart;          // 价格区间起始
    private String priceEnd;            // 价格区间结束
    private Boolean supportDropshipping; // 支持一件代发
    private Boolean isFactory;          // 源头工厂
    private Boolean verifiedSupplier;   // 认证供应商}/**
 * 搜索结果
 */@Datapublic class SearchResult {
    private int page;                   // 当前页
    private int pageSize;               // 每页数量
    private int totalResults;           // 本次可翻页总量
    private int realTotalResults;       // 实际命中总量（同款+相似款）
    private int pageCount;              // 总页数
    private List<ProductItem> items;    // 商品列表}/**
 * 商品信息
 */@Datapublic class ProductItem {
    // 基础信息
    private String productId;           // 商品ID
    private String offerId;             // 1688商品ID
    private String title;               // 商品标题
    private String picUrl;              // 主图URL
    private String detailUrl;           // 详情页链接
    
    // 价格信息
    private Double price;               // 当前价格
    private Double minPrice;            // 最低价格
    private Double maxPrice;            // 最高价格
    
    // 交易信息
    private Integer sales;              // 销量（简化版）
    private Integer salesCount;         // 30天销量（完整版）
    private Double turnover;            // 30天成交额
    private Integer moq;                // 最小起订量（Minimum Order Quantity）
    
    // 相似度
    private Double similarity;          // 相似度（0-100%）
    
    // 供应商信息
    private String supplierId;          // 供应商ID
    private String supplierName;        // 供应商名称
    private String shopName;            // 店铺名称
    private String location;            // 发货地
    private String creditLevel;         // 信用等级
    
    // 类目信息
    private String catId;               // 类目ID
    private String catName;             // 类目名称}

/**
 * 1688拍立淘使用示例
 */public class ItemSearchImgDemo {
    
    public static void main(String[] args) {
        // 配置应用凭证（替换为实际值）
        String appKey = "your_app_key_here";
        String appSecret = "your_app_secret_here";
        
        // 初始化客户端
        ItemSearchImgClient client = new ItemSearchImgClient(appKey, appSecret);
        
        try {
            // 场景1：使用图片URL搜索（推荐，速度更快）
            String imageUrl = "https://img.alicdn.com/imgextra/i3/15353738/TB2HDHAqN9YBuNjy0FfXXXIsVXa_!!15353738-0-beehive-scenes.jpg";
            
            SearchParam param = new SearchParam();
            param.setPage(1);
            param.setPageSize(20);
            param.setSort("sales"); // 按销量排序
            
            System.out.println("=== 使用图片URL搜索 ===");
            SearchResult result = client.searchByImageUrl(imageUrl, param);
            displayResults(result);
            
            // 场景2：使用本地图片搜索
            String localImagePath = "/path/to/your/local/image.jpg";
            String base64Image = ImageProcessor.localImageToBase64(localImagePath);
            
            System.out.println("\n=== 使用本地图片搜索 ===");
            SearchResult result2 = client.searchByImageBase64(base64Image, param);
            displayResults(result2);
            
            // 场景3：分页获取所有结果（前5页）
            System.out.println("\n=== 批量获取多页结果 ===");
            List<ProductItem> allItems = fetchAllPages(client, imageUrl, 5);
            System.out.println("共获取商品数: " + allItems.size());
            
        } catch (Exception e) {
            System.err.println("搜索失败: " + e.getMessage());
            e.printStackTrace();
        }
    }
    
    /**
     * 展示搜索结果
     */
    private static void displayResults(SearchResult result) {
        System.out.printf("找到 %d 个相似商品（第 %d/%d 页）%n", 
            result.getRealTotalResults(), result.getPage(), result.getPageCount());
        System.out.println("=".repeat(100));
        
        for (int i = 0; i < result.getItems().size(); i++) {
            ProductItem item = result.getItems().get(i);
            
            // 相似度分级显示 [^20^]
            String similarityLevel;
            if (item.getSimilarity() >= 90) {
                similarityLevel = "【高概率同款】";
            } else if (item.getSimilarity() >= 80) {
                similarityLevel = "【款式接近】";
            } else if (item.getSimilarity() >= 60) {
                similarityLevel = "【相似元素】";
            } else {
                similarityLevel = "【弱相关】";
            }
            
            System.out.printf("%d. %s %s%n", i + 1, similarityLevel, item.getTitle());
            System.out.printf("   价格: ¥%.2f - ¥%.2f  起订量: %d件%n", 
                item.getMinPrice(), item.getMaxPrice(), item.getMoq());
            System.out.printf("   30天销量: %d件  相似度: %.1f%%%n", 
                item.getSalesCount(), item.getSimilarity());
            System.out.printf("   供应商: %s (%s)  信用: %s%n", 
                item.getSupplierName(), item.getLocation(), item.getCreditLevel());
            System.out.printf("   链接: %s%n", item.getDetailUrl());
            System.out.println("-".repeat(100));
        }
    }
    
    /**
     * 批量获取多页结果
     */
    private static List<ProductItem> fetchAllPages(ItemSearchImgClient client, 
                                                   String imageUrl, int maxPages) throws Exception {
        List<ProductItem> allItems = new ArrayList<>();
        
        for (int page = 1; page <= maxPages; page++) {
            SearchParam param = new SearchParam();
            param.setPage(page);
            param.setPageSize(100); // 使用最大页大小减少请求次数
            param.setSort("default");
            
            SearchResult result = client.searchByImageUrl(imageUrl, param);
            allItems.addAll(result.getItems());
            
            System.out.printf("获取第 %d 页，本页 %d 条，累计 %d 条%n", 
                page, result.getItems().size(), allItems.size());
            
            // 检查是否已到最后一页
            if (page >= result.getPageCount() || result.getItems().isEmpty()) {
                break;
            }
            
            // 添加延迟，避免触发频率限制
            Thread.sleep(1500);
        }
        
        return allItems;
    }}

// 单SKU简化版（最常见）{
    "price": 99.0,
    "sales": 1050}// 多SKU完整版{
    "price": {
        "min_price": 85.0,
        "max_price": 120.0,
        "unit": "件"
    },
    "transaction": {
        "sales_count": 327,
        "turnover": 42156.5  // 30天成交额（元）
    }}

/**
 * 图片上传服务（将外部图片转为阿里CDN地址）
 */public class ImageUploadService {
    
    private final String appKey;
    private final String appSecret;
    
    public String uploadImage(byte[] imageData) throws Exception {
        // 调用1688图片上传接口
        // 返回格式: https://img.alicdn.com/imgextra/xxx.jpg
        // 实际实现需参考1688.upload.img接口文档
        return "https://img.alicdn.com/imgextra/xxx.jpg";
    }}

import java.util.concurrent.*;public class BatchImageSearchService {
    
    private final ExecutorService executor = Executors.newFixedThreadPool(10);
    private final ItemSearchImgClient client;
    
    public CompletableFuture<List<ProductItem>> searchAsync(String imageUrl) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                SearchParam param = new SearchParam();
                param.setPageSize(50);
                SearchResult result = client.searchByImageUrl(imageUrl, param);
                return result.getItems();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }, executor);
    }}

/**
 * 带重试机制的搜索
 */public SearchResult searchWithRetry(String imageUrl, SearchParam param, int maxRetries) {
    int attempts = 0;
    while (attempts < maxRetries) {
        try {
            return client.searchByImageUrl(imageUrl, param);
        } catch (Exception e) {
            attempts++;
            if (attempts >= maxRetries) throw e;
            
            // 指数退避
            long waitTime = (long) Math.pow(2, attempts) * 1000;
            try {
                Thread.sleep(waitTime);
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt();
                throw new RuntimeException(ie);
            }
        }
    }
    return null;}