Java Springboot操作Neo4j排序

Java Springboot操作Neo4j 精选

功能：
1.在Neo4j中有些节点之间存在类上下级的关系，将这些存在类上下级关系的节点排列成树状图
2.根据Neo4j中节点的某些值对节点进行排序

说明：功能1实现效果还需优化，如果有看到这篇文章并且有优化方法的朋友，还请分享一下优化思路

工具类：

package net.pushi.neo4jdata.util;

import net.pushi.neo4jdata.publicModule.dao.MapMapper;
import org.neo4j.driver.internal.InternalPath;
import org.neo4j.driver.v1.types.Node;
import org.neo4j.driver.v1.types.Relationship;
import org.neo4j.ogm.model.Property;
import org.neo4j.ogm.model.Result;
import org.neo4j.ogm.response.model.NodeModel;
import org.neo4j.ogm.response.model.RelationshipModel;
import org.neo4j.ogm.session.Session;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.math.BigDecimal;
import java.util.*;

@Component
public class DatabaseUtil {

    @Autowired
    private MapMapper Mysql;

    @Autowired
    private Session session;

    private static DatabaseUtil databaseUtil;


    @PostConstruct
    public void init() {
        databaseUtil = this;
        databaseUtil.Mysql = this.Mysql;
        databaseUtil.session = this.session;
    }


    /**
     * 将数据库语言  ？ 替换为 值
     *
     * @param sql   参数 为？ 的语句
     * @param param 正常值
     * @return
     */
    public static String getDatabaseLanguage(String sql, Object... param) {
        String newSql = sql;
        for (Object obj : param) {
            if (obj instanceof String) {
                String str = (String) obj;
                str = str.replace("\"", "\\\"");
                if (str.contains("\'")) {
                    newSql = newSql.replaceFirst("\\?", "\"" + str + "\"");
                } else {
                    if (str.contains("!")) {
                        newSql = newSql.replaceFirst("\\?", str);
                    } else {
                        newSql = newSql.replaceFirst("\\?", "\'" + str + "\'");
                    }
                }
            } else {
                newSql = newSql.replaceFirst("\\?", obj.toString());
            }

        }
        return newSql;
    }

    /**
     * 连接mysql数据库  返回多个map 查询结果
     *
     * @param sql
     * @param param
     * @return
     */
    public static List<Map<String, Object>> mySqlList(String sql, Object... param) {
        return databaseUtil.Mysql.sqlList(getDatabaseLanguage(sql, param));
    }

    /**
     * 连接mysql数据库  返回单个map 查询结果
     *
     * @param sql
     * @param param
     * @return
     */
    public static Map<String, Object> mySqlMap(String sql, Object... param) {
        return databaseUtil.Mysql.sqlMap(getDatabaseLanguage(sql, param));
    }

    /**
     * 连接mysql数据库   返回为数据类型的结构    一般用增删改  查询为聚合函数的
     *
     * @param sql
     * @param param
     * @return
     */
    public static Long mySqlExecute(String sql, Object... param) {
        return databaseUtil.Mysql.sqlExec(getDatabaseLanguage(sql, param));
    }

    //比较器(从大到小排序)
    public static List<Map<String, Object>> listComparator(List<Map<String, Object>> mapList, String string){
        Collections.sort(mapList, new Comparator<Map<String, Object>>() {
            @Override
            public int compare(Map<String, Object> o1, Map<String, Object> o2) {
                return new BigDecimal(o2.get(string).toString()).compareTo(new BigDecimal(o1.get(string).toString()));
            }
        });
        return mapList;
    }

    //关系模型===》Map
    public static List<Map<String, Object>> relationToMap(String string){
        Set<Map<String, Object>> relationships = new HashSet<>();
        Result resultRelations = DatabaseUtil.neo4jExecute(string);
        ArrayList<LinkedHashMap<String, ArrayList<RelationshipModel>>> listRelations = (ArrayList)resultRelations.queryResults();
        for (LinkedHashMap<String, ArrayList<RelationshipModel>> linkedHashMap:listRelations){
            for (ArrayList<RelationshipModel> value:linkedHashMap.values()){
                for (RelationshipModel relationshipModel:value){
                    relationships.add(DatabaseUtil.setPropertyRelationshipModel(relationshipModel));
                }
            }
        }
        return new ArrayList<>(relationships);
    }

