JAVA实现联动县市区街道API

2022-07-05

JAVA实现联动县市区街道API

申请API权限（腾讯位置服务）

新建应用，申请KEY

控制层

import com.folkspace.market.api.map.service.MapService;
import com.folkspace.market.common.config.ServerResponse;
import com.folkspace.market.config.annotation.DisableToken;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 行政区划 服务API
 * @date 2022/7/5 10:45 AM
 */
@RestController
@ApiOperation(value = "地图服务 API")
@RequestMapping("/map")
public class MapController {

    @Autowired private MapService mapService;

    @DisableToken
    @PostMapping("/getAll")
    @ApiOperation(value = "获取省市区列表")
    public ServerResponse getAllList() {
        return mapService.getAllList();
    }

    @DisableToken
    @PostMapping("/getProvince")
    @ApiOperation(value = "获取省份列表")
    public ServerResponse getProvinceList() {
        return mapService.getProvinceList();
    }

    @DisableToken
    @PostMapping("/getCity/{provinceId}")
    @ApiOperation(value = "获取省份对应的市列表")
    public ServerResponse getCityListByProvinceId(@PathVariable Integer provinceId) {
        return mapService.getCityListByProvinceId(provinceId);
    }

    @DisableToken
    @PostMapping("/getArea/{cityId}")
    @ApiOperation(value = "获取市对应的县/区列表")
    public ServerResponse getAreaListByCityId(@PathVariable Integer cityId) {
        return mapService.getAreaListByCityId(cityId);
    }

    @DisableToken
    @PostMapping("/getRow/{areaId}")
    @ApiOperation(value = "获取市对应的乡镇/街道列表")
    public ServerResponse getRowListByAreaId(@PathVariable Integer areaId) {
        return mapService.getRowListByAreaId(areaId);
    }
  
    @DisableToken
    @PostMapping("/verifyMapNameValid/{mapName}")
    @ApiOperation(value = "验证行政区划输入合法性")
    public void verifyMapNameValid(@PathVariable("mapName") String mapName) {
        mapService.verifyMapNameValid(mapName);
    }

    @DisableToken
    @PostMapping("/geocoder/{addressDetails}")
    @ApiOperation(value = "地址解析")
    public ServerResponse geocoderAddressDetails(
            @PathVariable("addressDetails") String addressDetails) {
        return mapService.geocoderAddressDetails(addressDetails);
    }
  
    @DisableToken
    @PostMapping("/place/suggestion")
    @ApiOperation(value = "地址输入提示")
    public ServerResponse placeSuggestion(@Valid GetPlaceSuggestionReq getPlaceSuggestionReq) {
        return mapService.placeSuggestion(getPlaceSuggestionReq);
    }
}

常量层

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 曳戈泰尔
 * @date 2022/7/5 10:50 AM
 */
public class MapConstant {

    /** 调用高德 KEY */
    public static final String KEY = "xxxxxxx";

    /** 调用腾讯KEY */
    public static final String TENCENT_KEY = "xxxxxxx";

    /** 高德请求API */
    public static final String URL = "https://restapi.amap.com/v3/config/district";

    /** 腾讯请求API */
    public static final String TENCENT_PARENT_URL = "https://apis.map.qq.com/ws/district/v1/list";
    public static final String TENCENT_CHILDREN_URL =
            "https://apis.map.qq.com/ws/district/v1/getchildren";
		public static final String TENCENT_SEARCH_URL = "https://apis.map.qq.com/ws/district/v1/search";
    // 地址解析
    public static final String TENCENT_GEOCODER_URL = "https://apis.map.qq.com/ws/geocoder/v1";
		// 地址输入提示
    public static final String TENCENT_PLACE_SUGGESTION_URL =
            "https://apis.map.qq.com/ws/place/v1/suggestion";
}

