高德地图API实现web服务端导航和定位等功能

package com.example.combat.gaodemapUtils;

import cn.hutool.core.io.FileUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.example.combat.gaodemapUtils.param.GaodeMapConstant;
import com.example.combat.gaodemapUtils.param.Geocodes;
import com.example.combat.gaodemapUtils.param.req.*;
import com.google.common.collect.Maps;
import com.sun.org.apache.regexp.internal.RE;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.binary.Base64;
import org.apache.http.NameValuePair;
import org.apache.http.client.utils.URIBuilder;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import sun.misc.BASE64Decoder;

import javax.imageio.ImageIO;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.awt.image.BufferedImage;
import java.awt.image.RenderedImage;
import java.io.*;
import java.net.URL;
import java.net.URLDecoder;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Random;
import java.util.zip.GZIPOutputStream;

import static com.example.combat.gaodemapUtils.HttpUtil.covertParams2NVPS;

/**
 * @description: 高德地图工具类
 * @author: zhucj
 * @date: 2019-11-25 17:22
 */
@Component
@Slf4j
public class GaodeMapUtil {


    @Value("${gaodemap.key}")
    private String key;

    @Value("${gaodemap.pathImg}")
    private String pathImg;

    /**
     * 结构化地址信息查询
     * @param geocodeRequestVo
     * @return
     */
    @ApiOperation(value ="结构化地址信息查询")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "address",value = "结构化地址信息",required = true,dataType = "String"),
            @ApiImplicitParam(name = "city",value = "指定查询城市 城市的中文或中文全拼 ",required = false,dataType = "String")
    })
    public R getGeocodes(GeocodeRequestVo geocodeRequestVo) {
        log.info("==>查询结构化地址:"+geocodeRequestVo.getAddress());
        //是否支持批量查询 true:支持 false:不支持
        geocodeRequestVo.setBatch(false);
        //支持的格式XML,JSON
        geocodeRequestVo.setOutput(GaodeMapConstant.JSON);
        Map<String, Object> stringObjectMap = beanToMap(geocodeRequestVo);
        stringObjectMap.put(GaodeMapConstant.KEY,key);
        String resultJson = null;
        try {
            resultJson = HttpUtil.httpGet(GaodeMapConstant.GEOCODE_GEO, stringObjectMap);
        } catch (Exception e) {
            log.error("请求服务异常:{}",e.getMessage());
            return R.error("请求服务异常").setCode(SystemConstant.SERVER_ERROR_CODE);
        }
        JSONObject jsonObject = JSON.parseObject(resultJson);
        if (Objects.equals(GaodeMapConstant.SUCCESS,jsonObject.get("status"))){
            String geocodes = JSON.toJSONString(jsonObject.get("geocodes"));
            List<Geocodes> geocodes1 = JSON.parseArray(geocodes, Geocodes.class);
            return R.ok(geocodes1.get(0)).setCode(SystemConstant.SUCCESS_CODE);
        }else {
            log.info("获取地址信息失败,原因:{}",jsonObject.get("info"));
            return R.error(jsonObject.get("info").toString()).setCode(SystemConstant.SERVER_ERROR_CODE);
        }
    }

    /**
     * 通过经纬度,获取地理位置信息
     * @param geocodeRequestVo
     * @return
     */
    @ApiOperation(value = "获取逆地理编码信息列表",notes = "朱传捷")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "location",value = "经纬度(格式:116.481488,39.990464)",required = true,dataType = "String"),
            @ApiImplicitParam(name = "poitype",value = "返回附近POI类型(extensions 参数为 all 时才生效)",required = false,dataType = "String"),
            @ApiImplicitParam(name = "radius",value = "搜索半径",required = false,dataType = "String"),
            @ApiImplicitParam(name = "extensions",value = "返回结果控制(base和all)",required = false,dataType = "String"),
            @ApiImplicitParam(name = "roadlevel",value = "道路等级",required = false,dataType = "String")
    })
    public R getReGeocodes(GeocodeRequestVo geocodeRequestVo) {
        //是否支持批量查询 true:支持 false:不支持
        geocodeRequestVo.setBatch(false);
        //支持的格式XML,JSON
        geocodeRequestVo.setOutput(GaodeMapConstant.JSON);
        Map<String, Object> stringObjectMap = beanToMap(geocodeRequestVo);
        stringObjectMap.put(GaodeMapConstant.KEY,key);
        try {
            String resultJson = HttpUtil.httpGet(GaodeMapConstant.GEOCODE_REGEO, stringObjectMap);
            JSONObject jsonObject = JSON.parseObject(resultJson);
            if (Objects.equals(GaodeMapConstant.SUCCESS,jsonObject.get("status"))){
                return R.ok(jsonObject.get("regeocode")).setCode(SystemConstant.SUCCESS_CODE);
            }else {
                return R.error(jsonObject.get("info").toString()).setCode(SystemConstant.SERVER_ERROR_CODE);
            }
        } catch (Exception e) {
            log.error("通过经纬度获取地址失败:{}",e.getMessage());
            return R.error("获取地址失败").setCode(SystemConstant.SERVER_ERROR_CODE);
        }
    }

    /**
     * 路线规划
     * @param directionRequestVo
     * @return
     */
    @ApiOperation(value = "地图路线规划,支持步行、公交、驾车方式")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "directionType",value = "交通工具类型1:步行 2:公交 3:驾车",required = true,dataType = "Integer"),
            @ApiImplicitParam(name = "origin",value = "出发点经纬度",required = true,dataType = "String"),
            @ApiImplicitParam(name = "destination",value = "终点经纬度",required = true,dataType = "String"),
            @ApiImplicitParam(name = "city",value = "城市/跨城规划时的起点城市,directionType = 2时必传",required = false,dataType = "String"),
            @ApiImplicitParam(name = "strategy",value = "换乘策略",required = false,dataType = "Integer")
    })
    public R getDirection(DirectionRequestVo directionRequestVo) {
        if (StringUtils.isEmpty(directionRequestVo.getOrigin())){
            return R.error(GaodeMapConstant.ERR_ORIGIN_PARAM_NULL).setCode(SystemConstant.PARAM_INCORRECT_CODE);
        }
        if (StringUtils.isEmpty(directionRequestVo.getDestination())){
            return R.error(GaodeMapConstant.ERR_DESTINATION_PARAM_NULL).setCode(SystemConstant.PARAM_INCORRECT_CODE);
        }
        //判断路线规划类型,目前只支持3种,strategy=2时,city城市名称
        String reqUrl = null;
        switch (directionRequestVo.getStrategy()){
            case 1:
                reqUrl = GaodeMapConstant.DIRECTION_WALKING;
                break;
            case 2:
                if (StringUtils.isEmpty(directionRequestVo.getCity())){
                    return R.error(GaodeMapConstant.ERR_CITY_PARAM_NULL).setCode(SystemConstant.PARAM_INCORRECT_CODE);
                }
                reqUrl = GaodeMapConstant.DIRECTION_INTEGRATED;
                break;

            case 3:
                reqUrl = GaodeMapConstant.DIRECTION_DRIVING;
                break;
                default:
                    return R.error(GaodeMapConstant.ERR_DIRECTIONTYPE_PARAM_NULL).setCode(SystemConstant.PARAM_INCORRECT_CODE);
        }
        Map<String, Object> stringObjectMap = beanToMap(directionRequestVo);
        stringObjectMap.put(GaodeMapConstant.KEY,key);
        try {
            String rusultStr = HttpUtil.httpGet(reqUrl, stringObjectMap);
            JSONObject jsonObject = JSON.parseObject(rusultStr);
            if (Objects.equals(GaodeMapConstant.SUCCESS,jsonObject.get("status"))){
                return R.ok(jsonObject.get("route"));
            }else {
                log.error("查询路线规划失败:{}",jsonObject.get("info").toString());
                return R.error(jsonObject.get("info").toString()).setCode(SystemConstant.SERVER_ERROR_CODE);
            }
        } catch (Exception e) {
            log.error("查询路线规划异常:{}",e.getMessage());
            return R.error("查询路线规划异常").setCode(SystemConstant.SERVER_ERROR_CODE);
        }
    }

    /**
     * 静态地图
     * @param staticMapRequest
     */
    @ApiOperation(value = "生成静态地图")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "locations",value = "经纬度集合",required = true,dataType = "List"),
            @ApiImplicitParam(name = "zoom",value = "地图缩放级别:[1,17]",required = true,dataType = "String"),
            @ApiImplicitParam(name = "size",value = "图片宽度*图片高度。最大值为1024*1024",required = true,dataType = "String"),
            @ApiImplicitParam(name = "scale",value = "清晰度",required = true,dataType = "Integer")
    })
    public void staticMap(StaticMapRequest staticMapRequest, HttpServletResponse response){

        //设置地图缩放级别
        staticMapRequest.setZoom(staticMapRequest.getZoom());
        //地图大小
        staticMapRequest.setSize(staticMapRequest.getSize());
        //设置高清
        staticMapRequest.setScale(staticMapRequest.getScale());
        List<String> localhosts = staticMapRequest.getLocalhosts();
        //设置默认第一个和最后一个点,标注,起,终
        Markers marker1 = Markers
                .builder()
                .color("0xFF0000")
                .size("mid")
                .label("起:"+localhosts.get(0))
                .build();
        Markers markers2 = Markers
                .builder()
                .size("mid")
                .color("0xFF0000")
                .label("终:"+localhosts.get(localhosts.size()-1))
                .build();
        //拼接markers属性
        String setMarkers1 = marker1.getSize()+","+marker1.getColor()+","+marker1.getLabel();
        String setMarkers2 = markers2.getSize()+","+markers2.getColor()+","+markers2.getLabel();
        staticMapRequest.setMarkers(setMarkers1+"|"+setMarkers2);
        //绘制折线
        Paths paths = Paths
                .builder()
                .weight(5)
                .color("0xFF0000")
                .transparency("1")
                .build();
        StringBuilder stringBuilder = new StringBuilder();
        for (String localhost:localhosts){
            stringBuilder.append(localhost+";");
        }
        String s = stringBuilder.deleteCharAt(stringBuilder.length() - 1).toString();
        String path = paths.getWeight()+","+paths.getColor()+","+paths.getTransparency()+","+","+":"+s;
        staticMapRequest.setPaths(path);
        Map<String, Object> stringObjectMap = beanToMap(staticMapRequest);
        stringObjectMap.put(GaodeMapConstant.KEY,key);
        try {
            // 转换请求参数
            List<NameValuePair> pairs = covertParams2NVPS(stringObjectMap);
            // 装载请求地址和参数
            URIBuilder ub = new URIBuilder();
            ub.setPath(GaodeMapConstant.STATUC_MAP);
            ub.setParameters(pairs);
            String s1 = ub.toString();
            String compress = compress(s1,pathImg );
            exportImg(response,pathImg+compress);
        } catch (Exception e) {
            log.error("下载图片异常"+e.getMessage());
        }
    }
    /**
     * bean -> map 实体类转map
     * @param bean
     * @param <T>
     * @return
     */
    public static <T> Map<String, Object> beanToMap(T bean) {
        Map<String, Object> map = Maps.newHashMap();
        if (bean != null) {
            BeanMap beanMap = BeanMap.create(bean);
            for (Object key : beanMap.keySet()) {
                if (Objects.nonNull(beanMap.get(key)) && !(Objects.equals("",beanMap.get(key)))){
                    map.put(key + "",beanMap.get(key));
                }
            }
        }
        return map;
    }

    /**
     * 下载地图
     * @param url
     * @param path
     * @return
     */
    public static String compress(String url,String path) {
        try {
            String imageName = "map.png";
            File file = new File(path +  imageName);
            //判断文件是否已经存在
            if (file.exists()) {
                file.delete();
            }
            file.createNewFile();
            URL uri = new URL(url);
            InputStream in = uri.openStream();
            FileOutputStream fo = new FileOutputStream(file);
            byte[] buf = new byte[1024];
            int length = 0;
            while ((length = in.read(buf, 0, buf.length)) != -1) {
                fo.write(buf, 0, length);
            }
            in.close();
            fo.close();
            return imageName;
        } catch (Exception e) {
            log.error("下载失败",e.getMessage());
            return null;
        }

    }

    /**
     * 输出图片
     * @param response
     * @param filePath
     */
    public static void exportImg(HttpServletResponse response, String filePath) {
        File file = new File(filePath);
        response.setCharacterEncoding("utf-8");
        //设置响应的内容类型
        response.setContentType("text/plain");
        //设置文件的名称和格式
        response.setHeader("content-type", "application/octet-stream");
        response.setContentType("application/octet-stream");
        response.addHeader("Content-Disposition", "attachment;filename=" + file.getName());
        BufferedOutputStream buff = null;
        ServletOutputStream outStr = null;
        try {
            outStr = response.getOutputStream();
            buff = new BufferedOutputStream(outStr);
            buff.write(FileUtil.readBytes(filePath));
            buff.flush();
            buff.close();
        } catch (Exception e) {
            e.printStackTrace();
            log.error("文件导出异常：", e);
        } finally {
            try {
                buff.close();
            } catch (Exception e) {
                log.error("流关闭异常：", e);
            }
            try {
                outStr.close();
            } catch (Exception e) {
                log.error("流关闭异常：", e);
            }
        }
    }

}