    //节点模型===》Map
    public static List<Map<String, Object>> nodeToMap(String string){
        Set<Map<String, Object>> nodes = new HashSet<>();
        Result resultNode = DatabaseUtil.neo4jExecute(string);
        ArrayList<LinkedHashMap<String, NodeModel>> listNodes = (ArrayList)resultNode.queryResults();
        for (LinkedHashMap<String,NodeModel> linkedHashMap:listNodes){
            for (NodeModel value:linkedHashMap.values()){
                nodes.add(DatabaseUtil.setPropertyNodeModel(value));
            }
        }
        return new ArrayList<>(nodes);
    }

    //节点or关系模型设置属性
    public static Map<String, Object> setPropertyList(List<Property<String, Object>> propertyList, Map<String, Object> map){
        for (Property<String, Object> property:propertyList){
            map.put(property.getKey(),property.getValue());
        }
        return map;
    }

    //关系模型转换map
    public static Map<String, Object> setPropertyRelationshipModel(RelationshipModel relationshipModel){
        Map<String, Object> relationshipModelMap = new HashMap<>();
        relationshipModelMap.put("id",relationshipModel.getId());
        relationshipModelMap.put("type",relationshipModel.getType());
        relationshipModelMap.put("startNodeId",relationshipModel.getStartNode());
        relationshipModelMap.put("endNodeId",relationshipModel.getEndNode());
        setPropertyList(relationshipModel.getPropertyList(),relationshipModelMap);
        return relationshipModelMap;
    }

    //节点模型转换map
    public static Map<String,Object> setPropertyNodeModel(NodeModel nodeModel){
        Map<String, Object> nodeModelMap = new HashMap<>();
        nodeModelMap.put("id",nodeModel.getId());
        nodeModelMap.put("labels",nodeModel.getLabels());
        setPropertyList(nodeModel.getPropertyList(),nodeModelMap);
        return nodeModelMap;
    }

    /*定位结构体系图中点坐标
    * x:结构体系图的x轴长
    * y:结构体系图每级节点的y轴间距
    * listResult:neo4j数据集
    * originIds:起始级节点集id
    * maxLength:结构图的级数(原点集中最长路径)
    * sign:递归结束的标记
    * nodesSet:返回的结果集
    * addSum:新增节点数
    * */
    public static Set<Map<String, Object>> locationPoint(double x, double y,ArrayList<LinkedHashMap<String, InternalPath>> allListResult,Set<Long> originIds,long maxLength,long sign,Set<Map<String, Object>> nodesSet,Set<Node> nodeSet){
        Set<Relationship> relationships1 = new HashSet<>();//起始级关系集
        Set<Long> nextNodeIds = new HashSet<>();//下级节点集id
        Set<Node> nextNodes =  new HashSet<>();//下级节点集
        for (LinkedHashMap<String, InternalPath> linkedHashMap : allListResult){
             for (InternalPath value : linkedHashMap.values()){
                  Iterable<Relationship> relationships = value.relationships();//关系集
                for (Relationship relationship:relationships){
                     for (Long originId:originIds){
                          Long startNodeId = relationship.startNodeId();
                        if (originId.longValue() == startNodeId.longValue()){
                            relationships1.add(relationship);//第一级关系
                            Long secondNodeId = relationship.endNodeId();//下一级节点id
                            nextNodeIds.add(secondNodeId);//下一级节点集id
                            Iterable<Node> secondNodesOld = value.nodes();
                            for (Node secondNode:secondNodesOld){
                                 Long secondNodeId1 = secondNode.id();
                                if (originId.longValue() != secondNodeId1.longValue()){
                                    List nodesIdList = new ArrayList();
                                    for (Map<String, Object> map : nodesSet){
                                        nodesIdList.add(map.get("id"));
                                    }
                                    if (!nodesIdList.contains(secondNodeId1)){
                                        nextNodes.add(secondNode);
                                    }
                                }
                            }
                        }
                     }
                }
             }
        }
        nodeSet.removeAll(nextNodes);
        int sum = nextNodes.size();
        double spacing = Math.round(x/(sum+1));//等额间距
        double x1 = spacing;
        double y1 = y + (sign*100);
        for (Node node:nextNodes){
             if (!originIds.contains(node.id())){
                Map<String,Object> asMap = node.asMap();
                nodesSet.add(setProperty(setPosition(node,x1,y1),asMap));
                x1 = x1 + spacing;
             }
        }
        sign++;
        if (sign < maxLength){
            return locationPoint(x,y,allListResult,nextNodeIds,maxLength,sign,nodesSet,nodeSet);
        }else {
            int sum1 = nodeSet.size();
            double spacing1;
            if (sum1 > 10){
                spacing1 = Math.round(x/10);//等额间距
            }else {
                spacing1 = Math.round(x/(sum1+1));//等额间距
            }
            double x2 = spacing1;
            double y2 = y1 + 100;
            int i = 0;
            for(Node node1 : nodeSet){
                Map<String, Object> asMap = node1.asMap();
                nodesSet.add(setProperty(setPosition(node1,x2,y2),asMap));
                x2 = x2 + spacing1;
                i++;
                if (i%9 == 0){
                    y2 = y2 + 100;
                    x2 = spacing1;
                }
            }
            return nodesSet;
        }
    }