服务层

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.aliyun.oss.common.utils.HttpUtil;
import com.folkspace.market.api.map.model.resp.GetAreaResp;
import com.folkspace.market.api.map.model.resp.GetCityResp;
import com.folkspace.market.api.map.model.resp.GetProvinceResp;
import com.folkspace.market.api.map.model.resp.GetRowResp;
import com.folkspace.market.common.config.ServerResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static com.folkspace.market.api.map.constant.MapConstant.*;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 曳戈泰尔
 * @date 2022/7/5 10:56 AM
 */
@Service
@Slf4j
public class MapService {

    public ServerResponse getAllList() {

        /** 拼接请求参数 */
        Map<String, String> map = new HashMap<>();
        map.put("key", TENCENT_KEY);
        String params = HttpUtil.paramToQueryString(map, "utf-8");

        String requestUrl = TENCENT_PARENT_URL + "?" + params;
        // log.info("请求字符串：{}", requestUrl);

        /** 发起请求 */
        String result = cn.hutool.http.HttpUtil.get(requestUrl);
        // log.info("请求结果：{}", result);

        /** 请求成功与否 */
        JSONObject jsonObject = JSONObject.parseObject(result);
        if (jsonObject.getInteger("status") != 0) {
            log.error("获取省市区列表数据失败");
            return ServerResponse.getInstance().failed().data(new ArrayList());
        }

        /** 本接口用于获取全部省市区三级行政区划 */
        JSONArray jsonArr = jsonObject.getJSONArray("result");

        return ServerResponse.getInstance().ok().data(jsonArr);
    }

    public ServerResponse getProvinceList() {

        /** 返回数据列表 */
        List<GetProvinceResp> getProvinceRespList = new ArrayList<>();

        /** 拼接请求参数 */
        Map<String, String> map = new HashMap<>();
        map.put("key", TENCENT_KEY);
        String params = HttpUtil.paramToQueryString(map, "utf-8");

        String requestUrl = TENCENT_CHILDREN_URL + "?" + params;

        /** 发起请求 */
        String result = cn.hutool.http.HttpUtil.get(requestUrl);

        /** 请求成功与否 */
        JSONObject jsonObject = JSONObject.parseObject(result);
        if (jsonObject.getInteger("status") != 0) {
            log.error("获取市列表数据失败");
            return ServerResponse.getInstance().failed().data(getProvinceRespList);
        }

        /** 获取省一级信息 */
        JSONArray jsonArr = jsonObject.getJSONArray("result");
        JSONArray provinceArr = (JSONArray) jsonArr.get(0);

        /** 遍历提取所需参数 */
        for (int i = 0; i < provinceArr.size(); i++) {
            JSONObject temp = (JSONObject) provinceArr.get(i);

            GetProvinceResp getProvinceResp =
                    GetProvinceResp.builder()
                            .provinceId(temp.getInteger("id"))
                            .name(temp.getString("name"))
                            .fullName(temp.getString("fullname"))
                            .build();

            getProvinceRespList.add(getProvinceResp);
        }

        return ServerResponse.getInstance().ok().data(getProvinceRespList);
    }

    public ServerResponse getCityListByProvinceId(Integer provinceId) {

        /** 返回数据列表 */
        List<GetCityResp> getCityRespList = new ArrayList<>();

        /** 拼接请求参数 */
        Map<String, String> map = new HashMap<>();
        map.put("key", TENCENT_KEY);
        map.put("id", String.valueOf(provinceId));
        String params = HttpUtil.paramToQueryString(map, "utf-8");

        String requestUrl = TENCENT_CHILDREN_URL + "?" + params;

        /** 发起请求 */
        String result = cn.hutool.http.HttpUtil.get(requestUrl);

        /** 请求成功与否 */
        JSONObject jsonObject = JSONObject.parseObject(result);
        if (jsonObject.getInteger("status") != 0) {
            log.error("获取市列表数据失败");
            return ServerResponse.getInstance().failed().data(getCityRespList);
        }

        /** 获取市一级数据 */
        JSONArray jsonArr = jsonObject.getJSONArray("result");
        JSONArray cityArr = (JSONArray) jsonArr.get(0);

        /** 遍历提取所需参数 */
        for (int i = 0; i < cityArr.size(); i++) {
            JSONObject temp = (JSONObject) cityArr.get(i);

            GetCityResp getCityResp =
                    GetCityResp.builder()
                            .cityId(temp.getInteger("id"))
                            .name(temp.getString("name"))
                            .fullName(temp.getString("fullname"))
                            .build();

            getCityRespList.add(getCityResp);
        }

        return ServerResponse.getInstance().ok().data(getCityRespList);
    }

