Java——聚水潭API调用（SDK）Orders订单信息

已于 2024-06-11 09:15:34 修改
阅读量2k 收藏 23
点赞数 20
分类专栏： Java 文章标签： java spring boot mysql mybatis
于 2024-03-13 17:17:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43023754/article/details/136684689
版权

〇、场景

1、紧接上篇 Java——聚水潭API调用（SDK）Sku商品信息
2、需求：调用聚水潭Orders API接口拉取数据，并存入到本地数据库。
3、技术：Spring Boot + MyBatis-Plus + MySQL

一、SDK调用说明

1、聚水潭开放平台SDK集成了API的请求封装、摘要签名，以及简单的响应解释等功能，使用SDK可以轻松完成API的调用，API结果的获取。
2、SDK只能用于API接口的调用，不能用于授权接口的调用。

通过该链接地址访问SDK详细说明，并下载SDK。链接: link，或访问聚水潭官方文档。
在这里插入图片描述

二、Orders订单信息API

环境Http请求地址
正式环境https://openapi.jushuitan.com/open/orders/single/query
测试环境https://dev-api.jushuitan.com/open/orders/single/query

三、将下载后的SDK Jar包添加至项目中

打开 File 菜单，点击 Project Structure，点击 Modules，点击 Dependencies，点击 + 号，选择 JARs or Directories...，找到下载SDK Jar包，点击OK添加成功

在这里插入图片描述

四、上代码

1、pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.3.2</version>
</dependency>
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.4.1</version>
</dependency>
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.0</version>
</dependency>
<dependency>
    <groupId>io.swagger</groupId>
    <artifactId>swagger-annotations</artifactId>
    <version>1.5.13</version>
</dependency>
<dependency>
    <groupId>net.sf.json-lib</groupId>
    <artifactId>json-lib</artifactId>
    <version>2.4</version>
    <classifier>jdk15</classifier>
</dependency>

2、MySQL数据表

-- 聚水潭Access_Token
CREATE TABLE access_token (
	id BIGINT(20) PRIMARY KEY COMMENT 'id',
	expires_in VARCHAR(20) comment 'access_token有效期',
	access_token VARCHAR(255) comment '访问令牌',
	scope VARCHAR(20) comment '固定值all',
	refresh_token VARCHAR(255) comment '更新令牌',
	expiration_time VARCHAR(20) comment '过期时间'
);
-- 聚水潭订单
CREATE TABLE orders (
	id VARCHAR(20) PRIMARY KEY COMMENT 'id',
	o_id VARCHAR(30) comment '聚水潭订单号',
	so_id VARCHAR(30) comment '线上订单号',
	l_id VARCHAR(30) comment '快递单号',
	order_date VARCHAR(30) comment '订单日期',
	type VARCHAR(25) comment '订单类型',
	shop_id VARCHAR(30) comment '店铺编号',
	shop_name VARCHAR(30) comment '店铺名称',
	order_from VARCHAR(25) comment '订单来源',
	order_status VARCHAR(25) comment '订单状态',
	shop_status VARCHAR(25) comment '平台订单状态',
	co_id VARCHAR(20) comment '公司编号',
	lc_id VARCHAR(20) comment '物流公司编号',
	logistics_company VARCHAR(20) comment '快递公司',
	wms_co_id VARCHAR(20) comment '发货仓编码',
	pay_amount DOUBLE comment '应付金额',
	paid_amount DOUBLE comment '实际支付金额',
	modified VARCHAR(30) comment '修改时间',
	longTime LONG comment '长时间',
	referrer_id VARCHAR(30) comment '主播id',
	labels VARCHAR(200) comment '标签',
	remark VARCHAR(500) comment '备注',
	create_date VARCHAR(30) comment '创建日期',
	isSyn TINYINT(1) comment '是否同步'
);
-- 聚水潭订单明细
CREATE TABLE orders_detail (
	id VARCHAR(20) PRIMARY KEY COMMENT 'id',
	seq BIGINT(20) comment '序号',
	parent_id VARCHAR(20) comment '父id',
	o_id VARCHAR(30) comment '聚水潭订单号',
	sku_id VARCHAR(30) comment '商品编码',
	sku_name VARCHAR(100) comment '商品名称',
	is_gift TINYINT(1) comment '是否赠品',
	base_price DOUBLE comment '基本售价（原价）',
	price DOUBLE comment '单价',
	amount DOUBLE comment '金额',
	qty DOUBLE comment '数量'
);
-- 日志
CREATE TABLE log (
	id BIGINT(20) PRIMARY KEY COMMENT 'id',
	requestTime VARCHAR(20) comment '请求时间',
	msg VARCHAR(255) comment '日志信息'
);