    //给节点设置坐标(x,y)
    public static Map<String, Object> setPosition(Node node, double x, double y){
        Map<String, Object> nodeMap = new HashMap<>();
        nodeMap.putAll(setBasePropertyNode(node));
        nodeMap.put("x",x);
        nodeMap.put("y",y);
        return nodeMap;
    }

    //将节点和关系的property转成map
    public static Map<String, Object> setProperty(Map<String, Object> newMap,Map<String, Object> oldMap){
        for (Map.Entry<String, Object> entry : oldMap.entrySet()){
            newMap.put(entry.getKey(),entry.getValue());
        }
        return newMap;
    }

    //设置节点基本属性
    public static Map<String, Object> setBasePropertyNode(Node node){
        Map<String, Object> nodeMap = new HashMap<>();
        nodeMap.put("id", node.id());
        List<String> labels = (List<String>) node.labels();
        nodeMap.put("labels", labels);
        return nodeMap;
    }

    //设置关系基本属性
    public static Map<String,Object> setBasePropertyRelation(Relationship relationship){
        Map<String, Object> relationshipMap = new HashMap<>();
        relationshipMap.put("startNodeId", relationship.startNodeId());
        relationshipMap.put("endNodeId", relationship.endNodeId());
        relationshipMap.put("type", relationship.type());
        relationshipMap.put("id", relationship.id());
        return relationshipMap;
    }

    //深度查询方法
    public static Map<String, Object> deepQuery(String string){
        Set<Map<String, Object>> nodeList = new HashSet<>();
        Set<Map<String, Object>> relationshipList = new HashSet<>();
        Map<String, Object> relation = new HashMap<>();
        Result result = DatabaseUtil.neo4jExecute(string);
        Iterable<Map<String, Object>> it = result.queryResults();
        for (Map<String, Object> data : it){
            for (Map.Entry<String, Object> entry : data.entrySet()){
                Object object = entry.getValue();
                if (object instanceof InternalPath){
                    InternalPath IP = (InternalPath) object;
                    //节点
                    Iterable<Node> nodes = IP.nodes();
                    for (Node node : nodes){
                        Map<String, Object> asMap = node.asMap();
                        nodeList.add(setProperty(setBasePropertyNode(node),asMap));
                    }
                    //关系
                    Iterable<Relationship> relationships = IP.relationships();
                    for (Relationship relationship : relationships){
                        Map<String, Object> asMap = relationship.asMap();
                        relationshipList.add(setProperty(setBasePropertyRelation(relationship),asMap));
                    }
                }
            }
        }
        relation.put("nodes",nodeList);
        relation.put("relationships",relationshipList);
        return relation;
    }

