調用高德API，通過輸入的地址，如省份、市、區獲取經緯度 ，通過輸入的經緯度，獲取區域詳情

一、pom

<?xml version="1.0" encoding="UTF-8"?>
<projectxmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>

 <groupId>com.java.gaode.GaoDeDemo</groupId>
 <artifactId>GaoDeDemo</artifactId>
 <version>1.0-SNAPSHOT</version>
 <dependencies>
 <dependency>
 <groupId>com.google.collections</groupId>
 <artifactId>google-collections</artifactId>
 <version>1.0</version>
 </dependency>
 <dependency>
 <groupId>com.google.guava</groupId>
 <artifactId>guava</artifactId>
 <version>20.0</version>
 </dependency>
 <dependency>
 <groupId>commons-httpclient</groupId>
 <artifactId>commons-httpclient</artifactId>
 <version>3.1</version>
 </dependency>
 <dependency>
 <groupId>org.apache.commons</groupId>
 <artifactId>commons-lang3</artifactId>
 <version>3.8.1</version>
 </dependency>
 <dependency>
 <groupId>org.apache.httpcomponents</groupId>
 <artifactId>httpclient</artifactId>
 <version>4.5.9</version>
 </dependency>
 <dependency>
 <groupId>com.alibaba</groupId>
 <artifactId>fastjson</artifactId>
 <version>1.2.31</version>
 </dependency>
 <dependency>
 <groupId>com.sun.jersey</groupId>
 <artifactId>jersey-client</artifactId>
 <version>1.19.1</version>
 </dependency>
 <dependency>
 <groupId>org.slf4j</groupId>
 <artifactId>slf4j-api</artifactId>
 <version>1.7.28</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-core</artifactId>
 <version>5.1.10.RELEASE</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-webmvc</artifactId>
 <version>5.1.10.RELEASE</version>
 </dependency>
 </dependencies>
</project>

二、HttpClientUtils工具類

package com.java.gao;

/**
 * @ClassName: HttpClientUtils
 * @Description:
 * @Version: v1.0.0
 * @Author: Fu Hao
 * @Date: 2019/10/22 0022 下午 8:15
 * Modification History:
 * Date Author Version Description
 * -------------------------------------------------------------
 * 2019/10/22 0022 Fu Hao v1.0.0 創建
 */
import com.google.common.base.Function;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.Lists;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.NoHttpResponseException;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.*;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.ResponseHandler;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.config.ConnectionConfig;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.config.SocketConfig;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HttpContext;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.SSLException;
import javax.net.ssl.SSLHandshakeException;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.UnknownHostException;
import java.nio.charset.CodingErrorAction;
import java.util.List;
import java.util.Map;


/**
 * HttpClient工具類
 */
public class HttpClientUtils {

 /**
 * 連接池最大連接數
 */
 private static final int MAX_TOTAL_CONNECTIONS = 4000;

 /**
 * 設置每個路由上的默認連接個數
 */
 private static final int DEFAULT_MAX_PER_ROUTE = 200;

 /**
 * 請求的請求超時時間 單位：毫秒
 */
 private static final int REQUEST_CONNECTION_TIMEOUT = 8 * 1000;

 /**
 * 請求的等待數據超時時間 單位：毫秒
 */
 private static final int REQUEST_SOCKET_TIMEOUT = 8 * 1000;

 /**
 * 請求的連接超時時間 單位：毫秒
 */
 private static final int REQUEST_CONNECTION_REQUEST_TIMEOUT = 5 * 1000;

 /**
 * 連接閑置多久后需要重新檢測 單位：毫秒
 */
 private static final int VALIDATE_AFTER_IN_ACTIVITY = 2 * 1000;

 /**
 * 關閉Socket時，要么發送完所有數據，要么等待多少秒后，就關閉連接，此時socket.close()是阻塞的　單位秒
 */
 private static final int SOCKET_CONFIG_SO_LINGER = 60;

 /**
 * 接收數據的等待超時時間,即讀超時時間，單位ms
 */
 private static final int SOCKET_CONFIG_SO_TIMEOUT = 5 * 1000;
 /**
 * 重試次數
 */
 private static int RETRY_COUNT = 5;
 /**
 * 聲明為 static volatile,會迫使線程每次讀取時作為一個全局變量讀取
 */
 private static volatile CloseableHttpClient httpClient = null;


 /**
 * @param uri
 * @return String
 * @description get請求方式
 * @author: long.he01
 */
 public static String doGet(String uri) {

 String responseBody;
 HttpGet httpGet = new HttpGet(uri);
 try {
 httpGet.setConfig(getRequestConfig());
 responseBody = executeRequest(httpGet);
 } catch (IOException e) {
 throw new RuntimeException("httpclient doGet方法異常 ", e);
 } finally {
 httpGet.releaseConnection();
 }

 return responseBody;
 }

