Skip to content

孙克 / smf-core

转到一个项目
切换导航栏
切换导航栏固定状态
Commit fe0b0488 由 LN
选项

增加与Mes对接代码

1 个父辈 baecefe2
内嵌 并排
正在显示 19 个修改的文件 包含 1655 行增加 和 34 行删除
pom.xml
......@@ -225,6 +225,11 @@
<artifactId>httpclient</artifactId>
<version>4.4</version>
</dependency>
<dependency>
<groupId>commons-httpclient</groupId>
<artifactId>commons-httpclient</artifactId>
<version>3.1</version>
</dependency>
</dependencies>
......
src/main/java/com/neotel/smfcore/common/utils/Constants.java
......@@ -143,4 +143,9 @@ public class Constants {
*/
public static final String CACHE_languageType="CACHE_languageType";
/**
* HIKAPI重发消息key
*/
public static final String CACHE_failedRequestMap = "CACHE_failedRequestMap";
}
src/main/java/com/neotel/smfcore/core/hik/rest/SingleInController.java
......@@ -68,17 +68,19 @@ public class SingleInController {
public List<ShelfPosInfo> codeIn(@RequestParam Map<String,String> paramsMap) {
String code = paramsMap.get("code");
if (ObjectUtils.isEmpty(code)) {
throw new ValidateException("smfcore.valueCanotNull", "{0}不能为空", new String[]{"code"});
int width=0;
int height=0;
if (!ObjectUtils.isEmpty(code)) {
// throw new ValidateException("smfcore.valueCanotNull", "{0}不能为空", new String[]{"code"});
Barcode barcode = resolveBarcode(code);
width = barcode.getPlateSize();
height = barcode.getHeight();
}
Barcode barcode = resolveBarcode(code);
List<ShelfPosInfo> shelfPosInfos = new ArrayList<>();
int width = barcode.getPlateSize();
int height = barcode.getHeight();
//获取对应尺寸的空位列表
//TODO 增加用户权限判断
String userId = SecurityUtils.getCurrentUserId();
User user = userManager.get(userId);
Set<String> mygroups = user.getGroups();
......@@ -101,8 +103,10 @@ public class SingleInController {
//
for (UsageItem item :
storage.getUsageMap().values()) {
if (item.getH() == height && item.getW() == width) {
if (height == 0 || width == 0) {
posTotalCount += item.getTotalCount();
posUsedCount = item.getUsedCount();
} else if (item.getH() == height && item.getW() == width) {
posTotalCount += item.getTotalCount();
posUsedCount = item.getUsedCount();
}
......@@ -120,10 +124,6 @@ public class SingleInController {
}
}
// List<Storage> storageList = storageManager.findAll();
// for (Storage storage : storageList
// ) {
// }
//根据空位数排序
Collections.sort(shelfPosInfos);
return shelfPosInfos;
......
src/main/java/com/neotel/smfcore/core/order/service/po/LiteOrder.java
......@@ -248,9 +248,9 @@ public class LiteOrder extends BasePo implements Serializable {
this.setBaseCode(outInfo.getBaseCode());
this.setLgort(outInfo.getLgort());
this.setWorkLine(outInfo.getWorkLine());
this.setStartDate(outInfo.getStartDate());
this.setStartDate(outInfo.getStartD());
this.setUpdateDate(new Date());
this.setEndDate(outInfo.getEndDate());
this.setEndDate(outInfo.getEndD());
this.setWemng(outInfo.getWemng());
}
......
src/main/java/com/neotel/smfcore/hikvision/HikApi.java 0 → 100644
package com.neotel.smfcore.hikvision;
import cn.hutool.core.util.ObjectUtil;
import com.neotel.smfcore.core.device.util.DataCache;
import com.neotel.smfcore.hikvision.bean.*;
import com.neotel.smfcore.hikvision.bean.api.HikApiRequest;
import com.neotel.smfcore.hikvision.bean.api.RequestParam;
import com.neotel.smfcore.hikvision.bean.api.ResponseParam;
import com.neotel.smfcore.hikvision.util.HttpHelper;
import com.neotel.smfcore.hikvision.util.JsonUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import springfox.documentation.spring.web.json.Json;
import javax.annotation.PostConstruct;
import java.text.SimpleDateFormat;
import java.util.*;
@Slf4j
public class HikApi {
//读取配置中的地址
private static String mesServer = "";
@Value("${hik.server:}")
public void setHost(String host) {
HikApi.mesServer = mesServer;
}
@Autowired
private DataCache dataCache;
@PostConstruct
public void init(){
mesServer=dataCache.GetConfigCache("hik.server","hik.server",mesServer);
log.info("HIK服务器地址："+mesServer);
}
/**
* 0 成功
*/
public static final int CODE_OK = 0;
/**
*1 参数错误，需要重发
*/
public static final int CODE_PARAMERROR = 1;
/**
*6 报文已处理，无需重发
*/
public static final int CODE_REPEAT = 6;
/**
*99 其他未知错误，需要重发
*/
public static final int CODE_ERROR = 99;
private static Integer currReqCodeNum=10000000;
/**
* 获取请求号
* @return
*/
private static String getReqCode()
{
String id="";
SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
String temp = sf.format(new Date());
id=temp+codeAdd();
return id;
}
private static synchronized String codeAdd(){
currReqCodeNum++;
return currReqCodeNum.toString();
}
public static String getUrl(String apiName){
if(ObjectUtil.isNotEmpty(mesServer)&&ObjectUtil.isNotEmpty(apiName)){
if(mesServer.endsWith("/")){
return mesServer+apiName;
}else{
return mesServer+"/"+apiName;
}
}
return "";
}
/**
*接口名 转储单接口
* 功能说明 针对亮灯货架的转储出库，SMF系统根据业务类型调用MES接口，推送转储单信息给SMF
* 提供方 MES
* 调用方 SMF
* 请求参数 参数名 数据类型 最大长度 是否必填 备注
* reqCode String 32 是 唯一请求号
* userCode String 32 是 操作人
* data docNo String 16 是 单据号
* docType Integer 是 单据类型(0物料凭证,1交货单,2预留单、3AGV任务单)
* 返回结果 code Integer 结果码
* message String 64 结果描述
* reqCode String 32 唯一请求号
* data docNo String 32 单据号
* outLgort String 16 转出库位
* inLgort String 16 转入库位
* materialNo String 16 物料号
* baseCode String 16 基地编号
* dumpQty Integer 转出数量
*/
public static List<TransferOrderInfo> transferOrderApi (String userName,String docNo,String docType) {
String apiName="Hik 转储单接口 (transferOrderApi): ";
String url =getUrl( "转储单接口");
Map<String, Object> dataMap = new HashMap<String, Object>();
dataMap.put("docNo", docNo);//单据号
dataMap.put("docType", docType);//单据类型(0物料凭证,1交货单,2预留单、3AGV任务单)
String data = JsonUtil.toJsonStr(dataMap);
RequestParam info = new RequestParam(getReqCode(), userName, data);
HikApiRequest request = new HikApiRequest(1, url, new Date(), info);
log.info("Hik 转储单接口 (transferOrder): 发送" + data);
try {
ResponseParam responseInfo = HttpHelper.postJson(url, info);
boolean needResend = false;
if (responseInfo == null || responseInfo.getCode().equals(-1)) {
needResend = true;
log.info(apiName+"未收到返回值，需要重发");
} else if (responseInfo.getCode().equals(CODE_PARAMERROR) || responseInfo.getCode().equals(CODE_REPEAT)) {
needResend = true;
log.info(apiName+"返回code=" + responseInfo.getCode() + ",需要重发," + JsonUtil.toJsonStr(responseInfo));
} else {
log.info(apiName + "返回" + JsonUtil.toJsonStr(responseInfo));
String dataStr = responseInfo.getData();
List<TransferOrderInfo> list = JsonUtil.toList(dataStr, TransferOrderInfo .class);
}
} catch (Exception e) {
log.error(apiName+" 出错", e);
}
HikApiCache.addFailedRequest(request);
return null;
}
/**
* 7.2转储单入库过账接口
* @param userName
* @param inInfo
* @return 返回记录转储过账信息 是否成功，true=成功
*/
public static boolean transferOrderInApi(String userName, TransferOrderInInfo inInfo){
String apiName="Hik 转储单入库过账接口 (transferOrderInApi): ";
String url = getUrl( "转储单入库过账接口");
Map<String, Object> dataMap = new HashMap<String, Object>();
dataMap.put("docNo", inInfo.getDocNo());//单据号
dataMap.put("docType", inInfo.getDocType());//单据类型(0物料凭证,1交货单,2预留单、3AGV任务单)
dataMap.put("trayId", inInfo.getTrayId());//唯一码
dataMap.put("baseCode", inInfo.getBaseCode());//基地编号
dataMap.put("lgort", inInfo.getLgort());//库位
dataMap.put("qty", inInfo.getQty());//数量
String data = JsonUtil.toJsonStr(dataMap);
RequestParam info = new RequestParam(getReqCode(), userName, data);
HikApiRequest request = new HikApiRequest(1, url, new Date(), info);
log.info(apiName+" 发送" + data);
try {
ResponseParam responseInfo = HttpHelper.postJson(url, info);
boolean needResend = false;
if (responseInfo == null || responseInfo.getCode().equals(-1)) {
needResend = true;
log.info(apiName+" 未收到返回值，需要重发");
} else if (responseInfo.getCode().equals(CODE_PARAMERROR) || responseInfo.getCode().equals(CODE_REPEAT)) {
needResend = true;
log.info(apiName+"返回code=" + responseInfo.getCode() + ",需要重发," + JsonUtil.toJsonStr(responseInfo));
} else {
log.info(apiName+" 返回" + JsonUtil.toJsonStr(responseInfo));
return true;
}
} catch (Exception e) {
log.error(apiName+"出错", e);
}
HikApiCache.addFailedRequest(request);
return false;
}
/**
* 7.3排程发料过账接口
* @param userName
* @param param
* @return 返回保存备料信息是否成功，true=成功
*/
public static boolean scheduleTaskApi(String userName, ScheduleTaskInfo param){
String apiName="Hik 排程发料接口 (scheduleTaskApi): ";
String url = getUrl( "排程发料接口");
// jobNo String 32 是 工单号/合单号
// replenishmentNo String 32 否 补料单号（补料单业务补料单为必填项）
// station String 40 是 站位号
// factoryCode String 8 是 工厂
// lgort  String 8 是 库位
// qty Integer 数量
// interceptFlag Integer 截料标识(0为不截料,1为截料)
// interceptQty Integer 截料数量
// trayId String 41 是 料盘ID
Map<String, Object> dataMap = new HashMap<String, Object>();
dataMap.put("jobNo", param.getJobNo());//工单号/合单号
dataMap.put("replenishmentNo", param.getReplenishmentNo());//补料单号（补料单业务补料单为必填项)
dataMap.put("station", param.getStation());//站位号
dataMap.put("factoryCode", param.getFactoryCode());//工厂
dataMap.put("lgort", param.getLgort());//库位
dataMap.put("qty", param.getQty());//数量
dataMap.put("interceptFlag", param.getInterceptFlag());//截料标识(0为不截料,1为截料)
dataMap.put("interceptQty", param.getInterceptQty());//截料数量
dataMap.put("trayId", param.getTrayId());//料盘ID
String data = JsonUtil.toJsonStr(dataMap);
RequestParam info = new RequestParam(getReqCode(), userName, data);
HikApiRequest request = new HikApiRequest(1, url, new Date(), info);
log.info(apiName+" 发送" + data);
try {
ResponseParam responseInfo = HttpHelper.postJson(url, info);
boolean needResend = false;
if (responseInfo == null || responseInfo.getCode().equals(-1)) {
needResend = true;
log.info(apiName+" 未收到返回值，需要重发");
} else if (responseInfo.getCode().equals(CODE_PARAMERROR) || responseInfo.getCode().equals(CODE_REPEAT)) {
needResend = true;
log.info(apiName+"返回code=" + responseInfo.getCode() + ",需要重发," + JsonUtil.toJsonStr(responseInfo));
} else {
log.info(apiName+" 返回" + JsonUtil.toJsonStr(responseInfo));
return true;
}
} catch (Exception e) {
log.error(apiName+"出错", e);
}
HikApiCache.addFailedRequest(request);
return false;
}
/**
* 7.4 退料唯一码数量获取接口
* @param userName
* @param trayId 料盘ID
* @return 根据退料唯一码获取退料数量
*/
public static int returnMaterialApi(String userName, String trayId){
String apiName="Hik 退料唯一码数量获取接口 (returnMaterialApi): ";
String url = getUrl( "退料唯一码数量获取接口");
// Map<String, Object> dataMap = new HashMap<String, Object>();
// dataMap.put("trayId", trayId);//料盘ID
// String data = JsonUtil.toJsonStr(dataMap);
// data String 41 是 料盘ID
RequestParam info = new RequestParam(getReqCode(), userName, trayId);
HikApiRequest request = new HikApiRequest(1, url, new Date(), info);
log.info(apiName+" 发送" + info.getData());
try {
ResponseParam responseInfo = HttpHelper.postJson(url, info);
boolean needResend = false;
if (responseInfo == null || responseInfo.getCode().equals(-1)) {
needResend = true;
log.info(apiName+" 未收到返回值，需要重发");
} else if (responseInfo.getCode().equals(CODE_PARAMERROR) || responseInfo.getCode().equals(CODE_REPEAT)) {
needResend = true;
log.info(apiName+"返回code=" + responseInfo.getCode() + ",需要重发," + JsonUtil.toJsonStr(responseInfo));
} else {
log.info(apiName+" 返回" + JsonUtil.toJsonStr(responseInfo));
Map<String,Object> rdataMap= JsonUtil.toMap(responseInfo.getData());
int num=Integer.parseInt(rdataMap.get("qty").toString());
return num;
}
} catch (Exception e) {
log.error(apiName+"出错", e);
}
HikApiCache.addFailedRequest(request);
return -1;
}
/**
* 7.5 入库上架过账接口
* @param userName
* @param param
* @return 入库上架过账 是否成功，true=成功
*/
public static boolean inputApi(String userName, InOutApiInfo param){
String apiName="Hik 入库上架过账接口 (inputApi): ";
String url = getUrl( "入库上架过账接口");
// warehousingType Integer 是 入库类型(0普通入库1退料入库2并盘入库3截料入库)
// trayId String 41 是 料盘ID/唯一码
// qty Integer 是 数量
// baseCode String 16 是 基地
// lgort String 16 是 库位
Map<String, Object> dataMap = new HashMap<String, Object>();
dataMap.put("warehousingType", param.getInType());//入库类型(0普通入库1退料入库2并盘入库3截料入库)
dataMap.put("trayId", param.getTrayId());//料盘ID/唯一码
dataMap.put("qty", param.getQty());//数量
dataMap.put("baseCode", param.getBaseCode());//基地
dataMap.put("lgort", param.getLgort());//库位
String data = JsonUtil.toJsonStr(dataMap);
RequestParam info = new RequestParam(getReqCode(), userName, data);
HikApiRequest request = new HikApiRequest(1, url, new Date(), info);
log.info(apiName+" 发送" + data);
try {
ResponseParam responseInfo = HttpHelper.postJson(url, info);
boolean needResend = false;
if (responseInfo == null || responseInfo.getCode().equals(-1)) {
needResend = true;
log.info(apiName+" 未收到返回值，需要重发");
} else if (responseInfo.getCode().equals(CODE_PARAMERROR) || responseInfo.getCode().equals(CODE_REPEAT)) {
needResend = true;
log.info(apiName+"返回code=" + responseInfo.getCode() + ",需要重发," + JsonUtil.toJsonStr(responseInfo));
} else {
log.info(apiName+" 返回" + JsonUtil.toJsonStr(responseInfo));
return true;
}
} catch (Exception e) {
log.error(apiName+"出错", e);
}
HikApiCache.addFailedRequest(request);
return false;
}
/**
* 7.6 出库下架过账接口
* @param userName
* @param param
* @return 保存下架过账信息 是否成功，true=成功
*/
public static boolean checkOutApi(String userName, InOutApiInfo param){
String apiName="Hik 出库下架过账接口 (checkOutApi): ";
String url = getUrl( "出库下架过账接口");
// warehousingType Integer 是 出库类型(0普通出库1并盘出库 2湿敏出库)
// trayId String 41 是 料盘ID/唯一码
// qty Integer 是 数量
// baseCode String 16 是 基地
// lgort String 16 是 库位
Map<String, Object> dataMap = new HashMap<String, Object>();
dataMap.put("warehousingType", param.getOutType());//出库类型(0普通出库1并盘出库 2湿敏出库)
dataMap.put("trayId", param.getTrayId());//料盘ID/唯一码
dataMap.put("qty", param.getQty());//数量
dataMap.put("baseCode", param.getBaseCode());//基地
dataMap.put("lgort", param.getLgort());//库位
String data = JsonUtil.toJsonStr(dataMap);
RequestParam info = new RequestParam(getReqCode(), userName, data);
HikApiRequest request = new HikApiRequest(1, url, new Date(), info);
log.info(apiName+" 发送" + data);
try {
ResponseParam responseInfo = HttpHelper.postJson(url, info);
boolean needResend = false;
if (responseInfo == null || responseInfo.getCode().equals(-1)) {
needResend = true;
log.info(apiName+" 未收到返回值，需要重发");
} else if (responseInfo.getCode().equals(CODE_PARAMERROR) || responseInfo.getCode().equals(CODE_REPEAT)) {
needResend = true;
log.info(apiName+"返回code=" + responseInfo.getCode() + ",需要重发," + JsonUtil.toJsonStr(responseInfo));
} else {
log.info(apiName+" 返回" + JsonUtil.toJsonStr(responseInfo));
return true;
}
} catch (Exception e) {
log.error(apiName+"出错", e);
}
HikApiCache.addFailedRequest(request);
return false;
}
/**
* 7.7 工单发料状态查询接口
* @param userName
* @param orderNo 工单号、合单号
* @return 保存下架过账信息 是否成功，true=成功
*/
public static List<OrderItemInfo> checkOrderApi(String userName, String orderNo){
String apiName="Hik 工单发料状态查询接口 (checkOrderApi): ";
String url = getUrl( "工单发料状态查询接口");
// data String 16 是 工单号/合单号
RequestParam info = new RequestParam(getReqCode(), userName, orderNo);
HikApiRequest request = new HikApiRequest(1, url, new Date(), info);
log.info(apiName+" 发送" + info.getData());
try {
ResponseParam responseInfo = HttpHelper.postJson(url, info);
boolean needResend = false;
if (responseInfo == null || responseInfo.getCode().equals(-1)) {
needResend = true;
log.info(apiName+" 未收到返回值，需要重发");
} else if (responseInfo.getCode().equals(CODE_PARAMERROR) || responseInfo.getCode().equals(CODE_REPEAT)) {
needResend = true;
log.info(apiName+"返回code=" + responseInfo.getCode() + ",需要重发," + JsonUtil.toJsonStr(responseInfo));
} else {
log.info(apiName + "返回" + JsonUtil.toJsonStr(responseInfo));
String dataStr = responseInfo.getData();
List<OrderItemInfo> list = JsonUtil.toList(dataStr, OrderItemInfo .class);
return list;
}
} catch (Exception e) {
log.error(apiName+"出错", e);
}
HikApiCache.addFailedRequest(request);
return null;
}
/**
* 7.8唯一码校验接口
* @param userName
* @param trayId 料盘ID
* @param baseCode 基地
* @param lgort 库位
* @return 提供唯一码校验功能 是否成功，true=成功
*/
public static ResponseParam riCheckApi(String userName, String trayId,String baseCode,String lgort){
String apiName="Hik 唯一码校验接口 (riCheckApi): ";
String url = getUrl( "唯一码校验接口");
// trayId String 41 是 料盘ID
// baseCode String 16 是 基地
// lgort String 16 是 库位
Map<String, Object> dataMap = new HashMap<String, Object>();
dataMap.put("trayId", trayId);//料盘ID
dataMap.put("baseCode", baseCode);//基地
dataMap.put("lgort", lgort);//库位
String data = JsonUtil.toJsonStr(dataMap);
RequestParam info = new RequestParam(getReqCode(), userName, data);
HikApiRequest request = new HikApiRequest(1, url, new Date(), info);
log.info(apiName+" 发送" + info.getData());
try {
ResponseParam responseInfo = HttpHelper.postJson(url, info);
boolean needResend = false;
if (responseInfo == null || responseInfo.getCode().equals(-1)) {
needResend = true;
log.info(apiName+" 未收到返回值，需要重发");
} else if (responseInfo.getCode().equals(CODE_PARAMERROR) || responseInfo.getCode().equals(CODE_REPEAT)) {
needResend = true;
log.info(apiName+"返回code=" + responseInfo.getCode() + ",需要重发," + JsonUtil.toJsonStr(responseInfo));
} else {
return responseInfo;
}
} catch (Exception e) {
log.error(apiName+"出错", e);
}
HikApiCache.addFailedRequest(request);
return null;
}
/**
* 7.9 补料单发料状态查询接口
* @param userName
* @param replenishmentNo 补料单号
* @return 返回备料列表
*/
public static List<OrderItemInfo> checkReplenishmentOrderApi(String userName, String replenishmentNo){
String apiName="Hik 补料单发料状态查询接口 (checkReplenishmentOrderApi): ";
String url = getUrl( "补料单发料状态查询接口");
// data String 41 是 补料单号
RequestParam info = new RequestParam(getReqCode(), userName, replenishmentNo);
HikApiRequest request = new HikApiRequest(1, url, new Date(), info);
log.info(apiName+" 发送" + info.getData());
try {
ResponseParam responseInfo = HttpHelper.postJson(url, info);
boolean needResend = false;
if (responseInfo == null || responseInfo.getCode().equals(-1)) {
needResend = true;
log.info(apiName+" 未收到返回值，需要重发");
} else if (responseInfo.getCode().equals(CODE_PARAMERROR) || responseInfo.getCode().equals(CODE_REPEAT)) {
needResend = true;
log.info(apiName+"返回code=" + responseInfo.getCode() + ",需要重发," + JsonUtil.toJsonStr(responseInfo));
} else {
List<OrderItemInfo> list = JsonUtil.toList(responseInfo.getData(), OrderItemInfo .class);
return list;
}
} catch (Exception e) {
log.error(apiName+"出错", e);
}
HikApiCache.addFailedRequest(request);
return null;
}
}
src/main/java/com/neotel/smfcore/hikvision/HikApiCache.java 0 → 100644
package com.neotel.smfcore.hikvision;
import com.neotel.smfcore.common.exception.ApiException;
import com.neotel.smfcore.common.utils.Constants;
import com.neotel.smfcore.core.device.util.DataCache;
import com.neotel.smfcore.hikvision.bean.api.HikApiRequest;
import com.neotel.smfcore.hikvision.bean.api.ResponseParam;
import com.neotel.smfcore.hikvision.util.HttpHelper;
import com.neotel.smfcore.hikvision.util.JsonUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
@Slf4j
@Repository
public class HikApiCache {
@Autowired
private static DataCache dataCache;
/**
* 需要重发的指令列表
*/
private static Map<String, HikApiRequest> failedRequestMap;
private static boolean isProcessTimer = false;
/**
* 定时器,每10秒执行一次
*/
public static void runTimer() {
if (!isProcessTimer) {
isProcessTimer = true;
try {
sendFailedRequest();
} catch (Exception e) {
log.error("发送失败请求定时器执行出错:" + e.getMessage());
} finally {
isProcessTimer = false;
}
}
}
public static void addFailedRequest(HikApiRequest apiRequest) {
String mapKey = apiRequest.getParam().getReqCode();
if (failedRequestMap.get(mapKey) == null) {
log.info(mapKey + "通知指令发送到Hik失败,加入到缓存");
failedRequestMap.put(apiRequest.getParam().getReqCode(), apiRequest);
dataCache.updateCache(Constants.CACHE_failedRequestMap, failedRequestMap);
}
}
public static void removeFailedRequest(HikApiRequest apiRequest) {
String mapKey = apiRequest.getParam().getReqCode();
if (failedRequestMap.get(mapKey) != null) {
log.info(mapKey + "通知指令发送到Hik成功,从缓存中移除");
failedRequestMap.remove(apiRequest.getParam().getReqCode());
dataCache.updateCache(Constants.CACHE_failedRequestMap, failedRequestMap);
}
}
/**
* 加载请求指令信息
*/
private static void initApiRequestMap() {
if (failedRequestMap == null) {
failedRequestMap = new ConcurrentHashMap<>();
Map<String, HikApiRequest> dbFailedRequestMap = dataCache.getCache(Constants.CACHE_failedRequestMap);
if (dbFailedRequestMap != null) {
failedRequestMap.putAll(dbFailedRequestMap);
log.info("当前发送通知失败指令:" + failedRequestMap);
}
}
}
/**
* 获取失败列表,进行定时发送
*/
private static void sendFailedRequest() throws ApiException {
List<HikApiRequest> failedList = new ArrayList<>();
failedList.addAll(failedRequestMap.values());
failedList.sort(new Comparator<HikApiRequest>() {
@Override
public int compare(HikApiRequest o1, HikApiRequest o2) {
return o1.getCreateTime().compareTo(o2.getCreateTime());
}
});
for (HikApiRequest apiRequest : failedList) {
ResponseParam responseParam = HttpHelper.postJson(apiRequest.getUrl(), apiRequest.getParam());
boolean needResend = false;
if (responseParam == null || responseParam.getCode().equals(-1)) {
needResend = true;
log.info("Hik 转储单接口 (transferOrderThread): 未收到返回值，需要重发");
} else if (responseParam.getCode().equals(HikApi.CODE_PARAMERROR) || responseParam.getCode().equals(HikApi.CODE_REPEAT)) {
needResend = true;
log.info("Hik 转储单接口 (transferOrderThread): 返回code=" + responseParam.getCode() + ",需要重发," + JsonUtil.toJsonStr(responseParam));
} else {
log.info("Hik 转储单接口 (transferOrderThread): 返回" + JsonUtil.toJsonStr(responseParam));
// Map<String, Object> result = JsonUtil.toMap(responseParam.getData());
// return result;
}
}
}
}
src/main/java/com/neotel/smfcore/hikvision/bean/HikOutInfo.java
package com.neotel.smfcore.hikvision.bean;
import com.neotel.smfcore.common.utils.DateUtil;
import com.neotel.smfcore.core.order.service.po.LiteOrderItem;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.unit.DataUnit;
import java.io.Serializable;
import java.util.Date;
@Slf4j
@Getter
@Setter
public class HikOutInfo implements Serializable {
/**
* jobNo String true 工单号/合单号[合并唯一]
*/
private String jobNo;
protected String jobNo;
/**
*replenishmentNo String false 补料单号,如果有值表示此单为补料单[合并唯一]
*/
private String replenishmentNo;
protected String replenishmentNo;
/**
*baseCode String true 基地编号
*/
private String baseCode;
protected String baseCode;
/**
*lgort String true 库位
*/
private String lgort;
protected String lgort;
/**
*workLine String true 产线
*/
private String workLine;
protected String workLine;
/**
*startDate String true 开工时间
* "startDate": "2022-03-01 08:00:00",
*/
private Date startDate;
protected String startDate;
/**
*endDate String true 完工时间
* "endDate": "2022-03-01 22:00:00",
*/
private Date endDate;
protected String endDate;
/**
* materialNo String true 物料号[详情]
*/
private String materialNo;
protected String materialNo;
/**
* station String true 站位号
*/
private String station;
protected String station;
/**
*qty Integer true 需求数量
*/
private Integer qty;
protected Integer qty;
/**
*overFlag Integer true 超发标识[贵重物料](1是不允许超发,0是允许超发)
*/
private Integer overFlag;
protected Integer overFlag;
/**
*increment Integer true 发料增量
*/
private Integer increment;
protected Integer increment;
/**
*wemng Integer true 排程数量
*/
private Integer wemng;
protected Integer wemng;
/**
*reason String false 移动原因
*/
private String reason;
protected String reason;
public LiteOrderItem crateOrderItem(String orderNo) {
LiteOrderItem item = new LiteOrderItem();
......@@ -87,4 +93,24 @@ public class HikOutInfo implements Serializable {
return item;
}
public Date getStartD(){
// "startDate": "2022-03-01 08:00:00",
Date sDate=null;
try {
sDate= DateUtil.toDate(startDate,"yyyy-MM-dd HH:mm:ss");
}catch (Exception ex){
log.error("HitOutInfo getStartD ["+startDate+"] 出错:"+ex.toString());
}
return sDate;
}
public Date getEndD(){
Date sDate=null;
try {
sDate= DateUtil.toDate(endDate,"yyyy-MM-dd HH:mm:ss");
}catch (Exception ex){
log.error("HitOutInfo getStartD ["+endDate+"] 出错:"+ex.toString());
}
return sDate;
}
}
src/main/java/com/neotel/smfcore/hikvision/bean/InOutApiInfo.java 0 → 100644
package com.neotel.smfcore.hikvision.bean;
import com.sun.corba.se.impl.resolver.SplitLocalResolverImpl;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 7.5入库上架过账接口
* 7.6出库下架过账接口
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class InOutApiInfo {
// warehousingType Integer 是 入库类型(0普通入库1退料入库2并盘入库3截料入库)
// trayId String 41 是 料盘ID/唯一码
// qty Integer 是 数量
// baseCode String 16 是 基地
// lgort String 16 是 库位
// warehousingType Integer 是 出库类型(0普通出库1并盘出库 2湿敏出库)
// trayId String 41 是 料盘ID/唯一码
// qty Integer 是 数量
// baseCode String 16 是 基地
// lgort String 16 是 库位
/**
* 入库类型(0普通入库1退料入库2并盘入库3截料入库)
*/
private Integer inType;
/**
* 出库类型(0普通出库1并盘出库 2湿敏出库)
*/
private Integer outType;
/**
* 料盘ID/唯一码
*/
private String trayId;
/**
* 数量
*/
private Integer qty;
/**
* 基地
*/
private String baseCode;
/**
* 库位
*/
private String lgort;
}
src/main/java/com/neotel/smfcore/hikvision/bean/OrderItemInfo.java 0 → 100644
package com.neotel.smfcore.hikvision.bean;
import lombok.Getter;
import lombok.Setter;
import java.io.Serializable;
import java.util.Date;
@Getter
@Setter
public class OrderItemInfo extends HikOutInfo {
// jobNo String 16 工单号/合单号
// station String 32 站位号
// baseCode String 16 基地编号
// lgort String 16 库位
// workLine String 16 产线
// startDate String 19 开工时间
// endDate String 19 完工时间
// materialNo String 9 物料号
// qty Integer 需求数量
// overFlag Integer 超发标识(1是不允许超发,0是允许超发)
// prepareIncrement Integer 发料增量
// wemng Integer 排程数量
/**
*increment Integer true 发料增量
*/
private Integer prepareIncrement;
public Integer getIncrement(){
if(getIncrement()<=0&&prepareIncrement>=0){
return prepareIncrement;
}
return increment;
}
}
src/main/java/com/neotel/smfcore/hikvision/bean/ScheduleTaskInfo.java 0 → 100644
package com.neotel.smfcore.hikvision.bean;
import io.swagger.models.auth.In;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 7.3排程发料过账接口 参数
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ScheduleTaskInfo {
// jobNo String 32 是 工单号/合单号
// replenishmentNo String 32 否 补料单号（补料单业务补料单为必填项）
// station String 40 是 站位号
// factoryCode String 8 是 工厂
// lgort  String 8 是 库位
// qty Integer 数量
// interceptFlag Integer 截料标识(0为不截料,1为截料)
// interceptQty Integer 截料数量
// trayId String 41 是 料盘ID
/**
* 工单号/合单号
*/
private String jobNo;
/**
*补料单号（补料单业务补料单为必填项）
*/
private String replenishmentNo;
/**
*站位号
*/
private String station;
/**
*工厂
*/
private String factoryCode;
/**
*库位
*/
private String lgort;
/**
*数量
*/
private Integer qty;
/**
*截料标识(0为不截料,1为截料)
*/
private Integer interceptFlag;
/**
*截料数量
*/
private Integer interceptQty;
/**
*料盘ID
*/
private String trayId;
}
src/main/java/com/neotel/smfcore/hikvision/bean/TransferOrderInInfo.java 0 → 100644
package com.neotel.smfcore.hikvision.bean;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 转储单入库信息 ,7.2 转储单入库过账接口
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TransferOrderInInfo {
// docNo String 16 是 单据号
// docType Integer 是 单据类型(0物料凭证,1交货单,2预留单、3AGV任务单)
// trayId String 41 唯一码
// baseCode String 16 基地编号
// lgort String 16 库位
// qty Integer 数量
/**
* 单据号
*/
private String docNo;
/**
*单据类型(0物料凭证,1交货单,2预留单、3AGV任务单)
*/
private Integer docType;
/**
* 唯一码
*/
private String trayId;
/**
* 基地编号
*/
private String baseCode;
/**
* 库位
*/
private String lgort;
/**
* 数量
*/
private String qty;
}
src/main/java/com/neotel/smfcore/hikvision/bean/TransferOrderInfo.java 0 → 100644
package com.neotel.smfcore.hikvision.bean;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 转储单 ,7.1 转储单接口
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class TransferOrderInfo {
// docNo String 32 单据号
// outLgort String 16 转出库位
// inLgort String 16 转入库位
// materialNo String 16 物料号
// baseCode String 16 基地编号
// dumpQty Integer 转出数量
/**
* 单据号
*/
private String docNo;
/**
* 单据类型(0物料凭证,1交货单,2预留单、3AGV任务单)
*/
private Integer docType=0;
/**
* 转出库位
*/
private String outLgort;
/**
* 转入库位
*/
private String inLgort;
/**
* 物料号
*/
private String materialNo;
/**
*基地编号
*/
private String baseCode;
/**
*转出数量
*/
private String dumpQty;
}
src/main/java/com/neotel/smfcore/hikvision/bean/api/HikApiRequest.java 0 → 100644
package com.neotel.smfcore.hikvision.bean.api;
import com.neotel.smfcore.hikvision.bean.api.RequestParam;
import lombok.*;
import java.io.Serializable;
import java.util.Date;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class HikApiRequest implements Serializable {
/**
* 消息类型
*/
private int apiType=0;
/**
* url
*/
private String url="";
/**
* 消息创建时间
*/
private Date createTime;
/**
* 参数信息
*/
private RequestParam param;
}
src/main/java/com/neotel/smfcore/hikvision/bean/api/RequestParam.java 0 → 100644
package com.neotel.smfcore.hikvision.bean.api;
import lombok.*;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class RequestParam {
/**
* reqCode 是 String 请求唯一标识
*/
private String reqCode;
/**
*userCode String 32 是 操作人
*/
private String userCode;
/**
* data 否 Json 视具体业务而定
*/
private String data;
}
src/main/java/com/neotel/smfcore/hikvision/bean/api/ResponseParam.java 0 → 100644
package com.neotel.smfcore.hikvision.bean.api;
import lombok.*;
import java.io.Serializable;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ResponseParam implements Serializable {
/**
* reqCode 是 String 唯一请求号，与传入的参数reqCode保持一致
*/
private String reqCode;
/**
* code 是 String 结果码：0-成功，1~N-失败
*/
private String code;
/**
* message 是 String 0：成功 1~N：失败原因
*/
private String message;
/**
*data 选填 Json 返回的数据结构
*/
private String data;
}
src/main/java/com/neotel/smfcore/hikvision/util/HttpHelper.java 0 → 100644
package com.neotel.smfcore.hikvision.util;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.neotel.smfcore.common.exception.ApiException;
import com.neotel.smfcore.common.utils.DateUtil;
import com.neotel.smfcore.hikvision.bean.api.RequestParam;
import com.neotel.smfcore.hikvision.bean.api.ResponseParam;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.httpclient.methods.StringRequestEntity;
import org.apache.commons.httpclient.methods.multipart.MultipartRequestEntity;
import org.apache.commons.httpclient.params.HttpMethodParams;
import org.apache.logging.log4j.util.Strings;
import org.apache.commons.httpclient.*;
import org.apache.commons.httpclient.cookie.CookiePolicy;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.multipart.FilePart;
import org.apache.commons.httpclient.methods.multipart.Part;
import org.apache.commons.httpclient.methods.multipart.StringPart;
import java.io.*;
import java.net.URL;
import java.net.URLConnection;
import java.util.*;
/**
* HTTP网络请求
*/
@Slf4j
public class HttpHelper {
// 编码方式
private static final String CONTENT_CHARSET = "UTF-8";
// 连接超时时间
private static final int CONNECTION_TIMEOUT = 3000;
// 读数据超时时间
private static final int READ_DATA_TIMEOUT = 3000;
// 设置User-Agent
private static final String USER_AGENT = "SMD-BOX";
// public static String postJson(String url, Map<String, Object> params) throws ApiException {
// return postJson(url,params,null, "http");
// }
public static String get(String url,HashMap<String, String> params) throws ApiException {
return get(url,params,null, "http");
}
public static String postParamWithAuth(String url, Map<String, Object> paramMap, String user, String pwd) throws ApiException {
PrintWriter out = null;
BufferedReader in = null;
String result = "";
try {
URL realUrl = new URL(url);
// 打开和URL之间的连接
URLConnection conn = realUrl.openConnection();
// 设置通用的请求属性
conn.setRequestProperty("accept", "*/*");
conn.setRequestProperty("connection", "Keep-Alive");
conn.setRequestProperty("user-agent","Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
conn.setRequestProperty("Accept-Charset", "UTF-8");
//设置用户名和密码
if(Strings.isNotBlank(user)){
String auth = user+":"+pwd;
//对其进行加密
byte[] rel = Base64.getEncoder().encode(auth.getBytes());
String res = new String(rel);
//设置认证属性
conn.setRequestProperty("Authorization","Basic " + res);
}
// conn.setRequestProperty("Charset", "UTF-8");
// 发送POST请求必须设置如下两行
conn.setDoOutput(true);
conn.setDoInput(true);
conn.setConnectTimeout(20000);
// 获取URLConnection对象对应的输出流
//out = new PrintWriter(conn.getOutputStream());
out = new PrintWriter(new OutputStreamWriter(conn.getOutputStream(),"utf-8"));
// 设置请求属性
String param = "";
if (paramMap != null && paramMap.size() > 0) {
Iterator<String> ite = paramMap.keySet().iterator();
while (ite.hasNext()) {
String key = ite.next();// key
Object valueObj = paramMap.get(key);
String value = "";
if(valueObj != null){
if(valueObj instanceof Date){
DateUtil.toDateString((Date)valueObj,"yyyyMMdd");
}else{
value = valueObj.toString();
}
}
param += key + "=" + value + "&";
}
param = param.substring(0, param.length() - 1);
}
// 发送请求参数
out.print(param);
// flush输出流的缓冲
out.flush();
// 定义BufferedReader输入流来读取URL的响应
//in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
String line;
while ((line = in.readLine()) != null) {
result += line;
}
} catch (Exception e) {
throw new ApiException("Request [" + url + "] failed:" + e.getMessage());
}
// 使用finally块来关闭输出流、输入流
finally {
try {
if (out != null) {
out.close();
}
if (in != null) {
in.close();
}
} catch (IOException ex) {
throw new ApiException("Request [" + url + "] close instream failed:" + ex.getMessage());
}
}
return result;
}
/**
* 向指定URL发送POST请求
* @param url
* @param paramMap
* @return 响应结果
*/
public static String postParam(String url, Map<String, Object> paramMap) throws ApiException {
return postParamWithAuth(url,paramMap, null, null);
}
/**
* 发送POST请求
*
* @param url
* 请求URL地址
* @param params
* 请求参数
* @param protocol
* 请求协议 "http" / "https"
* @return 服务器响应的请求结果
*/
private static String postInBody(String url, HashMap<String, String> params,
HashMap<String, String> cookies, String protocol) throws ApiException {
// if (protocol.equalsIgnoreCase("https")) {
// Protocol httpsProtocol = new Protocol("https", new SecureProtocolSocketFactoryImpl(), 443);
// Protocol.registerProtocol("https", httpsProtocol);
// }
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod(url);
// 设置请求参数
if (params != null && !params.isEmpty()) {
NameValuePair[] data = new NameValuePair[params.size()];
Iterator<Map.Entry<String, String>> iterator = params.entrySet().iterator();
int i = 0;
while (iterator.hasNext()) {
Map.Entry<String, String> entry = iterator.next();
data[i] = new NameValuePair(entry.getKey(), entry.getValue());
++i;
}
postMethod.setRequestBody(data);
}
// 设置cookie
if (cookies != null && !cookies.isEmpty()) {
Iterator<Map.Entry<String, String>> iterator = cookies.entrySet().iterator();
StringBuilder buffer = new StringBuilder(128);
while (iterator.hasNext()) {
Map.Entry<String, String> entry = iterator.next();
buffer.append(entry.getKey()).append("=").append(entry.getValue()).append("; ");
}
// 设置cookie策略
postMethod.getParams().setCookiePolicy(CookiePolicy.IGNORE_COOKIES);
// 设置cookie内容
postMethod.setRequestHeader("Cookie", buffer.toString());
}
// 设置User-Agent
postMethod.setRequestHeader("User-Agent", USER_AGENT);
// 设置建立连接超时时间
httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(CONNECTION_TIMEOUT);
// 设置读数据超时时间
httpClient.getHttpConnectionManager().getParams().setSoTimeout(READ_DATA_TIMEOUT);
// 设置编码
postMethod.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, CONTENT_CHARSET);
// 使用系统提供的默认的恢复策略
postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler());
try {
try {
int statusCode = httpClient.executeMethod(postMethod);
if (statusCode != HttpStatus.SC_OK) {
throw new ApiException("Request [" + url + "] failed:" + postMethod.getStatusLine());
}
// 读取内容
byte[] responseBody = postMethod.getResponseBody();
return new String(responseBody, CONTENT_CHARSET);
} finally {
// 释放链接
postMethod.releaseConnection();
}
} catch (HttpException e) {
// 发生致命的异常，可能是协议不对或者返回的内容有问题
throw new ApiException("Request [" + url + "] failed:" + e.getMessage());
} catch (IOException e) {
// 发生网络异常
throw new ApiException("Request [" + url + "] failed:" + e.getMessage());
}
}
/**
* 发送Get请求
*
* @param url
* 请求URL地址
* @param params
* 请求参数
* @param protocol
* 请求协议 "http" / "https"
* @return 服务器响应的请求结果
*/
public static String get(String url, HashMap<String, String> params,
HashMap<String, String> cookies, String protocol) throws ApiException {
// if (protocol.equalsIgnoreCase("https")) {
// Protocol httpsProtocol = new Protocol("https", new SecureProtocolSocketFactoryImpl(), 443);
// Protocol.registerProtocol("https", httpsProtocol);
// }
HttpClient httpClient = new HttpClient();
GetMethod getMethod = new GetMethod(url);
// PostMethod postMethod = new PostMethod(url);
// 设置请求参数
if (params != null && !params.isEmpty()) {
NameValuePair[] data = new NameValuePair[params.size()];
Iterator<Map.Entry<String, String>> iterator = params.entrySet().iterator();
int i = 0;
while (iterator.hasNext()) {
Map.Entry<String, String> entry = iterator.next();
data[i] = new NameValuePair(entry.getKey(), entry.getValue());
++i;
}
getMethod.setQueryString(data);
}
// 设置cookie
if (cookies != null && !cookies.isEmpty()) {
Iterator<Map.Entry<String, String>> iterator = cookies.entrySet().iterator();
StringBuilder buffer = new StringBuilder(128);
while (iterator.hasNext()) {
Map.Entry<String, String> entry = iterator.next();
buffer.append(entry.getKey()).append("=").append(entry.getValue()).append("; ");
}
// 设置cookie策略
getMethod.getParams().setCookiePolicy(CookiePolicy.IGNORE_COOKIES);
// 设置cookie内容
getMethod.setRequestHeader("Cookie", buffer.toString());
}
// 设置User-Agent
getMethod.setRequestHeader("User-Agent", USER_AGENT);
// 设置建立连接超时时间
httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(CONNECTION_TIMEOUT);
// 设置读数据超时时间
httpClient.getHttpConnectionManager().getParams().setSoTimeout(READ_DATA_TIMEOUT);
// 设置编码
getMethod.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, CONTENT_CHARSET);
// 使用系统提供的默认的恢复策略
getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler());
try {
try {
int statusCode = httpClient.executeMethod(getMethod);
if (statusCode != HttpStatus.SC_OK) {
throw new ApiException("Request [" + url + "] failed:" + getMethod.getStatusLine());
}
// 读取内容
byte[] responseBody = getMethod.getResponseBody();
return new String(responseBody, CONTENT_CHARSET);
} finally {
// 释放链接
getMethod.releaseConnection();
}
} catch (HttpException e) {
// 发生致命的异常，可能是协议不对或者返回的内容有问题
throw new ApiException("Request [" + url + "] failed:" + e.getMessage());
} catch (IOException e) {
// 发生网络异常
throw new ApiException("Request [" + url + "] failed:" + e.getMessage());
}
}
/**
* POST提交JSON格式的内容
*/
private static String postJson(String url, Map<String, Object> params,
HashMap<String, String> cookies, String protocol) throws ApiException {
// if (protocol.equalsIgnoreCase("https")) {
// Protocol httpsProtocol = new Protocol("https", new SecureProtocolSocketFactoryImpl(), 443);
// Protocol.registerProtocol("https", httpsProtocol);
// }
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod(url);
// 设置请求参数
if (params != null && !params.isEmpty()) {
ObjectMapper mapper = new ObjectMapper();
try {
String requestBody = mapper.writeValueAsString(params);
StringRequestEntity requestEntity = new StringRequestEntity(
requestBody, "text/json", CONTENT_CHARSET);
postMethod.setRequestEntity(requestEntity);
} catch (JsonProcessingException e) {
throw new ApiException("Request [" + url + "] failed:" + e.getMessage());
} catch (UnsupportedEncodingException e) {
throw new ApiException("Request [" + url + "] failed:" + e.getMessage());
}
}
// 设置cookie
if (cookies != null && !cookies.isEmpty()) {
Iterator<Map.Entry<String, String>> iterator = cookies.entrySet().iterator();
StringBuilder buffer = new StringBuilder(128);
while (iterator.hasNext()) {
Map.Entry<String, String> entry = iterator.next();
buffer.append(entry.getKey()).append("=").append(entry.getValue()).append("; ");
}
// 设置cookie策略
postMethod.getParams().setCookiePolicy(CookiePolicy.IGNORE_COOKIES);
// 设置cookie内容
postMethod.setRequestHeader("Cookie", buffer.toString());
}
// 设置User-Agent
postMethod.setRequestHeader("User-Agent", USER_AGENT);
// 设置建立连接超时时间
httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(CONNECTION_TIMEOUT);
// 设置读数据超时时间
httpClient.getHttpConnectionManager().getParams().setSoTimeout(READ_DATA_TIMEOUT);
// 设置编码
postMethod.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, CONTENT_CHARSET);
// 使用系统提供的默认的恢复策略
postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler());
try {
try {
int statusCode = httpClient.executeMethod(postMethod);
if (statusCode != HttpStatus.SC_OK) {
throw new ApiException("Request [" + url + "] failed:" + postMethod.getStatusLine());
}
// 读取内容
byte[] responseBody = postMethod.getResponseBody();
return new String(responseBody, CONTENT_CHARSET);
} finally {
// 释放链接
postMethod.releaseConnection();
}
} catch (HttpException e) {
// 发生致命的异常，可能是协议不对或者返回的内容有问题
throw new ApiException("Request [" + url + "] failed:" + e.getMessage());
} catch (IOException e) {
// 发生网络异常
throw new ApiException("Request [" + url + "] failed:" + e.getMessage());
}
}
/**
* 发送POST请求（上传文件）
*
* @param url
* 请求URL地址
* @param params
* 请求参数
* @param protocol
* 请求协议 "http" / "https"
* @param fp
* 上传的文件
* @return 服务器响应的请求结果
*/
private static String postWithFile(String url,
HashMap<String, String> params, HashMap<String, String> cookies,
FilePart fp, String protocol) throws ApiException {
// if (protocol.equalsIgnoreCase("https")) {
// Protocol httpsProtocol = new Protocol("https", new SecureProtocolSocketFactoryImpl(), 443);
// Protocol.registerProtocol("https", httpsProtocol);
// }
HttpClient httpClient = new HttpClient();
PostMethod postMethod = new PostMethod(url);
List<Part> parts = new ArrayList<Part>();
parts.add(fp);
// 设置请求参数
if (params != null && !params.isEmpty()) {
Iterator<Map.Entry<String, String>> iterator = params.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, String> entry = iterator.next();
// 设置参数为UTF-8编码集，解决中文乱码问题，并且将参数加到post中
parts.add(new StringPart(entry.getKey(), entry.getValue(), CONTENT_CHARSET));
}
}
MultipartRequestEntity requestEntity = new MultipartRequestEntity(
(Part[]) parts.toArray(), postMethod.getParams());
postMethod.setRequestEntity(requestEntity);
// 设置cookie
if (cookies != null && !cookies.isEmpty()) {
Iterator<Map.Entry<String, String>> iterator = cookies.entrySet().iterator();
StringBuilder buffer = new StringBuilder(128);
while (iterator.hasNext()) {
Map.Entry<String, String> entry = iterator.next();
buffer.append(entry.getKey()).append("=").append(entry.getValue()).append("; ");
}
// 设置cookie策略
postMethod.getParams().setCookiePolicy(CookiePolicy.IGNORE_COOKIES);
// 设置cookie内容
postMethod.setRequestHeader("Cookie", buffer.toString());
}
// 设置User-Agent
postMethod.setRequestHeader("User-Agent", USER_AGENT);
// 设置建立连接超时时间
httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(CONNECTION_TIMEOUT);
// 设置读数据超时时间
httpClient.getHttpConnectionManager().getParams().setSoTimeout(READ_DATA_TIMEOUT);
// 使用系统提供的默认的恢复策略
postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler());
// 发送请求
try {
try {
postMethod.getParams().setContentCharset("UTF-8");
int statusCode = httpClient.executeMethod(postMethod);
if (statusCode != HttpStatus.SC_OK) {
throw new ApiException("Request [" + url + "] failed:" + postMethod.getStatusLine());
}
// 读取内容
byte[] responseBody = postMethod.getResponseBody();
return new String(responseBody, CONTENT_CHARSET);
} finally {
// 释放链接
postMethod.releaseConnection();
}
} catch (HttpException e) {
// 发生致命的异常，可能是协议不对或者返回的内容有问题
throw new ApiException("Request [" + url + "] failed:" + e.getMessage());
} catch (IOException e) {
// 发生网络异常
throw new ApiException("Request [" + url + "] failed:" + e.getMessage());
}
}
public static ResponseParam postJson(String url, RequestParam requestInfo) throws ApiException {
Map<String, Object> params = new HashMap<>();
HashMap<String, String> cookies = null;
String protocol = "http";
params.put("reqCode", requestInfo.getReqCode());
params.put("userCode", requestInfo.getUserCode());
params.put("data", requestInfo.getData());
String result = postJson(url, params, cookies, protocol);
ResponseParam responseInfo = JsonUtil.toObj(result, ResponseParam.class);
if (requestInfo == null) {
log.error("[" + url + "]发送[" + requestInfo.getReqCode() + "][" + requestInfo.getUserCode() + "][" + requestInfo.getData() + "],返回值：" + result);
responseInfo = new ResponseParam(requestInfo.getReqCode(), "-1", "", "");
}
return responseInfo;
}
}
\ No newline at end of file
src/main/java/com/neotel/smfcore/hikvision/util/JsonUtil.java 0 → 100644
package com.neotel.smfcore.hikvision.util;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Slf4j
public class JsonUtil {
// 定义jackson对象
private static final ObjectMapper MAPPER = new ObjectMapper();
static{
MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
}
/**
* 将对象转换成json字符串。
* <p>Title: pojoToJson</p>
* <p>Description: </p>
* @param data
* @return
*/
public static String toJsonStr(Object data) {
try {
String string = MAPPER.writeValueAsString(data);
return string;
} catch (Exception e) {
log.info("转换JSON字符串出错:",e);
}
return null;
}
/**
* 将json结果集转化为对象
*
* @param jsonStr json数据
* @param beanType 对象中的object类型
* @return
*/
public static <T> T toObj(String jsonStr, Class<T> beanType) {
try {
T t = MAPPER.readValue(jsonStr, beanType);
return t;
} catch (Exception e) {
log.info(jsonStr + "转换对象出错:",e);
}
return null;
}
/**
* 将json数据转换成对象list
* <p>Title: jsonToList</p>
* <p>Description: </p>
* @param jsonStr
* @param beanType
* @return
*/
public static <T> List<T> toList(String jsonStr, Class<T> beanType) {
JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);
try {
List<T> list = MAPPER.readValue(jsonStr, javaType);
return list;
} catch (Exception e) {
log.info(jsonStr + "转换List出错:",e);
}
return new ArrayList<>();
}
public static Map<String, Object> toMap(String jsonStr){
//JavaType javaType = MAPPER.getTypeFactory().constructParametricType(HashMap.class, String.class, String.class);
try {
//Map<String, String> map = MAPPER.readValue(jsonStr, javaType);
Map<String, Object> map = MAPPER.readValue(jsonStr, Map.class);
return map;
} catch (Exception e) {
log.info(jsonStr + "转换Map出错:",e);
}
return new HashMap<>();
}
public static void main(String args[]) throws Exception{
String jsonStr = "[{\n" +
" \"action\": \"补料\",\n" +
" \"hSerial\": \"82\",\n" +
" \"so\": \"879235\",\n" +
"\"refno\": \"F001_879235N_1\",\n" +
"\"partNum\": \"7H.47134.1F1\",\n" +
" \"slot\": \"1-11\",\n" +
"\"qty\": \"2006\",\n" +
"\"facility\": \"SU\",\n" +
"\"sdte\": \"20191118\",\n" +
"\"stme\": \"85957\",\n" +
"\"reelcut\": \"N\",\n" +
"\"mdte\": \"20191115\",\n" +
"\"mtme\": \"172238\"\n" +
"},\n{\n" +
" \"action\": \"补料\",\n" +
" \"hSerial\": \"82\",\n" +
" \"so\": \"879235\",\n" +
"\"refno\": \"F001_879235N_1\",\n" +
"\"partNum\": \"7H.47134.1F1\",\n" +
" \"slot\": \"1-11\",\n" +
"\"qty\": \"2006\",\n" +
"\"facility\": \"SU\",\n" +
"\"sdte\": \"20191118\",\n" +
"\"stme\": \"85957\",\n" +
"\"reelcut\": \"N\",\n" +
"\"mdte\": \"20191115\",\n" +
"\"mtme\": \"172238\"\n" +
"}\n]";
// List<RequestOutItemBean> items = JsonUtil.toList(jsonStr, RequestOutItemBean.class);
// for (RequestOutItemBean item : items) {
// System.out.println(item);
// }
// System.out.println(DateUtil.toDateString(new Date(),"yyyyMMddHHmmssS"));
// System.out.println(DateUtil.toDateString(new Date(),"yyyyMMddHHmmssS"));
// System.out.println(DateUtil.toDateString(new Date(),"yyyyMMddHHmmssS"));
// System.out.println(DateUtil.toDateString(new Date(),"yyyyMMddHHmmssS"));
//
// System.out.println(System.nanoTime());
// System.out.println(System.nanoTime());
// System.out.println(System.currentTimeMillis());
// System.out.println(System.currentTimeMillis());
jsonStr = "{\"state\":\"0\",\"msg\":\"鏂欏嵎浣嶆暟涓嶅尮閰??\",\"info\":{\"so\":\"\",\"facility\":\"12334\",\"company\":\"\",\"qty\":\"\",\"soseq\":\"\"}}";
jsonStr = "{\"data\":[{\"Serial\":\"58890\",\"VehicleID\":\"D15\",\"Status\":\"\"},{\"Serial\":\"58890\",\"VehicleID\":\"D44\",\"Status\":\"\"},{\"Serial\":\"58890\",\"VehicleID\":\"D83\",\"Status\":\"\"},{\"Serial\":\"58890\",\"VehicleID\":\"D90\",\"Status\":\"\"},{\"Serial\":\"58890\",\"VehicleID\":\"D98\",\"Status\":\"\"}]}";
Map<String, Object> map = JsonUtil.toMap(jsonStr);
Object data = map.get("data");
if(data != null){
List<Object> dataList = (List)data;
for (Object info : dataList) {
Map<String,String> infoMap = (Map)info;
System.out.println(infoMap.get("Serial"));
}
}
}
}
src/main/resources/config/application-dev.yml
......@@ -4,7 +4,7 @@ spring:
mongodb:
host: localhost # 主机地址
port: 27017 # 端口
database: smf # 数据库
database: hikvision # 数据库
# 登录相关配置
login:
......
src/main/resources/config/application.yml
server:
port: 8800
hella:
#host: 127.0.0.1
port: 3333
hik:
server:
# 文件存储路径
file:
......@@ -22,7 +20,7 @@ spring:
mongodb:
host: localhost # 主机地址
port: 27017 # 端口
database: smf # 数据库
database: hikvision # 数据库
messages:
encoding: utf-8
main:
......
支持 Markdown 格式
你添加了 0 人 到此讨论。请谨慎行事。
Finish editing this message first!