    //批量操作neo4j
    public static Result neo4jExecutes(String cypher, List list) {
        Map<String, Object> map = new HashMap<>();
        map.put("list", list);
        return databaseUtil.session.query(cypher, map);
    }

    /**
     * 执行noe4j时 通用方法（增删改查都可以）
     *
     * @param cypher
     * @return
     * @throws Exception
     */
    public static Result neo4jExecute(String cypher) {
        return neo4jExecute(cypher, null);
    }

    /**
     * 执行noe4j时 通用方法 如果map不为空  cypher值要包含  UNWIND {list}
     *
     * @param cypher
     * @param map
     * @return
     * @throws Exception
     */
    public static Result neo4jExecute(String cypher, Map<String, Object> map) {
        Map<String, Object> condition = new HashMap<>();
        if (map != null && map.size() > 0) {
            List list = new ArrayList<Map>();
            list.add(map);
            condition.put("list", list);
        }
        return databaseUtil.session.query(cypher, condition);
    }

    /**
     * 将Result 遍历  转为listMap
     *
     * @param r
     * @return
     */
    public static List<Map<String, Object>> turnListMap(Result r) {
        List<Map<String, Object>> mapList = new ArrayList<>();
        if (r != null) {
            Iterable<Map<String, Object>> it = r.queryResults();
            for (Map<String, Object> data : it) {
                for (String key : data.keySet()) {
                    Object obj = data.get(key);
                    if (obj instanceof NodeModel) {
                        NodeModel nm = (NodeModel) obj;
                        Map<String, Object> map = new HashMap<>();
                        map.put("编号", nm.getId().toString());
                        map.put("类型", nm.getLabels());//getLabels 是一个String 数组 节点标签
                        //在es导入的时候遇到 中焦 这个海岛，他有类型这个节点属性  与这里代表的标签类型冲突 所以在下面建立一个标签类型
                        //后面修改 所有取节点标签类型
                        map.put("节点标签类型", nm.getLabels());
                        List<Property<String, Object>> propertyList = nm.getPropertyList();
                        for (Property<String, Object> property : propertyList) {
                            String propertyName = property.getKey();
                            Object propertyValue = property.getValue();
                            map.put(propertyName, propertyValue);
                        }
                        mapList.add(map);
                    }
                }
            }
        }
        return mapList;
    }

    /**
     * 将Result 遍历  转为Map
     *
     * @param r
     * @return
     */
    public static Map<String, Object> turnMap(Result r) {
        List<Map<String, Object>> mapList = turnListMap(r);
        if (mapList != null && mapList.size() > 0) {
            return mapList.get(0);
        }
        return null;
    }