    public ServerResponse getAreaListByCityId(Integer cityId) {

        /** 返回数据列表 */
        List<GetAreaResp> getAreaRespList = new ArrayList<>();

        /** 拼接请求参数 */
        Map<String, String> map = new HashMap<>();
        map.put("key", TENCENT_KEY);
        map.put("id", String.valueOf(cityId));
        String params = HttpUtil.paramToQueryString(map, "utf-8");

        String requestUrl = TENCENT_CHILDREN_URL + "?" + params;

        /** 发起请求 */
        String result = cn.hutool.http.HttpUtil.get(requestUrl);

        /** 请求成功与否 */
        JSONObject jsonObject = JSONObject.parseObject(result);
        if (jsonObject.getInteger("status") != 0) {
            log.error("获取市列表数据失败");
            return ServerResponse.getInstance().failed().data(getAreaRespList);
        }

        /** 获取县/区一级数据 */
        JSONArray jsonArr = jsonObject.getJSONArray("result");
        JSONArray areaArr = (JSONArray) jsonArr.get(0);

        /** 遍历提取所需参数 */
        for (int i = 0; i < areaArr.size(); i++) {
            JSONObject temp = (JSONObject) areaArr.get(i);

            GetAreaResp getAreaResp =
                    GetAreaResp.builder()
                            .areaId(temp.getInteger("id"))
                            .fullName(temp.getString("fullname"))
                            .build();

            getAreaRespList.add(getAreaResp);
        }

        return ServerResponse.getInstance().ok().data(getAreaRespList);
    }

    public ServerResponse getRowListByAreaId(Integer areaId) {

        /** 返回数据列表 */
        List<GetRowResp> getRowRespList = new ArrayList<>();

        /** 拼接请求参数 */
        Map<String, String> map = new HashMap<>();
        map.put("key", TENCENT_KEY);
        map.put("id", String.valueOf(areaId));
        String params = HttpUtil.paramToQueryString(map, "utf-8");

        String requestUrl = TENCENT_CHILDREN_URL + "?" + params;

        /** 发起请求 */
        String result = cn.hutool.http.HttpUtil.get(requestUrl);

        /** 请求成功与否 */
        JSONObject jsonObject = JSONObject.parseObject(result);
        if (jsonObject.getInteger("status") != 0) {
            log.error("获取市列表数据失败");
            return ServerResponse.getInstance().failed().data(getRowRespList);
        }

        /** 获取乡镇/街道一级数据 */
        JSONArray jsonArr = jsonObject.getJSONArray("result");
        JSONArray rowArr = (JSONArray) jsonArr.get(0);

        /** 遍历提取所需参数 */
        for (int i = 0; i < rowArr.size(); i++) {
            JSONObject temp = (JSONObject) rowArr.get(i);

            GetRowResp getRowResp =
                    GetRowResp.builder()
                            .rowId(temp.getInteger("id"))
                            .fullName(temp.getString("fullname"))
                            .build();

            getRowRespList.add(getRowResp);
        }

        return ServerResponse.getInstance().ok().data(getRowRespList);
    }
  