package com.example.combat.gaodemapUtils;

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.binary.Base64;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
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.HttpRequestBase;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
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.ssl.SSLContextBuilder;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.ssl.TrustStrategy;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.SSLContext;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.security.KeyStore;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

@Slf4j
public class HttpUtil {

    public static final ContentType TEXT_PLAIN = ContentType.create("text/plain", StandardCharsets.UTF_8);

    /**
     * HttpClient 连接池
     */
    private static PoolingHttpClientConnectionManager cm = null;

    static {
        // 初始化连接池，可用于请求HTTP/HTTPS（信任所有证书）
        cm = new PoolingHttpClientConnectionManager(getRegistry());
        // 整个连接池最大连接数
        cm.setMaxTotal(200);
        // 每路由最大连接数，默认值是2
        cm.setDefaultMaxPerRoute(5);
    }

    /**
     * 发送 HTTP GET请求
     * <p>不带请求参数和请求头</p>
     * @param url 地址
     * @return
     * @throws Exception
     */
    public static String httpGet(String url) throws Exception {
        log.info("请求参数:{}",url);
        HttpGet httpGet = new HttpGet(url);

        return doHttp(httpGet);
    }

    /**
     * 发送 HTTP GET请求
     * <p>带请求参数，不带请求头</p>
     * @param url    地址
     * @param params 参数
     * @return
     * @throws Exception
     * @throws Exception
     */
    public static String httpGet(String url, Map<String, Object> params) throws Exception {
        // 转换请求参数
        List<NameValuePair> pairs = covertParams2NVPS(params);

        // 装载请求地址和参数
        URIBuilder ub = new URIBuilder();
        ub.setPath(url);
        ub.setParameters(pairs);
        HttpGet httpGet = new HttpGet(ub.build());

        return doHttp(httpGet);
    }

