调用三方Http接口，得到相应体，遍历JSON得到具体的Entry

1、HttpClient调起三方接口：

相关依赖

<!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpclient -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.12</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>

public static String doPost(String url, HashMap<String, String> paramsMap) {
		HttpPost post = new HttpPost(url);
		List<NameValuePair> para = new ArrayList<NameValuePair>();
		Set<String> keySet = paramsMap.keySet();
		for (String key : keySet) {
			para.add(new BasicNameValuePair(key, paramsMap.get(key)));
		}

		try {
			post.setEntity(new UrlEncodedFormEntity(para));
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		CloseableHttpClient httpClient = HttpClients.createDefault();
		CloseableHttpResponse response = null;
		try {
			response = httpClient.execute(post);
		} catch (ClientProtocolException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}

		HttpEntity entity = response.getEntity();
		String entityStr = null;
		try {
			entityStr = EntityUtils.toString(entity);
		} catch (ParseException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}

		return entityStr;
	}

/**
	 * @param baseUrl
	 * @param paraConcat  如：？data="gyggfeeywty623548gygfysgfyusgf"(MD5加密字符串)>>paraConcat="data"
	 * @param paramsMap
	 * @param invokeN   1:用于加密入参 ； 2： 调用三方接口（需要加密参数）
	 * @return
	 * @throws MalformedURLException
	 * @throws UnsupportedEncodingException
	 */
	public static String doGet(String baseUrl, String paraConcat,HashMap<String, String> paramsMap,int invokeN)
			throws MalformedURLException, UnsupportedEncodingException {
		String paramStr = URLEncoder.encode(JSON.toJSONString(paramsMap), "UTF-8");
		String paramStr_1 = null;
		if (invokeN == 2) { // 用于调用需要加密参数的接口
			for (String key : paramsMap.keySet()) { // paramsMap只有一个entry
				paramStr_1 = paramsMap.get(key);
			}
		} else if (invokeN == 1) { // 用于构造加密参数
			paramStr_1 = paramStr;
		}

		String urlStr = baseUrl + "?" + paraConcat + "=" + paramStr_1;
		HttpGet get = new HttpGet(urlStr);// E
		CloseableHttpClient httpClient = HttpClients.createDefault();
		CloseableHttpResponse response = null;
		try {
			response = httpClient.execute(get);
		} catch (ClientProtocolException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		HttpEntity entity = response.getEntity();
		String entityStr = null;
		try {
			entityStr = EntityUtils.toString(entity);
		} catch (ParseException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		response.getStatusLine();
		return entityStr;
	}

2、解析响应体JSON

	public Object jsonLoopRequest_2(Object object) {
		if (object instanceof JSONObject) {
			Map<String, Object> map = new HashMap<String, Object>();
			JSONObject jsonObject = (JSONObject) object;
			Iterator iter = jsonObject.entrySet().iterator();
			while (iter.hasNext()) {
				Map.Entry entry = (Map.Entry) iter.next();
				Object o = entry.getValue();
				String key = (String) entry.getKey();
				if (o instanceof JSONObject) {
					map.put(key, jsonLoopRequest_2(o));
				} else if (o instanceof JSONArray) {
					map.put(key, jsonLoopRequest_2(o));
				} else {
					map.put(key, String.valueOf(o));
				}
			}
			return map;
		} else if (object instanceof JSONArray) {
			JSONArray jsonArray = (JSONArray) object;
			List<Object> result = new ArrayList<Object>();
			for (int i = 0; i < jsonArray.size(); i++) {
				result.add(jsonLoopRequest_2(jsonArray.get(i)));
			}
			return result;
		}
		return String.valueOf(object);
	}



/**
	 * @param object
	 * @return List<Map<String, String>> 可用于Key值重复 主要Method
	 */
	public List<Map<String, String>> jsonLoopList(Object object) {
		List<Map<String, String>> list = new ArrayList<Map<String, String>>();
		Map<String, String> mapStr = new HashMap<String, String>();
		JSONObject jsonObject = null;
		if (object instanceof JSONObject) {
			jsonObject = (JSONObject) object;
			for (Map.Entry<String, Object> entry : jsonObject.entrySet()) {
				Object obj = entry.getValue();
				if (obj instanceof Integer) {
					mapStr.put(entry.getKey(), String.valueOf((Integer) entry.getValue()));
				}
				if (obj instanceof Float) {
					mapStr.put(entry.getKey(), Float.toString((Float) entry.getValue()));
				}
				if (obj instanceof Double) {
					mapStr.put(entry.getKey(), Double.toString((Double) entry.getValue()));
				}
				if (obj instanceof Boolean) {
					mapStr.put(entry.getKey(), Boolean.toString((Boolean) entry.getValue()));
				}
				if (obj instanceof String) { // entry
					mapStr.put(entry.getKey(), (String) entry.getValue());
				} else {
					list.addAll(jsonLoopList(obj)); // jsonObject
				}
			}
			list.add(mapStr);
		}
		if (object instanceof JSONArray) {
			JSONArray jsonArray = (JSONArray) object;
			for (int i = 0; i < jsonArray.size(); i++) {
//				jsonObject = (JSONObject) jsonArray.get(i);
				jsonObject = JSONObject.parseObject(jsonArray.get(i).toString());
				list.addAll(jsonLoopList(jsonObject));
			}
		}
		return list;
	}



/**
	 * @param listMaps
	 * @param flag
	 * @return  根据key返回value
	 */
	@SuppressWarnings("rawtypes")
	public String getStrData(List<Map<String, String>> listMaps, String flag) {
		String str = null;
		for (int i = 0; i < listMaps.size(); i++) {
			Map<String, String> map = listMaps.get(i);
			Iterator iterator = map.keySet().iterator();
			while (iterator.hasNext()) {
				String str_1 = (String) iterator.next();
				if (str_1.equalsIgnoreCase(flag)) {
					str = map.get(str_1);
				}
			}
		}
		return str;
	}



/**
	 * @param str
	 * @param indexStrKey
	 * @return  解析接口返回JSON，根据key精准取值
	 */
	public String getResponseStr(String str, String indexStrKey) {
		String str_R = null;
		Object object = this.jsonLoopRequest_2(JSONObject.parseObject(str));
		JSONObject obj = JSONObject.parseObject(JSON.toJSONString(object));
		List<Map<String, String>> list = this.jsonLoopList(obj);
		str_R = this.getStrData(list, indexStrKey);
		return str_R;
	}

//综合调用
public void parseDataFromJson() {
		HashMap<String, String> paramsMap = new HashMap<String, String>();
		String baseUrl = "http://47.111.243.124/vv/user/encrypt";
		paramsMap.put("telephone", "13720654892");
		try {
			String str = this.doGet(baseUrl, "json", paramsMap, 1); // 参数加密
			String str_1 = this.getResponseStr(str, "data");
			System.out.println("responseOfEntry_value[data] is : "+str_1);
		} catch (MalformedURLException e) {
			e.printStackTrace();
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
	}