全国省市数据结构从数据库到接口

数据库中存储省市级数据，id和pid的形式

数据库结构

DROP TABLE IF EXISTS `area`;
CREATE TABLE `bfm_area` (
  `AREA_ID` decimal(6,0) NOT NULL COMMENT '区域，网络服务区域，是一种逻辑的划分，通常和行政区域划分重叠',
  `PARENT_ID` decimal(6,0) DEFAULT NULL,
  `AREA_LEVEL` decimal(6,0) DEFAULT NULL,
  `AREA_NAME` varchar(60) NOT NULL,
  `COMMENTS` varchar(255) DEFAULT NULL,
  `AREA_CODE` varchar(60) DEFAULT NULL,
  `SP_ID` decimal(6,0) DEFAULT NULL,
  PRIMARY KEY (`AREA_ID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='区域，网络服务区域，是一种逻辑的划分，通常和行政区域划分重叠\r\n\r\nSEQ:\r\n  T_B';

前端接收数据

[
  {
    value: 'zhejiang',
    label: 'Zhejiang',
    children: [
      {
        value: 'hangzhou',
        label: 'Hangzhou',
        children: [
          {
            value: 'xihu',
            label: 'West Lake',
          },
        ],
      },
    ],
  },
  {
    value: 'jiangsu',
    label: 'Jiangsu',
    children: [
      {
        value: 'nanjing',
        label: 'Nanjing',
        children: [
          {
            value: 'zhonghuamen',
            label: 'Zhong Hua Men',
          },
        ],
      },
    ],
  },
]

数据库数据插入示范

INSERT INTO `bfm_area` VALUES ('1', null, '1', '中国', '国家', '1', '0');
INSERT INTO `bfm_area` VALUES ('11', '1', '2', '北京市', '省份', '11', '0');
INSERT INTO `bfm_area` VALUES ('12', '1', '2', '天津市', '省份', '12', '0');
INSERT INTO `bfm_area` VALUES ('13', '1', '2', '河北省', '省份', '13', '0');
INSERT INTO `bfm_area` VALUES ('14', '1', '2', '山西省', '省份', '14', '0');

实体对象

public class AreaEntity {
    String areaId;
    String parentId;
    String areaLevel;
    String areaName;
    String comments;
    String areaCode;
}

数据转换pojo，将数据库取出的数据进行转换为此对象列表

public class Area {
//行记录id
    String areaId;
    //省市级对象父id
    String parentId;
    //省市级级别
    String areaLevel;
    //省市级名称
    String areaName;
    //省市级对象id
    String areaCode;
    //下属数据
    List<Area> children;
}

执行数据转换的逻辑代码：
这是一种用数据结构解决省市县格式输出的方式，一次性取出所有数据也是为了减少与数据库的io操作。

    public  List<Area> getAreaNode(){
        //先从数据库中取出三级省市区对象
        List<AreaEntity> secondLevel = areaDictMapper.getAreaByLevel("2");
        List<AreaEntity> thirdLevel = areaDictMapper.getAreaByLevel("3");
        List<AreaEntity> forthLevel = areaDictMapper.getAreaByLevel("4");
        //总体思路，遍历顺序县-市-省，向上插入
        //以父id为key，子链表为value构造map集合
        
        //存放数据结构  三级节点，和每级节点对应的list集合
        Map<String,List<Area>> forthMap = new HashMap<>();
        for(AreaEntity areaEntity:forthLevel){
            String parentId = areaEntity.getParentId();
            Area area = new Area();
            //为了将从数据库中取出的数据转换为前端需要的数据格式
            BeanUtils.copyProperties(areaEntity,area);
            //如果不存在，就为此父节点new一个子链表
            if(!forthMap.containsKey(parentId)){
                List<Area> forthList = new ArrayList<>();
                forthMap.put(areaEntity.getParentId(),forthList);
            }
            List<Area> current = forthMap.get(parentId);
            current.add(area);
        }

        Map<String,List<Area>> thirdMap = new HashMap<>();
        for(AreaEntity areaEntity:thirdLevel){
            String parentId = areaEntity.getParentId();
            Area area = new Area();
            //1 三级结构，如果此父code有子链表，则子必在forthMap中，直接取出放在父节点的children中
            if(forthMap.containsKey(areaEntity.getAreaCode())){
                area.setChildren(forthMap.get(areaEntity.getAreaCode()));
            }
            BeanUtils.copyProperties(areaEntity,area);
            //2 如果此节点是第一次添加进map集合，先new一个
            if(!thirdMap.containsKey(parentId)){
                List<Area> thirdList = new ArrayList<>();
                thirdMap.put(parentId,thirdList);
            }
            List<Area> current = thirdMap.get(parentId);
            current.add(area);
        }

        List<Area> secondList = new ArrayList<>();
        for(AreaEntity areaEntity:secondLevel){
            String areaCode = areaEntity.getAreaCode();
            Area area = new Area();
            BeanUtils.copyProperties(areaEntity,area);
            if(thirdMap.containsKey(areaEntity.getAreaCode())){
                area.setChildren(thirdMap.get(areaCode));
            }
            secondList.add(area);
        }
        return secondList;
    }

下面介绍一种之前用的使用递归方式生成省市县数据格式的方式：缺点是io频繁

javaNode对象

public class DomResTypeNode {
    DomResType data;
    List<DomResTypeNode> childList;
    public DomResTypeNode(DomResType data) {
        this.data = data;
        this.childList = new ArrayList<DomResTypeNode>();
    }
    public DomResTypeNode(DomResType data, List<DomResTypeNode> childList) {
        this.data = data;
        this.childList = childList;
    }
}

javaBean对象

public class DomResType {
    Integer domId;
    Integer id;
    String description;
    Integer pId;
    String name;
    Integer status;
}

        //先new一个初始节点，用此节点的id等于要查询的父节点往下查询
        DomResType DomResTypeRoot = new DomResType();

    public DomResTypeNode createDomResTypeTree(DomResTypeNode domResTypeNode) {
        int domId = domResTypeNode.getData().getDomId();
        int resTypeId = domResTypeNode.getData().getId();
        //找到子节点的资源属主
        //看看谁的pid等于当前的id，谁就是当前节点的子节点
        List<DomResType> child = domResTypeMapper.getDomResTypesByPid(domId,resTypeId);
        //将子节点加入节点中
        for(DomResType domResType : child){
            DomResTypeNode domResTypeNode1 = new DomResTypeNode(domResType);
            domResTypeNode.getChildList().add(domResTypeNode1);
        }
        //递归遍历子节点，让每个子节点递归生成子树
        for(DomResTypeNode domResTypeNode1 : domResTypeNode.getChildList()){
            if(domResTypeNode1.getData() != null){
                createDomResTypeTree(domResTypeNode1);
            }
        }
        return domResTypeNode;
    }