    /**
     * 发送 HTTP GET请求
     * <p>带请求参数和请求头</p>
     * @param url     地址
     * @param headers 请求头
     * @param params  参数
     * @return
     * @throws Exception
     * @throws Exception
     */
    public static String httpGet(String url, Map<String, Object> headers, Map<String, Object> params) throws Exception {
        // 转换请求参数
        List<NameValuePair> pairs = covertParams2NVPS(params);

        // 装载请求地址和参数
        URIBuilder ub = new URIBuilder();
        ub.setPath(url);
        ub.setParameters(pairs);

        HttpGet httpGet = new HttpGet(ub.build());
        // 设置请求头
        for (Map.Entry<String, Object> param : headers.entrySet()){
            httpGet.addHeader(param.getKey(), String.valueOf(param.getValue()));}

        return doHttp(httpGet);
    }

    /**
     * 发送 HTTP POST请求
     * <p>不带请求参数和请求头</p>
     *
     * @param url 地址
     * @return
     * @throws Exception
     */
    public static String httpPost(String url) throws Exception {
        HttpPost httpPost = new HttpPost(url);

        return doHttp(httpPost);
    }

    /**
     * 发送 HTTP POST请求
     * <p>带请求参数，不带请求头</p>
     *
     * @param url    地址
     * @param params 参数
     * @return
     * @throws Exception
     */
    public static String httpPost(String url, Map<String, Object> params) throws Exception {
        // 转换请求参数
        List<NameValuePair> pairs = covertParams2NVPS(params);

        HttpPost httpPost = new HttpPost(url);
        // 设置请求参数
        httpPost.setEntity(new UrlEncodedFormEntity(pairs, StandardCharsets.UTF_8.name()));

        return doHttp(httpPost);
    }