3、使用MyBatis-Plus生成entity、mapper、service文件，这里entity和mapper文件就不展示出来了。

  • AccessTokenSerivce.java
import com.xjmy.jushuitan.entity.AccessToken;
import com.xjmy.jushuitan.mapper.AccessTokenMapper;
import net.sf.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.text.SimpleDateFormat;
import java.util.Date;


@Service
public class AccessTokenService {

    @Autowired
    AccessTokenMapper accessTokenMapper;

    /**
     * 插入数据
     * @param jsonObject JSON数据
     */
    public void insertData(JSONObject jsonObject) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        AccessToken accessToken = new AccessToken();
        accessToken.setAccessToken(jsonObject.getString("access_token")); //访问令牌
        accessToken.setRefreshToken(jsonObject.getString("refresh_token")); //更新令牌
        accessToken.setScope(jsonObject.getString("scope")); //固定值all
        accessToken.setExpiresIn(jsonObject.getString("expires_in")); //access_token有效期
        Long expirationTime = System.currentTimeMillis() / 1000 + Long.valueOf(jsonObject.getString("expires_in")) - 3600;
        //过期时间设置提前设置1小时
        Date date = new Date(expirationTime * 1000);
        accessToken.setExpirationTime(sdf.format(date)); //过期时间
        //保存到数据库
        accessTokenMapper.insert(accessToken);
        System.out.println("access_token数据保存成功!");
    }

    /**
     * 查询AccessToken
     * @return
     */
    public String selectAccessToken() {
        AccessToken accessToken = accessTokenMapper.selectOne(null);
        return accessToken.getAccessToken();
    }

    /**
     * 查询RefreshToken
     * @return
     */
    public String selectRefreshToken() {
        AccessToken accessToken = accessTokenMapper.selectOne(null);
        return accessToken.getRefreshToken();
    }

    /**
     * 删除AccessToken
     */
    public void deleteAccessToken() {
        accessTokenMapper.delete(null);
    }

    /**
     * 查询一条数据
     */
    public AccessToken selectOne() {
        AccessToken accessTokenObj = accessTokenMapper.selectOne(null);
        return accessTokenObj;
    }

}
  • ApiService.java
import com.jushuitan.api.*;
import com.jushuitan.api.util.AuthUtil;
import com.xjmy.jushuitan.utils.OtherUtils;
import net.sf.json.JSONObject;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @Description: 聚水潭API
 */
@Service
public class ApiService {
    @Autowired
    AccessTokenService accessTokenService;
    @Autowired
    LogService logService;

	/**
	 * @param url 具体API URL地址
	 * @param biz 参数
	 */
    public String requestApi(String url, String biz) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String result = "";
        // 实例化client
        ApiClient client = new DefaultApiClient();
        // 设置超时时间
        ((DefaultApiClient)client).setReadTimeout(3000);
        ((DefaultApiClient)client).setConnectTimeout(2000);