 /**
 * @param uri
 * @param params
 * @return string
 * @description 帶map參數get請求, 此方法會將map參數拼接到連接地址上。
 */
 public static String doGet(String uri, Map<String, String> params) {

 return doGet(getGetUrlFromParams(uri, params));

 }

 /**
 * @param uri
 * @param params
 * @return String
 * @description 根據map參數拼接完整的url地址
 */
 private static String getGetUrlFromParams(String uri, Map<String, String> params) {


 List<BasicNameValuePair> resultList = FluentIterable.from(params.entrySet()).transform(
 new Function<Map.Entry<String, String>, BasicNameValuePair>() {
 @Override
 public BasicNameValuePair apply(Map.Entry<String, String> innerEntry) {

 return new BasicNameValuePair(innerEntry.getKey(), innerEntry.getValue());
 }

 }).toList();

 String paramSectionOfUrl = URLEncodedUtils.format(resultList, Consts.UTF_8);
 StringBuffer resultUrl = new StringBuffer(uri);

 if (StringUtils.isEmpty(uri)) {
 return uri;
 } else {
 if (!StringUtils.isEmpty(paramSectionOfUrl)) {
 if (uri.endsWith("?")) {
 resultUrl.append(paramSectionOfUrl);
 } else {
 resultUrl.append("?").append(paramSectionOfUrl);
 }
 }
 return resultUrl.toString();
 }


 }


 /**
 * @param uri
 * @param params
 * @return String
 * @description 帶map參數的post請求方法
 */
 public static String doPost(String uri, Map<String, String> params) {

 String responseBody;
 HttpPost httpPost = new HttpPost(uri);
 try {
 List<NameValuePair> nvps = Lists.newArrayList();
 for (Map.Entry<String, String> entry : params.entrySet()) {
 String key = entry.getKey();
 String value = entry.getValue();
 nvps.add(new BasicNameValuePair(key, value));
 }
 httpPost.setEntity(new UrlEncodedFormEntity(nvps, Consts.UTF_8));
 httpPost.setConfig(getRequestConfig());
 responseBody = executeRequest(httpPost);

 } catch (Exception e) {
 throw new RuntimeException("httpclient doPost方法異常 ", e);
 } finally {
 httpPost.releaseConnection();
 }

 return responseBody;

 }


 /**
 * @param uri
 * @param param
 * @param contentType 根據具體請求情況指定,比如json可以是 ContentType.APPLICATION_JSON
 * @return String
 * @description 帶單string參數執行post方法
 */
 public static String doPost(String uri, String param, ContentType contentType) {

 String responseBody;
 HttpPost httpPost = new HttpPost(uri);
 try {
 StringEntity reqEntity = new StringEntity(param, contentType);
 httpPost.setEntity(reqEntity);
 httpPost.setConfig(getRequestConfig());
 responseBody = executeRequest(httpPost);

 } catch (IOException e) {
 throw new RuntimeException("httpclient doPost方法異常 ", e);
 } finally {
 httpPost.releaseConnection();
 }
 return responseBody;
 }

 /**
 * @return RequestConfig
 * @description: 獲得請求配置信息
 */
 private static RequestConfig getRequestConfig() {


 RequestConfig defaultRequestConfig = RequestConfig.custom()
 //.setCookieSpec(CookieSpecs.DEFAULT)
 .setExpectContinueEnabled(true)
 //.setTargetPreferredAuthSchemes(Arrays.asList(AuthSchemes.NTLM, AuthSchemes.DIGEST))
 //.setProxyPreferredAuthSchemes(Arrays.asList(AuthSchemes.BASIC))
 .build();

 return RequestConfig.copy(defaultRequestConfig)
 .setSocketTimeout(REQUEST_CONNECTION_TIMEOUT)
 .setConnectTimeout(REQUEST_SOCKET_TIMEOUT)
 .setConnectionRequestTimeout(REQUEST_CONNECTION_REQUEST_TIMEOUT)
 .build();

 }


 /**
 * @param method
 * @return String
 * @throws IOException
 * @description 通用執行請求方法
 */
 private static String executeRequest(HttpUriRequest method) throws IOException {

 ResponseHandler<String> responseHandler = new ResponseHandler<String>() {

 @Override
 public String handleResponse(final HttpResponse response) throws IOException {

 int status = response.getStatusLine().getStatusCode();
 String result;
 if (status >= HttpStatus.SC_OK && status < HttpStatus.SC_MULTIPLE_CHOICES) {
 HttpEntity entity = response.getEntity();
 result = entity != null ? EntityUtils.toString(entity) : null;
 EntityUtils.consume(entity);
 return result;
 } else {
 throw new ClientProtocolException("Unexpected response status: " + status);
 }
 }

 };
 String result = getHttpClientInstance().execute(method, responseHandler);

 return result;
 }