    /**
     * 发送 HTTP POST请求
     * <p>带请求参数和请求头</p>
     *
     * @param url     地址
     * @param headers 请求头
     * @param params  参数
     * @return
     * @throws Exception
     */
    public static String httpPost(String url, Map<String, Object> headers, Map<String, Object> params) throws Exception {
        log.info("POST请求参数:{}",params);
        HttpPost httpPost = new HttpPost(url);
        // 设置请求参数
        StringEntity entity = new StringEntity(JSON.toJSONString(params),ContentType.APPLICATION_JSON);
        httpPost.setEntity(entity);
        // 设置请求头
        for (Map.Entry<String, Object> param : headers.entrySet()){
            httpPost.addHeader(param.getKey(), String.valueOf(param.getValue()));}

        return doHttp(httpPost);
    }




    /**
     * 转换请求参数
     *
     * @param params
     * @return
     */
    public static List<NameValuePair> covertParams2NVPS(Map<String, Object> params) {
        List<NameValuePair> pairs = new ArrayList<NameValuePair>();

        for (Map.Entry<String, Object> param : params.entrySet()){
            pairs.add(new BasicNameValuePair(param.getKey(), String.valueOf(param.getValue())));}

        return pairs;
    }

    /**
     * 发送 HTTP 请求
     *
     * @param request
     * @return
     * @throws Exception
     */
    private static String doHttp(HttpRequestBase request) throws Exception {
        // 通过连接池获取连接对象
        CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(cm).build();

        return doRequest(httpClient, request);
    }

    /**
     * 发送 HTTPS 请求
     * <p>使用指定的证书文件及密码</p>
     *
     * @param request
     * @param path
     * @param password
     * @return
     * @throws Exception
     * @throws Exception
     */
    private static String doHttps(HttpRequestBase request, String path, String password) throws Exception {
        // 获取HTTPS SSL证书
        SSLConnectionSocketFactory csf = getSSLFactory(path, password);
        // 通过连接池获取连接对象
        CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(csf).build();

        return doRequest(httpClient, request);
    }