    /**
     * 将Result 遍历 (含关系 p)  转为map
     * @param r
     * @return
     */
    public static Map<String, Object> turnByPMap(Result r) {
        Map<String,Object> retMap=new HashMap<>();
        Set<Map<String, Object>> nodeList = new HashSet<>();
        Set<Map<String, Object>> relationshipList = new HashSet<>();
        Iterable<Map<String, Object>> it = r.queryResults();
        for (Map<String, Object> data : it) {//返回值条数   多少条数据
            for (String key : data.keySet()) {//返回值的个数  比如返回p   就一个key p  比如返回r，m  就2个
                Object obj = data.get(key);
                if (obj instanceof InternalPath) {
                    InternalPath IP = (InternalPath) obj;
                    //取出节点数据
                    Iterable<Node> nodes = IP.nodes();
                    for (Node in : nodes) {
                        Map<String, Object> nodeMap = new HashMap<>();
                        long rteId = in.id();
                        nodeMap.put("编号", rteId);
                        List<String> li = (ArrayList) in.labels();
                       // nodeMap.put("类型", li);
                        nodeMap.put("节点标签类型", li);
                        Map<String, Object> Map = in.asMap();
                        for (String Mkey : Map.keySet()) {
                            nodeMap.put(Mkey, Map.get(Mkey));
                        }
                        nodeList.add(nodeMap);
                    }
                    //取出关系数据
                    Iterable<Relationship> relationships = IP.relationships();
                    for (Relationship rs : relationships) {
                        Map<String, Object> relationshipMap = new HashMap<>();
                        relationshipMap.put("from", rs.startNodeId());
                        relationshipMap.put("to", rs.endNodeId());
                        relationshipMap.put("编号", rs.id());
                        Map<String, Object> map = rs.asMap();
                        for (String Mkey : map.keySet()) {
                            relationshipMap.put(Mkey, map.get(Mkey));
                        }
                        relationshipList.add(relationshipMap);
                    }
                }
            }
        }
        retMap.put("nodeSet",nodeList);
        retMap.put("relationshipSet",nodeList);
        return retMap;
    }

    /**
     * 将查询条件 变为模糊查询条件  只针对neo4j数据库
     *
     * @param condition
     * @return
     */
    public static String dimCondition(String condition) {
        if (condition != null && !"".equals(condition)) {
            return "~\'.*" + condition + ".*\'";
        }
        return "";
    }

    /**
     * 将 string查询条件 加上‘’ 号
     *
     * @param condition
     * @return
     */
    public static String strCondition(String condition) {
        if (condition != null && !"".equals(condition)) {
            return "\'" + condition + "\'";
        }
        return "";
    }
}

功能代码：

package net.pushi.neo4jdata.dataStorage.service.impl;

import net.pushi.neo4jdata.dataStorage.service.SetupService;
import net.pushi.neo4jdata.util.DatabaseUtil;
import org.neo4j.driver.internal.InternalPath;
import org.neo4j.driver.v1.types.Node;
import org.neo4j.driver.v1.types.Relationship;
import org.neo4j.ogm.model.Result;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.*;

@Service
public class SetupServiceImpl implements SetupService {