 /**
 * @return CloseableHttpClient
 * @description 單例獲取httpclient實例
 */
 private static CloseableHttpClient getHttpClientInstance() {

 if (httpClient == null) {
 synchronized (CloseableHttpClient.class) {
 if (httpClient == null) {
 httpClient = HttpClients.custom().setConnectionManager(initConfig()).setRetryHandler(getRetryHandler()).build();
 }
 }
 }
 return httpClient;

 }

 /**
 * @return HttpRequestRetryHandler
 * @description :獲取重試handler
 */
 private static HttpRequestRetryHandler getRetryHandler() {

 // 請求重試處理
 return new HttpRequestRetryHandler() {
 @Override
 public boolean retryRequest(IOException exception,
 int executionCount, HttpContext context) {
 if (executionCount >= RETRY_COUNT) {
 // 假設已經重試了5次，就放棄
 return false;
 }
 if (exception instanceof NoHttpResponseException) {
 // 假設server丟掉了連接。那么就重試
 return true;
 }
 if (exception instanceof SSLHandshakeException) {
 // 不要重試SSL握手異常
 return false;
 }
 if (exception instanceof InterruptedIOException) {
 // 超時
 return false;
 }
 if (exception instanceof UnknownHostException) {
 // 目標server不可達
 return false;
 }
 if (exception instanceof ConnectTimeoutException) { 
// 連接被拒絕
return false; } 

if (exception instanceof SSLException) { 
// SSL握手異常
return false; } HttpRequest request = HttpClientContext.


adapt(context).getRequest(); 
// 假設請求是冪等的，就再次嘗試
return !(request instanceof HttpEntityEnclosingRequest); } }; } 

/**
 * @return PoolingHttpClientConnectionManager
 * @description 初始化連接池等配置信息
*/
private static PoolingHttpClientConnectionManager initConfig() { Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>

create() .register(
"http", PlainConnectionSocketFactory.INSTANCE) .register(
"https", new SSLConnectionSocketFactory(SSLContexts.createSystemDefault())) .build(); PoolingHttpClientConnectionManager connManager = 


new PoolingHttpClientConnectionManager(socketFactoryRegistry); 

/**
 * 以下參數設置含義分別為:
 * 1 是否立即發送數據，設置為true會關閉Socket緩沖，默認為false
 * 2 是否可以在一個進程關閉Socket后，即使它還沒有釋放端口，其它進程還可以立即重用端口
* 3 接收數據的等待超時時間，單位ms
 * 4 關閉Socket時，要么發送完所有數據，要么等待多少秒后，就關閉連接，此時socket.close()是阻塞的
* 5 開啟監視TCP連接是否有效
* 其中setTcpNoDelay(true)設置是否啟用Nagle算法，設置true后禁用Nagle算法，默認為false（即默認啟用Nagle算法）。
* Nagle算法試圖通過減少分片的數量來節省帶寬。當應用程序希望降低網絡延遲並提高性能時，
* 它們可以關閉Nagle算法，這樣數據將會更早地發 送，但是增加了網絡消耗。 單位為：毫秒
*/

 SocketConfig socketConfig = SocketConfig.custom() .setTcpNoDelay(
true) .setSoReuseAddress(
true) .setSoTimeout(
SOCKET_CONFIG_SO_TIMEOUT) 
//.setSoLinger(SOCKET_CONFIG_SO_LINGER)
 //.setSoKeepAlive(true)
 .build(); connManager.setDefaultSocketConfig(socketConfig); connManager.setValidateAfterInactivity(


VALIDATE_AFTER_IN_ACTIVITY); ConnectionConfig connectionConfig = ConnectionConfig.

custom() .setMalformedInputAction(CodingErrorAction.
IGNORE) .setUnmappableInputAction(CodingErrorAction.
IGNORE) .setCharset(Consts.
UTF_8) .build(); connManager.setDefaultConnectionConfig(connectionConfig); connManager.setDefaultMaxPerRoute(


DEFAULT_MAX_PER_ROUTE); connManager.setMaxTotal(
MAX_TOTAL_CONNECTIONS); 
return connManager; }}


三、GaoDeMapUtils工具類

package com.java.gao;

import com.sun.deploy.net.URLEncoder;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * @ClassName: GaoDeMapUtils
 * @Description:
 * @Version: v1.0.0
 * @Author: Fu Hao
 * @Date: 2019/10/22 0022 下午 8:05
 * Modification History:
 * Date Author Version Description
 * -------------------------------------------------------------
 * 2019/10/22 0022 Fu Hao v1.0.0 創建
 */