    /**
     * 获取HTTPS SSL连接工厂
     * <p>使用指定的证书文件及密码</p>
     *
     * @param path     证书全路径
     * @param password 证书密码
     * @return
     * @throws Exception
     * @throws Exception
     */
    private static SSLConnectionSocketFactory getSSLFactory(String path, String password) throws Exception {

        // 初始化证书，指定证书类型为“PKCS12”
        KeyStore keyStore = KeyStore.getInstance("PKCS12");
        // 读取指定路径的证书
        FileInputStream input = new FileInputStream(new File(path));

        try {
            // 装载读取到的证书，并指定证书密码
            keyStore.load(input, password.toCharArray());
        } finally {
            input.close();
        }

        // 获取HTTPS SSL证书连接上下文
        SSLContext sslContext = SSLContexts.custom().loadKeyMaterial(keyStore, password.toCharArray()).build();

        // 获取HTTPS连接工厂，指定TSL版本
        SSLConnectionSocketFactory sslCsf = new SSLConnectionSocketFactory(sslContext, new String[]{"SSLv2Hello", "SSLv3", "TLSv1", "TLSv1.2"}, null, SSLConnectionSocketFactory.getDefaultHostnameVerifier());

        return sslCsf;
    }

    /**
     * 获取HTTPS SSL连接工厂
     * <p>跳过证书校验，即信任所有证书</p>
     *
     * @return
     * @throws Exception
     */
    private static SSLConnectionSocketFactory getSSLFactory() throws Exception {
        // 设置HTTPS SSL证书信息，跳过证书校验，即信任所有证书请求HTTPS
        SSLContextBuilder sslBuilder = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
            public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                return true;
            }
        });

        // 获取HTTPS SSL证书连接上下文
        SSLContext sslContext = sslBuilder.build();

        // 获取HTTPS连接工厂
        SSLConnectionSocketFactory sslCsf = new SSLConnectionSocketFactory(sslContext, new String[]{"SSLv2Hello", "SSLv3", "TLSv1", "TLSv1.2"}, null, NoopHostnameVerifier.INSTANCE);

        return sslCsf;
    }

    /**
     * 获取 HTTPClient注册器
     *
     * @return
     * @throws Exception
     */
    private static Registry<ConnectionSocketFactory> getRegistry() {
        Registry<ConnectionSocketFactory> registry = null;

        try {
            registry = RegistryBuilder.<ConnectionSocketFactory>create().register("http", new PlainConnectionSocketFactory()).register("https", getSSLFactory()).build();
        } catch (Exception e) {
            log.error("获取 HTTPClient注册器失败", e);
        }

        return registry;
    }


    /**
     * 处理Http/Https请求，并返回请求结果
     * <p>注：默认请求编码方式 UTF-8</p>
     *
     * @param httpClient
     * @param request
     * @return
     * @throws Exception
     */
    private static String doRequest(CloseableHttpClient httpClient, HttpRequestBase request) throws Exception {
        String result = null;
        CloseableHttpResponse response = null;

        try {
            // 获取请求结果
            response = httpClient.execute(request);
            // 解析请求结果
            HttpEntity entity = response.getEntity();
            if ((entity.getContentEncoding() != null)
                    && entity.getContentEncoding().getValue().contains("gzip")) {
                GZIPInputStream gzip = new GZIPInputStream(
                        new ByteArrayInputStream(EntityUtils.toByteArray(entity)));
                InputStreamReader isr = new InputStreamReader(gzip);
                BufferedReader br = new BufferedReader(isr);
                StringBuilder sb = new StringBuilder();
                String temp;
                while((temp = br.readLine()) != null){
                    sb.append(temp);
                    sb.append("
");
                }
                isr.close();
                gzip.close();
                return sb.toString();
            }
            // 转换结果
            result = EntityUtils.toString(entity, StandardCharsets.UTF_8.name());
            // 关闭IO流
            EntityUtils.consume(entity);
        } finally {
            if (null != response){
                response.close();}
        }

        return result;
    }


}

package com.example.combat.gaodemapUtils;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.ToString;

import java.io.Serializable;

/**
 * 返回类型
 * @author choleece
 * @date 2018/9/27
 */
@ApiModel
@ToString
public class R<T> implements Serializable {

    private static final long serialVersionUID = -6287952131441663819L;

    /**
     * 编码
     */
    @ApiModelProperty(value = "响应码", example = "200")
    private int code = 200;

    /**
     * 成功标志
     */
    @ApiModelProperty(value = "成功标志", example = "true")
    private Boolean success;

    /**
     * 返回消息
     */
    @ApiModelProperty(value = "返回消息说明", example = "操作成功")
    private String msg="操作成功";

    /**
     * 返回数据
     */
    @ApiModelProperty(value = "返回数据")
    private T data;

    /**
     * 创建实例
     * @return
     */
    public static R instance() {
        return new R();
    }

    public int getCode() {
        return code;
    }

    public R setCode(int code) {
        this.code = code;
        return this;
    }

    public Boolean getSuccess() {
        return success;
    }

    public R setSuccess(Boolean success) {
        this.success = success;
        return this;
    }

