修改北向接口，增加产品枚举

ebc-sea-platform/src/main/java/com/ai/ipu/server/dao/impl/DeviceManageDaoImpl.java

@@ -1,97 +1,74 @@
package com.ai.ipu.server.dao.impl;
import com.ai.ipu.data.JList;
import com.ai.ipu.data.JMap;
import com.ai.ipu.data.impl.JsonList;
import com.ai.ipu.data.impl.JsonMap;
import com.ai.ipu.server.dao.interfaces.DeviceManageDao;
import com.ai.ipu.sql.mgmt.ISqlMgmtDao;
import com.ai.ipu.sql.mgmt.SqlMgmtDaoFactory;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.io.IOException;
import java.util.Map;
@Component
public class DeviceManageDaoImpl implements DeviceManageDao {
    private String connName = "ebc";
    @Override
    public PageInfo queryDeviceInfo(JMap params) throws Exception {
        JMap params1 = params.getJMap("params");
        PageHelper.startPage(params1.getInt("pageNum"),params1.getInt("pageSize"));
        ISqlMgmtDao dao = SqlMgmtDaoFactory.createFileSqlMgmtDao(connName);
        List<Map<String, Object>> mapTagList= dao.executeSelect("ipu.DeviceManageDao", "queryDeviceInfo", params1);
        List<Map<String, Object>> mapTagXyList= dao.executeSelect("ipu.DeviceManageDao", "queryDeviceXyInfo", params1);
        //将后台拼接成级联属性
        mapTagList.forEach((mapTag)->{
            ArrayList<Object> arrayList = new ArrayList<>();
            mapTagXyList.forEach((mapTagXy)->{
                if(mapTag.get("MAP_TAG_ID")==mapTagXy.get("MAP_TAG_ID")){
                    arrayList.add(mapTagXy);
                    System.out.println(arrayList.toString());
                }
            });
            mapTag.put("EBC_MAP_TAG_XY",arrayList);
        });
        PageInfo pageInfo = new PageInfo(mapTagList);
        return pageInfo;
    }
    @Override
    public int modifyDeviceInfo (JMap params) throws Exception {
        deleteDeviceXyInfo(params);
        //将新数据插入
        int num = addDeviceInfo(params);
        return num;
    }
    @Override
    public int addDeviceInfo(JMap params) throws Exception {
        Object mapTagContent = params.get("MAP_TAG_CONTENT");
        String mapTagContentStr = JSONObject.toJSONString(mapTagContent);
        params.put("MAP_TAG_CONTENT",mapTagContentStr);
        ISqlMgmtDao dao = SqlMgmtDaoFactory.createFileSqlMgmtDao(connName);
        int num = dao.executeInsert("ipu.DeviceManageDao", "addDeviceInfo", params);
        if(num>0){
            JMap paramsMap=new JsonMap();
            JList paramsList=new JsonList();
            JList paramsJList = params.getJList("EBC_MAP_TAG_XY");
            paramsJList.forEach(s->{
                HashMap hashMap = JSON.parseObject(JSONObject.toJSONString(s), HashMap.class);
                hashMap.put("MAP_TAG_ID",params.getInt("MAP_TAG_ID"));
                paramsList.add(hashMap);
            });
            paramsMap.put("paramsList",paramsList);
            int i = dao.executeInsert("ipu.DeviceManageDao", "addDevicexyInfo", paramsMap);
        }
        return num;
    }
    @Override
    public boolean deleteDeviceXyInfo(JMap params) throws Exception {
        ISqlMgmtDao dao = SqlMgmtDaoFactory.createFileSqlMgmtDao(connName);
        //先删除子表在删除父表
        dao.executeDelete( "ipu.DeviceManageDao", "deleteDeviceXyInfo", params);
        int num = dao.executeDelete("ipu.DeviceManageDao", "deleteDeviceInfo", params);
        if(num>0){
            return true;
        }
        return false;
    }
import org.springframework.stereotype.Component;
import com.ai.ipu.data.JMap;
import com.ai.ipu.database.dao.impl.AbstractBizDao;
import com.ai.ipu.server.dao.interfaces.DeviceManageDao;
import com.ai.ipu.server.model.IotUrlEnum;
import com.ai.ipu.server.util.EbcConstant;
import com.ai.ipu.server.util.HttpURLConnectionUtil;
@Component
public class DeviceManageDaoImpl extends AbstractBizDao implements DeviceManageDao {
	public DeviceManageDaoImpl() throws IOException {
		super("ebc");
	}
	@Override
	public Map<String, String> queryDeviceInfo(JMap params) throws Exception {
		// 拼接接口地址
		String url = IotUrlEnum.queryPageDevice.getUrl();
		// Map map = HttpURLConnectionUtil.iotCallMothod(url,params);
		return null;
	}
	@Override
	public Map<String, String> addDeviceInfo(Map<String, String> paramsMap) throws Exception {
		// 拼接接口地址
		String url = IotUrlEnum.addDevice.getUrl();
		Map map = HttpURLConnectionUtil.iotCallMothod(url, paramsMap);
		return map;
	}
	@Override
	public Map<String, String> modifyDeviceInfo(Map<String, String> paramsMap) throws Exception {
		// 拼接接口地址
		String url = IotUrlEnum.updateDevice.getUrl();
		Map map = HttpURLConnectionUtil.iotCallMothod(url, paramsMap);
		return map;
	}
	@Override
	public Map<String, String> deleteDeviceInfo(Map<String, String> paramsMap) throws Exception {
		// 拼接接口地址
		String url = IotUrlEnum.deleteDevice.getUrl();
		Map map = HttpURLConnectionUtil.iotCallMothod(url, paramsMap);
		return map;
	}
	@Override
	public int bindDevice(Map params, String type) throws Exception {
		if (EbcConstant.bind_device_type_user.equals(type)) {
			return dao.insert("LR_PARTY_TERMINAL", params);
		} else if (EbcConstant.bind_device_type_ship.equals(type)) {
			return dao.update("LR_FACILITY", params);
		}
		return 0;
	}
	@Override
	public int unbindDevice(Map params, String type) throws Exception {
		if (EbcConstant.bind_device_type_user.equals(type)) {
			return dao.delete("LR_PARTY_TERMINAL", params);
		} else if (EbcConstant.bind_device_type_ship.equals(type)) {
			return dao.update("LR_FACILITY", params);
		}
		return 0;
	}
}

ebc-sea-platform/src/main/java/com/ai/ipu/server/dao/interfaces/DeviceManageDao.java

@@ -1,15 +1,20 @@
package com.ai.ipu.server.dao.interfaces;
import java.util.Map;
import com.ai.ipu.data.JMap;
import com.github.pagehelper.PageInfo;
public interface DeviceManageDao {
    PageInfo queryDeviceInfo(JMap params) throws Exception;
	Map<String, String> queryDeviceInfo(JMap params) throws Exception;
	Map<String, String> addDeviceInfo(Map<String, String> paramsMap) throws Exception;
	Map<String, String> modifyDeviceInfo(Map<String, String> paramsMap) throws Exception;
    int modifyDeviceInfo(JMap params) throws Exception;
	Map<String, String> deleteDeviceInfo(Map<String, String> paramsMap) throws Exception;
    int addDeviceInfo(JMap params) throws Exception;
	int bindDevice(Map params,String type) throws Exception;
    boolean deleteDeviceXyInfo(JMap params) throws Exception;
	int unbindDevice(Map params,String type) throws Exception;
}

ebc-sea-platform/src/main/java/com/ai/ipu/server/model/IotUrlEnum.java

@@ -0,0 +1,33 @@
package com.ai.ipu.server.model;
/**
 * iot 北向接口业务数据的地址枚举
 * 
 * @author konghl@asiainfo.com
 * 2020-10-20
 */
public enum IotUrlEnum {
	// 注册设备
	addDevice("device"),
	// 删除设备
	deleteDevice("deleteDevice"),
	// 修改设备
	updateDevice("updateDevice"),
	// 查询指定设备
	queryDevice("device-detail"),
	// 分页查询设备
	queryPageDevice("findTerminal"),
	// 按产品id查询设备
	queryProductDevice("product/device-status");
	private String url;
	private IotUrlEnum(String url) {
		this.url = url;
	}
	public String getUrl() {
		return UrlAddress.IOT_URL1 + "/" + url;
	}
}

ebc-sea-platform/src/main/java/com/ai/ipu/server/model/UrlAddress.java

@@ -1,10 +1,13 @@
package com.ai.ipu.server.model;
public interface UrlAddress {
	// gis的token地址
	public static final String GIS_TOKEN = "http://192.168.74.189:9999/gisIntf/account/gettoken";
    public static final String IOT_URL="http://60.205.219.67:8300/dmp/terminalNorthApi/";
	// iot的北向接口注册地址
	public static final String IOT_LOGIN = "http://60.205.219.67:8300/sso/login";
    public static final String IOT_LOGIN="http://60.205.219.67:8300/sso/login";
	// iot的北向接口统一地址
	public static final String IOT_URL1 = "http://60.205.219.67:8300/dmp/terminalNorthApi";
    public static final String GIS_TOKEN="http://192.168.74.189:9999/gisIntf/account/gettoken";
}

ebc-sea-platform/src/main/java/com/ai/ipu/server/service/impl/DeviceManageServiceImpl.java

@@ -1,41 +1,81 @@
package com.ai.ipu.server.service.impl;
import com.ai.ipu.data.JMap;
import com.ai.ipu.server.dao.interfaces.DeviceManageDao;
import com.ai.ipu.server.service.interfaces.DeviceManageService;
import com.github.pagehelper.PageInfo;
import java.util.HashMap;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ai.ipu.data.JMap;
import com.ai.ipu.server.dao.interfaces.DeviceManageDao;
import com.ai.ipu.server.service.interfaces.DeviceManageService;
import com.ai.ipu.server.util.EbcConstant;
import com.github.pagehelper.PageInfo;
@Service
public class DeviceManageServiceImpl implements DeviceManageService  {
    Logger logger = LoggerFactory.getLogger(DeviceManageServiceImpl.class);
    @Autowired
    DeviceManageDao deviceManageDao;
    @Override
    public PageInfo queryDeviceInfo(JMap params) throws Exception {
        return deviceManageDao.queryDeviceInfo(params);
    }
    @Override
    public int modifyDeviceInfo(JMap params) throws Exception{
        //將原來数据删除，然后在从新插入
        return deviceManageDao.modifyDeviceInfo(params);
    }
    @Override
    public int addDeviceInfo(JMap params) throws Exception{
        return deviceManageDao.addDeviceInfo(params);
    }
    @Override
    public boolean deleteDeviceXyInfo(JMap params) throws Exception{
        return deviceManageDao.deleteDeviceXyInfo(params);
    }
public class DeviceManageServiceImpl implements DeviceManageService {
	Logger logger = LoggerFactory.getLogger(DeviceManageServiceImpl.class);
	@Autowired
	DeviceManageDao deviceManageDao;
	@Override
	public PageInfo queryDeviceInfo(JMap params) throws Exception {
		PageInfo pageInfo = new PageInfo();
		Map map = deviceManageDao.queryDeviceInfo(params);
		return pageInfo;
	}
	@Override
	public Map<String, String> addDeviceInfo(JMap params) throws Exception {
		Map<String, String> paramsMap = new HashMap<String, String>();
		String deviceId = params.getString("deviceId");
		paramsMap.put("deviceId", deviceId);// 终端id
		paramsMap.put("terminalSN", deviceId); // 终端编号
		paramsMap.put("productId", EbcConstant.beidouDevice_product_id); // 所属产品
		paramsMap.put("deviceName", EbcConstant.beidouDevice_name + deviceId); // 设备名称
		paramsMap.put("remarks", params.getString("remarks")); // 备注
		Map map = deviceManageDao.addDeviceInfo(paramsMap);
		return map;
	}
	@Override
	public Map<String, String> modifyDeviceInfo(JMap params) throws Exception {
		Map<String, String> paramsMap = new HashMap<String, String>();
		String deviceId = params.getString("deviceId");
		
		paramsMap.put("deviceId", params.getString("deviceId"));// 终端id
		paramsMap.put("remarks", params.getString("remarks")); // 备注
		Map map = deviceManageDao.modifyDeviceInfo(paramsMap);
		return map;
	}
	@Override
	public Map<String, String> deleteDeviceInfo(JMap params) throws Exception {
		Map<String, String> paramsMap = new HashMap<String, String>();
		paramsMap.put("deviceId", params.getString("deviceId"));// 终端id (支持删多个，用逗号分隔)
		paramsMap.put("productId", EbcConstant.beidouDevice_product_id); // 所属产品
		
		Map map = deviceManageDao.deleteDeviceInfo(paramsMap);
		return map;
	}
	@Override
	public boolean bindDevice(JMap params) throws Exception {
		int num = deviceManageDao.bindDevice(params, params.getString("type"));
		return num > 0;
	}
	@Override
	public boolean unbindDevice(JMap params) throws Exception {
		int num = deviceManageDao.bindDevice(params, params.getString("type"));
		return num > 0;
	}
}

ebc-sea-platform/src/main/java/com/ai/ipu/server/service/impl/EquipmentManageServiceImpl.java

@@ -24,30 +24,28 @@ public class EquipmentManageServiceImpl implements EquipmentManageService {
    @Autowired
    EquipmentManageDao equipmentManageDao;
    @Override
    public PageInfo queryEquipmentInfo(JMap params) throws Exception {
        PageInfo pageInfo = new PageInfo();
        //拼接接口地址
        String IOT_URL=UrlAddress.IOT_URL+"device";
        Map map = HttpURLConnectionUtil.iotCallMothod(params, IOT_URL);
        //String IOT_URL=UrlAddress.IOT_URL+"device";
        //Map map = HttpURLConnectionUtil.iotCallMothod(params, IOT_URL);
        return pageInfo;
    }
    @Override
    public int modifyEquipmentInfo(JMap params) throws Exception{
        //拼接接口地址
        String IOT_URL=UrlAddress.IOT_URL+"device";
        Map map = HttpURLConnectionUtil.iotCallMothod(params, IOT_URL);
        //String IOT_URL=UrlAddress.IOT_URL+"device";
        //Map map = HttpURLConnectionUtil.iotCallMothod(params, IOT_URL);
        return 1;
    }
    @Override
    public int addEquipmentInfo(JMap params) throws Exception{
        //拼接接口地址
        String IOT_URL=UrlAddress.IOT_URL+"device";
        Map map = HttpURLConnectionUtil.iotCallMothod(params, IOT_URL);
        //String IOT_URL=UrlAddress.IOT_URL+"device";
        //Map map = HttpURLConnectionUtil.iotCallMothod(params, IOT_URL);
        return 1;
    }
@@ -55,24 +53,24 @@ public class EquipmentManageServiceImpl implements EquipmentManageService {
    public boolean deleteEquipmentInfo(JMap params) throws Exception{
        //拼接接口地址
        String IOT_URL=UrlAddress.IOT_URL+"device";
        Map map = HttpURLConnectionUtil.iotCallMothod(params, IOT_URL);
        //String IOT_URL=UrlAddress.IOT_URL+"device";
        //Map map = HttpURLConnectionUtil.iotCallMothod(params, IOT_URL);
        return true;
    }
    @Override
    public boolean deleteEquipmentsInfo(JMap params) throws Exception {
        //拼接接口地址
        String IOT_URL=UrlAddress.IOT_URL+"device";
        Map map = HttpURLConnectionUtil.iotCallMothod(params, IOT_URL);
        //String IOT_URL=UrlAddress.IOT_URL+"device";
        //Map map = HttpURLConnectionUtil.iotCallMothod(params, IOT_URL);
        return false;
    }
    @Override
    public boolean importEquipmentInfo(JMap params) throws Exception {
        //拼接接口地址
        String IOT_URL=UrlAddress.IOT_URL+"device";
        Map map = HttpURLConnectionUtil.iotCallMothod(params, IOT_URL);
        //String IOT_URL=UrlAddress.IOT_URL+"device";
        //Map map = HttpURLConnectionUtil.iotCallMothod(params, IOT_URL);
        return false;
    }

ebc-sea-platform/src/main/java/com/ai/ipu/server/service/impl/GisTokenServiceImpl.java

@@ -1,43 +1,40 @@
package com.ai.ipu.server.service.impl;
import com.ai.ipu.data.JMap;
import com.ai.ipu.server.dao.interfaces.TrackAnalysisDao;
import com.ai.ipu.server.model.UrlAddress;
import com.ai.ipu.server.service.interfaces.GisTokenService;
import com.ai.ipu.server.service.interfaces.TrackAnalysisService;
import com.ai.ipu.server.util.HttpURLConnectionUtil;
import com.alibaba.fastjson.JSON;
import com.github.pagehelper.PageInfo;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.Map;
import com.ai.ipu.server.model.UrlAddress;
import com.ai.ipu.server.service.interfaces.GisTokenService;
import com.ai.ipu.server.util.HttpServiceUtil;
import com.alibaba.fastjson.JSON;
@Service
public class GisTokenServiceImpl implements GisTokenService {
    Logger logger = LoggerFactory.getLogger(GisTokenServiceImpl.class);
    @Value("${aap.gis.userName}")
    private String gisUserName;
    @Value("${aap.gis.passwd}")
    private String gisPasswd;
    @Override
    public Map<String, Object> queryGisToken() {
        Map<String,String> mapParams=new HashMap<>();
        HashMap<Object, Object> requestParams = new HashMap<>();
        requestParams.put("userName", gisUserName);
        requestParams.put("passwd", gisPasswd);
        String  requestParamsJson= JSON.toJSONString(requestParams);
        String resultJson = HttpURLConnectionUtil.endoPost(UrlAddress.GIS_TOKEN, requestParamsJson, mapParams);
        Map<String,Object> resultMap = JSON.parseObject(resultJson, Map.class);
        return resultMap;
    }
	Logger logger = LoggerFactory.getLogger(GisTokenServiceImpl.class);
	@Value("${aap.gis.userName}")
	private String gisUserName;
	@Value("${aap.gis.passwd}")
	private String gisPasswd;
	@Override
	public Map<String, Object> queryGisToken() {
		Map<String, String> mapParams = new HashMap<>();
		HashMap<Object, Object> requestParams = new HashMap<>();
		requestParams.put("userName", gisUserName);
		requestParams.put("passwd", gisPasswd);
		Charset charset = Charset.forName("utf-8");
		String resultJson = HttpServiceUtil.senendPost(UrlAddress.GIS_TOKEN, mapParams, charset);
		Map<String, Object> resultMap = JSON.parseObject(resultJson, Map.class);
		return resultMap;
	}
}

ebc-sea-platform/src/main/java/com/ai/ipu/server/service/interfaces/DeviceManageService.java

@@ -1,15 +1,21 @@
package com.ai.ipu.server.service.interfaces;
import java.util.Map;
import com.ai.ipu.data.JMap;
import com.github.pagehelper.PageInfo;
public interface DeviceManageService {
    PageInfo queryDeviceInfo(JMap params) throws Exception;
	PageInfo queryDeviceInfo(JMap params) throws Exception;
	Map<String, String> addDeviceInfo(JMap params) throws Exception;
	Map<String, String> modifyDeviceInfo(JMap params) throws Exception;
    int modifyDeviceInfo(JMap params) throws Exception;
	Map<String, String> deleteDeviceInfo(JMap params) throws Exception;
    int addDeviceInfo(JMap params) throws Exception;
	boolean bindDevice(JMap params) throws Exception;
    boolean deleteDeviceXyInfo(JMap params) throws Exception;
	boolean unbindDevice(JMap params) throws Exception;
}

ebc-sea-platform/src/main/java/com/ai/ipu/server/util/EbcConstant.java

@@ -0,0 +1,21 @@
package com.ai.ipu.server.util;
/**
 * 业务常量
 * @author konghl@asiainfo.com
 * 2020-10-20
 */
public class EbcConstant {
	// 终端的产品id
	public static final String beidouDevice_product_id = "57700004344";
	
	// 终端的名称前缀
	public static final String beidouDevice_name = "康派北斗定位器";
	// 终端和人员绑定
	public static final String bind_device_type_user = "1";
	// 终端和船舶绑定
	public static final String bind_device_type_ship = "2";
}

ebc-sea-platform/src/main/java/com/ai/ipu/server/util/HttpServiceUtil.java

@@ -0,0 +1,290 @@
package com.ai.ipu.server.util;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.ailk.common.BaseException;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
/**
 * http服务请求工具类
 *
 * @author chencai
 */
@Slf4j
public class HttpServiceUtil {
	static Logger log = LoggerFactory.getLogger(HttpServiceUtil.class);
	private static final String HTTP_CONTENT_TYPE_JSON = "application/json; charset=utf-8";
	public static String buildUrl(Map<String, String> paramMap, String serviceUrl) {
		String url = null;
		StringBuffer urlString = new StringBuffer();
		urlString.append(serviceUrl);
		if (!paramMap.isEmpty()) {
			// 参数列表不为空，地址尾部增加'?'
			urlString.append('?');
			// 拼接参数
			Set<Map.Entry<String, String>> entrySet = paramMap.entrySet();
			for (Map.Entry<String, String> entry : entrySet) {
				try {
					urlString.append(entry.getKey()).append('=').append(URLEncoder.encode(entry.getValue(), "UTF-8"))
							.append('&');
				} catch (UnsupportedEncodingException e) {
					log.error(" Exception: " + e);
				}
			}
			// 去掉最后一个字符“&”
			url = urlString.substring(0, urlString.length() - 1);
		}
		return url;
	}
	public static String sendRequest(String url) {
		InputStream inputStream = null;
		BufferedReader bufferedReader = null;
		HttpURLConnection httpURLConnection = null;
		try {
			log.error("It's not error. request url: " + url);
			URL requestURL = new URL(url);
			// 获取连接
			httpURLConnection = (HttpURLConnection) requestURL.openConnection();
			httpURLConnection.setConnectTimeout(10000); // 建立连接的超时时间，毫秒
			httpURLConnection.setReadTimeout(25000); // 获得返回的超时时间，毫秒
			httpURLConnection.setRequestMethod("GET");
			httpURLConnection.setRequestProperty("Content-type", "text/html;charset=UTF-8");
			httpURLConnection.setRequestProperty("Accept",
					"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8");
			// 通过输入流获取请求的内容
			inputStream = httpURLConnection.getInputStream();
			bufferedReader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
			String temp = null;
			StringBuffer stringBuffer = new StringBuffer();
			// 循环读取返回的结果
			while ((temp = bufferedReader.readLine()) != null) {
				stringBuffer.append(temp);
			}
			return stringBuffer.toString();
		} catch (Exception e) {
			log.error("sendRequest Exception: " + e);
		} finally {
			// 断开连接
			if (httpURLConnection != null) {
				httpURLConnection.disconnect();
			}
			// 关闭流
			if (bufferedReader != null) {
				try {
					bufferedReader.close();
				} catch (IOException e) {
					log.error("bufferedReader Exception: " + e);
				}
			}
			if (inputStream != null) {
				try {
					inputStream.close();
				} catch (IOException e) {
					log.error("inputStream Exception: " + e);
				}
			}
		}
		return null;
	}
	public static String sendPostRequest(String url, Map<String, String> map, String encoding) {
		String retStr = "";
		try {
			retStr = sendPostRequest(url, map, encoding, 0, 0);
		} catch (Exception ex) {
			log.error("sendPostRequest error: " + ex);
		}
		return retStr;
	}
	public static String sendPostRequest(String url, Map<String, String> map, String encoding, int ebossConnectTimeout,
			int ebossServiceTimeout) throws BaseException {
		CloseableHttpClient httpClient = HttpClients.createDefault();
		HttpPost httpPost = new HttpPost(url);
		String body = "";
		try {
			MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();
			if (map != null) {
				for (Map.Entry<String, String> entry : map.entrySet()) {
					multipartEntityBuilder.addTextBody(entry.getKey(), entry.getValue());
				}
			}
			log.debug("ebossConnectTimeout:" + ebossConnectTimeout);
			log.debug("ebossServiceTimeout:" + ebossServiceTimeout);
			httpPost.setEntity(multipartEntityBuilder.build());
			if (ebossConnectTimeout != 0 && ebossServiceTimeout != 0) {
				RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(ebossServiceTimeout)
						.setConnectTimeout(ebossConnectTimeout).build();// 设置请求和传输超时时间
				httpPost.setConfig(requestConfig);
			}
			CloseableHttpResponse response = httpClient.execute(httpPost);
			if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
				HttpEntity entity = response.getEntity();
				if (entity != null) {
					// 按指定编码转换结果实体为String类型
					body = EntityUtils.toString(entity, encoding);
				}
				EntityUtils.consume(entity);
			}
		} catch (ClientProtocolException e) {
			log.error("ClientProtocolException Exception: " + e);
		} catch (UnsupportedEncodingException e) {
			log.error("UnsupportedEncodingException Exception: " + e);
		} catch (IOException e) {
			log.error("IOException Exception: " + e);
			// throw new BaseException("10", "调用Eboss超时");
		} finally {
			// 关闭连接,释放资源
			try {
				httpClient.close();
			} catch (IOException e) {
				log.error("httpClient Exception: " + e);
			}
		}
		return body;
	}
	public static String sendGet(String url, Charset encoding) {
		HttpClient httpClient = HttpClients.createDefault();
		String resp = "";
		HttpGet httpGet = new HttpGet(url);
		httpGet.addHeader(HTTP.CONTENT_TYPE, HTTP_CONTENT_TYPE_JSON);
		CloseableHttpResponse response = null;
		try {
			response = (CloseableHttpResponse) httpClient.execute(httpGet);
		} catch (IOException e) {
			log.error("请求错误");
		}
		return responseEx(httpClient, response, encoding);
	}
	public static String sendPost(String url, Map<String, String> params, Charset encoding) {
		HttpClient httpClient = HttpClients.createDefault();
		String resp = "";
		HttpPost httpPost = new HttpPost(url);
		httpPost.addHeader(HTTP.CONTENT_TYPE, HTTP_CONTENT_TYPE_JSON);
		if (params != null && params.size() > 0) {
			StringEntity se = new StringEntity(JSONObject.toJSONString(params), encoding);
			httpPost.setEntity(se);
		}
		CloseableHttpResponse response = null;
		try {
			response = (CloseableHttpResponse) httpClient.execute(httpPost);
		} catch (IOException e) {
			log.error("sendPost Exception: ", e.getMessage());
		}
		return responseEx(httpClient, response, encoding);
	}
	public static String sendPost(String url, Map<String, String> params, Charset encoding,
			Map<String, String> headerMap) {
		HttpClient httpClient = HttpClients.createDefault();
		String resp = "";
		HttpPost httpPost = new HttpPost(url);
		Iterator<String> iter = headerMap.keySet().iterator();
		String key = "";
		String value = "";
		while (iter.hasNext()) {
			key = iter.next();
			value = headerMap.get(key);
			httpPost.setHeader(key, value);
		}
		httpPost.addHeader(HTTP.CONTENT_TYPE, HTTP_CONTENT_TYPE_JSON);
		if (params != null && params.size() > 0) {
			StringEntity se = new StringEntity(JSONObject.toJSONString(params), encoding);
			httpPost.setEntity(se);
		}
		CloseableHttpResponse response = null;
		try {
			response = (CloseableHttpResponse) httpClient.execute(httpPost);
		} catch (IOException e) {
			log.error("sendPost Exception: ", e.getMessage());
		}
		return responseEx(httpClient, response, encoding);
	}
	public static String sendPut(String url, Map<String, String> params, Charset encoding) {
		HttpClient httpClient = HttpClients.createDefault();
		String resp = "";
		HttpPut httpPut = new HttpPut(url);
		httpPut.addHeader(HTTP.CONTENT_TYPE, HTTP_CONTENT_TYPE_JSON);
		if (params != null && params.size() > 0) {
			StringEntity se = new StringEntity(JSONObject.toJSONString(params), encoding);
			httpPut.setEntity(se);
		}
		CloseableHttpResponse response = null;
		try {
			response = (CloseableHttpResponse) httpClient.execute(httpPut);
		} catch (IOException e) {
			log.error("请求错误");
		}
		return responseEx(httpClient, response, encoding);
	}
	private static String responseEx(HttpClient httpClient, CloseableHttpResponse response, Charset encoding) {
		String resp = "";
		try {
			if (response != null && 200 == response.getStatusLine().getStatusCode()) {
				resp = EntityUtils.toString(response.getEntity(), encoding);
			}
		} catch (Exception e) {
			log.error(e.getMessage(), e);
		} finally {
			if (response != null) {
				try {
					response.close();
				} catch (IOException e) {
					log.error(e.getMessage(), e);
				}
			}
		}
		return resp;
	}
}

ebc-sea-platform/src/main/java/com/ai/ipu/server/util/HttpURLConnectionUtil.java

@@ -1,20 +1,19 @@
package com.ai.ipu.server.util;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import com.ai.ipu.data.JMap;
import com.ai.ipu.server.model.UrlAddress;
import com.alibaba.fastjson.JSON;
import com.sun.istack.internal.Nullable;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import com.ai.ipu.basic.log.ILogger;
import com.ai.ipu.basic.log.IpuLoggerFactory;
import com.ai.ipu.server.model.UrlAddress;
import com.alibaba.fastjson.JSON;
/**
 *
@@ -23,247 +22,123 @@ import java.util.concurrent.ConcurrentHashMap;
@Component
public class HttpURLConnectionUtil {
    private static String userCode;
    private static String passWord;
    @Value("${aap.iot.userCode}")
    public void setUserCode(String userCode) {
        HttpURLConnectionUtil.userCode = userCode;
    }
    @Value("${aap.iot.passWord}")
    public void setPassWord(String passWord) {
        HttpURLConnectionUtil.passWord = passWord;
    }
    //定义静态存储map空间存放sign与sessionId
    private volatile static Map<String, String> cacheMap = new ConcurrentHashMap<String, String>();// 缓存map
    //set
    public static void setMapCache(Map<String, String> map) {
        Set<String> set = map.keySet();
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            String key = it.next();
            cacheMap.put(key, map.get(key));
        }
    }
    //get
    public static Map<String, String> getMapCache() {
        return cacheMap;
    }
    //清除cache
    public static void clear(){
        cacheMap.clear();
    }
    /**
     * Http get请求
     * @param httpUrl 连接
     * @return 响应数据
     */
    public static String doGet(String httpUrl){
        //链接
        HttpURLConnection connection = null;
        InputStream is = null;
        BufferedReader br = null;
        StringBuffer result = new StringBuffer();
        try {
            //创建连接
            URL url = new URL(httpUrl);
            connection = (HttpURLConnection) url.openConnection();
            //设置请求方式
            connection.setRequestMethod("GET");
            //设置连接超时时间
            connection.setReadTimeout(15000);
            //开始连接
            connection.connect();
            //获取响应数据
            if (connection.getResponseCode() == 200) {
                //获取返回的数据
                is = connection.getInputStream();
                if (null != is) {
                    br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
                    String temp = null;
                    while (null != (temp = br.readLine())) {
                        result.append(temp);
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (null != br) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != is) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            //关闭远程连接
            connection.disconnect();
        }
        return result.toString();
    }
    /**
     * Http post请求
     * @param httpUrl 连接
     * @param param 参数
     * @return
     */
    public static String doPost(String httpUrl, @Nullable String param, Map<String,String> pramMap) {
        StringBuffer result = new StringBuffer();
        //连接
        HttpURLConnection connection = null;
        OutputStream os = null;
        InputStream is = null;
        BufferedReader br = null;
        try {
            //创建连接对象
            URL url = new URL(httpUrl);
            //创建连接
            connection = (HttpURLConnection) url.openConnection();
            //设置请求方法
            connection.setRequestMethod("POST");
            //设置连接超时时间
            connection.setConnectTimeout(15000);
            //设置读取超时时间
            connection.setReadTimeout(15000);
            //DoOutput设置是否向httpUrlConnection输出，DoInput设置是否从httpUrlConnection读入，此外发送post请求必须设置这两个
            //设置是否可读取
            connection.setDoOutput(true);
            connection.setDoInput(true);
            //设置通用的请求属性
            connection.setRequestProperty("accept", "*/*");
            connection.setRequestProperty("connection", "Keep-Alive");
            connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)");
            connection.setRequestProperty("Content-Type", "application/json;charset=utf-8");
            //拼装参数
            if (null != param && !param.equals("")) {
                //设置参数
                os = connection.getOutputStream();
                //拼装参数
                os.write(param.getBytes("UTF-8"));
            }
            //设置权限
            //设置请求头等
            if(pramMap!=null&&pramMap.size()>0){
                connection.setRequestProperty("sign", pramMap.get("sign"));
                connection.setRequestProperty("session_id", pramMap.get("session_id"));
            }
            //开启连接
            connection.connect();
            //读取响应
            if (connection.getResponseCode() == 200) {
                is = connection.getInputStream();
                if (null != is) {
                    br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
                    String temp = null;
                    while (null != (temp = br.readLine())) {
                        result.append(temp);
                        result.append("\r\n");
                    }
                }
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭连接
            if(br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(os!=null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            //关闭连接
            connection.disconnect();
        }
        return result.toString();
    }
    /**
     * 调用登录接口获取sessionId与sign
     * @return
     */
    public static Map<String,String> iotLogin() {
        HashMap<String, String> paramHashMap = new HashMap<>();
        //调用登录接口获取sessionId与sign
        //设置登录接口参数
        String loginParam=" {\"userCode\": "+userCode+",\"passWord\":"+passWord +"}";
        String loginResult =doPost(UrlAddress.IOT_LOGIN, loginParam,paramHashMap);
        Map mapType = JSON.parseObject(loginResult,Map.class);
        Map result = (Map) mapType.get("result");
        if ((int)mapType.get("resultCode")==0){
            //将数据存到
            HttpURLConnectionUtil.setMapCache(result);
        }
        return cacheMap;
    }
    /**
     * 调用北向接口方法
     * @return
     */
    public static Map iotCallMothod(JMap params, String str) throws Exception {
        //调用北向服务的接口
        //1.在缓存中获取sessionId与sign
        Map<String, String> mapCache = HttpURLConnectionUtil.getMapCache();
        if(mapCache.isEmpty()||mapCache.get("sign")==null||mapCache.get("sessionId")==null){
            //2.如果没有调用登录接口从新获取
            HttpURLConnectionUtil.iotLogin();
        }
        //3.调用北向服务接口
        //(1)将参数转为json
        String  jmapParam= JSON.toJSONString(params);
        //(2)调用接口
        String resultJson = HttpURLConnectionUtil.doPost(str, jmapParam,mapCache);
        //(3)将参数转为json
        Map<String,String> resultMap = JSON.parseObject(resultJson, Map.class);
        //判断是否调用成功
        if("0".equals(resultMap.get("resultCode"))){
            //成功返回
            return resultMap;
        }else{
            //4.调用不成功过期，清除缓存，在调用登录接口
            HttpURLConnectionUtil.clear();
            HttpURLConnectionUtil.iotLogin();
            //5.调用北向服务接口
            //(2)调用接口
            String fianlresultJson = HttpURLConnectionUtil.doPost(str, jmapParam,mapCache);
            //(3)将json转为f返回值
            Map<String,String> fianlresultMap = JSON.parseObject(fianlresultJson, Map.class);
            //返回
            return fianlresultMap;
        }
    }
	private static final ILogger logger = IpuLoggerFactory.createLogger(HttpURLConnectionUtil.class);
	private static String userCode;
	private static String passWord;
	@Value("${aap.iot.userCode}")
	public void setUserCode(String userCode) {
		HttpURLConnectionUtil.userCode = userCode;
	}
	@Value("${aap.iot.passWord}")
	public void setPassWord(String passWord) {
		HttpURLConnectionUtil.passWord = passWord;
	}
	// 定义静态存储map空间存放sign与sessionId
	private volatile static Map<String, String> cacheMap = new ConcurrentHashMap<String, String>();// 缓存map
	// set
	public static void setMapCache(Map<String, String> map) {
		Set<String> set = map.keySet();
		Iterator<String> it = set.iterator();
		while (it.hasNext()) {
			String key = it.next();
			cacheMap.put(key, map.get(key));
		}
	}
	// get
	public static Map<String, String> getMapCache() {
		return cacheMap;
	}
	// 清除cache
	public static void clear() {
		cacheMap.clear();
	}
	/**
	 * 调用登录接口获取sessionId与sign
	 * 
	 * @return
	 */
	public static Map<String, String> iotLogin() {
		logger.debug("登录北向接口");
		// 调用登录接口获取sessionId与sign
		HashMap<String, String> loginParamMap = new HashMap<>();
		loginParamMap.put("userCode", userCode);
		loginParamMap.put("passWord", passWord);
		// 设置字符集
		Charset charset = Charset.forName("utf-8");
		// 调用登录接口
		String loginResult = HttpServiceUtil.sendPost(UrlAddress.IOT_LOGIN, loginParamMap, charset);
		Map mapType = JSON.parseObject(loginResult, Map.class);
		Map result = (Map) mapType.get("result");
		if ("0".equals(String.valueOf(mapType.get("resultCode")))) {
			logger.info("登录北向接口成功");
			// 将数据存到缓存中
			HttpURLConnectionUtil.setMapCache(result);
		} else {
			logger.info("登录北向接口失败");
		}
		return cacheMap;
	}
	/**
	 * 调用北向接口方法
	 * 
	 * @return
	 */
	public static Map<String, String> iotCallMothod(String url, Map<String, String> params) throws Exception {
		// 调用北向服务的接口
		logger.debug("调用北向接口");
		// 1.在缓存中获取sessionId与sign
		Map<String, String> mapCache = HttpURLConnectionUtil.getMapCache();
		if (mapCache.isEmpty() || mapCache.get("sign") == null || mapCache.get("sessionId") == null) {
			// 2.如果没有调用登录接口从新获取
			HttpURLConnectionUtil.iotLogin();
		}
		// 3.调用北向服务接口
		// 设置字符集
		Charset charset = Charset.forName("utf-8");
		// (1)调用接口
		String resultJson = HttpServiceUtil.sendPost(url, params, charset);
		// (2)将参数转为Map<String,String>【将返回值统一为String】
		Map<String, String> resultMap = JSON.parseObject(resultJson, Map.class);
		// 登录超时，需重新登录
		if ("登录超时".equals(resultMap.get("resultMsg"))) {
			logger.info("调用北向接口失败，需重新登录");
			// 4.调用不成功可能是登录过期
			// (1)清除缓存
			HttpURLConnectionUtil.clear();
			// (2)重新登录
			HttpURLConnectionUtil.iotLogin();
			// (3)再次调用接口
			String fianlresultJson = HttpServiceUtil.sendPost(url, params, charset);
			// (4)获取返回值
			resultMap = JSON.parseObject(fianlresultJson, Map.class);
		}
		// 判断是否调用成功
		if ("0".equals(resultMap.get("resultCode"))) {
			logger.info("调用北向接口成功");
		} else {
			logger.info("调用北向接口失败");
		}
		return resultMap;
	}
}

ebc-sea-platform/src/main/java/com/ai/ipu/server/util/ProductEnum.java

@@ -0,0 +1,76 @@
package com.ai.ipu.server.util;
import java.util.HashMap;
import java.util.Map;
/**
 * 设备类型枚举
 * 
 * @author konghl@asiainfo.com 
 * 2020-10-19
 */
public enum ProductEnum {
	// 船舶
	ship("001", "船舶", 1),
	// 风机
	fan("002", "风机", 2),
	// 升压站
	booster("003", "升压站", 2),
	// 测风塔
	anemometer("004", "测风塔", 2);
	private String productId;
	private String productName;
	private int productType;
	private ProductEnum(String productId, String productName, int productType) {
		this.productId = productId;
		this.productName = productName;
		this.productType = productType;
	}
	public String getProductId() {
		return productId;
	}
	public String getProductName() {
		return productName;
	}
	public int getProductType() {
		return productType;
	}
	/**
	 * 根据类型获取对应的产品类型列表
	 * 
	 * @param type 类型(1:绑定终端，2:不绑定终端)
	 * @return
	 */
	public static Map<String, Object> getProductByType(int type) {
		Map<String, Object> map = new HashMap<String, Object>();
		for (ProductEnum productEnum : ProductEnum.values()) {
			if (productEnum.getProductType() == type) {
				map.put("id", productEnum.getProductId());
				map.put("name", productEnum.getProductName());
			}
		}
		return map;
	}
	/**
	 * 获取所有的产品类型列表
	 * 
	 * @return
	 */
	public static Map<String, Object> getAllProduct() {
		Map<String, Object> map = new HashMap<String, Object>();
		for (ProductEnum productEnum : ProductEnum.values()) {
			map.put("id", productEnum.getProductId());
			map.put("name", productEnum.getProductName());
		}
		return map;
	}
}