    public boolean verifyMapNameValid(String mapName) {

        /** 拼接请求参数 */
        Map<String, String> map = new HashMap<>();
        map.put("key", TENCENT_KEY);
        map.put("keyword", mapName);
        String params = HttpUtil.paramToQueryString(map, "utf-8");

        String requestUrl = TENCENT_SEARCH_URL + "?" + params;

        /** 发起请求 */
        String result = cn.hutool.http.HttpUtil.get(requestUrl);

        /** 请求成功与否 */
        JSONObject jsonObject = JSONObject.parseObject(result);
        if (jsonObject.getInteger("status") != 0) {
            log.error("输入行政区划名不合法：{}", mapName);
            return false;
        }

        /** 获取搜素结果 */
        JSONArray jsonArr = jsonObject.getJSONArray("result");
        if (jsonArr.size() == 0) {
            log.error("输入行政区划名不合法：{}", mapName);
            return false;
        }

        return true;
    }
  

    /**
     * 地址解析
     *
     * @param addressDetails
     * @return
     */
    public ServerResponse geocoderAddressDetails(String addressDetails) {

        /** 拼接请求参数 */
        Map<String, String> map = new HashMap<>();
        map.put("key", TENCENT_KEY);
        map.put("address", addressDetails);
        String params = HttpUtil.paramToQueryString(map, "utf-8");

        String requestUrl = TENCENT_GEOCODER_URL + "?" + params;

        /** 发起请求 */
        String result = cn.hutool.http.HttpUtil.get(requestUrl);

        // 构造返回结果
        GetStreetResp getStreetResp = GetStreetResp.builder().build();

        /** 请求成功与否 */
        JSONObject jsonObject = JSONObject.parseObject(result);
        if (jsonObject.getInteger("status") != 0) {
            log.error("地址解析错误：{}", addressDetails);
            return ServerResponse.getInstance().failed().data(getStreetResp);
        }

        /** 获取地址解析结果 */
        JSONObject jsonResult = jsonObject.getJSONObject("result");
        if (jsonResult == null) {
            log.error("地址解析错误：{}", addressDetails);
            return ServerResponse.getInstance().failed().data(getStreetResp);
        }

        // 获取街道数据
        JSONObject jsonComponents = jsonResult.getJSONObject("address_components");
        String street = jsonComponents.getString("street");
        getStreetResp.setStreet(street);

        // 返回数据
        return ServerResponse.getInstance().ok().data(getStreetResp);
    }
  