    public String getMsg() {
        return msg;
    }

    public R setMsg(String msg) {
        this.msg = msg;
        return this;
    }

    public T getData() {
        return data;
    }
    public R setData(T data) {
        this.data = data;
        return this;
    }

    public static R ok() {
        return R.instance().setSuccess(true);
    }

    public static R ok(Object data) {
        return ok().setData(data);
    }

    public static R ok(Object data, String msg) {
        return ok(data).setMsg(msg);
    }

    public static R error() {
        return R.instance().setSuccess(false);
    }

    public static R error(String msg) {
        return error().setMsg(msg);
    }

    /**
     * 无参
     */
    public R() {
    }

    public R(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public R(int code, T data){
        this.code = code;
        this.data = data;
    }

    /**
     * 有全参
     * @param code
     * @param msg
     * @param data
     * @param success
     */
    public R(int code, String msg, T data, Boolean success) {
        this.code = code;
        this.msg = msg;
        this.data = data;
        this.success = success;
    }

    /**
     * 有参
     * @param code
     * @param msg
     * @param data
     */
    public R(int code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }
}

package com.example.combat.gaodemapUtils;

/** 前端返回信息
 * @Author: zhucj
 * @Date: 2019/5/21 16:19
 */
public class SystemConstant {


    /** 传参不规范,code：400*/
    public static final Integer PARAM_INCORRECT_CODE = 400;

    /** 成功,code：200*/
    public static final Integer SUCCESS_CODE = 200;

    /** 服务内部调用失败,code：500*/
    public static final Integer SERVER_ERROR_CODE = 500;

    /** 登录失效,code：401*/
    public static final Integer AUTH_FAIL_CODE = 401;

    /** 无对应接口权限,code：402*/
    public static final Integer HAVE_NOT_PERMISSION_CODE = 402;