    //布局接口
    @Override
    public Map<String, Object> layout(Map<String ,Object> map) {
        /*map.put("x","2000");//窗口宽度
        map.put("y","200");//第二行节点y坐标
        map.put("label","X1体系实体");//实体标签
        map.put("describe","指挥");//关系描述*/

        Map<String, Object> htData = new HashMap<>();
        Set<Map<String, Object>> nodesSet = new HashSet<>();
        Set<Map<String, Object>> relationshipList = new HashSet<>();
        String cypher = "MATCH p=(n:`" + map.get("label") + "`)-[r]->(m:`" + map.get("label") + "`) WHERE r.关系描述='" + map.get("describe") + "' RETURN p";
        String cypher1 = "MATCH p=(n:`" + map.get("label") + "`)-[r]->(m:`" + map.get("label") + "`) RETURN p";
        Result result = DatabaseUtil.neo4jExecute(cypher);
        ArrayList<LinkedHashMap<String, InternalPath>> listResult = (ArrayList)result.queryResults();
        Result allResult = DatabaseUtil.neo4jExecute(cypher1);
        ArrayList<LinkedHashMap<String, InternalPath>> allListResult = (ArrayList) allResult.queryResults();

        //取节点集
        Set<Node> nodeSet = new HashSet<>();//节点集
        for (LinkedHashMap<String, InternalPath> linkedHashMap : allListResult){
             for (InternalPath value : linkedHashMap.values()){
                  Iterable<Node> nodes = value.nodes();//节点集
                  for(Node node1:nodes){
                      nodeSet.add(node1);
                  }
             }
        }

        //取关系集
        Set<Relationship> relationshipSet = new HashSet<>(); //关系集
        for (LinkedHashMap<String, InternalPath> linkedHashMap : allListResult){
             for (InternalPath value : linkedHashMap.values()){
                  Iterable<Relationship> relationships = value.relationships();//关系集
                  for(Relationship relationship:relationships){
                      relationshipSet.add(relationship);
                  }
             }
        }

        //设置属性
        for (Relationship relationship:relationshipSet){
             Map<String, Object> asMap = relationship.asMap();
             relationshipList.add(DatabaseUtil.setProperty(DatabaseUtil.setBasePropertyRelation(relationship),asMap));
        }

        //1.寻找体系结构第一级节点集
        Set<Long> startNodeIds = new HashSet<>();//起始点集ID
        Set<Long> endNodeIds = new HashSet<>();//终止点集ID
        Set<Long> originIds = new HashSet<>();//第一级节点集ID
        for (LinkedHashMap<String, InternalPath> linkedHashMap : listResult){
             for (InternalPath value : linkedHashMap.values()){
//                Iterator<Path.Segment> segments = value.iterator();//三元组
                  Node startNode = value.start();
                  startNodeIds.add(startNode.id());
                  Node endNode = value.end();
                  endNodeIds.add(endNode.id());
             }
        }
        originIds.addAll(startNodeIds);
        for (Long startNodeId:startNodeIds) {
             for (Long endNodeId:endNodeIds){
                  if (startNodeId.longValue() == endNodeId.longValue()){
                      originIds.remove(startNodeId);
                  }
             }
        }
//        System.out.println("第一级节点集id===》"+originIds);
        //第一级节点集中最长路径
        long maxLength = 0;
        Set<Node> originNodes = new HashSet<>();//第一级节点集
        for (Long originId:originIds){
             for (Node node:nodeSet){//取第一级节点集
                  Long nodeId = node.id();
                  if (originId.longValue() == nodeId.longValue()){
                     originNodes.add(node);
                  }
             }
            //查询单个第一级节点集的最长路径
            String lengthCypher = "MATCH p=(n:`" + map.get("label") + "`)-[*{关系描述:'"+map.get("describe")+"'}]->(m:`" + map.get("label") + "`) WHERE id(n) = " + originId + " RETURN MAX(length(p))";
            Result lengthResult = DatabaseUtil.neo4jExecute(lengthCypher);
            ArrayList<LinkedHashMap<String, Long>> lengthResultList = (ArrayList)lengthResult.queryResults();
            for (LinkedHashMap<String, Long> linkedHashMap:lengthResultList){
                 for (Long value : linkedHashMap.values()){
                      if (maxLength < value){
                          maxLength = value;
                      }
                      //System.out.println("当前第一级节点集中最长路径====》"+maxLength);
                 }
            }
        }
        nodeSet.removeAll(originNodes);
//        maxLength = maxLength + 2;
        //System.out.println("第一级节点集===》"+originNodes);
        //给第一级节点添加坐标
        double x = Double.valueOf(map.get("x").toString());
        //double y = Double.valueOf(map.get("y").toString());
        double spacing = Math.round(x/(originNodes.size()+1));//等额间距
        double x1 = spacing;
        double y1 = 100;
        for (Node node:originNodes){
             Map<String, Object> asMap = node.asMap();
             nodesSet.add(DatabaseUtil.setProperty(DatabaseUtil.setPosition(node,x1,y1),asMap));
             x1 = x1 + spacing;
        }
        //递归定位每层节点坐标
        long sign = 0;
        nodesSet.addAll(DatabaseUtil.locationPoint(Double.valueOf(map.get("x").toString()),Double.valueOf(map.get("y").toString()),allListResult,originIds,maxLength,sign,nodesSet,nodeSet));
        System.out.println("===树节点====个数》"+nodesSet.size());
        htData.put("nodes",nodesSet);
        htData.put("edges",relationshipList);
        return htData;
    }