        // 替换为POP分配给应用的app_key,app_secret,accessToken等
        String appKey = "";
        String appSecret = "";
        ApiResponse response = null; //API响应结果
        // 执行接口调用
        try {
            // 构建请求对象
            ApiRequest request = new ApiRequest.Builder(url, appKey, appSecret).biz(biz).build();
            // 查询数据库中accessToken
            String accessToken = accessTokenService.selectAccessToken();
            if (!StringUtils.isEmpty(accessToken)) {
                response = client.execute(request, accessToken);
                JSONObject responseJson =  JSONObject.fromObject(response.getBody());
                // 判断该accessToken是否失效，失效则调用refreshToken()刷新accessToken
                if (responseJson.getInt("code") == 100) {
                    // 获取存在数据库中的 refreshToken
                    String refreshToken = accessTokenService.selectRefreshToken();
                    // 构建获取AccessToken请求对象
                    AuthRequest authRequest = new AuthRequest.Builder(appKey,appSecret).code(OtherUtils.get6UUID()).refreshToken(refreshToken).build();
                    // 刷新AccessToken
                    String accessTokenInfo = AuthUtil.refreshToken(authRequest);
                    JSONObject accessTokenJson = JSONObject.fromObject(accessTokenInfo);
                    if ("0".equals(accessTokenJson.getString("code"))) {
                        String data = accessTokenJson.getString("data");
                        JSONObject dataJson = JSONObject.fromObject(data);
                        accessToken = dataJson.getString("access_token");
                        // 清空access_token表数据
                        accessTokenService.deleteAccessToken();
                        // 重新新增数据
                        accessTokenService.insertData(dataJson);
                    }
                    response = client.execute(request, accessToken);
                }
            } else {
                AuthRequest authRequest = new AuthRequest.Builder(appKey,appSecret).code(OtherUtils.get6UUID()).build();
                String initAccessToken = AuthUtil.getInitToken(authRequest);
                JSONObject initAccessTokenJson = JSONObject.fromObject(initAccessToken);
                if ("0".equals(initAccessTokenJson.getString("code"))) {
                    String data = initAccessTokenJson.getString("data");
                    JSONObject dataJson = JSONObject.fromObject(data);
                    accessToken = dataJson.getString("access_token");
                    // 重新新增数据
                    accessTokenService.insertData(dataJson);
                }
                response = client.execute(request, accessToken);
            }
            result = response.getBody();
        } catch (Exception e) {
            String requestTime = sdf.format(new Date());
            String msg = e.getMessage();
            logService.insertData(requestTime,msg);
        }
        return result;
    }
}
  • OtherUtils.java
import java.util.UUID;

public class OtherUtils {

    /**
     * 获取6位UUID字符串
     * @return
     */
    public static String get6UUID() {
        String uuid = UUID.randomUUID().toString();
        String randomString = uuid.replaceAll("-", "").substring(0, 6);
        return randomString;
    }
    
    /**
     * 获得20个长度的十六进制的UUID
     * @return UUID
     */
    public static String get20UUID(){
        UUID id=UUID.randomUUID();
        String[] idd=id.toString().split("-");
        return idd[0]+idd[1]+idd[2]+idd[3];
    }
    
    /**
     * 获得12个长度的十六进制的UUID
     * @return UUID
     */
    public static String get12UUID(){
        UUID id=UUID.randomUUID();
        String[] idd=id.toString().split("-");
        return idd[0]+idd[1];
    }

}
  • OrdersService.java
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.xjmy.jushuitan.entity.Orders;
import com.xjmy.jushuitan.entity.OrdersDetail;
import com.xjmy.jushuitan.entity.Sku;
import com.xjmy.jushuitan.mapper.OrdersDetailMapper;
import com.xjmy.jushuitan.mapper.OrdersMapper;
import com.xjmy.jushuitan.mapper.SkuMapper;
import com.xjmy.jushuitan.utils.OtherUtils;
import lombok.extern.slf4j.Slf4j;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

@Slf4j
@Service
public class OrdersService {

    @Autowired
    OrdersMapper ordersMapper;
    @Autowired
    OrdersDetailMapper ordersDetailMapper;
    @Autowired
    SkuMapper skuMapper;
    @Autowired
    ApiService apiService;
    @Autowired
    LogService logService;

    private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private static final SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");