    /** 操作无记录,code：403*/
    public static final Integer NO_RECORD_OPERATION = 403;





}

package com.example.combat.gaodemapUtils.param.req;

import io.swagger.annotations.ApiModel;
import lombok.*;

/**
 * @description:
 * @author: zhucj
 * @date: 2019-08-05 11:19
 */
@Data
@ApiModel(description = "路径规划请求视图")
@Builder
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class DirectionRequestVo {

    /**
     * 交通工具类型 1:步行 2:公交 3:驾车
     */
    private Integer  directionType;
    /**
     * 出发点 lon，lat（经度，纬度）， “,”分割，如117.500244, 40.417801
     */
    private String origin;

    /**
     * 目的地 lon，lat（经度，纬度）， “,”分割，如117.500244, 40.417801
     */
    private String destination;

    /**
     * 城市/跨城规划时的起点城市,directionType = 2时必传
     */
    private String city;

    /**
     * 公交换乘策略 directionType = 2和3时选传 默认0 可选值：
     * 0：最快捷模式,1：最经济模式,2：最少换乘模式,3：最少步行模式,5：不乘地铁模式
     * 下方10~20的策略，会返回多条路径规划结果。（高德地图APP策略也包含在内，强烈建议从此策略之中选择）
     * 下方策略 0~9的策略，仅会返回一条路径规划结果
     */
    /**
     * 下方策略仅返回一条路径规划结果
     * 0，速度优先，不考虑当时路况，此路线不一定距离最短
     * 1，费用优先，不走收费路段，且耗时最少的路线
     * 2，距离优先，不考虑路况，仅走距离最短的路线，但是可能存在穿越小路/小区的情况
     * 3，速度优先，不走快速路，例如京通快速路（因为策略迭代，建议使用13）
     * 4，躲避拥堵，但是可能会存在绕路的情况，耗时可能较长
     * 5，多策略（同时使用速度优先、费用优先、距离优先三个策略计算路径）。
     * 其中必须说明，就算使用三个策略算路，会根据路况不固定的返回一~三条路径规划信息。
     * 6，速度优先，不走高速，但是不排除走其余收费路段
     * 7，费用优先，不走高速且避免所有收费路段
     * 8，躲避拥堵和收费，可能存在走高速的情况，并且考虑路况不走拥堵路线，但有可能存在绕路和时间较长
     * 9，躲避拥堵和收费，不走高速
     * 下方策略返回多条路径规划结果
     * 10，返回结果会躲避拥堵，路程较短，尽量缩短时间，与高德地图的默认策略也就是不进行任何勾选一致
     * 11，返回三个结果包含：时间最短；距离最短；躲避拥堵 （由于有更优秀的算法，建议用10代替）
     * 12，返回的结果考虑路况，尽量躲避拥堵而规划路径，与高德地图的“躲避拥堵”策略一致
     * 13，返回的结果不走高速，与高德地图“不走高速”策略一致
     * 14，返回的结果尽可能规划收费较低甚至免费的路径，与高德地图“避免收费”策略一致
     * 15，返回的结果考虑路况，尽量躲避拥堵而规划路径，并且不走高速，与高德地图的“躲避拥堵&不走高速”策略一致
     * 16，返回的结果尽量不走高速，并且尽量规划收费较低甚至免费的路径结果，与高德地图的“避免收费&不走高速”策略一致
     * 17，返回路径规划结果会尽量的躲避拥堵，并且规划收费较低甚至免费的路径结果，与高德地图的“躲避拥堵&避免收费”策略一致
     * 18，返回的结果尽量躲避拥堵，规划收费较低甚至免费的路径结果，并且尽量不走高速路，与高德地图的“避免拥堵&避免收费&不走高速”策略一致
     * 19，返回的结果会优先选择高速路，与高德地图的“高速优先”策略一致
     * 20，返回的结果会优先考虑高速路，并且会考虑路况躲避拥堵，与高德地图的“躲避拥堵&高速优先”策略一致
     */
    private Integer strategy;

}

package com.example.combat.gaodemapUtils.param.req;

import io.swagger.annotations.ApiModel;
import lombok.*;

/**
 * @description:
 * @author:zhucj
 * @date: 2019-08-02 11:50
 */
@Data
@ApiModel(description = "地理名称请求视图")
@Builder
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class GeocodeRequestVo {

    //TODO: 地理编码参数
    /**
     * 结构化地址信息
     * 如：北京市朝阳区阜通东大街6号。如果需要解析多个地址的话，
     * 请用"|"进行间隔，并且将 batch 参数设置为 true，
     * 最多支持 10 个地址进进行"|"分割形式的请求。
     */
    private String address;

    /**
     * 城市名称
     * 指定城市的中文（如北京）、指定城市的中文全拼（beijing）、
     * citycode（010）、adcode（110000），不支持县级市。
     */
    private String city;

    /**
     * 批量查询控制
     * batch 参数设置为 true 时进行批量查询操作，最多支持 10 个地址进行批量查询。
     * batch 参数设置为 false 时进行单点查询，此时即使传入多个地址也只返回第一个地址的解析查询结果。
     */
    private Boolean batch;

    /**
     * 返回数据格式类型
     * 可选输入内容包括：JSON，XML
     */
    private String output;

    /**
     * 数字签名
     */
    private String sig;

    /**
     * 回调函数
     */
    private String callback;

    //TODO:逆地理编码参数

    /**
     * 经纬度坐标
     * 经度在前，纬度在后，经纬度间以“,”分割，经纬度小数点后不要超过 6 位
     */
    private String location;

    /**
     * 搜索半径
     * radius取值范围在0~3000，默认是1000。单位：米
     */
    private String radius ;

    /**
     * 返回结果控制
     * extensions 参数默认取值是 base，也就是返回基本地址信息；
     * extensions 参数取值为 all 时会返回基本地址信息、附近 POI 内容、道路信息以及道路交叉口信息。
     */
    private String extensions;

    /**
     *道路等级
     * 以下内容需要 extensions 参数为 all 时才生效。
     * 可选值：0，1
     * 当roadlevel=0时，显示所有道路
     * 当roadlevel=1时，过滤非主干道路，仅输出主干道路数据
     */
    private String roadlevel;

    /**
     * 是否优化POI返回顺序
     * 以下内容需要 extensions 参数为 all 时才生效。
     * homeorcorp 参数的设置可以影响召回 POI 内容的排序策略，目前提供三个可选参数：
     * 0：不对召回的排序策略进行干扰。
     * 1：综合大数据分析将居家相关的 POI 内容优先返回，即优化返回结果中 pois 字段的poi顺序。
     * 2：综合大数据分析将公司相关的 POI 内容优先返回，即优化返回结果中 pois 字段的poi顺序。
     */
    private String homeorcorp;
}

package com.example.combat.gaodemapUtils.param.req;

import io.swagger.annotations.ApiModel;
import lombok.*;

/**
 * @description:
 * @author: zhucj
 * @date: 2019-11-26 11:15
 */
@Data
@ApiModel(description = "标注视图")
@Builder
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Markers {

    /**
     * 可选值： small,mid,large
     */
    private String size;

    /**
     * 0x000000 black,
     * 0x008000 green,
     * 0x800080 purple,
     * 0xFFFF00 yellow,
     * 0x0000FF blue,
     * 0x808080 gray,
     * 0xffa500 orange,
     * 0xFF0000 red,
     * 0xFFFFFF white
     */
    private String color;

    /**
     * 0-9]、[A-Z]、[单个中文字] 当size为small时，图片不展现标注名。
     * 格式 A:116.31604,39.96491
     */
    private String label;
}

package com.example.combat.gaodemapUtils.param.req;

import io.swagger.annotations.ApiModel;
import lombok.*;

/**
 * @description:
 * @author: zhucj
 * @date: 2019-11-26 11:20
 */
@Data
@ApiModel(description = "折线视图")
@Builder
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Paths {

    /**
     * 线条粗细。
     * 可选值： [2,15]
     */
    private Integer weight;

    /**
     * 折线颜色。 选值范围：[0x000000, 0xffffff]
     * 例如：
     * 0x000000 black,
     * 0x008000 green,
     * 0x800080 purple,
     * 0xFFFF00 yellow,
     * 0x0000FF blue,
     * 0x808080 gray,
     * 0xffa500 orange,
     * 0xFF0000 red,
     * 0xFFFFFF white
     */
    private String color;

    /**
     * 透明度。
     * 可选值[0,1]，小数后最多2位，0表示完全透明，1表示完全不透明。
     */
    private String transparency;

    /**
     * 多边形的填充颜色，此值不为空时折线封闭成多边形。取值规则同color
     */
    private String fillcolor;

    /**
     * 填充面透明度。
     * 可选值[0,1]，小数后最多2位，0表示完全透明，1表示完全不透明
     */
    private String fillTransparency;
}

package com.example.combat.gaodemapUtils.param.req;

import io.swagger.annotations.ApiModel;
import lombok.*;

import java.util.List;

/**
 * @description: 绘制静态地图请求实体
 * @author:zhucj
 * @date: 2019-11-26 10:48
 */
@Data
@ApiModel(description = "绘制静态地图请求视图")
@Builder
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class StaticMapRequest {

    /**
     * 路线主键Id
     */
    private Long id;

    /**
     * 地图中心点 中心点坐标。
     * 规则：经度和纬度用","分隔 经纬度小数点后不得超过6位。
     */
    private String location;

    /**
     * 地图缩放级别:[1,17]
     */
    private Integer zoom;

    /**
     * 图片宽度*图片高度。最大值为1024*1024
     */
    private String size;

    /**
     *1:返回普通图；
     * 2:调用高清图，图片高度和宽度都增加一倍，zoom也增加一倍（当zoom为最大值时，zoom不再改变）。
     */
    private Integer scale;

    /**
     * 标注
     */
    private String markers;

    /**
     * 折线
     */
    private String paths;


    /**
     * 经纬度集合
     */
    private List<String> localhosts;

}

package com.example.combat.gaodemapUtils.param;

/**
 * @description: 高德地图服务枚举
 * @author:zhucj
 * @date: 2019-08-02 11:25
 */
public class GaodeMapConstant {

