修改北向接口缓存方式

location-rescue-service/src/main/java/com/ai/bss/location/rescue/controller/MapTagManageController.java

@@ -145,11 +145,12 @@ public class MapTagManageController {
            return CommonResponse.fail("500","删除失败");
        }
        List<String> mapTagIdsList = null;
        List<String> mapTagIdsList = new ArrayList<String>();
        if (params.get("mapTagIds") instanceof List) {
            mapTagIdsList = (List<String>) params.get("mapTagIds");
            for (Object object : (List<Object>)params.get("mapTagIds")) {
                mapTagIdsList.add(object.toString())   ;
            }
        } else if (params.get("mapTagIds") instanceof String) {
            mapTagIdsList = new ArrayList<String>();
            mapTagIdsList.add((String) params.get("mapTagIds"));
        } else {
            return CommonResponse.fail("501","删除失败:标记类型错误");

location-rescue-service/src/main/java/com/ai/bss/location/rescue/service/impl/MapTagManageServiceImpl.java

@@ -89,7 +89,7 @@ public class MapTagManageServiceImpl implements MapTagManageService {
	@Override
	public CommonResponse<Void> addMapTagInfo(MapTagInfoDto mapTagInfoDto) throws Exception {
		mapTagInfoDto.setMapAreaSetId("0"); //TODO 固定值 所属地图围栏集合标识
		mapTagInfoDto.setMapAreaSetId(0L); //TODO 固定值 所属地图围栏集合标识
		mapTagInfoDto.setPriority("10");  //优先级
		mapTagInfoDto.setMapType(MapArea.MAP_TYPE_GEOMETRY);	//围栏形状,GEO多边形, RAD 圆形
@@ -105,7 +105,7 @@ public class MapTagManageServiceImpl implements MapTagManageService {
	@Override
	public CommonResponse<Void> modifyMapTagInfo(MapTagInfoDto mapTagInfoDto) throws Exception {
		mapTagInfoDto.setMapAreaSetId("0"); //TODO 固定值 所属地图围栏集合标识
		mapTagInfoDto.setMapAreaSetId(0L); //TODO 固定值 所属地图围栏集合标识
		mapTagInfoDto.setPriority("10");  //优先级
		mapTagInfoDto.setMapType(MapArea.MAP_TYPE_GEOMETRY);	//围栏形状,GEO多边形, RAD 圆形

location-rescue-service/src/main/java/com/ai/bss/location/rescue/util/CacheUtil.java

@@ -0,0 +1,41 @@
package com.ai.bss.location.rescue.util;
import com.ai.ipu.cache.CacheFactory;
import com.ai.ipu.cache.ICache;
public class CacheUtil {
    //private static final Logger logger = LoggerFactory.getLogger(CacheUtil.class);
    private static final String CACHE_NAME = "ssn";
    public static boolean setCache(String key, Object value) throws Exception {
        if (value == null) getCache(key);
        if (key == null) new NullPointerException();
        ICache cache = CacheFactory.getCache(CacheFactory.CacheType.redis, CACHE_NAME);
        return cache.put(key, value);
    }
    public static Object getCache(String key) throws Exception {
        if (key == null) new NullPointerException();
        ICache cache = CacheFactory.getCache(CacheFactory.CacheType.redis, CACHE_NAME);
        return cache.get(key);
    }
    public static boolean removeCache(String key) throws Exception {
        if (key == null) new NullPointerException();
        ICache cache = CacheFactory.getCache(CacheFactory.CacheType.redis, CACHE_NAME);
        return cache.remove(key);
        //CacheFactory.close(CACHE_NAME, cache);
    }
    public static boolean keyExists(String value) throws Exception {
        if (value == null) new NullPointerException();
        ICache cache = CacheFactory.getCache(CacheFactory.CacheType.redis, CACHE_NAME);
        return cache.keyExists(value);
    }
}

location-rescue-service/src/main/java/com/ai/bss/location/rescue/util/HttpServiceUtil.java

@@ -186,7 +186,7 @@ public class HttpServiceUtil {
		return body;
	}
	public static String sendGet(String url, Charset encoding) {
	public static String sendGet(String url, Charset encoding,Map<String,String> headerMap) {
		HttpClient httpClient = HttpClients.createDefault();
		HttpGet httpGet = new HttpGet(url);
		httpGet.addHeader(HTTP.CONTENT_TYPE, HTTP_CONTENT_TYPE_JSON);

location-rescue-service/src/main/java/com/ai/bss/location/rescue/util/NorthboundInterfaceUtil.java

@@ -1,264 +1,252 @@
package com.ai.bss.location.rescue.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.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
import com.ai.bss.location.rescue.controller.MapTagManageController;
import com.alibaba.fastjson.JSON;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Map;
/**
 *北向接口统一入口
 * 北向接口统一入口
 *
 * @date 2010/09/24 23:42
 */
@Configuration
public class NorthboundInterfaceUtil {
	private static final Logger logger = LoggerFactory.getLogger(MapTagManageController.class);
	
	@Value("${aap.iot.userCode:IOT_ADMIN}")
	private String userCode;
	@Value("${aap.iot.passWord:123456}")
	private String passWord;
	@Value("${url.iot.login:http://47.105.130.83:8083/sso/login}")
	private String iotLoginUrl;
	@Value("${url.iot.service:http://47.105.130.83:8083/dmp/terminalNorthApi/}")
	private String iotServiceUrl;
	// 定义静态存储map空间存放sign与sessionId
	private volatile static Map<String, String> cacheMap = new ConcurrentHashMap<String, String>();// 缓存map
	// set
	public 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 Map<String, String> getMapCache() {
		return cacheMap;
	}
	// 清除cache
	public void clear() {
		cacheMap.clear();
	}
	/**
	 * GET请求调用北向接口方法
	 * 
	 * @param url
	 * @param params
	 * @return
	 * @throws Exception
	 */
	public Map<String, Object> iotGetCallUtil(String url) throws Exception {
		// 调用北向服务的接口
		logger.debug("GET调用北向接口");
		boolean loginFlag = true;
		// 1.在缓存中获取sessionId与sign
		Map<String, String> mapCache = getMapCache();
		if (mapCache.isEmpty() || mapCache.get("sign") == null || mapCache.get("session_id") == null) {
			// 2.如果没有调用登录接口从新获取
			loginFlag = iotLogin();
		}
		if (!loginFlag) {
			logger.debug("调用北向接口登录失败");
			return new HashMap<String, Object>();
		}
		// 3.调用北向服务接口
		// (1)设置字符集
		Charset charset = Charset.forName("utf-8");
		// (2)调用接口
		String resultJson = HttpServiceUtil.sendGet(iotServiceUrl + url, charset);
		// (3)将参数转为Map<String,String>【将返回值统一为String】
		Map<String, Object> resultMap = JSON.parseObject(resultJson, Map.class);
		// 4.登录超时，需重新登录
		if ("登录超时".equals(resultMap.get("resultMsg"))) {
			logger.info("调用北向接口失败，需重新登录");
			// 4.调用不成功可能是登录过期
			// (1)清除缓存
			clear();
			// (2)重新登录
			loginFlag = iotLogin();
			if (!loginFlag) {
				logger.debug("再次调用北向接口登录失败");
				return new HashMap<String, Object>();
			}
			try {
				// (3)再次调用接口
				String fianlresultJson = HttpServiceUtil.sendGet(iotServiceUrl + url, charset);
				// (4)获取返回值
				resultMap = JSON.parseObject(fianlresultJson, Map.class);
			} catch (Exception e) {
				logger.error("再次调用北向接口失败: " + e.getMessage());
				return new HashMap<String, Object>();
			}
			if (resultMap == null) {
				logger.error("再次调用北向接口返回值为空");
				return new HashMap<String, Object>();
			}
		}
		// 5.判断是否调用成功
		if (NorthboundInterfaceConstant.resultCode_succeed.equals(resultMap.get("resultCode"))) {
			logger.info("调用北向接口成功");
		} else {
			logger.info("调用北向接口失败");
		}
		return resultMap;
	}
	/**
	 * POST请求调用北向接口方法
	 * 
	 * @param url
	 * @param paramsMap
	 * @return
	 * @throws Exception
	 */
	public Map<String, Object> iotPostCallUtil(String url, Map<String, Object> paramsMap) throws Exception {
		// 调用北向服务的接口
		logger.debug("POSt调用北向接口");
		boolean loginFlag = true;
		// 1.在缓存中获取sessionId与sign
		Map<String, String> mapCache = getMapCache();
		if (mapCache.isEmpty() || mapCache.get("sign") == null || mapCache.get("session_id") == null) {
			// 2.如果没有调用登录接口从新获取
			loginFlag = iotLogin();
		}
		if (!loginFlag) {
			logger.debug("调用北向接口登录失败");
			return new HashMap<String, Object>();
		}
		// 3.调用北向服务接口
		// (1)设置字符集
		Charset charset = Charset.forName("utf-8");
		// 返回值
		Map<String, Object> resultMap = null;
		try {
			// (2)调用接口
			String resultJson = HttpServiceUtil.sendPost(iotServiceUrl + url, paramsMap, charset, getMapCache());
			// (3)将参数转为Map<String,String>【将返回值统一为String】
			resultMap = JSON.parseObject(resultJson, Map.class);
		} catch (Exception e) {
			logger.error("调用北向接口失败: " + e.getMessage());
			return new HashMap<String, Object>();
		}
		if (resultMap == null) {
			logger.error("调用北向接口返回值为空");
			return new HashMap<String, Object>();
		}
		// 4.登录超时，需重新登录
		if ("登录超时".equals(resultMap.get("resultMsg"))) {
			logger.info("调用北向接口登录超时，需重新登录");
			// 4.调用不成功可能是登录过期
			// (1)清除缓存
			clear();
			// (2)重新登录
			loginFlag = iotLogin();
			if (!loginFlag) {
				logger.debug("再次调用北向接口登录失败");
				return new HashMap<String, Object>();
			}
			try {
				// (3)再次调用接口
				String fianlresultJson = HttpServiceUtil.sendPost(iotServiceUrl + url, paramsMap, charset,
						getMapCache());
				// (4)获取返回值
				resultMap = JSON.parseObject(fianlresultJson, Map.class);
			} catch (Exception e) {
				logger.error("再次调用北向接口失败: " + e.getMessage());
				return new HashMap<String, Object>();
			}
			if (resultMap == null) {
				logger.error("再次调用北向接口返回值为空");
				return new HashMap<String, Object>();
			}
		}
		// 5.判断是否调用成功
		if (NorthboundInterfaceConstant.resultCode_succeed.equals(resultMap.get("resultCode"))) {
			logger.info("调用北向接口成功");
		} else {
			logger.info("调用北向接口失败");
		}
		return resultMap;
	}
	/**
	 * 调用登录接口获取sessionId与sign
	 * 
	 * @return
	 */
	private boolean iotLogin() {
		logger.debug("登录北向接口");
		// 调用登录接口获取sessionId与sign
		HashMap<String, Object> loginParamMap = new HashMap<>();
		loginParamMap.put("userCode", userCode);
		loginParamMap.put("passWord", passWord);
		// 设置字符集
		Charset charset = Charset.forName("utf-8");
		Map loginResultMap = null;
		try {
			// 调用登录接口
			String loginResult = HttpServiceUtil.sendPost(iotLoginUrl, loginParamMap, charset);
			loginResultMap = JSON.parseObject(loginResult, Map.class);
		} catch (Exception e) {
			logger.error("登录北向接口失败: " + e.getMessage());
			return false;
		}
		if (loginResultMap != null && NorthboundInterfaceConstant.resultCode_succeed
				.equals(String.valueOf(loginResultMap.get("resultCode")))) {
			logger.info("登录北向接口成功");
			Map result = (Map) loginResultMap.get("result");
			// 将数据存到缓存中
			setMapCache(result);
			return true;
		} else {
			logger.info("登录北向接口失败");
			return false;
		}
	}
    private static final Logger logger = LoggerFactory.getLogger(NorthboundInterfaceUtil.class);
    @Value("${aap.iot.userCode:IOT_ADMIN}")
    private String userCode;
    @Value("${aap.iot.passWord:123456}")
    private String passWord;
    @Value("${url.iot.login:http://47.105.130.83:8083/sso/login}")
    private String iotLoginUrl;
    @Value("${url.iot.service:http://47.105.130.83:8083/dmp/terminalNorthApi/}")
    private String iotServiceUrl;
    /**
     * GET请求调用北向接口方法
     *
     * @param url
     * @return
     * @throws Exception
     */
    public Map<String, Object> iotGetCallUtil(String url) throws Exception {
        logger.debug("GET调用北向接口");
        Map<String, Object> resultMap = new HashMap<String, Object>();
        Map<String, String> signMap = new HashMap<String, String>();
        // 1.在缓存中获取sessionId与sign
        Object sign =CacheUtil.getCache("ebc_iot_north_sign");
        Object session_id = CacheUtil.getCache("ebc_iot_north_session_id");
        if (sign == null ) {
            // 2.如果没有调用登录接口从新获取
            signMap = iotLogin();
            if (signMap == null) {
                logger.debug("调用北向接口登录失败");
                return resultMap;
            }
        } else {
            signMap.put("ebc_iot_north_sign", String.valueOf(sign));
            signMap.put("ebc_iot_north_session_id", String.valueOf(session_id));
        }
        // 3.调用北向服务接口
        // (1)设置字符集
        Charset charset = Charset.forName("utf-8");
        try {
            // (2)调用接口
            String resultJson = HttpServiceUtil.sendGet(iotServiceUrl + url, charset, signMap);
            // (3)将参数转为Map<String,String>【将返回值统一为String】
            resultMap = JSON.parseObject(resultJson, Map.class);
        } catch (Exception e) {
            logger.error("调用北向接口失败: " + e.getMessage());
            return new HashMap<String, Object>();
        }
        if (resultMap == null) {
            logger.error("调用北向接口返回值为空");
            return new HashMap<String, Object>();
        } else if ("登录超时".equals(resultMap.get("resultMsg"))) {
            // 4.登录超时，需重新登录
            logger.info("调用北向接口失败，需重新登录");
            // (1)清除缓存
            CacheUtil.removeCache("ebc_iot_north_sign");
            CacheUtil.removeCache("ebc_iot_north_session_id");
            // (2)重新登录
            signMap = iotLogin();
            if (signMap == null) {
                logger.debug("再次调用北向接口登录失败");
                return resultMap;
            }
            try {
                // (3)再次调用接口
                String resultJson = HttpServiceUtil.sendGet(iotServiceUrl + url, charset, signMap);
                // (4)获取返回值
                resultMap = JSON.parseObject(resultJson, Map.class);
            } catch (Exception e) {
                logger.error("再次调用北向接口失败: " + e.getMessage());
                return new HashMap<String, Object>();
            }
            if (resultMap == null) {
                logger.error("再次调用北向接口返回值为空");
                return new HashMap<String, Object>();
            }
        }
        // 5.判断是否调用成功
        if (NorthboundInterfaceConstant.resultCode_succeed.equals(resultMap.get("resultCode"))) {
            logger.info("调用北向接口成功");
            return resultMap;
        } else {
            logger.info("调用北向接口失败");
            return new HashMap<String, Object>();
        }
    }
    /**
     * POST请求调用北向接口方法
     *
     * @param url
     * @param paramsMap
     * @return
     * @throws Exception
     */
    public Map<String, Object> iotPostCallUtil(String url, Map<String, Object> paramsMap) throws Exception {
        logger.debug("POSt调用北向接口");
        Map<String, Object> resultMap = new HashMap<String, Object>();
        Map<String, String> signMap = new HashMap<String, String>();
        // 1.在缓存中获取sessionId与sign
        Object sign =CacheUtil.getCache("ebc_iot_north_sign");
        Object session_id = CacheUtil.getCache("ebc_iot_north_session_id");
        if (sign == null ) {
            // 2.如果没有调用登录接口从新获取
            signMap = iotLogin();
            if (signMap == null) {
                logger.debug("调用北向接口登录失败");
                return resultMap;
            }
        } else {
            signMap.put("ebc_iot_north_sign", String.valueOf(sign));
            signMap.put("ebc_iot_north_session_id", String.valueOf(session_id));
        }
        // 3.调用北向服务接口
        // (1)设置字符集
        Charset charset = Charset.forName("utf-8");
        try {
            // (2)调用接口
            String resultJson = HttpServiceUtil.sendPost(iotServiceUrl + url, paramsMap, charset, signMap);
            // (3)将参数转为Map<String,String>【将返回值统一为String】
            resultMap = JSON.parseObject(resultJson, Map.class);
        } catch (Exception e) {
            logger.error("调用北向接口失败: " + e.getMessage());
            return new HashMap<String, Object>();
        }
        if (resultMap == null) {
            logger.error("调用北向接口返回值为空");
            return new HashMap<String, Object>();
        } else if ("登录超时".equals(resultMap.get("resultMsg"))) {
            // 4.登录超时，需重新登录
            logger.info("调用北向接口登录超时，需重新登录");
            // (1)清除缓存
            CacheUtil.removeCache("ebc_iot_north_sign");
            CacheUtil.removeCache("ebc_iot_north_session_id");
            // (2)重新登录
            signMap = iotLogin();
            if (signMap == null) {
                logger.debug("再次调用北向接口登录失败");
                return resultMap;
            }
            try {
                // (3)再次调用接口
                String resultJson = HttpServiceUtil.sendPost(iotServiceUrl + url, paramsMap, charset, signMap);
                // (4)获取返回值
                resultMap = JSON.parseObject(resultJson, Map.class);
            } catch (Exception e) {
                logger.error("再次调用北向接口失败: " + e.getMessage());
                return new HashMap<String, Object>();
            }
            if (resultMap == null) {
                logger.error("再次调用北向接口返回值为空");
                return new HashMap<String, Object>();
            }
        }
        // 5.判断是否调用成功
        if (NorthboundInterfaceConstant.resultCode_succeed.equals(resultMap.get("resultCode"))) {
            logger.info("调用北向接口成功");
            return resultMap;
        } else {
            logger.info("调用北向接口失败");
            return new HashMap<String, Object>();
        }
    }
    /**
     * 调用登录接口获取sessionId与sign
     *
     * @return
     */
    private Map<String, String> iotLogin() throws Exception {
        logger.debug("登录北向接口");
        HashMap<String, Object> loginParamMap = new HashMap<>();
        // 调用登录接口获取sessionId与sign
        loginParamMap.put("userCode", userCode);
        loginParamMap.put("passWord", passWord);
        // 设置字符集
        Charset charset = Charset.forName("utf-8");
        //Map<String, String> loginResultMap =new HashMap<String,String>();
        JSONObject loginResultJsonObject = null;
        try {
            // 调用登录接口
            String loginResult = HttpServiceUtil.sendPost(iotLoginUrl, loginParamMap, charset);
            loginResultJsonObject = JSON.parseObject(loginResult);
        } catch (Exception e) {
            logger.error("登录北向接口失败: " + e.getMessage());
            return null;
        }
        if (loginResultJsonObject != null && NorthboundInterfaceConstant.resultCode_succeed.equals(String.valueOf(loginResultJsonObject.get("resultCode")))) {
            logger.info("登录北向接口成功");
            Map<String, String> resultMap = (Map<String, String>) loginResultJsonObject.get("result");
            // 将数据存到缓存中
            CacheUtil.setCache("ebc_iot_north_sign", resultMap.get("sign"));
            CacheUtil.setCache("ebc_iot_north_session_id", resultMap.get("session_id"));
            return resultMap;
        } else {
            logger.info("登录北向接口失败");
            return null;
        }
    }
}