    //根据各算法值排序
    @Override
    public Map<String, Object> sort(Map<String, Object> map) {
        Map<String ,Object> data = new HashMap<>();
        String cypher = "MATCH (n:`"+map.get("label")+"`) RETURN n";
        if (map.containsKey("algorithm") && map.get("algorithm") != null){
            data.put("nodes", DatabaseUtil.listComparator(DatabaseUtil.nodeToMap(cypher),map.get("algorithm").toString()));
        }else {
            data.put("nodes", DatabaseUtil.nodeToMap(cypher));
        }
        return data;
    }

    //装备分布
    @Override
    public Map<String, Object> distribution(Map<String, Object> map) {
        String[] strings = {"red","yellow","green","purple","blue","turq","pink","orange","gilt","brown"};
        Map<String,Object> worldData = new HashMap<>();//返回数据
        Set<Map<String, Object>> showCountrydata = new HashSet<>();//国家信息
        Map<String,Object> geoCoordShowCountryMap = new HashMap<>();//国家坐标
        String cypher = "MATCH (n:`"+map.get("label")+"`) with n.`国家` as name,count(*) as value  RETURN name, value";
        Result result = DatabaseUtil.neo4jExecute(cypher);
        ArrayList<LinkedHashMap<String, Object>> listResult = (ArrayList)result.queryResults();
        for (LinkedHashMap<String, Object> linkedHashMap : listResult){
            Map<String,Object> countryMap = new HashMap<>();
            for (Map.Entry<String, Object> entry : linkedHashMap.entrySet()){
                countryMap.put(entry.getKey(),entry.getValue());
            }
            Random random = new Random();
            int randomIndex = random.nextInt(strings.length);
            countryMap.put("label","拥有"+map.get("label")+countryMap.get("value"));
            countryMap.put("color",strings[randomIndex]);
            showCountrydata.add(countryMap);
        }
        String countryCypher = "MATCH (n:`地图`) WHERE n.`父级编号`= '000000000' with n.`名称` as name,n.`经度` as longitude,n.`纬度` as latitude  RETURN name,longitude,latitude";
        Result coordinateResult = DatabaseUtil.neo4jExecute(countryCypher);
        ArrayList<LinkedHashMap<String, Object>> countryList = (ArrayList)coordinateResult.queryResults();
        for (LinkedHashMap<String, Object> country : countryList){
            List countryCoo = new ArrayList<>();
            List coordinateStart = new ArrayList<>();
            List coordinateEnd = new ArrayList<>();
            for (Map<String, Object> countryMap: showCountrydata){
                if (countryMap.get("name").equals(country.get("name"))){
                    coordinateStart.add(Double.parseDouble(country.get("longitude").toString()));//经度
                    coordinateStart.add(Double.parseDouble(country.get("latitude").toString()));//纬度
                    if (new BigDecimal(-30).compareTo(new BigDecimal(country.get("latitude").toString())) < 0 && new BigDecimal(60).compareTo(new BigDecimal(country.get("latitude").toString())) > 0){
                        if (new BigDecimal(0).compareTo(new BigDecimal(country.get("longitude").toString())) < 0){
                            coordinateEnd.add(190d);
                            coordinateEnd.add(Double.parseDouble(country.get("latitude").toString()));
                        }else {
                            coordinateEnd.add(-190d);
                            coordinateEnd.add(Double.parseDouble(country.get("latitude").toString()));
                        }
                    }else if (new BigDecimal(-30).compareTo(new BigDecimal(country.get("latitude").toString())) > 0){
                        coordinateEnd.add(Double.parseDouble(country.get("longitude").toString()));
                        coordinateEnd.add(-70d);
                    }else {
                        coordinateEnd.add(Double.parseDouble(country.get("longitude").toString()));
                        coordinateEnd.add(80d);
                    }
                    countryCoo.add(coordinateStart);
                    countryCoo.add(coordinateEnd);
                    geoCoordShowCountryMap.put(country.get("name").toString(),countryCoo);
                }
            }
        }
        worldData.put("showCountrydata",showCountrydata);
        worldData.put("geoCoordShowCountryMap",geoCoordShowCountryMap);
        return worldData;
    }
}

效果图：









如有转载请注明出处！