调用京灵平台接口，很详细
- 一、准备
- 1、开发资源
- 2、申请环境
- 二、测试接口调用
- 1、查看接口文档
- 2、查看示例代码
- 3、引入对应依赖
- 4、改造后需要的依赖
- 5、测试调用
- 三、工具类
- 1、配置dto
- 2、公共参数dto
- 3、请求参数dto
- 4、响应参数dto
- 4、调用工具类（重要）
一、准备
在确定好要对接京东的京灵平台的时，会把你拉进一个技术群。
1、开发资源
找群里的技术要到API文档、demo等。他们会问需要Java还是PHP，我的项目是Java写的，所有已Java为例，资源如下图所示：
2、申请环境
申请测试环境和正式环境的步骤是一样的，这里以申请测试环境为例：
先解压公私钥生成工具
进入根目录会看到一个生成命令的TXT文件，打开后面需要用到，
内容如下：
RSA密钥生成命令：
生成RSA私钥
openssl>genrsa -out app_rsa_private_key.pem 1024
生成RSA公钥
openssl>rsa -in app_rsa_private_key.pem -pubout -out app_rsa_public_key.pem
将RSA私钥转换成PKCS8格式
openssl>pkcs8 -topk8 -inform PEM -in app_rsa_private_key.pem -outform PEM -nocrypt -out app_rsa_private_pkcs8_key.pem
注意：“>”符号后面的才是需要输入的命令。
注: 生成的密钥文件
app_rsa_private_pkcs8_key.pem (应用私钥，开发者自行保存)
app_rsa_public_key.pem (应用公钥，上传至数科开放平台)
php语言，请把两个文件放在\config目录下面
然后进入“bin”目录，
双击“openssl.exe”文件
打开“生成命令.txt”文件中的命令，先输入“生成RSA私钥”命令，命令如下：
genrsa -out app_rsa_private_key.pem 1024
接着输入“生成RSA公钥”命令：
rsa -in app_rsa_private_key.pem -pubout -out app_rsa_public_key.pem
最后输入“将RSA私钥转换成PKCS8格式 ”命令：
pkcs8 -topk8 -inform PEM -in app_rsa_private_key.pem -outform PEM -nocrypt -out app_rsa_private_pkcs8_key.pem
回到“bin”目录，我们会发现多了三个秘钥文件，将公钥文件发给对接的技术，公钥如下图所示：
保存好生成的私钥，后面调用接口需要用到，私钥如下图所示：
最后一个目前没有用到，然后等他们走完流程，走完之后会给AppId、token、sysId、serviceCompanyId测试环境参数，就算把测试环境申请下来了。
申请正式环境的过程也是如此。
二、测试接口调用
这开始认为已经拿到AppId、token、sysId、serviceCompanyId测试环境参数了
1、查看接口文档
这里以“查询灵工合同信息”接口为例，文档参数如下：
2、查看示例代码
解压这个
重命名为“demo”，查看此目录下的案例即可
具体内容如下：
package com.jdd.open.demo.esu.spi.inner;
import com.jddglobal.open.client.SpiInnerClient;
import com.jddglobal.open.request.base.JddRequest;
import com.jddglobal.open.response.base.BaseJddResponse;
import com.jddglobal.open.support.app.AppInfo;
import com.jddglobal.open.support.http.HttpClientConfig;
import com.jddglobal.open.support.util.JacksonUtils;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.apache.http.client.utils.DateUtils;
import java.util.Date;
public class SpiInnerInvoker {
public static void main(String[] args) throws Exception {
/*密钥平台*/
/*AppInfo appInfo = new AppInfo();
appInfo.setAppId("6b232709d5a25d554b59ea05b4a621e0");
appInfo.setEncryptType("ENV_RSA"); // 加密算法，支持 NONE、RSA、ENV_RSA
appInfo.setSignType("MD5_RSA"); // 加签算法，支持 MD5_RSA、SHA1withRSA
HttpClientConfig httpClientConfig = new HttpClientConfig.Builder().build();
String serverUrl = "http://59.151.67.121:1058"; // 服务端调用地址！测试: http://59.151.67.121:1058、生产: http://api-out.jdfin.local
SpiInnerClient spiInnerClient = new SpiInnerClient(serverUrl, appInfo, httpClientConfig);*/
/*AKS*/
AppInfo appInfo = new AppInfo();
appInfo.setAppId("4a5634fca025625860d8f3ad9c3b005f");
appInfo.setEncryptType("3DES_RSA"); //加密算法，支持 3DES_RSA
appInfo.setSignType("SHA256withRSA"); // 加签算法，支持 SHA256withRSA
HttpClientConfig httpClientConfig = new HttpClientConfig.Builder().build();
String serverUrl = "http://59.151.67.121:1058"; // 服务端调用地址！测试: http://59.151.67.121:1058、生产: http://api-out.jdfin.local
SpiInnerClient spiInnerClient = new SpiInnerClient(serverUrl, appInfo, httpClientConfig);
/*国密*/
/*AppInfo appInfo = new AppInfo();
appInfo.setAppId("4a5634fca025625860d8f3ad9c3b005f");
appInfo.setEncryptType("SM4_SM2"); //加密算法，支持 SM2、SM4_SM2
appInfo.setSignType("SM3withSM2"); // 加签算法，支持 SM3withSM2
HttpClientConfig httpClientConfig = new HttpClientConfig.Builder().build();
String serverUrl = "http://127.0.0.1:8095"; // 服务端调用地址！测试: http://59.151.67.121:1058、生产: http://api-out.jdfin.local
SpiInnerClient spiInnerClient = new SpiInnerClient(serverUrl, appInfo, httpClientConfig);*/
SpiBizDemoRequest bizDemoRequest = new SpiBizDemoRequest();
bizDemoRequest.setAge("22");
bizDemoRequest.setName("张三");
String appUrl = "http://127.0.0.1:8089/spi/demo"; // 外部商户调用地址
BaseJddResponse result = spiInnerClient.execute(bizDemoRequest, appUrl);
System.err.println(JacksonUtils.toJson(result));
}
@Data
static class SpiBizDemoRequest implements JddRequest<SpiBizDemoResponse> {
private String name;
private String age;
@Override
public String getApiMethod() {
return "/spi/v1/ghw-url/test_spi_02";
}
@Override
public String getJsonParams() {
return JacksonUtils.toJson(this);
}
@Override
public Class getResponseClass() {
return SpiBizDemoResponse.class;
}
@Override
public String getRequestTime() {
return DateUtils.formatDate(new Date(), "yyyyMMddHHmmssSSS");
}
}
@EqualsAndHashCode(callSuper = true)
@Data
static class SpiBizDemoResponse extends BaseJddResponse {
}
}
主要关注传参这部分
以我调用“查询灵工合同信息”接口为例，对应的请求参数实体如下：
响应参数继承“BaseJddResponse”，加上对应的返回参数就可以了，具体如下：
还有这个
具体内容如下：
package com.jdd.open.demo.esu.smapi;
import com.jddglobal.open.client.JddClient;
import com.jddglobal.open.request.base.HttpBizDemoRequest;
import com.jddglobal.open.response.base.HttpBizDemoResponse;
import com.jddglobal.open.support.config.EsuSdkConfig;
import com.jddglobal.open.support.util.JacksonUtils;
public class SmapiDemoInvoker {
public static void main(String[] args) throws Exception {
// 设置配置文件路径，默认为如下值，可不设置
JddClient jddClient = EsuSdkConfig.getJddClient();
HttpBizDemoRequest request = new HttpBizDemoRequest();
request.setBal(123);
HttpBizDemoResponse adaptResponse = jddClient.execute(request);
System.out.println(JacksonUtils.toJson(adaptResponse));
}
}
这个发送请求参数和公共参数的案例，需要在“resources”中加上案例中的如下文件：
感觉麻烦了点，后面修改参数也不方便。
3、引入对应依赖
这里插一句，如果不想跑demo，想要直接用笔者改造后的工具类，可以看“4、改造后的依赖”。
在项目中京灵平台的案例会发现报错，需要引入对应的依赖包，在根目录的“lib”目录下
关键是这三个jar包
引入的方式可以在项目中加上“lib”目录引入，也可以安装到本地maven仓库再引入，可以自行百度，或者看这里。
其他的依赖包有对应的maven依赖，具体如下：
“bcprov-jdk15on”对应依赖如下：
<!-- https://mvnrepository.com/artifact/org.bouncycastle/bcprov-jdk15on -->
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcprov-jdk15on</artifactId>
<version>1.60</version>
</dependency>
目前最高版本为“1.70”，但据我测试，最多使用“1.66”版本，再高就不行了，“1.66”版本依赖如下：
<!-- https://mvnrepository.com/artifact/org.bouncycastle/bcprov-jdk15on -->
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcprov-jdk15on</artifactId>
<version>1.66</version>
</dependency>
“bcpkix-jdk15on”对应的依赖如下：
<!-- https://mvnrepository.com/artifact/org.bouncycastle/bcpkix-jdk15on -->
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcpkix-jdk15on</artifactId>
<version>1.60</version>
</dependency>
目前最高版本也是“1.70”，但最多只能使用“1.66”，再高就不行了，“1.66”版本依赖如下：
<!-- https://mvnrepository.com/artifact/org.bouncycastle/bcpkix-jdk15on -->
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcpkix-jdk15on</artifactId>
<version>1.66</version>
</dependency>
“gson”对应的依赖如下：
<!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.6</version>
</dependency>
虽然“gson”从始至终都没有用到。。。
4、改造后需要的依赖
<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<!--阿里巴巴相关依赖-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>2.0.42</version>
</dependency>
<!--https://hutool.cn/docs/#/?id=%f0%9f%93%a6%e5%ae%89%e8%a3%85-->
<!--hutool工具包相关依赖-->
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.16</version>
</dependency>
<!-- Lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.24</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.bouncycastle/bcpkix-jdk15on -->
<!--调用京灵平台需要，只能1.66版本及以下，版本高了调用京灵平台接口会报错-->
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcpkix-jdk15on</artifactId>
<version>1.66</version>
</dependency>
<!-- https://mvnrepository.com/artifact/commons-codec/commons-codec -->
<!--调用京灵平台需要-->
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
<version>1.15</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
<!--调用京灵平台需要-->
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.5.14</version>
</dependency>
<!--京灵平台依赖包，sdk的核心处理包，通讯、加解密、加验签等-->
<!--这是本地依赖，需要拿到京灵平台的jar包导入到本地maven仓库-->
<dependency>
<groupId>com.jddglobal.open</groupId>
<artifactId>jddglobal_open_sdk</artifactId>
<version>1.6.1</version>
</dependency>
<!--京灵平台依赖包，商户请求响应实体类-->
<!--这是本地依赖，需要拿到京灵平台的jar包导入到本地maven仓库-->
<dependency>
<groupId>com.jddglobal.open</groupId>
<artifactId>jdd_api_domain</artifactId>
<version>1.0.0</version>
</dependency>
<!--京灵平台依赖包，JD加解密SDK-->
<!--这是本地依赖，需要拿到京灵平台的jar包导入到本地maven仓库-->
<dependency>
<groupId>com.jddglobal.open</groupId>
<artifactId>wyaks_security</artifactId>
<version>1.1.0</version>
</dependency>
5、测试调用
因为嫌京灵平台的调用方式麻烦，这里就自己改造了一下，只是调用部分，完整的代码在“工具类”中。这是“查询灵工合同信息”接口的测试案例
这是调用返回结果
三、工具类
1、配置dto
package com.zsp.demo.jl.dto;
import lombok.Data;
import java.io.Serializable;
/**
* 京灵平台参数
*
* @author：gan
* @date: 2024-04-25 11:36
*/
@Data
public class JLConfig implements Serializable {
/**
* 京灵平台请求地址
*/
private String url;
/**
* 京灵平台appId
*/
private String appId;
/**
* 京灵平台用户公钥
*/
private String publicKey;
/**
* 京灵平台用户私钥
*/
private String privateKey;
/**
* 京灵平台服务端密钥系统类型
*/
private String jddKeyType;
/**
* 京灵平台服务端密钥系统类型
*/
private String appKeyType;
/**
* 京灵平台加密算法，支持 3DES_RSA，无特殊要求不需要修改
*/
private String encryptType;
/**
* 京灵平台加签算法，支持 SHA256withRSA
*/
private String signType;
//====================以下为非必填参数
/**
* 京灵平台财税服务商id
*/
private String serviceCompanyId;
/**
* 京灵平台系统id
*/
private String sysId;
/**
* 京灵平台token
*/
private String token;
/**
* 京灵平台客户端盐值，AKS 加密方式不需要（传值）
*/
private String md5Salt;
/**
* 京灵平台，http请求代理ip
*/
private String host;
/**
* 京灵平台，http请求代理端口
*/
private String port;
/**
* 京灵平台，国密证书存在路径(证书存放位置支持绝对路径和jar资源文件目录下)
*/
private String path;
/**
* 京灵平台，国密证书打开的密码
*/
private String password;
}
2、公共参数dto
package com.zsp.demo.jl.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
import java.io.Serializable;
/**
* 公共参数
*
* @author：gan
* @date: 2024-05-29 18:13
*/
@Data
public class CommonParams implements Serializable {
/**
* 请求号，全局唯一，不参与业务逻辑
*/
@JsonProperty("requestNo")
private String requestNo;
/**
* 请求时间，格式: yyyyMMddHHmmss
*/
@JsonProperty("reqTime")
private String reqTime;
/**
* 请求时间，格式: yyyyMMddHHmmss
*/
@JsonProperty("requestTime")
private String requestTime;
/**
* 鉴权标识
*/
@JsonProperty("token")
private String token;
/**
* 请求数据对象
*/
@JsonProperty("requestData")
private Object requestData;
/**
* 京接入系统唯一标识（由京灵侧提供）
*/
@JsonProperty("sysId")
private String sysId;
}
3、请求参数dto
这里以“查询灵工合同信息”接口为例，需要调用其他接口针对性添加
package com.zsp.demo.jl.dto;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import com.jddglobal.open.request.base.JddRequest;
import com.jddglobal.open.support.util.JacksonUtils;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* 查询灵工合同信息，请求参数
*
* @author：gan
* @date: 2024-05-09 11:19
*/
@Data
public class QueryFreelancerContractInfoParams extends CommonParams implements JddRequest<QueryFreelancerContractInfoResult>, Serializable {
/**
* 灵工身份证号
*/
private String certNo;
/**
* 服务商Id
*/
private String serviceCompanyId;
@Override
public String getApiMethod() {
return "/smapi/v1/ffp-common/queryFreelancerContractInfo";
}
@Override
public String getJsonParams() {
return JacksonUtils.toJson(this);
}
@Override
public Class getResponseClass() {
return QueryFreelancerContractInfoResult.class;
}
@Override
public String getRequestTime() {
return DateUtil.format(new Date(), DatePattern.PURE_DATETIME_MS_PATTERN);
}
}
4、响应参数dto
这里以“查询灵工合同信息”接口为例，需要调用其他接口针对性添加
package com.zsp.demo.jl.dto;
import com.jddglobal.open.response.base.BaseJddResponse;
import lombok.Data;
import java.io.Serializable;
/**
* 查询灵工合同信息，响应参数
*
* @author：gan
* @date: 2024-05-09 11:28
*/
@Data
public class QueryFreelancerContractInfoResult extends BaseJddResponse implements Serializable {
/**
* 合同id
*/
private String contractId;
/**
* 合同名称
*/
private String contractName;
/**
* 签约时间
*/
private String signTime;
/**
* 签约人
*/
private String freelancerName;
/**
* 服务商id
*/
private String serviceCompanyId;
/**
* 服务商名称
*/
private String serviceCompanyName;
/**
* 灵工身份证号
*/
private String certNo;
/**
* 合同文件地址
*/
private String contractUrl;
}
4、调用工具类（重要）
其中“VerifyUtil”是自己写的判空工具类，放在了这里，也可以用自己的方式判空。
package com.zsp.demo.jl.utils;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;
import com.jddglobal.open.client.DefaultJddClient;
import com.jddglobal.open.client.JddClient;
import com.jddglobal.open.request.base.JddRequest;
import com.jddglobal.open.support.app.AppInfo;
import com.jddglobal.open.support.http.HttpClientConfig;
import com.jddglobal.open.support.security.GMKeyStore;
import com.zsp.demo.jl.dto.*;
import com.zsp.demo.utils.VerifyUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 京灵平台相关工具类
*
* @author：gan
* @date: 2024-04-25 11:28
*/
public class JLUtils {
private static final Logger log = LoggerFactory.getLogger(JLUtils.class);
public static void main(String[] args) throws Exception {
JLConfig jlConfig = new JLConfig();
jlConfig.setAppId("你的AppId");
jlConfig.setJddKeyType("AKS");
jlConfig.setPublicKey("京灵平台demo中的公钥");
jlConfig.setAppKeyType("PAIR");
jlConfig.setPrivateKey("通过京灵技术提供的秘钥工具生成的秘钥");
jlConfig.setMd5Salt("");
jlConfig.setEncryptType("3DES_RSA");
jlConfig.setSignType("SHA256withRSA");
jlConfig.setUrl("请求地址");
jlConfig.setServiceCompanyId("你的服务商id");
jlConfig.setSysId("你的系统id");
jlConfig.setToken("你的token");
//这两个一般不设置，demo中也是这样
// jlConfig.setHost("127.0.0.1");
// jlConfig.setPort("1111");
//============================查询灵工合同信息 接口测试================================
QueryFreelancerContractInfoParams queryFreelancerContractInfoParams = new QueryFreelancerContractInfoParams();
queryFreelancerContractInfoParams.setCertNo("你的测试身份证号");
queryFreelancerContractInfoParams.setServiceCompanyId("你的服务商id");
JSONObject responseJsonObject = JLUtils.sendRequest(jlConfig, queryFreelancerContractInfoParams);
}
/**
* 发送请求
* @param config 京灵平台配置
* @param requestParams 请求参数
* @return
* @throws Exception
*/
public static JSONObject sendRequest(JLConfig config, CommonParams requestParams) throws Exception {
List<String> noEmptyFiledList = Arrays.asList("url", "appId", "publicKey", "privateKey", "jddKeyType", "appKeyType", "encryptType", "signType");
VerifyUtil.checkBeanByNonEmptyFieldList(config, noEmptyFiledList, "京灵平台配置");
AppInfo appInfo = new AppInfo();
appInfo.setAppId(config.getAppId());
appInfo.setOpenPublicKey(config.getPublicKey());
appInfo.setAppPrivateKey(config.getPrivateKey());
appInfo.setMd5Salt(config.getMd5Salt());
appInfo.setEncryptType(config.getEncryptType());
appInfo.setSignType(config.getSignType());
appInfo.setJddKeyType(AppInfo.JddKeyTypeEnum.valueOf(config.getJddKeyType()));
appInfo.setAppKeyType(AppInfo.AppKeyTypeEnum.valueOf(config.getAppKeyType()));
if (AppInfo.AppKeyTypeEnum.CER.equals(appInfo.getAppKeyType())) {
appInfo.setKeystore(GMKeyStore.getKeystore(config.getPath(), config.getPassword()));
}
HttpClientConfig httpClientConfig = new HttpClientConfig
.Builder()
.proxyHost(VerifyUtil.isNotEmpty(config.getHost()) ? config.getHost() : null)
.proxyPort(VerifyUtil.isNotEmpty(config.getPort()) ? Integer.parseInt(config.getPort()) : null)
.build();
JddClient jddClient = new DefaultJddClient(config.getUrl(), appInfo, httpClientConfig);
JLUtils.setCommonParams(config, requestParams);
JSONObject responseJsonObject = JSONObject.parseObject(JSONObject.toJSONString(jddClient.execute((JddRequest) requestParams)));
log.info("京灵平台响应结果：{}", responseJsonObject);
return responseJsonObject;
}
/**
* 发送请求
* @param config 京灵平台配置
* @param requestParams 请求参数
* @param objectClass 响应参数class
* @return
* @throws Exception
*/
public static <T> T sendRequest(JLConfig config, CommonParams requestParams, Class<T> objectClass) throws Exception {
JSONObject responseJsonObject = JLUtils.sendRequest(config, requestParams);
JSONObject bizContent = JLUtils.getBizContent(responseJsonObject);
//如何没有成功 “responseData” 为空
JSONObject responseData = bizContent.getJSONObject("responseData");
VerifyUtil.checkParam(responseData, "响应结果中的【responseData】不存在！");
return JSONObject.parseObject(responseData.toString(), objectClass);
}
/**
* 获得响应结果参数中的bizContent
* @param responseJsonObject 响应结果参数
* @return
* @throws Exception
*/
public static JSONObject getBizContent(JSONObject responseJsonObject) throws Exception {
if(!"00000".equals(responseJsonObject.getString("code"))) {
throw new RuntimeException(responseJsonObject.getString("msg"));
}
JSONObject bizContent = responseJsonObject.getJSONObject("bizContent");
VerifyUtil.checkParam(bizContent, "响应结果中的【bizContent】不存在！");
if (!"00000".equals(bizContent.getString("code"))) {
throw new RuntimeException(bizContent.getString("msg"));
}
return bizContent;
}
/**
* 获得响应结果参数中的responseData，返回对应实体
* @param responseJsonObject 响应结果参数
* @param objectClass 响应参数class
* @return
* @throws Exception
*/
public static <T> T getResponseDataObject(JSONObject responseJsonObject, Class<T> objectClass) throws Exception {
JSONObject bizContent = JLUtils.getBizContent(responseJsonObject);
//如何没有成功 “responseData” 为空
JSONObject responseData = bizContent.getJSONObject("responseData");
VerifyUtil.checkParam(responseData, "响应结果中的【responseData】不存在！");
return JSONObject.parseObject(responseData.toString(), objectClass);
}
/**
* 获得响应结果参数中的responseData，返回对应实体集合
* @param responseJsonObject 响应结果参数
* @param objectClass 响应参数class
* @return
* @throws Exception
*/
public static <T> List<T> getResponseDataList(JSONObject responseJsonObject, Class<T> objectClass) throws Exception {
JSONObject bizContent = JLUtils.getBizContent(responseJsonObject);
List<T> responseDataList = null; //返回数据集合
try {
responseDataList = JSONObject.parseArray(bizContent.getString("responseData"), objectClass);
} catch (JSONException e) {
//e.printStackTrace();
//出现这个异常大概率就是有分页
responseDataList = JSONObject.parseArray(bizContent.getJSONObject("responseData").getString("dataList"), objectClass);
}
return responseDataList;
}
/**
* 获取京灵平台公共分页结果
* @param responseJsonObject
* @return
*/
public static CommonPageResult getCommonPageResult(JSONObject responseJsonObject) throws Exception {
JSONObject bizContent = JLUtils.getBizContent(responseJsonObject);
return JSONObject.parseObject(bizContent.getString("responseData"), CommonPageResult.class);
}
/**
* 设置公共参数
* @param config 京灵平台配置
* @param params 请求参数
*/
private static void setCommonParams(JLConfig config, CommonParams params) {
String dateTime = DateUtil.format(DateUtil.date(), DatePattern.PURE_DATETIME_PATTERN);
params.setRequestNo(IdUtil.getSnowflakeNextIdStr());
params.setReqTime(dateTime);
params.setRequestTime(dateTime);
params.setToken(config.getToken());
params.setSysId(config.getSysId());
params.setRequestData(handleRequestParams(params));
}
/**
* 处理请求参数
* @param params 请求参数
*/
private static Map handleRequestParams(Object params) {
List<Map> fieldsInfo = VerifyUtil.getFieldsInfo(params);
Map requestMap = new HashMap();
for (Map map : fieldsInfo) {
requestMap.put(map.get("name"), map.get("value"));
}
return requestMap;
}
/**
* 是否请求成功
* @param responseJsonObject
* @return
*/
public boolean isSuccess(JSONObject responseJsonObject) {
return "00000".equals(responseJsonObject.getString("code"));
}
}
