地区经纬度信息获取（利用Google地图API获取）

package com.leg3s.rld.util;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.log4j.Logger;

/**
* 地址经纬度信息获取工具类
*
* @author liuw
* @create date 2010/01/18
*/
public class AddressLatLngUtil
{
private static final String REQUEST_ENCODE = "UTF-8";
private static final String ADDRESS_KEY = "\"address\"";
private static final String ADDRESS_COUNTRY_KEY = "\"CountryName\"";
private static final String ADDRESS_REGION_KEY = "\"AdministrativeAreaName\"";
private static final String ADDRESS_CITY_KEY = "\"LocalityName\"";
private static final String ADDRESS_POINT_KEY = "\"coordinates\"";
private static final String ADDRESS_SPLIT_STR = ":";

private static final String LOCATION_COUNTRY_KEY = "\"country\"";
private static final String LOCATION_REGION_KEY = "\"region\"";
private static final String LOCATION_CITY_KEY = "\"city\"";
//private static final String LOCATION_POINT_KEY = "\"location\"";
private static final String LOCATION_POINT_LATITUDE_KEY = "\"latitude\"";
private static final String LOCATION_POINT_LONGITUDE_KEY = "\"longitude\"";
private static final String LOCATION_POINT_PRECISIONY_KEY = "\"accuracy\"";
private static final String LOCATION_SPLIT_STR = ",";


public static final int MIN_ZOOM = 11;
public static final int MAX_ZOOM = 18;

private static final int DOWNNUM_FOR_PROXY = 8000;
private static final int CONNECT_TIMEOUT = 30000; // 30秒
private static final int THREAD_SLEEP_MILLIS = 200;
private static boolean flag = false;
private static int downNum = 0;

private static String proxyHost = "165.228.128.10";
private static String proxyPort = "3128";
private static String proxySet = "true";

private static final Logger logger = Logger.getLogger(AddressLatLngUtil.class);

/**
* 获取地址详细信息及经纬度信息
*
* @param address
* @return Map<地址, 经纬度>
*/
public static Map<String, Point> getAddressLatLng(String address)
{
StringBuilder urlBuilder = new StringBuilder();
urlBuilder.append("http://ditu.google.cn/maps/geo");
urlBuilder.append("?output=json");
urlBuilder.append("&oe=utf-8");
urlBuilder.append("&q=").append(encodeURLForUTF8(address));
urlBuilder.append("&key=ABQIAAAAzr2EBOXUKnm_jVnk0OJI7xSosDVG8KKPE1-m51RBrvYughuyMxQ-i1QfUnH94QxWIa6N4U6MouMmBA");
urlBuilder.append("&mapclient=jsapi");
urlBuilder.append("&hl=zh-CN");
urlBuilder.append("&callback=_xdc_._1g4gm5mh3");
//logger.info(urlBuilder.toString());

HttpURLConnection httpConnection = null;
try
{
// 1、构造HttpURLConnection连接
URL url = new URL(urlBuilder.toString());
URLConnection urlConnection = url.openConnection();
httpConnection = (HttpURLConnection) urlConnection;
httpConnection.setDoInput(true);
httpConnection.setDoOutput(true);
httpConnection.setConnectTimeout(CONNECT_TIMEOUT);
httpConnection.connect();

// 2、接收响应结果
InputStream inStream = httpConnection.getInputStream();
String htmlContent = getContentByStream(inStream, REQUEST_ENCODE);
// 关闭流资源
inStream.close();

// 3、解析结果
Map<String, Point> map = parseAddressLatLng(htmlContent);
updateProxy();

return map;
} catch (Exception e)
{
// TODO Auto-generated catch block
e.printStackTrace();
logger.error("===========获取经纬度信息异常！请求地址：" + address, e);
return java.util.Collections.emptyMap();
} finally
{
// 关闭连接
if (null != httpConnection)
{
httpConnection.disconnect();
}
}
}

/**
* 根据地址信息获取经纬度
*
* @param addressList 地址集合
* @return List<Map<地址, 经纬度对象>>
*/
public static List<Map<String, Point>> getAddressLatLng(List<String> addressList)
{
List<Map<String, Point>> list = new ArrayList<Map<String, Point>>();
if (null == addressList || addressList.isEmpty())
{
return list;
}

for (String address : addressList)
{
try
{
// 休息一下
Thread.sleep(THREAD_SLEEP_MILLIS);
} catch (InterruptedException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}

Map<String, Point> addrMap = getAddressLatLng(address);
if(false == addrMap.isEmpty())
{
list.add(addrMap);
}
else
{
//System.out.println(address + " point is null!!!");
logger.warn("===========获取经纬度信息为空！请求地址：" + address);
}
}
return list;
}

/**
* 解析网页内容地址信息及经纬度信息
*
* @param htmlContent
* @return Map<地址, 经纬度>
*/
private static Map<String, Point> parseAddressLatLng(String htmlContent)
{
Map<String, Point> addr = new HashMap<String, Point>(1);
if (isNullOrEmpty(htmlContent))
{
return addr;
}

String[] contents = htmlContent.split("\r\n");
String[] ss = null;
String address = null;
String country = null;
String region = null;
String city = null;
Point point = null;
for (String line : contents)
{
if (isNullOrEmpty(line))
{
continue;
}
line = line.trim();
if (line.contains(ADDRESS_POINT_KEY))
{
/*
* "coordinates": [ 113.9465830, 22.5309650, 0 ]
*/
ss = line.split(ADDRESS_SPLIT_STR);
if (null != ss && ss.length > 1)
{
String pointStr = getMiddleStr(ss[1], "[", "]");
String[] pss = pointStr.split(",");
if (null != pss && pss.length > 1)
{
double defaultValue = 0D;
point = new Point(isNullOrEmpty(pss[0])?defaultValue:Double.parseDouble(pss[0].trim()),
isNullOrEmpty(pss[1])?defaultValue:Double.parseDouble(pss[1].trim()));
}
}
}
else if (line.contains(ADDRESS_KEY))
{
address = getValue(line, ADDRESS_KEY);
}
else if (line.contains(ADDRESS_COUNTRY_KEY))
{
country = getValue(line, ADDRESS_COUNTRY_KEY);
}
else if (line.contains(ADDRESS_REGION_KEY))
{
region = getValue(line, ADDRESS_REGION_KEY);
}
else if (line.contains(ADDRESS_CITY_KEY))
{
city = getValue(line, ADDRESS_CITY_KEY);
}

// 默认取第一个地址信息
if (false == isNullOrEmpty(address)
&& null != point)
{
point.setCountry(country);
point.setRegion(region);
point.setCity(city);
break;
}
} // end-for-contents

// 如果地址不为空
if (false == isNullOrEmpty(address))
{
addr.put(address, point);
}
return addr;
}

/**
* 获取中间字符串内容
*
* @param content
* @param beginStr
* @param endStr
* @return
*/
private static String getMiddleStr(String content, String beginStr, String endStr)
{
String str = "";
if (isNullOrEmpty(content))
{
return str;
}

content = content.trim();
int bIndex = content.indexOf(beginStr);
int eIndex = -1;
if (null != beginStr && beginStr.equals(endStr))
{
int index = content.substring(bIndex+beginStr.length()).indexOf(endStr);
eIndex = content.substring(0, bIndex+beginStr.length()).length() + index;
}
else if (null != endStr && false == endStr.equals(beginStr))
{
eIndex = content.indexOf(endStr);
}

if (-1 != bIndex && -1 != eIndex)
{
str = content.substring(bIndex+beginStr.length(), eIndex);
}
return str;
}

private static final String PROXY_HOST_KEY = "http.proxyHost";
private static final String PROXY_PORT_KEY = "http.proxyPort";
private static final String PROXY_SET_KEY = "http.proxySet";

/**
* 切换代理
*/
private static synchronized void updateProxy()
{
downNum++;
if (downNum % DOWNNUM_FOR_PROXY == 0)
{
if (flag)
{
clearProxy();
flag = false;
}
else
{
setProxy();
flag = true;
}
}
}

private static void setProxy()
{
System.setProperty(PROXY_HOST_KEY, proxyHost);
System.setProperty(PROXY_PORT_KEY, proxyPort);
System.setProperty(PROXY_SET_KEY, proxySet);

logger.info("setProxy====="+proxyHost+":"+proxyPort);
//System.out.println("setProxy====="+proxyHost+":"+proxyPort);
}

private static void clearProxy()
{
System.clearProperty(PROXY_HOST_KEY);
System.clearProperty(PROXY_PORT_KEY);
System.clearProperty(PROXY_SET_KEY);

logger.info("clearProxy=====");
//System.out.println("clearProxy=====");
}

private static String encodeURLForUTF8(String str)
{
try
{
str = java.net.URLEncoder.encode(str, "UTF-8");
} catch (UnsupportedEncodingException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
logger.error("字符串转码异常，字符串："+ str, e);
}
return str;
}

/**
* 按照指定编码从流中读取信息
*
* @param inStream
* @param encode
* @return
* @throws IOException
*/
private static String getContentByStream(InputStream inStream, String encode) throws IOException
{
if (null == inStream)
{
return null;
}

StringBuilder content = new StringBuilder();
// 采用指定编码格式读取流内容
BufferedReader reader = new BufferedReader(new InputStreamReader(inStream, encode));
String message = null;
while (null != (message = reader.readLine()))
{
content.append(message);
content.append("\r\n");
}
// 关闭读取器，释放资源
reader.close();
return (content.toString());
}

/**
* 获取偏移后的经纬度（Google中国地图偏移接口）
* 中国地图和卫星图都存在偏移量，这个是由中国规划局确定的，
* google的地图服务，以ditu.gogle开头的都没有偏差，以maps.google开头的服务就有偏差
*
* @param zoom
* 偏移级别（从11级到18级，18级最精确）
* @param sourcePoint
* 经纬度对象
* @return
*/
public static Point getOffsetLatLng(int zoom, Point sourcePoint)
{
if (null == sourcePoint)
{
return null;
}

StringBuilder urlBuilder = new StringBuilder();
urlBuilder.append("http://ditu.google.cn/maps/vp");
urlBuilder.append("?spn=0.0,0.0");
urlBuilder.append("&z=").append(zoom);
urlBuilder.append("&vp=");
urlBuilder.append(sourcePoint.getLatitude());// 纬度
urlBuilder.append(",");
urlBuilder.append(sourcePoint.getLongitude());// 经度

HttpURLConnection httpConnection = null;
try
{
// 1、构造HttpURLConnection连接
URL url = new URL(urlBuilder.toString());
URLConnection urlConnection = url.openConnection();
httpConnection = (HttpURLConnection) urlConnection;
httpConnection.setDoInput(true);
httpConnection.setDoOutput(true);
httpConnection.setConnectTimeout(CONNECT_TIMEOUT);
httpConnection.connect();

// 2、接收响应结果
InputStream inStream = httpConnection.getInputStream();
String htmlContent = getContentByStream(inStream, REQUEST_ENCODE);
// 关闭流资源
inStream.close();

// 3、解析结果
String offset = parseOffsetFromZoom(zoom, htmlContent);
// 如果没有偏移值，则返回原经纬度对象
if (isNullOrEmpty(offset))
{
return sourcePoint;
}
Point targetPoint = getOffsetPoint(offset, zoom, sourcePoint);
updateProxy();

logger.info("sourcePoint: "+ sourcePoint);
logger.info("targetPoint: "+ targetPoint);

return targetPoint;
} catch (Exception e)
{
// TODO Auto-generated catch block
e.printStackTrace();
logger.error("===========获取偏移经纬度信息异常！zoom = " + zoom + ", sourcePoint = " + sourcePoint, e);
} finally
{
// 关闭连接
if (null != httpConnection)
{
httpConnection.disconnect();
}
}
return null;
}

/**
* 获取对应级别像素偏移量
*
* @param zoom
* @param htmlContent
* @return
*/
private static String parseOffsetFromZoom(int zoom, String htmlContent)
{
String offset = null;
if (isNullOrEmpty(htmlContent) || zoom > MAX_ZOOM || zoom < MIN_ZOOM)
{
return offset;
}

/*
* 下面分别表示经纬度、级别、偏移像素数量【级别从11级到18级，共8组数字】
* 前一组数字精确的等于后一组数字除二，我们为了得到最精确的偏移，故选择第18级的偏移量1193，-270，
* 1193为x方向上精度的偏移像素，-270为y方向上维度偏移像素
*
* window.GTileShiftUpdateOffset && window.GTileShiftUpdateOffset(
* 39.111195, 117.148067, 18, [9, -2, 18, -4, 37, -8, 74, -16, 149, -33,
* 298, -67, 596, -135, 1193, -270]);
*/
int beginIndex = htmlContent.lastIndexOf("[");
int endIndex = htmlContent.lastIndexOf("]");
if (beginIndex > 0 && endIndex > 0)
{
// 获取各级别像素偏移量内容
String content = htmlContent.substring(beginIndex + 1, endIndex);
offset = getOffsetByZoom(zoom, content);
}
return offset;
}

/**
* 获取zoom级别的像素偏移量
*
* @param zoom
* @param content
* @return
*/
private static String getOffsetByZoom(int zoom, String content)
{
String[] ss = content.split(",");
int index = ((zoom - 10) << 1) - 2;
if (null == ss || ss.length < (index + 1))
{
return null;
}
return (ss[index].trim() + "," + ss[index + 1].trim());
}

/**
* 获取校正后的经纬度
*
* @param offset
* @param zoom
* @param point
* @return
*/
private static Point getOffsetPoint(String offset, int zoom, Point point)
{
String[] ss = offset.split(",");
int offsetX = Integer.parseInt(ss[0]);
int offsetY = Integer.parseInt(ss[1]);

double lngPixel = (Math.round(lngToPixel(point.getLongitude(), zoom)) - offsetX);
double latPixel = (Math.round(latToPixel(point.getLatitude(), zoom)) - offsetY);
return new Point(pixelToLng(lngPixel, zoom), pixelToLat(latPixel, zoom));
}

/*
* sinLatitude = sin(latitude * pi/180)
*
* pixelX = ((longitude + 180) / 360) * 256 * 2level
*
* pixelY = (0.5 – log((1 + sinLatitude) / (1 – sinLatitude)) / (4 * pi)) * 256 * 2level
*/

/**
* 经度到像素X值
*
* @param lng
* @param zoom
* @return
*/
private static double lngToPixel(double lng, int zoom)
{
return (lng + 180) * (256L << zoom) / 360;
}

/**
* 纬度到像素Y
*
* @param lat
* @param zoom
* @return
*/
private static double latToPixel(double lat, int zoom)
{
double siny = Math.sin(lat * Math.PI / 180);
double y = Math.log((1 + siny) / (1 - siny));
return (256L << zoom) * (0.5 - y / (4 * Math.PI));
}

/**
* 像素X到经度
*
* @param pixelX
* @param zoom
* @return
*/
private static double pixelToLng(double pixelX, int zoom)
{
return pixelX * 360 / (256L << zoom) - 180;
}

/**
* 像素Y到纬度
*
* @param pixelY
* @param zoom
* @return
*/
private static double pixelToLat(double pixelY, int zoom)
{
double y = 4 * Math.PI * (0.5 - pixelY / (256L << zoom));
double z = Math.pow(Math.E, y);
double siny = (z - 1) / (z + 1);
return Math.asin(siny) * 180 / Math.PI;
}

/**
* 根据地区编码（LAC）和基站编号（CID）获取经纬度信息
*
* @param lac 地区编码
* @param cellId 基站编号
* @deprecated 改为调用 getLocationByLacAndCid方法
* @return
*/
public static Point getLatLngByLacAndCid(int lac, int cellId)
{
String urlString = "http://www.google.com/glm/mmap";

HttpURLConnection httpConn = null;
try
{
// ---open a connection to Google Maps API---
URL url = new URL(urlString);
URLConnection conn = url.openConnection();
httpConn = (HttpURLConnection) conn;
httpConn.setDoOutput(true);
httpConn.setDoInput(true);
httpConn.setDefaultUseCaches(false);
httpConn.setRequestMethod("POST");
httpConn.setConnectTimeout(CONNECT_TIMEOUT);
httpConn.connect();

// ---write some custom data to Google Maps API---
OutputStream outputStream = httpConn.getOutputStream();
writeData(outputStream, cellId, lac);
outputStream.close();

// ---get the response---
DataInputStream dataInputStream = new DataInputStream(httpConn.getInputStream());

// ---interpret the response obtained---
dataInputStream.readShort();
dataInputStream.readByte();
int code = dataInputStream.readInt();
Point point = null;
if (code == 0)
{
double lat = (double) dataInputStream.readInt() / 1000000D;
double lng = (double) dataInputStream.readInt() / 1000000D;
int i = dataInputStream.readInt();
int j = dataInputStream.readInt();
String s = dataInputStream.readUTF();
// 关闭流
dataInputStream.close();

// 包装结果
point = new Point(lng, lat);
point.setPrecision(i); // 精确度

// ---display Google Maps---
//logger.info("lac = "+lac+", cellId = "+cellId+", Latitude = "+lat+", Longitude = "+lng
//+ ", precision = "+i+", j = "+j+", s = "+s);
//System.out.println("Latitude = " + lat + ", Longitude = " + lng
//+ ", precision = " + i + ", j = " + j + ", s = " + s);
}
else
{
logger.warn("===========根据地区编码和基站编号获取经纬度信息失败！lac = "+ lac + ", cellId = " + cellId);
}

return point;
} catch (Exception e)
{
// TODO Auto-generated catch block
e.printStackTrace();
logger.error("===========根据地区编码和基站编号获取经纬度信息异常！lac = "+ lac + ", cellId = " + cellId, e);
} finally
{
// 关闭连接
if (null != httpConn)
{
httpConn.disconnect();
}
}
return null;
}

private static void writeData(OutputStream out, int cellId, int lac)
throws IOException
{
DataOutputStream dataOutputStream = new DataOutputStream(out);
dataOutputStream.writeShort(21);
dataOutputStream.writeLong(0);
dataOutputStream.writeUTF("en");
dataOutputStream.writeUTF("Android");
dataOutputStream.writeUTF("1.0");
dataOutputStream.writeUTF("Web");
dataOutputStream.writeByte(27);
dataOutputStream.writeInt(0);
dataOutputStream.writeInt(0);
if (cellId >= 65536)
{
// 联通3G
dataOutputStream.writeInt(5);
}
else
{
// 移动3G
dataOutputStream.writeInt(3);
}
dataOutputStream.writeUTF("");

dataOutputStream.writeInt(cellId);
dataOutputStream.writeInt(lac);

dataOutputStream.writeInt(0); //mnc
dataOutputStream.writeInt(0); //mcc
dataOutputStream.writeInt(0);
dataOutputStream.writeInt(0);
dataOutputStream.flush();
dataOutputStream.close();
}

/**
* 根据地区编码（LAC）和基站编号（CID）获取地区信息
*
* @param lac 地区编码
* @param cellId 基站编号
* @return
*/
public static Point getLocationByLacAndCid(int lac, int cellId)
{
String urlString = "http://www.google.cn/loc/json";

HttpURLConnection httpConn = null;
try
{
// ---open a connection to Google Maps API---
URL url = new URL(urlString);
URLConnection conn = url.openConnection();
httpConn = (HttpURLConnection) conn;
httpConn.setDoOutput(true);
httpConn.setDoInput(true);
httpConn.setDefaultUseCaches(false);
httpConn.setRequestMethod("POST");
httpConn.setRequestProperty("Content-Type", "application/json");
httpConn.setConnectTimeout(CONNECT_TIMEOUT);
httpConn.connect();

// ---write some custom data to Google Maps API---
OutputStreamWriter outputStream = new OutputStreamWriter(httpConn.getOutputStream());
outputStream.write(getLocationRequest(lac, cellId));
outputStream.flush();
outputStream.close();

// ---get the response---
String responseContent = getContentByStream(httpConn.getInputStream(), REQUEST_ENCODE);

// ---interpret the response obtained---
Point point = parseLocationContent(responseContent);

//logger.info(responseContent);
return point;
} catch (Exception e)
{
// TODO Auto-generated catch block
e.printStackTrace();
logger.error("===========根据地区编码和基站编号获取地区信息异常！lac = "+ lac + ", cellId = " + cellId, e);
} finally
{
// 关闭连接
if (null != httpConn)
{
httpConn.disconnect();
}
}
return null;
}

private static String getLocationRequest(int lac, int cellId)
{
StringBuilder requestContent = new StringBuilder();
requestContent.append("{ ");
requestContent.append(" \"version\" : \"1.1.0\", ");
requestContent.append(" \"host\" : \"ditu.google.cn\", ");
requestContent.append(" \"access_token\" : \"2:k7j3G6LaL6u_lafw:4iXOeOpTh1glSXe\", ");
requestContent.append(" \"request_address\" : true,");
requestContent.append(" \"cell_towers\" : ");
requestContent.append(" [ ");
requestContent.append(" { ");
requestContent.append(" \"cell_id\" : ").append(cellId).append(", ");
requestContent.append(" \"location_area_code\" : ").append(lac).append(", ");
requestContent.append(" \"mobile_country_code\" : 460, ");
requestContent.append(" \"mobile_network_code\" : 00, ");
requestContent.append(" \"age\" : 0, ");
requestContent.append(" \"signal_strength\" : -60, ");
requestContent.append(" \"timing_advance\" : 5555 ");
requestContent.append(" } ");
requestContent.append(" ] ");
requestContent.append("} ");
return (requestContent.toString());
}

/**
* 解析地区信息，并构造Point对象
*
* @param respContent
* @return
*/
private static Point parseLocationContent(String respContent)
{
if (isNullOrEmpty(respContent))
{
return null;
}
/*
* {"location":{"latitude":31.148662,"longitude":114.957975,
* "address":{"country":"中国","country_code":"CN","region":"湖北省","city":"黄冈市"},
* "accuracy":1625.0},
* "access_token":"2:i1-PwttBtQsSyYvX:VVq7Nsl89ut7l9aV"}
*
*/
// 获取纬度、经度、精确度、国家、省份、城市信息
String latitude = getValue(respContent, LOCATION_POINT_LATITUDE_KEY);
String longitude = getValue(respContent, LOCATION_POINT_LONGITUDE_KEY);
String precisiony = getValue(respContent, LOCATION_POINT_PRECISIONY_KEY);
String country = getValue(respContent, LOCATION_COUNTRY_KEY);
String region = getValue(respContent, LOCATION_REGION_KEY);
String city = getValue(respContent, LOCATION_CITY_KEY);
Point point = null;
if (false == isNullOrEmpty(latitude)
&& false == isNullOrEmpty(longitude))
{
point = new Point(Double.parseDouble(longitude), Double.parseDouble(latitude));
if (false == isNullOrEmpty(precisiony))
{
point.setPrecision(Double.parseDouble(precisiony));
}
point.setCountry(country);
point.setRegion(region);
point.setCity(city);
}
return point;
}

private static String getValue(String content, String key)
{
if (false == isNullOrEmpty(content) && false == isNullOrEmpty(key))
{
String[] ss = content.split("\r\n");
for (String line : ss)
{
if (isNullOrEmpty(line))
{
continue;
}

line = line.replace("{", "").replace("}", "").replace("[", "").replace("]", "").trim();
String[] sss = line.split(LOCATION_SPLIT_STR);
for (String str : sss)
{
if (isNullOrEmpty(str) || false == str.contains(key))
{
continue;
}

String[] sub = str.split(ADDRESS_SPLIT_STR);
for (int i = 0; i < sub.length; i++)
{
if (isNullOrEmpty(sub[i]))
{
continue;
}
sub[i] = sub[i].trim();
}
List<String> subList = java.util.Arrays.asList(sub);
int subIndex = subList.indexOf(key);
if (-1 != subIndex
&& subList.size() > (subIndex + 1))
{
String value = subList.get(subIndex + 1);
return (value.replace("\"", "").trim());
}
}// end-for-sss

}// end-for-ss
}
return null;
}

/**
* 判断字符串是否为空
*
* @param str
* @return
*/
public static boolean isNullOrEmpty(String str)
{
if (null == str || "".equals(str))
{
return true;
}
return false;
}

/**
* 经纬度坐标信息
*/
public static class Point
{
/**
* 经度
*/
private double longitude;

/**
* 纬度
*/
private double latitude;

/**
* 精确度
*/
private double precision;

/**
* 国家
*/
private String country;

/**
* 省份
*/
private String region;

/**
* 城市
*/
private String city;

/**
* 构造函数
* @param longitude 经度
* @param latitude 纬度
*/
public Point (double longitude, double latitude)
{
this.longitude = longitude;
this.latitude = latitude;
}

public double getLongitude()
{
return longitude;
}

public void setLongitude(double longitude)
{
this.longitude = longitude;
}

public double getLatitude()
{
return latitude;
}

public void setLatitude(double latitude)
{
this.latitude = latitude;
}

public double getPrecision()
{
return precision;
}

public void setPrecision(double precision)
{
this.precision = precision;
}

public String toString()
{
StringBuilder content = new StringBuilder();
content.append(getClass().getName());
content.append("[ latitude=");
content.append(this.latitude);
content.append(", longitude=");
content.append(this.longitude);
if (this.precision != 0.0)
{
content.append(", precision=");
content.append(this.precision);
}

if (false == isNullOrEmpty(this.country))
{
content.append(", country=");
content.append(this.country);
}

if (false == isNullOrEmpty(this.region))
{
content.append(", region=");
content.append(this.region);
}

if (false == isNullOrEmpty(this.city))
{
content.append(", city=");
content.append(this.city);
}
content.append(" ]");
return (content.toString());
}

public String getCountry()
{
return country;
}

public void setCountry(String country)
{
this.country = country;
}

public String getRegion()
{
return region;
}

public void setRegion(String region)
{
this.region = region;
}

public String getCity()
{
return city;
}

public void setCity(String city)
{
this.city = city;
}
}

public static String getProxyHost()
{
return proxyHost;
}

public static void setProxyHost(String proxyHost)
{
AddressLatLngUtil.proxyHost = proxyHost;
}

public static String getProxyPort()
{
return proxyPort;
}

public static void setProxyPort(String proxyPort)
{
AddressLatLngUtil.proxyPort = proxyPort;
}

/**
* 测试
* @param args
*/
public static void main(String[] args)
{
//System.getProperties().list(System.out);

//深圳: (经度)lng:114.0578,(纬度)lat:22.5434
List<String> addrList = new ArrayList<String>();
addrList.add("留学生创业大厦");
//addrList.add("深圳市");
//addrList.add("世界之窗");
//addrList.add("地王大厦");
//addrList.add("黄鹤楼");

List<Map<String, Point>> list = getAddressLatLng(addrList);
for (Map<String, Point> map : list)
{
for (Entry<String, Point> entry : map.entrySet())
{
logger.info(entry.getKey() + entry.getValue());

// 获取偏移坐标
Point offsetPoint = getOffsetLatLng(MAX_ZOOM, entry.getValue());
logger.info("偏移经纬度：" + offsetPoint);
System.out.println();
}
}

int lac = 0x717f;
int cellId = 0x3341;
Point point = getLocationByLacAndCid(lac, cellId);
logger.info(point);

point = getOffsetLatLng(MAX_ZOOM, point);
logger.info(point);

System.out.println("finished!");

}
}