    /**
     * 执行
     * @param modified_begin 修改开始日期
     * @param modified_end 修改结束日期
     */
    public void apiThread(String modified_begin,String modified_end) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String url = "https://openapi.jushuitan.com/open/orders/single/query";// 正式地址
        Integer page_index = 1;
        Integer page_size = 50;
        //JSON参数
        JSONObject paramsJson = new JSONObject();
        paramsJson.put("page_index",page_index); //页码
        paramsJson.put("page_size",page_size);//每页多少条数据
        paramsJson.put("modified_begin",modified_begin);//修改开始时间
        paramsJson.put("modified_end",modified_end);//修改结束时间
        paramsJson.put("date_type",3); //(0:修改时间modified，2:订单日期order_date，3:发货时间send_date；非必填，默认0)
        paramsJson.put("status","Sent");//订单状态：已发货
        String biz = paramsJson.toString();
        try {
            // 获取API接口返回报文
            String apiResult = apiService.requestApi(url,biz);
            if (!StringUtils.isEmpty(apiResult)) {
                // 将报文字符串转成JSON
                JSONObject resultJson = JSONObject.fromObject(apiResult);
                // 判断该API返回报文结果是否是调用API成功
                if ("执行成功".equals(resultJson.getString("msg")) && resultJson.getInt("code") == 0) {
                    // 解析第一层data
                    String dataStr = resultJson.getString("data");
                    JSONObject dataJson = JSONObject.fromObject(dataStr);
                    // 页数
                    int page_count = dataJson.getInt("page_count");
                    // 数据量
                    int data_count = dataJson.getInt("data_count");
                    for (int j = 1;j <= page_count;j++) {
                        //JSON参数
                        paramsJson = new JSONObject();
                        paramsJson.put("page_index",j); //页码
                        paramsJson.put("page_size",page_size);//每页多少条数据
                        paramsJson.put("modified_begin",modified_begin);//修改开始时间
                        paramsJson.put("modified_end",modified_end);//修改结束时间
                        paramsJson.put("date_type",3); //(0:修改时间modified，2:订单日期order_date，3:发货时间send_date；非必填，默认0)
                        paramsJson.put("status","Sent");//订单状态：已发货
                        biz = paramsJson.toString();
                        // 获取API接口返回报文
                        apiResult = apiService.requestApi(url,biz);
                        resultJson = JSONObject.fromObject(apiResult);
                        if ("执行成功".equals(resultJson.getString("msg")) && resultJson.getInt("code") == 0) {
                            // 解析第一层data
                            dataStr = resultJson.getString("data");
                            dataJson = JSONObject.fromObject(dataStr);
                            // 解析第二层orders
                            String ordersData = dataJson.getString("orders");
                            JSONArray ordersArrays = JSONArray.fromObject(ordersData);
                            for (int i = 0;i < ordersArrays.size();i++){
                                JSONObject orderJson = ordersArrays.getJSONObject(i);
                                System.out.println("聚水潭单号"+i+"："+orderJson.getString("o_id"));
                                System.out.println("线上单号"+i+"："+orderJson.getString("so_id"));
                                //新增订单
                                insertOrders(orderJson);
                            }
                        }
                    }
                    log.info("Orders订单数据拉取成功! 拉取期间：{}——{}，数据量：{}",modified_begin,modified_end,data_count);
                    log.info("===========================================================");
                } else {
                    String requestTime = sdf.format(new Date());
                    String msg = resultJson.getInt("code") + ";" + resultJson.getString("msg");
                    logService.insertData(requestTime,"同步Orders订单任务失败，错误信息：" + msg);
                }
            }
        } catch (Exception e) {
            String requestTime = sdf.format(new Date());
            logService.insertData(requestTime,"同步Orders订单任务异常，异常信息：" + e.getMessage());
        }
    }

    /**
     * 新增订单信息
     */
    public void insertOrders(JSONObject jsonObj) throws Exception {
        //查询该订单是否存在
        QueryWrapper<Orders> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("o_id",jsonObj.getString("o_id"));
        Orders orders = ordersMapper.selectOne(queryWrapper);
        if (orders != null) {
            return;
        }
        String id = OtherUtils.get20UUID(); //UUID
        String items = jsonObj.getString("items"); //解析JSON字符串
        JSONArray itemsArrays = JSONArray.fromObject(items);
        int row = 0;
        for (int i = 0;i < itemsArrays.size();i++) {
            JSONObject itemsJson = itemsArrays.getJSONObject(i);
            //新增订单明细详情
            row = insertOrdersDetail(itemsJson, i, id);
        }
        if (row == 0) { //新增订单详情中如商品在数据库中不存在，则该订单不存入数据库中
            return;
        }
        //新增订单
        insertOrdersBill(jsonObj,id);
    }

    /**
     * 新增订单信息
     * @param jsonObj 数据来源
     * @param id id
     * @throws Exception
     */
    public void insertOrdersBill(JSONObject jsonObj,String id) throws Exception {
        Orders newOrders = new Orders();
        newOrders.setId(id);//id
        newOrders.setOId(jsonObj.getString("o_id"));//聚水潭订单号
        newOrders.setSoId(jsonObj.getString("so_id"));//线上订单号
        newOrders.setLId(jsonObj.getString("l_id"));//快递单号
        newOrders.setOrderDate(jsonObj.getString("order_date"));//订单日期
        newOrders.setType(jsonObj.getString("type"));//订单类型
        newOrders.setOrderFrom(jsonObj.getString("order_from"));//订单来源
        newOrders.setOrderStatus(jsonObj.getString("status"));//订单状态
        newOrders.setShopStatus(jsonObj.getString("shop_status"));//平台订单状态
        newOrders.setShopId(jsonObj.getString("shop_id"));//店铺编号
        newOrders.setShopName(jsonObj.getString("shop_name"));//店铺名称
        newOrders.setCoId(jsonObj.getString("co_id"));//公司编号
        newOrders.setLcId(jsonObj.getString("lc_id"));//物流公司编号
        newOrders.setWmsCoId(jsonObj.getString("wms_co_id"));//发货仓编号
        newOrders.setLogisticsCompany(jsonObj.getString("logistics_company"));//快递公司
        newOrders.setPayAmount(jsonObj.getDouble("pay_amount"));//应付金额
        newOrders.setPaidAmount(jsonObj.getDouble("paid_amount"));//实际支付金额
        newOrders.setModified(jsonObj.getString("modified"));//修改时间
        Long modifiedTime = sdf.parse(jsonObj.getString("modified")).getTime();
        newOrders.setLongtime(modifiedTime.toString()); //时间戳
        newOrders.setReferrerId(jsonObj.getString("referrer_id"));//主播id
        newOrders.setLabels(jsonObj.getString("labels"));//标签
        newOrders.setRemark(jsonObj.getString("remark"));//备注
        newOrders.setIssyn(false);//是否同步
        newOrders.setCreateDate(sdf2.format(new Date()));//创建日期
        ordersMapper.insert(newOrders);
    }

    /**
     * 新增订单详情
     */
    public int insertOrdersDetail(JSONObject jsonObj,int seq,String parentID) {
        String sku_id = jsonObj.getString("sku_id");
        //判断该订单详情中的商品是否在本地数据库SKU商品表中存在，不存在则该订单不拉取存入数据库中
        QueryWrapper<Sku> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("sku_id", sku_id);
        Sku sku = skuMapper.selectOne(queryWrapper);
        if (sku == null) {
            return 0;
        }
        OrdersDetail ordersDetail = new OrdersDetail();
        String id = OtherUtils.get12UUID();
        ordersDetail.setId(id);//
        ordersDetail.setSeq((long) seq+1);//序号
        ordersDetail.setParentId(parentID);//父id
        ordersDetail.setOId(jsonObj.getString("o_id"));//聚水潭订单号
        ordersDetail.setSkuId(jsonObj.getString("sku_id"));//原始商品编码
        ordersDetail.setSkuName(jsonObj.getString("name"));//原始商品名称
        ordersDetail.setIsGift(jsonObj.getBoolean("is_gift"));//是否赠品
        ordersDetail.setBasePrice(jsonObj.getDouble("base_price"));//基本售价（原价）
        ordersDetail.setPrice(jsonObj.getDouble("price"));//单价
        ordersDetail.setAmount(jsonObj.getDouble("amount"));//金额
        ordersDetail.setQty(jsonObj.getDouble("qty"));//数量
        return ordersDetailMapper.insert(ordersDetail);
    }
}
  • Test.java