    /**
     * 前端返回字段不匹配异常信息
     **/
    public static final String ERR_ORIGIN_PARAM_NULL = "出发点经纬度,不为空!";

    public static final String ERR_CITY_PARAM_NULL = "公交路线规划,传入的城市名称不为空!";


    public static final String ERR_DESTINATION_PARAM_NULL = "目的地经纬度,不为空!";

    public static final String ERR_DIRECTIONTYPE_PARAM_NULL = "传入的规划类型,暂不支持目前只有1,2,3";

    /**
     * 地理请求地址
     */
    public static final String GEOCODE_GEO = "https://restapi.amap.com/v3/geocode/geo";


    /**
     * 逆地理请求地址
     */
    public static final String GEOCODE_REGEO = "https://restapi.amap.com/v3/geocode/regeo";

    /**
     * 步行规划路线请求地址
     */
    public static final String DIRECTION_WALKING =  "https://restapi.amap.com/v3/direction/walking";

    /**
     * 公交规划路线请求地址
     */
    public static final String DIRECTION_INTEGRATED =   "https://restapi.amap.com/v3/direction/transit/integrated";

    /**
     * 驾车路线规划
     */
    public static final String DIRECTION_DRIVING =   "https://restapi.amap.com/v3/direction/driving";

    /**
     * 货车路线规划
     */
    public static final String DIRECTION_TRUCK =  "https://restapi.amap.com/v4/direction/truck";

    /**
     * 距离测量
     */
    public static final String DISTANCE =  "https://restapi.amap.com/v3/distance";

    /**
     * 静态地图
     */
    public static final String STATUC_MAP = "https://restapi.amap.com/v3/staticmap";



    /**
     * 返回状态码 成功
     */
    public static final String SUCCESS = "1";

    /**
     * 返回状态码 失败
     */
    public static final String FAIL= "0";

    /**
     * 返回数据格式
     */
    public static final String JSON = "JSON";

    /**
     * 高德地图key秘钥
     */
    public static final String KEY = "key";
}

package com.example.combat.gaodemapUtils.param;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @description: 地址编码返回参数
 * @author: zhucj
 * @date: 2019-11-25 18:17
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Geocodes {

    private String formatted_address;

    private String country;

    private String province;

    private String city;

    private String citycode;

    private String district;

    private String street;

    private String number;

    private String adcode;

    private String location;

    private String level;
}

#高德地图配置
gaodemap:
  key: ********
  pathImg: E://upload/