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;
}
}
效果图:
如有转载请注明出处!