@Test
void contextLoads() {
    String startDate = "2024-03-13 16:05:00";
    String endDate = "2024-03-13 16:06:00";
    ordersService.apiThread(startDate,endDate);
}
  • 返回结果
    在这里插入图片描述
    在这里插入图片描述

本人也是初次调用聚水潭API，代码并不完美，提供参考。

Java——聚水潭API调用（SDK）Sku商品信息
qq_43023754的博客
03-13 1855
聚水潭API（商品SKU）
java调用百度云api_百度云—使用机器人视觉SDK调用百度API方法教程
weixin_36354351的博客
02-24 1539
本文将分为两部分：机器人视觉应用的建立和如何使用机器人视觉SDK调用百度API两方面为您一一介绍。一、机器人视觉应用的建立使用百度AI平台的在线API之前，首先需要在百度云控制台中建立机器人视觉的应用。步骤一：步骤二：步骤三：查看所创建应用的API Key和Secret Key，他们用途是获取百度AI平台在线API服务授权的accesss_token。关于授权机制主要针对HTTP API...
调用电商集成平台 聚水潭 api接口示例
andrew_dear的博客
11-16 1403
注意代码待完善：accessToken是有过期时间的，但可以在主账号设置，如果超过限制我不会进行记录会漏掉这条数据。我定义了一个erpDatas和erpItems类来接收数据，由于返回值是下划线的，而我项目架构是驼峰命名，会导致映射值失败，最下面是处理方法（可以不用的自行删除）。调用接口的限制：分页，每页数量50，请求限制，一秒钟不能超过5次，一分钟不能超过一百次。
企业数据管理：聚水潭数据高效导入MySQL的技术攻略
最新发布
weixin_55464238的博客
02-22 1030
在企业数据管理中，如何高效、准确地将聚水潭的数据集成到MySQL数据库，是一个具有挑战性的任务。本篇文章将详细探讨“聚水谭-供应商查询单-->BI斯莱蒙-供应商表”的具体实现方案。首先，我们需要通过聚水潭提供的API接口来获取供应商数据。为了确保数据不漏单，我们采用定时可靠的抓取机制，定期从聚水潭接口拉取最新的数据，并处理分页和限流问题，以保证数据完整性和实时性。在数据写入方面，MySQL提供了强大的高吞吐量写入能力，使得大量数据能够快速被集成到目标数据库中。我们利用MySQL的API 进行批量数据写入操作
集成框架 -- 聚水潭对接
寿春
11-14 1411
token 建议放到redis 加过期时间，通过过期时间来判断是否需要刷新token，来重新续命。直接拿到demo运行，其他的自己封装即可。
java聚水潭_聚水潭.sln · killvs/jusuitan - Gitee.com
weixin_39517868的博客
02-28 423
Microsoft Visual Studio Solution File, Format Version 12.00# Visual Studio 2013VisualStudioVersion = 12.0.21005.1MinimumVisualStudioVersion = 10.0.40219.1Project("{E24C65DC-7377-472B-9ABA-BC803B73C61...
对接聚水潭-胜算接口
c601757850的博客
08-18 1265
对接胜算接口的时候， 需要注意无法直接使用奇门的JKD ， 需要重写奇门的请求方法 ，因为有部分参数，奇门JDK中不存在 ，需要手动填写。比如：target_app_key 等。
java聚水潭_java排序方式对比
weixin_36415835的博客
02-28 237
packagecom.liruilong;importjava.util.ArrayList;importjava.util.Collections;importjava.util.Comparator;importjava.util.List;/*** @Description : 聚集排序整理* @Author: Liruilong* @Date: 2019/7/31 22:21*/publi...
京东SDK调用实例（open-api-sdk-2.0.jar）
12-25
1. **环境配置**：确保Java运行环境已安装，并在项目中引入"open-api-sdk-2.0.jar"作为依赖。 2. **初始化SDK**：配置AppKey和AppSecret，初始化SDK客户端。 3. **构建请求**：根据业务需求，选择合适的API，构建...
斑马打印机，Java调用官方API架包及调用样例
02-17
6. **错误处理**：在调用API时，要处理可能出现的异常，如`IOException`，确保程序的健壮性。 除了上述基本操作，斑马打印机的API还提供了丰富的功能，如设置打印参数（如宽度、高度、间距等）、条形码和二维码的...
德邦快递API接口SDK文件
01-14
1. **认证管理**：调用API时，需要提供有效的API密钥和安全签名，以确保请求的来源合法性。 2. **错误处理**：对接口返回的错误码进行捕获和处理，以优雅地处理可能出现的问题。 3. **异步调用**：对于可能会耗时...
EJB开发——Java 2 SDK.rar_java ppt
09-23
【标题】"EJB开发——Java 2 SDK.rar_java ppt" 涉及的主要知识点是企业级Java Bean（Enterprise JavaBeans，简称EJB）的开发，以及与Java 2 Software Development Kit（SDK）相关的编程概念。这个标题暗示了一个PPT...
聚水潭操作手册_财务系统对接_售前方案.docx
02-24
概述： 本文内容，主要是为了帮助销售人员或者售前人员，能够更加顺畅的与客户沟通财务系统对接方案。如果实施人员想查看具体的操作文档，可点击链接：JST操作手册_财务系统对接工具.docx 1、对接方式 目前，主要支持两种对接方式： 1)“第三方财务系统”调用“聚水潭”API接口，实现对接。（API地址：http://open.jushuitan.com/） 优点： 对接方式比较灵活，可以支持双方系统数据交互传输 举例： ①　“第三方财务系统”传递采购单到“聚水潭”，聚水潭入库后直接传递入库数据返回给“第三方财务系统”。 ②　“第三方财务系统”需要从“聚水潭”抓取订单信息。 ③　。
聚水潭SDK第一版（有待完善）
05-12
最近因为项目需要写了一个聚水潭的sdk，方便自己使用。目前算是第一版，还不是很完善。但是因为时间原因，最近没有时间来完善这个了。先上传这里，一般后续继续。
聚水潭对接打通金蝶云星空仓库查询接口与其他往来单位新增接口
kobeN1的博客
01-30 818
在方案配置表单中选择对应的源业务系统：聚水潭，然后选择对应的连接器。然后再写入目标平台配置目标系统为金蝶云星空，并且选择对应连接器（关于金蝶云星空的接口如何连接可以在轻易云数据集成社区论坛bbs.qeasy.cloud中找到相关信息）。实现API文档的统一管理，建立API的上线、下线、监控的统一管理体系。轻易云应用集成主要解决已有应用系统的无序蔓延现象，减少各业务系统间的维护成本，减少各应用系统的操作系统、开发语言、访问协议、通信技术多而杂、整合难度大的问题，将企业数据平滑对接，减少信息竖井。
聚水潭订单数据高效集成到MySQL的实现方案
weixin_55464238的博客
10-22 892
在数据集成的过程中，将已经集成的源平台数据进行ETL转换，转为目标平台 MySQLAPI接口所能够接收的格式，并最终写入目标平台，是一个关键步骤。从API资产管理功能，到统一视图控制台，再到定制化的数据映射对接，每一个环节都经过精心设计，以实现资源的高效利用和优化配置。综上所述，通过合理的数据清洗与转换、批量写入、异常处理与重试机制、分页与限流，以及实时监控与日志记录，可以高效地将聚水潭·奇门接口的数据集成到MySQL平台，实现无缝对接和高效管理。同时，通过自定义的数据转换逻辑，适配不同的数据结构需求。
聚水潭和金蝶云星空接口打通对接实战
CUNCAOSVEN的博客
12-11 234
金蝶K/3Cloud围绕着“生态、人人、体验”，旨在帮助企业打造面向新时代的生态互联与协同平台，围绕生态中的每个角色，提供随手可得的云服务，最终实现敏捷协同，智慧运营的企业运营新境界。采用元数据模型驱动的低代码集成工具，基于系统预置的数据模型、映射、编排、日志、脚本等集成核心引擎，通过可视化配置，快速实现客户灵活多变的动态集成需求，让集成开发简单、执行过程可靠、问题风险可控。通过流程我们需要建立对应的方案来吧这些流程一一的落地，轻易云集成平台开箱即用的、可视化拖、拉、拽实现接口服务编排与聚合。
如何通过数据集成平台实现聚水潭到MySQL的高效对接
liqiu0913的博客
10-26 828
定时抓取聚水潭接口数据：通过设置定时任务，可靠地调用聚水潭API获取最新的店铺查询单信息。处理分页与限流：设计合理的分页策略，并在遇到限流时实现自动重试机制，以确保所有数据都能成功获取。自定义转换与映射：利用轻易云平台提供的数据转换工具，将获取的数据格式化为符合MySQL存储要求的结构。批量写入MySQL数据库：使用MySQL API实现高效的大批量数据写入操作，同时保证事务的一致性和完整性。实时监控与日志记录：通过集中监控系统，对整个集成过程进行实时跟踪，并记录详细日志以便后续审计和问题排查。
金蝶云星空和聚水潭单据接口对接
CUNCAOSVEN的博客
09-26 270
金蝶K/3Cloud围绕着“生态、人人、体验”，旨在帮助企业打造面向新时代的生态互联与协同平台，围绕生态中的每个角色，提供随手可得的云服务，最终实现敏捷协同，智慧运营的企业运营新境界。任何一家使用金蝶K/3Cloud产品的企业，其拥有的是包含金蝶在内的众多基于同一个平台提供服务的IT服务伙伴。那么对接就需要根据接口配置对应的规则，例如取数就要根据查询接口获取聚水潭的数据，并且根据对应的条件进行取数，目标系统就必须根据目标系统的格式，以及获取的数据进行加工处理后进行写入到金蝶云星空中。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值