public class GaoDeMapUtils {


 /**
 * 高德地圖請求秘鑰
 */
 private static final String KEY = "高德官網申請";
 /**
 * 返回值類型
 */
 private static final String OUTPUT = "JSON";
 /**
 * 根據地名獲取高德經緯度
 */
 private static final String GET_LNG_LAT_URL = "http://restapi.amap.com/v3/geocode/geo";
 /**
 * 根據高德經緯度獲取地名
 */
 private static final String GET_ADDRESS_URL = "http://restapi.amap.com/v3/geocode/regeo";

 /**
 * 根據高德經緯度獲取地址信息
 *
 * @param gdLon 高德地圖經度
 * @param gdLat 高德地圖緯度
 * @return
 */
 public static String getAddressByLonLat(double gdLon, double gdLat) {

 String location = gdLon + "," + gdLat;
 Map<String, String> params = new HashMap<>();
 params.put("location", location);

 try {
 // 拼裝url,output返回值類型，GET_ADDRESS_URL根據高德經緯度獲取地名
 String url = jointUrl(params, OUTPUT, KEY, GET_ADDRESS_URL);
 // 調用高德SDK
 return HttpClientUtils.doPost(url, params);
 // 解析Json字符串,獲取城市名稱
 // JSONObject jsonObject = JSON.parseObject(jsonResult);
 // String regeocode = jsonObject.getString("regeocode");
 // JSONObject regeocodeObj = JSON.parseObject(regeocode);
 // String address = regeocodeObj.getString("formatted_address");
 // 組裝結果
 // result.put(location, address);
 } catch (Exception e) {
 e.printStackTrace();
 }
 return null;
 }

 /**
 * 根據地址信息獲取高德經緯度
 *
 * @param address 地址信息
 * @return
 */
 public static String getLonLarByAddress(String address) {
 Map<String, String> params = new HashMap<>();
 params.put("address", address);

 // Map<String, String> result = new HashMap<>();
 try {
 // 拼裝url
 String url = jointUrl(params, OUTPUT, KEY, GET_LNG_LAT_URL);
 // 調用高德地圖SDK
 return HttpClientUtils.doPost(url, params);

 // 解析JSON字符串,取到高德經緯度
 // JSONObject jsonObject = JSON.parseObject(jsonResult);
 // JSONArray geocodes = jsonObject.getJSONArray("geocodes");
 // String geocode = JSON.toJSONString(geocodes.get(0));
 // JSONObject geocodeObj = JSON.parseObject(geocode);
 // String lonAndLat = geocodeObj.getString("location");
 // 組裝結果
 // result.put(address, lonAndLat);
 } catch (Exception e) {
 e.printStackTrace();
 }
 return null;
 }

 /**
 * 拼接請求字符串
 *
 * @param params
 * @param output
 * @param key
 * @param url
 * @return
 * @throws IOException
 */
 private static String jointUrl(Map<String, String> params, String output, String key, String url) throws IOException {
 StringBuilder baseUrl = new StringBuilder();
 baseUrl.append(url);

 int index = 0;
 Set<Map.Entry<String, String>> entrys = params.entrySet();
 for (Map.Entry<String, String> param : entrys) {
 // 判斷是否是第一個參數
 if (index == 0) {
 baseUrl.append("?");
 } else {
 baseUrl.append("&");
 }
 baseUrl.append(param.getKey()).append("=").append(URLEncoder.encode(param.getValue(), "utf-8"));
 index++;
 }
 baseUrl.append("&output=").append(output).append("&key=").append(key);

 return baseUrl.toString();
 }


}


四、測試

package com.java.gao;

/**gao包里的三個方法是根據經緯度獲取區域或者根據區域獲取經緯度
 * 本方法兩個功能：通過輸入的地址，如省份、市、區獲取經緯度
 * 通過輸入的經緯度，獲取地址值
 * 總共三個類：Controller、GaoDeMapUtils、HttpClientUtils工具類
 * @ClassName: Controller
 * @Description:
 * @Version: v1.0.0
 * @Author: Fu Hao
 * @Date: 2019/10/22 0022 下午 8:23
 * Modification History:
 * Date Author Version Description
 * -------------------------------------------------------------
 * 2019/10/22 0022 Fu Hao v1.0.0 創建
 */


public class Controller {
 public static void main(String[] args) {
 System.out.println(GaoDeMapUtils.getLonLarByAddress("中國"));

 System.out.println("---------------------------------------");

 System.out.println(GaoDeMapUtils.getAddressByLonLat(118,29));

 }
}