package com.xiaopeng.map.service.serviceimpl;
|
|
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.xiaopeng.api.model.operation.XpOpenCity;
|
import com.xiaopeng.api.model.operation.XpRegion;
|
import com.xiaopeng.common.core.constant.CacheConstants;
|
import com.xiaopeng.common.redis.service.RedisService;
|
import com.xiaopeng.map.mapper.XpRegionMapper;
|
import com.xiaopeng.map.service.XpOpenCityService;
|
import com.xiaopeng.map.service.XpRegionService;
|
import com.xiaopeng.map.vo.RegionCascaderVO;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.stereotype.Service;
|
|
import javax.annotation.Resource;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* <p>
|
* 省市区三级联动 服务实现类
|
* </p>
|
*
|
* @author liu
|
* @since 2026-02-03
|
*/
|
@Service
|
public class XpRegionServiceImpl extends ServiceImpl<XpRegionMapper, XpRegion> implements XpRegionService {
|
|
@Resource
|
private RedisService redisService;
|
@Resource
|
private XpOpenCityService openCityService;
|
|
@Override
|
public List<List<XpRegion>> getXpRegion() {
|
|
// 缓存数据
|
List<Object> cacheList = redisService.getCacheList(CacheConstants.XP_REGION);
|
if (cacheList != null && !cacheList.isEmpty()) {
|
try {
|
return cacheList.stream()
|
.filter(obj -> obj instanceof List)
|
.map(obj -> {
|
List<?> list = (List<?>) obj;
|
return list.stream()
|
.filter(item -> item instanceof XpRegion)
|
.map(item -> (XpRegion) item)
|
.collect(Collectors.toList());
|
})
|
.collect(Collectors.toList());
|
} catch (ClassCastException e) {
|
// 缓存数据结构异常，重新加载
|
redisService.deleteObject(CacheConstants.XP_REGION);
|
}
|
}
|
String[] initials = {"A", "B", "C", "D", "E", "F",
|
"G", "H", "I", "J", "K", "L",
|
"M", "N", "O", "P", "Q", "R",
|
"S", "T", "U", "V", "W", "X", "Y", "Z"};
|
List<XpRegion> tRegions = this.baseMapper.selectList(Wrappers.lambdaQuery(XpRegion.class).isNotNull(XpRegion::getInitial));
|
List<List<XpRegion>> result = new ArrayList<>();
|
for (String initial : initials) {
|
List<XpRegion> init = tRegions.stream().filter(e -> e.getInitial().equals(initial) && !e.getCode().contains("0000")).collect(Collectors.toList());
|
result.add(init);
|
}
|
redisService.setCacheList(CacheConstants.XP_REGION, result);
|
return result;
|
}
|
|
@Override
|
public List<RegionCascaderVO> getRegionCascader() {
|
List<Object> cacheList = redisService.getCacheList(CacheConstants.XP_REGION_CASCADER);
|
if (cacheList != null && !cacheList.isEmpty()) {
|
try {
|
return cacheList.stream()
|
.filter(item -> item instanceof RegionCascaderVO)
|
.map(item -> (RegionCascaderVO) item)
|
.collect(Collectors.toList());
|
} catch (ClassCastException e) {
|
redisService.deleteObject(CacheConstants.XP_REGION_CASCADER);
|
}
|
}
|
|
List<XpRegion> regionList = this.baseMapper.selectList(Wrappers.lambdaQuery(XpRegion.class));
|
if (regionList == null || regionList.isEmpty()) {
|
return Collections.emptyList();
|
}
|
|
List<XpOpenCity> openCityList = openCityService.list(Wrappers.lambdaQuery(XpOpenCity.class)
|
.eq(XpOpenCity::getStatus, 1));
|
Set<String> openCityCodeSet = openCityList.stream()
|
.map(XpOpenCity::getCityCode)
|
.filter(StringUtils::isNotBlank)
|
.collect(Collectors.toCollection(HashSet::new));
|
Set<String> openDistrictCodeSet = openCityList.stream()
|
.map(XpOpenCity::getDistrictCode)
|
.filter(StringUtils::isNotBlank)
|
.collect(Collectors.toCollection(HashSet::new));
|
|
Map<Long, List<XpRegion>> childrenMap = regionList.stream()
|
.collect(Collectors.groupingBy(region -> region.getParentId() == null ? 0L : region.getParentId()));
|
List<XpRegion> provinceList = childrenMap.getOrDefault(0L, Collections.emptyList()).stream()
|
.sorted(REGION_COMPARATOR)
|
.collect(Collectors.toList());
|
List<RegionCascaderVO> result = provinceList.stream()
|
.map(region -> buildRegionNode(region, childrenMap, openCityCodeSet, openDistrictCodeSet))
|
.collect(Collectors.toList());
|
|
redisService.setCacheList(CacheConstants.XP_REGION_CASCADER, result);
|
return result;
|
}
|
|
private RegionCascaderVO buildRegionNode(XpRegion current,
|
Map<Long, List<XpRegion>> childrenMap,
|
Set<String> openCityCodeSet,
|
Set<String> openDistrictCodeSet) {
|
List<XpRegion> children = childrenMap.getOrDefault(current.getId(), Collections.emptyList()).stream()
|
.sorted(REGION_COMPARATOR)
|
.collect(Collectors.toList());
|
List<RegionCascaderVO> childNodes = children.stream()
|
.map(child -> buildRegionNode(child, childrenMap, openCityCodeSet, openDistrictCodeSet))
|
.collect(Collectors.toList());
|
|
Integer level = resolveRegionLevel(current.getCode());
|
Integer selfOpen = resolveSelfOpen(level, current.getCode(), openCityCodeSet, openDistrictCodeSet);
|
boolean hasOpenChild = childNodes.stream().anyMatch(node -> Integer.valueOf(1).equals(node.getIsOpen()));
|
|
RegionCascaderVO node = new RegionCascaderVO();
|
node.setCode(current.getCode());
|
node.setName(current.getName());
|
node.setLeaf(Integer.valueOf(3).equals(level));
|
node.setChildren(childNodes);
|
node.setIsOpen(selfOpen == 1 || hasOpenChild ? 1 : 0);
|
return node;
|
}
|
|
private Integer resolveRegionLevel(String code) {
|
if (StringUtils.isBlank(code) || code.length() < 4) {
|
return 3;
|
}
|
if (code.endsWith("0000")) {
|
return 1;
|
}
|
if (code.endsWith("00")) {
|
return 2;
|
}
|
return 3;
|
}
|
|
private Integer resolveSelfOpen(Integer level,
|
String code,
|
Set<String> openCityCodeSet,
|
Set<String> openDistrictCodeSet) {
|
if (StringUtils.isBlank(code)) {
|
return 0;
|
}
|
if (Integer.valueOf(2).equals(level)) {
|
return openCityCodeSet.contains(code) ? 1 : 0;
|
}
|
if (Integer.valueOf(3).equals(level)) {
|
return openDistrictCodeSet.contains(code) ? 1 : 0;
|
}
|
return 0;
|
}
|
|
private static final Comparator<XpRegion> REGION_COMPARATOR = Comparator
|
.comparing((XpRegion region) -> StringUtils.defaultString(region.getInitial()))
|
.thenComparing((XpRegion region) -> StringUtils.defaultString(region.getCode()));
|
|
}
|