    /**
     * 地址输入提示
     *
     * @param getPlaceSuggestionReq
     * @return
     */
    public ServerResponse placeSuggestion(GetPlaceSuggestionReq getPlaceSuggestionReq) {

        /** 返回数据列表 */
        List<GetPlaceSuggestionResp> getPlaceSuggestionRespList = new ArrayList<>();

        /** 拼接请求参数 */
        Map<String, String> map = new HashMap<>();
        map.put("key", TENCENT_KEY);
        map.put("keyword", getPlaceSuggestionReq.getKeyword());
        map.put("region", getPlaceSuggestionReq.getRegion());
        map.put("page_index", String.valueOf(getPlaceSuggestionReq.getPageNum()));
        map.put("page_size", String.valueOf(getPlaceSuggestionReq.getPageSize()));
        String params = HttpUtil.paramToQueryString(map, "utf-8");

        String requestUrl = TENCENT_PLACE_SUGGESTION_URL + "?" + params;

        /** 发起请求 */
        String result = cn.hutool.http.HttpUtil.get(requestUrl);

        /** 请求成功与否 */
        JSONObject jsonObject = JSONObject.parseObject(result);
        if (jsonObject.getInteger("status") != 0) {
            log.error("获取关键词输入提示列表数据失败");
            return ServerResponse.getInstance().ok().data(getPlaceSuggestionRespList);
        }

        /** 获取乡镇/街道一级数据 */
        JSONArray jsonArr = jsonObject.getJSONArray("data");
        if (jsonArr.size() <= 0) {
            return ServerResponse.getInstance().ok().data(getPlaceSuggestionRespList);
        }

        /** 遍历提取所需参数 */
        for (int i = 0; i < jsonArr.size(); i++) {
            JSONObject temp = (JSONObject) jsonArr.get(i);

            // 处理街道数据
            String rowName = null;
            if (temp.getString("district") != null) {
                int index =
                        temp.getString("address").indexOf(temp.getString("district"))
                                + temp.getString("district").length();
                if (index < temp.getString("address").length()) {
                    rowName = temp.getString("address").substring(index);
                }
            } else {
                int index =
                        temp.getString("address").indexOf(temp.getString("city"))
                                + temp.getString("city").length();
                if (index < temp.getString("address").length()) {
                    rowName = temp.getString("address").substring(index);
                }
            }

            GetPlaceSuggestionResp getPlaceSuggestionResp =
                    GetPlaceSuggestionResp.builder()
                            .provinceName(temp.getString("province"))
                            .cityName(temp.getString("city"))
                            .areaName(temp.getString("district"))
                            .rowName(rowName)
                            .address(temp.getString("address"))
                            .title(temp.getString("title"))
                            .build();

            getPlaceSuggestionRespList.add(getPlaceSuggestionResp);
        }

        // 构造 页 返回数据
        DataResponse dataResponse = new DataResponse();
        dataResponse.setPageNum(getPlaceSuggestionReq.getPageNum());
        dataResponse.setPageSize(getPlaceSuggestionReq.getPageSize());
        dataResponse.setTotal(jsonObject.getInteger("count"));
        dataResponse.setData(getPlaceSuggestionRespList);

        return ServerResponse.getInstance().ok().data(dataResponse);
    }
}

实体层

import lombok.Builder;
import lombok.Data;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 曳戈泰尔
 * @date 2022/7/5 11:29 AM
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GetProvinceResp {

    private Integer provinceId;
    private String name;
    private String fullName;
}

import lombok.Builder;
import lombok.Data;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 曳戈泰尔
 * @date 2022/7/5 11:29 AM
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GetCityResp {

    private Integer cityId;
    private String name;
    private String fullName;
}

import lombok.Builder;
import lombok.Data;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 曳戈泰尔
 * @date 2022/7/5 11:29 AM
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GetAreaResp {

    private Integer areaId;
    private String fullName;
}

import lombok.Builder;
import lombok.Data;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 曳戈泰尔
 * @date 2022/7/5 11:29 AM
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GetRowResp {

    private Integer rowId;
    private String fullName;
}

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

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 曳戈泰尔
 * @date 2022/7/5 11:29 AM
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GetStreetResp {

    private String street;
}

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

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 曳戈泰尔
 * @date 2022/7/5 11:29 AM
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GetPlaceSuggestionResp {

    private String provinceName;
    private String cityName;
    private String areaName;
    private String rowName;

    private String title;
    private String address;

    private Integer total;
}

import com.folkspace.market.common.config.PageConfig;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;

/**
 * @author 曳戈泰尔
 * @version 1.0
 * @description 曳戈泰尔
 * @date 2022/7/5 11:29 AM
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GetPlaceSuggestionReq {

    /** 城市 */
    private String region;

    /** 关键词 */
    private String keyword;

    @NotNull(message = "pageNum不能为空")
    @Min(value = 1, message = "页数从1开始")
    Integer pageNum = PageConfig.pageNum;

    @NotNull(message = "pageSize不能为空")
    @Min(value = 1, message = "每页最少包含1项")
    @Max(value = 100, message = "超出每页最大限制")
    Integer pageSize = PageConfig.pageSize;
}

/**
 * @description 返回结果的页面设置
 */
public class PageConfig {
    public static final Integer pageNum = 1;
    public static final Integer pageSize = 20;

    public static final Integer max_page_num = 100;
    public static final Integer max_page_size = 100;

    public static final Integer min_page_num = 1;
    public static final Integer min_page_size = 1;
}