devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Spring Boot2 集成 Neo4j 实现知识图谱_java 集成neo4j 实现知识图谱

作者：我家小花儿 | 2024-05-29 09:32:03

赞

踩

java 集成neo4j 实现知识图谱

一 Neo4j 简介

Neo4j是一个高性能的,NOSQL图形数据库，它将结构化数据存储在网络上而不是表中。Neo4j也可以被看作是一个高性能的图引擎，该引擎具有成熟数据库的所有特性。程序员工作在一个面向对象的、灵活的网络结构下而不是严格、静态的表中——但是他们可以享受到具备完全的事务特性、企业级的数据库的所有好处。

1.1 图形数据结构

在一个图中包含两种基本的数据类型：Nodes（节点） 和 Relationships（关系）。Nodes 和 Relationships 包含key/value形式的属性。Nodes通过Relationships所定义的关系相连起来，形成关系型网络结构。

1.2 安装Neo4j

1.2.1 下载安装包

liunx环境Neo4j下载地址：https://neo4j.com/download/other-releases/#releases(社区版免费)

注意：下载各自系统所需版本tar即可，我是Centos系统，故下载的是liunx版本，4.X后需要JDK11版本，3.X需要JDK8

1.2.2 上传下载的tar包，进行解压

tar -zxvf neo4j-community-3.4.5-unix.tar.gz

1.2.3 修改配置文件

在安装目录下找到conf目录下的neo4j.conf文件

vim neo4j.conf

修改相应配置如下：

1.2.4 常用命令

进入bin目录执行命令

启动命令：./neo4j start

停止命令：./neo4j stop

查看图数据库状态：./neo4j status

1.2.5 客户端访问

http://服务器ip地址:7474/browser/

在浏览器访问图数据库所在的机器上的7474端口（第一次访问账号neo4j，密码neo4j，会提示修改初始密码）

二 Spring Boot2 集成 Neo4j

Spring Boo2版本为：2.0.6

2.1 pom.xml依赖

  1.         <!-- neo4j-->
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-data-neo4j</artifactId>
  5.         </dependency>
  6.  
  7.         <!-- neo4j driver驱动-->
  8.         <dependency>
  9.             <groupId>org.neo4j.driver</groupId>
  10.             <artifactId>neo4j-java-driver</artifactId>
  11.             <version>1.7.5</version>
  12.         </dependency>

完整pom.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>2.0.6.RELEASE</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  11.     <groupId>com.modules</groupId>
  12.     <artifactId>spring-boot2-neo4j</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>spring-boot2-neo4j</name>
  15.     <description>Demo project for Spring Boot</description>
  16.     <properties>
  17.         <java.version>1.8</java.version>
  18.         <spring-cloud.version>Hoxton.SR3</spring-cloud.version>
  19.     </properties>
  20.     <dependencies>
  21.  
  22.         <!-- spring boot2 核心-->
  23.         <dependency>
  24.             <groupId>org.springframework.boot</groupId>
  25.             <artifactId>spring-boot-starter</artifactId>
  26.         </dependency>
  27.  
  28.         <!-- spring boot2 web-->
  29.         <dependency>
  30.             <groupId>org.springframework.boot</groupId>
  31.             <artifactId>spring-boot-starter-web</artifactId>
  32.         </dependency>
  33.  
  34.         <!-- devtools-->
  35.         <dependency>
  36.             <groupId>org.springframework.boot</groupId>
  37.             <artifactId>spring-boot-devtools</artifactId>
  38.             <scope>runtime</scope>
  39.             <optional>true</optional>
  40.         </dependency>
  41.  
  42.         <!-- test-->
  43.         <dependency>
  44.             <groupId>org.springframework.boot</groupId>
  45.             <artifactId>spring-boot-starter-test</artifactId>
  46.             <scope>test</scope>
  47.         </dependency>
  48.  
  49.         <!-- neo4j-->
  50.         <dependency>
  51.             <groupId>org.springframework.boot</groupId>
  52.             <artifactId>spring-boot-starter-data-neo4j</artifactId>
  53.         </dependency>
  54.  
  55.         <!-- neo4j driver驱动-->
  56.         <dependency>
  57.             <groupId>org.neo4j.driver</groupId>
  58.             <artifactId>neo4j-java-driver</artifactId>
  59.             <version>1.7.5</version>
  60.         </dependency>
  61.  
  62.         <!-- fastjson -->
  63.         <dependency>
  64.             <groupId>com.alibaba</groupId>
  65.             <artifactId>fastjson</artifactId>
  66.             <version>1.2.58</version>
  67.         </dependency>
  68.  
  69.         <!-- lombok -->
  70.         <dependency>
  71.             <groupId>org.projectlombok</groupId>
  72.             <artifactId>lombok</artifactId>
  73.         </dependency>
  74.  
  75.         <!-- swagger2-->
  76.         <dependency>
  77.             <groupId>io.springfox</groupId>
  78.             <artifactId>springfox-swagger2</artifactId>
  79.             <version>2.9.2</version>
  80.             <exclusions>
  81.                 <exclusion>
  82.                     <groupId>io.swagger</groupId>
  83.                     <artifactId>swagger-annotations</artifactId>
  84.                 </exclusion>
  85.                 <exclusion>
  86.                     <groupId>io.swagger</groupId>
  87.                     <artifactId>swagger-models</artifactId>
  88.                 </exclusion>
  89.             </exclusions>
  90.         </dependency>
  91.  
  92.         <!-- swagger2-UI-->
  93.         <dependency>
  94.             <groupId>io.springfox</groupId>
  95.             <artifactId>springfox-swagger-ui</artifactId>
  96.             <version>2.9.2</version>
  97.         </dependency>
  98.  
  99.         <!--防止进入swagger页面报类型转换错误，排除2.9.2中的引用，手动增加1.5.21版本-->
  100.         <dependency>
  101.             <groupId>io.swagger</groupId>
  102.             <artifactId>swagger-annotations</artifactId>
  103.             <version>1.5.21</version>
  104.         </dependency>
  105.  
  106.         <dependency>
  107.             <groupId>io.swagger</groupId>
  108.             <artifactId>swagger-models</artifactId>
  109.             <version>1.5.21</version>
  110.         </dependency>
  111.  
  112.     </dependencies>
  113.  
  114.     <!-- 依赖版本管理 -->
  115.     <dependencyManagement>
  116.         <dependencies>
  117.             <dependency>
  118.                 <groupId>org.springframework.cloud</groupId>
  119.                 <artifactId>spring-cloud-dependencies</artifactId>
  120.                 <version>${spring-cloud.version}</version>
  121.                 <type>pom</type>
  122.                 <scope>import</scope>
  123.             </dependency>
  124.         </dependencies>
  125.     </dependencyManagement>
  126.  
  127.     <build>
  128.         <plugins>
  129.             <plugin>
  130.                 <groupId>org.springframework.boot</groupId>
  131.                 <artifactId>spring-boot-maven-plugin</artifactId>
  132.                 <!-- 引入系统范围内的依赖 -->
  133.                 <configuration>
  134.                     <includeSystemScope>true</includeSystemScope>
  135.                 </configuration>
  136.             </plugin>
  137.             <!--添加配置跳过测试-->
  138.             <plugin>
  139.                 <groupId>org.apache.maven.plugins</groupId>
  140.                 <artifactId>maven-surefire-plugin</artifactId>
  141.                 <version>2.22.2</version>
  142.                 <configuration>
  143.                     <skipTests>true</skipTests>
  144.                 </configuration>
  145.             </plugin>
  146.         </plugins>
  147.     </build>
  148.  
  149. </project>

2.2 application.properties配置

  1.  
  2. server.port=8088
  3. server.servlet.context-path=/neo4j
  4. # 启用优雅关机
  5. server.shutdown=graceful
  6. # 缓冲10秒
  7. spring.lifecycle.timeout-per-shutdown-phase=10s
  8.  
  9. # neo4j配置
  10. spring.data.neo4j.uri= bolt://172.16.21.201:7687
  11. spring.data.neo4j.username=neo4j
  12. spring.data.neo4j.password=111111
  13.  
  14. #日志配置
  15. logging.level.com.modules.project.dao=debug
  16.  
  17. # 设置时间
  18. spring.jackson.time-zone=GMT+8
  19. # 全局格式化日期
  20. spring.jackson.date-format=yyyy-MM-dd HH:mm:ss

2.3 Neo4j 配置类

  1. package com.modules.common.config;
  2.  
  3.  
  4. import org.neo4j.driver.v1.AuthTokens;
  5. import org.neo4j.driver.v1.Driver;
  6. import org.neo4j.driver.v1.GraphDatabase;
  7. import org.springframework.beans.factory.annotation.Value;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.Configuration;
  10.  
  11. /**
  12.  * neo4j图数据库配置
  13.  *
  14.  * @author li'chao
  15.  */
  16.  
  17. @Configuration
  18. public class Neo4jConfig {
  19.     @Value("${spring.data.neo4j.uri}")
  20.     private String url;
  21.  
  22.     @Value("${spring.data.neo4j.username}")
  23.     private String username;
  24.  
  25.     @Value("${spring.data.neo4j.password}")
  26.     private String password;
  27.  
  28.     /**
  29.      * neo4j图数据库驱动模式
  30.      *
  31.      * @return
  32.      */
  33.     @Bean
  34.     public Driver neo4jDriver() {
  35.         return GraphDatabase.driver(url, AuthTokens.basic(username, password));
  36.     }
  37. }

2.4 Neo4jUtil工具类

  1. package com.modules.common.utils;
  2.  
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.neo4j.driver.v1.*;
  5. import org.neo4j.driver.v1.types.Node;
  6. import org.neo4j.driver.v1.types.Path;
  7. import org.neo4j.driver.v1.types.Relationship;
  8. import org.neo4j.driver.v1.util.Pair;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.stereotype.Component;
  11.  
  12. import java.lang.reflect.Field;
  13. import java.util.*;
  14. import java.util.Map.Entry;
  15.  
  16. @Slf4j
  17. @Component
  18. public class Neo4jUtil {
  19. 	@Autowired
  20. 	private Driver neo4jDriver;
  21.  
  22. 	public boolean isNeo4jOpen() {
  23. 		try (Session session = neo4jDriver.session()) {
  24. 			log.info("连接成功：" + session.isOpen());
  25. 			return session.isOpen();
  26. 		} catch (Exception e) {
  27. 			log.error("连接异常：" + e.getMessage());
  28. 			return false;
  29. 		}
  30. 	}
  31.  
  32. 	public StatementResult excuteCypherSql(String cypherSql) {
  33. 		StatementResult result = null;
  34. 		try (Session session = neo4jDriver.session()) {
  35. 			log.info("cypher语句：" + cypherSql);
  36. 			result = session.run(cypherSql);
  37. 			session.close();
  38. 		} catch (Exception e) {
  39. 			throw e;
  40. 		}
  41. 		return result;
  42. 	}
  43.  
  44.  
  45. 	public HashMap<String, Object> getEntityMap(String cypherSql) {
  46. 		HashMap<String, Object> rss = new HashMap<String, Object>();
  47. 		try {
  48. 			StatementResult result = excuteCypherSql(cypherSql);
  49. 			if (result.hasNext()) {
  50. 				List<Record> records = result.list();
  51. 				for (Record recordItem : records) {
  52. 					for (Value value : recordItem.values()) {
  53. 						if (value.type().name().equals("NODE")) {// 结果里面只要类型为节点的值
  54. 							Node noe4jNode = value.asNode();
  55. 							Map<String, Object> map = noe4jNode.asMap();
  56. 							for (Entry<String, Object> entry : map.entrySet()) {
  57. 								String key = entry.getKey();
  58. 								if (rss.containsKey(key)) {
  59. 									String oldValue = rss.get(key).toString();
  60. 									String newValue = oldValue + "," + entry.getValue();
  61. 									rss.replace(key, newValue);
  62. 								} else {
  63. 									rss.put(key, entry.getValue());
  64. 								}
  65. 							}
  66.  
  67. 						}
  68. 					}
  69. 				}
  70. 			}
  71.  
  72. 		} catch (Exception e) {
  73. 			e.printStackTrace();
  74. 		}
  75. 		return rss;
  76. 	}
  77.  
  78. 	public List<HashMap<String, Object>> getGraphNode(String cypherSql) {
  79. 		List<HashMap<String, Object>> ents = new ArrayList<HashMap<String, Object>>();
  80. 		try {
  81. 			StatementResult result = excuteCypherSql(cypherSql);
  82. 			if (result.hasNext()) {
  83. 				List<Record> records = result.list();
  84. 				for (Record recordItem : records) {
  85. 					List<Pair<String, Value>> f = recordItem.fields();
  86. 					for (Pair<String, Value> pair : f) {
  87. 						HashMap<String, Object> rss = new HashMap<String, Object>();
  88. 						String typeName = pair.value().type().name();
  89. 						if (typeName.equals("NODE")) {
  90. 							Node noe4jNode = pair.value().asNode();
  91. 							String uuid = String.valueOf(noe4jNode.id());
  92. 							Map<String, Object> map = noe4jNode.asMap();
  93. 							for (Entry<String, Object> entry : map.entrySet()) {
  94. 								String key = entry.getKey();
  95. 								rss.put(key, entry.getValue());
  96. 							}
  97. 							rss.put("uuid", uuid);
  98. 							ents.add(rss);
  99. 						}
  100. 					}
  101.  
  102. 				}
  103. 			}
  104.  
  105. 		} catch (Exception e) {
  106. 			e.printStackTrace();
  107. 		}
  108. 		return ents;
  109. 	}
  110.  
  111. 	public List<HashMap<String, Object>> getGraphRelationShip(String cypherSql) {
  112. 		List<HashMap<String, Object>> ents = new ArrayList<HashMap<String, Object>>();
  113. 		try {
  114. 			StatementResult result = excuteCypherSql(cypherSql);
  115. 			if (result.hasNext()) {
  116. 				List<Record> records = result.list();
  117. 				for (Record recordItem : records) {
  118. 					List<Pair<String, Value>> f = recordItem.fields();
  119. 					for (Pair<String, Value> pair : f) {
  120. 						HashMap<String, Object> rss = new HashMap<String, Object>();
  121. 						String typeName = pair.value().type().name();
  122. 						if (typeName.equals("RELATIONSHIP")) {
  123. 							Relationship rship = pair.value().asRelationship();
  124. 							String uuid = String.valueOf(rship.id());
  125. 							String sourceid = String.valueOf(rship.startNodeId());
  126. 							String targetid = String.valueOf(rship.endNodeId());
  127. 							Map<String, Object> map = rship.asMap();
  128. 							for (Entry<String, Object> entry : map.entrySet()) {
  129. 								String key = entry.getKey();
  130. 								rss.put(key, entry.getValue());
  131. 							}
  132. 							rss.put("uuid", uuid);
  133. 							rss.put("sourceid", sourceid);
  134. 							rss.put("targetid", targetid);
  135. 							ents.add(rss);
  136. 						}
  137. 					}
  138. 				}
  139. 			}
  140. 		} catch (Exception e) {
  141. 			e.printStackTrace();
  142. 		}
  143. 		return ents;
  144. 	}
  145. 	public List<HashMap<String, Object>> getGraphItem(String cypherSql) {
  146. 		List<HashMap<String, Object>> ents = new ArrayList<HashMap<String, Object>>();
  147. 		List<String> nodeids = new ArrayList<String>();
  148. 		List<String> shipids = new ArrayList<String>();
  149. 		try {
  150. 			StatementResult result = excuteCypherSql(cypherSql);
  151. 			if (result.hasNext()) {
  152. 				List<Record> records = result.list();
  153. 				for (Record recordItem : records) {
  154. 					List<Pair<String, Value>> f = recordItem.fields();
  155. 					HashMap<String, Object> rss = new HashMap<String, Object>();
  156. 					for (Pair<String, Value> pair : f) {
  157. 						String typeName = pair.value().type().name();
  158. 						if (typeName.equals("NODE")) {
  159. 							Node noe4jNode = pair.value().asNode();
  160. 							String uuid = String.valueOf(noe4jNode.id());
  161. 							if(!nodeids.contains(uuid)) {
  162. 								Map<String, Object> map = noe4jNode.asMap();
  163. 								for (Entry<String, Object> entry : map.entrySet()) {
  164. 									String key = entry.getKey();
  165. 									rss.put(key, entry.getValue());
  166. 								}
  167. 								rss.put("uuid", uuid);
  168. 							}
  169. 						}else if (typeName.equals("RELATIONSHIP")) {
  170. 							Relationship rship = pair.value().asRelationship();
  171. 							String uuid = String.valueOf(rship.id());
  172. 							if (!shipids.contains(uuid)) {
  173. 								String sourceid = String.valueOf(rship.startNodeId());
  174. 								String targetid = String.valueOf(rship.endNodeId());
  175. 								Map<String, Object> map = rship.asMap();
  176. 								for (Entry<String, Object> entry : map.entrySet()) {
  177. 									String key = entry.getKey();
  178. 									rss.put(key, entry.getValue());
  179. 								}
  180. 								rss.put("uuid", uuid);
  181. 								rss.put("sourceid", sourceid);
  182. 								rss.put("targetid", targetid);
  183. 							}
  184. 						}else {
  185. 							rss.put(pair.key(),pair.value().toString());
  186. 						}
  187. 					}
  188. 					ents.add(rss);
  189. 				}
  190. 			}
  191. 		} catch (Exception e) {
  192. 			e.printStackTrace();
  193. 		}
  194. 		return ents;
  195. 	}
  196. 	/*
  197. 	 * 获取值类型的结果,如count,uuid
  198. 	 * @return 1 2 3 等数字类型
  199. 	 */
  200. 	public long getGraphValue(String cypherSql) {
  201. 		long val=0;
  202. 		try {
  203. 			StatementResult cypherResult = excuteCypherSql(cypherSql);
  204. 			if (cypherResult.hasNext()) {
  205. 				Record record = cypherResult.next();
  206. 				for (Value value : record.values()) {
  207. 					val = value.asLong();
  208. 				}
  209. 			}
  210. 		} catch (Exception e) {
  211. 			e.printStackTrace();
  212. 		}
  213. 		return val;
  214. 	}
  215.  
  216. 	public HashMap<String, Object> getGraphNodeAndShip(String cypherSql) {
  217. 		HashMap<String, Object> mo = new HashMap<String, Object>();
  218. 		try {
  219. 			StatementResult result = excuteCypherSql(cypherSql);
  220. 			if (result.hasNext()) {
  221. 				List<Record> records = result.list();
  222. 				List<HashMap<String, Object>> ents = new ArrayList<HashMap<String, Object>>();
  223. 				List<HashMap<String, Object>> ships = new ArrayList<HashMap<String, Object>>();
  224. 				List<String> uuids = new ArrayList<String>();
  225. 				List<String> shipids = new ArrayList<String>();
  226. 				for (Record recordItem : records) {
  227. 					List<Pair<String, Value>> f = recordItem.fields();
  228. 					for (Pair<String, Value> pair : f) {
  229. 						HashMap<String, Object> rships = new HashMap<String, Object>();
  230. 						HashMap<String, Object> rss = new HashMap<String, Object>();
  231. 						String typeName = pair.value().type().name();
  232. 						if (typeName.equals("NULL")) {
  233. 							continue;
  234. 						} else if (typeName.equals("NODE")) {
  235. 							Node noe4jNode = pair.value().asNode();
  236.                             Map<String, Object> map = noe4jNode.asMap();
  237.                             String uuid = String.valueOf(noe4jNode.id());
  238.                             if (!uuids.contains(uuid)) {
  239.                                 for (Entry<String, Object> entry : map.entrySet()) {
  240.                                     String key = entry.getKey();
  241.                                     rss.put(key, entry.getValue());
  242.                                 }
  243.                                 rss.put("uuid", uuid);
  244.                                 uuids.add(uuid);
  245.                             }
  246.                             if (rss != null && !rss.isEmpty()) {
  247.                                 ents.add(rss);
  248.                             }
  249. 						} else if (typeName.equals("RELATIONSHIP")) {
  250. 							Relationship rship = pair.value().asRelationship();
  251.                             String uuid = String.valueOf(rship.id());
  252.                             if (!shipids.contains(uuid)) {
  253.                                 String sourceid = String.valueOf(rship.startNodeId());
  254.                                 String targetid = String.valueOf(rship.endNodeId());
  255.                                 Map<String, Object> map = rship.asMap();
  256.                                 for (Entry<String, Object> entry : map.entrySet()) {
  257.                                     String key = entry.getKey();
  258.                                     rships.put(key, entry.getValue());
  259.                                 }
  260.                                 rships.put("uuid", uuid);
  261.                                 rships.put("sourceid", sourceid);
  262.                                 rships.put("targetid", targetid);
  263. 								shipids.add(uuid);
  264.                                 if (rships != null && !rships.isEmpty()) {
  265.                                     ships.add(rships);
  266.                                 }
  267.                             }
  268.  
  269. 						} else if (typeName.equals("PATH")) {
  270. 							Path path = pair.value().asPath();
  271. 							Map<String, Object> startNodemap = path.start().asMap();
  272. 							String startNodeuuid = String.valueOf(path.start().id());
  273. 							if (!uuids.contains(startNodeuuid)) {
  274. 								rss=new HashMap<String, Object>();
  275. 								for (Entry<String, Object> entry : startNodemap.entrySet()) {
  276. 									String key = entry.getKey();
  277. 									rss.put(key, entry.getValue());
  278. 								}
  279. 								rss.put("uuid", startNodeuuid);
  280. 								uuids.add(startNodeuuid);
  281. 								if (rss != null && !rss.isEmpty()) {
  282. 									ents.add(rss);
  283. 								}
  284. 							}
  285.  
  286. 							Map<String, Object> endNodemap = path.end().asMap();
  287. 							String endNodeuuid = String.valueOf(path.end().id());
  288. 							if (!uuids.contains(endNodeuuid)) {
  289. 								rss=new HashMap<String, Object>();
  290. 								for (Entry<String, Object> entry : endNodemap.entrySet()) {
  291. 									String key = entry.getKey();
  292. 									rss.put(key, entry.getValue());
  293. 								}
  294. 								rss.put("uuid", endNodeuuid);
  295. 								uuids.add(endNodeuuid);
  296. 								if (rss != null && !rss.isEmpty()) {
  297. 									ents.add(rss);
  298. 								}
  299. 							}
  300. 							Iterator<Node> allNodes = path.nodes().iterator();
  301. 							while (allNodes.hasNext()) {
  302. 								Node next = allNodes.next();
  303. 								String uuid = String.valueOf(next.id());
  304. 								if (!uuids.contains(uuid)) {
  305. 									rss=new HashMap<String, Object>();
  306. 									Map<String, Object> map = next.asMap();
  307. 									for (Entry<String, Object> entry : map.entrySet()) {
  308. 										String key = entry.getKey();
  309. 										rss.put(key, entry.getValue());
  310. 									}
  311. 									rss.put("uuid", uuid);
  312. 									uuids.add(uuid);
  313. 									if (rss != null && !rss.isEmpty()) {
  314. 										ents.add(rss);
  315. 									}
  316. 								}
  317. 							}
  318. 							Iterator<Relationship> reships = path.relationships().iterator();
  319. 							while (reships.hasNext()) {
  320. 								Relationship next = reships.next();
  321. 								String uuid = String.valueOf(next.id());
  322. 								if (!shipids.contains(uuid)) {
  323. 									rships=new HashMap<String, Object>();
  324. 									String sourceid = String.valueOf(next.startNodeId());
  325. 									String targetid = String.valueOf(next.endNodeId());
  326. 									Map<String, Object> map = next.asMap();
  327. 									for (Entry<String, Object> entry : map.entrySet()) {
  328. 										String key = entry.getKey();
  329. 										rships.put(key, entry.getValue());
  330. 									}
  331. 									rships.put("uuid", uuid);
  332. 									rships.put("sourceid", sourceid);
  333. 									rships.put("targetid", targetid);
  334. 									shipids.add(uuid);
  335. 									if (rships != null && !rships.isEmpty()) {
  336. 										ships.add(rships);
  337. 									}
  338. 								}
  339. 							}
  340. 						} else if (typeName.contains("LIST")) {
  341. 							Iterable<Value> val=pair.value().values();
  342.                             Value next = val.iterator().next();
  343.                             String type=next.type().name();
  344.                             if (type.equals("RELATIONSHIP")) {
  345.                                 Relationship rship = next.asRelationship();
  346.                                 String uuid = String.valueOf(rship.id());
  347.                                 if (!shipids.contains(uuid)) {
  348.                                     String sourceid = String.valueOf(rship.startNodeId());
  349.                                     String targetid = String.valueOf(rship.endNodeId());
  350.                                     Map<String, Object> map = rship.asMap();
  351.                                     for (Entry<String, Object> entry : map.entrySet()) {
  352.                                         String key = entry.getKey();
  353.                                         rships.put(key, entry.getValue());
  354.                                     }
  355.                                     rships.put("uuid", uuid);
  356.                                     rships.put("sourceid", sourceid);
  357.                                     rships.put("targetid", targetid);
  358. 									shipids.add(uuid);
  359.                                     if (rships != null && !rships.isEmpty()) {
  360.                                         ships.add(rships);
  361.                                     }
  362.                                 }
  363.                             }
  364. 						} else if (typeName.contains("MAP")) {
  365. 							rss.put(pair.key(), pair.value().asMap());
  366. 						} else {
  367. 							rss.put(pair.key(), pair.value().toString());
  368.                             if (rss != null && !rss.isEmpty()) {
  369.                                 ents.add(rss);
  370.                             }
  371. 						}
  372. 					}
  373. 				}
  374. 				mo.put("node", ents);
  375. 				mo.put("relationship", ships);
  376. 			}
  377. 		} catch (Exception e) {
  378. 			throw new RuntimeException("执行Cypher查询异常");
  379. 		}
  380. 		return mo;
  381. 	}
  382. 	/**
  383. 	 * 匹配所有类型的节点,可以是节点,关系,数值,路径
  384. 	 * @param cypherSql
  385. 	 * @return
  386. 	 */
  387. 	public List<HashMap<String, Object>> getEntityList(String cypherSql) {
  388. 		List<HashMap<String, Object>> ents = new ArrayList<HashMap<String, Object>>();
  389. 		try {
  390. 			StatementResult result = excuteCypherSql(cypherSql);
  391. 			if (result.hasNext()) {
  392. 				List<Record> records = result.list();
  393. 				for (Record recordItem : records) {
  394. 					HashMap<String, Object> rss = new HashMap<String, Object>();
  395. 					List<Pair<String, Value>> f = recordItem.fields();
  396. 					for (Pair<String, Value> pair : f) {
  397. 						String typeName = pair.value().type().name();
  398. 						if (typeName.equals("NULL")) {
  399. 							continue;
  400. 						} else if (typeName.equals("NODE")) {
  401. 							Node noe4jNode = pair.value().asNode();
  402. 							Map<String, Object> map = noe4jNode.asMap();
  403. 							for (Entry<String, Object> entry : map.entrySet()) {
  404. 								String key = entry.getKey();
  405. 								rss.put(key, entry.getValue());
  406. 							}
  407. 						} else if (typeName.equals("RELATIONSHIP")) {
  408. 							Relationship rship = pair.value().asRelationship();
  409. 							Map<String, Object> map = rship.asMap();
  410. 							for (Entry<String, Object> entry : map.entrySet()) {
  411. 								String key = entry.getKey();
  412. 								rss.put(key, entry.getValue());
  413. 							}
  414. 						} else if (typeName.equals("PATH")) {
  415.  
  416. 						} else if (typeName.contains("LIST")) {
  417. 							rss.put(pair.key(), pair.value().asList());
  418. 						} else if (typeName.contains("MAP")) {
  419. 							rss.put(pair.key(), pair.value().asMap());
  420. 						} else {
  421. 							rss.put(pair.key(), pair.value().toString());
  422. 						}
  423. 					}
  424. 					ents.add(rss);
  425. 				}
  426. 			}
  427.  
  428. 		} catch (Exception e) {
  429. 			e.printStackTrace();
  430. 		}
  431. 		return ents;
  432. 	}
  433.  
  434. 	public <T> List<T> getEntityItemList(String cypherSql, Class<T> type) {
  435. 		List<HashMap<String, Object>> ents = getGraphNode(cypherSql);
  436. 		List<T> model = hashMapToObject(ents, type);
  437. 		return model;
  438. 	}
  439.  
  440. 	public <T> T getEntityItem(String cypherSql, Class<T> type) {
  441. 		HashMap<String, Object> rss = new HashMap<String, Object>();
  442. 		try {
  443. 			StatementResult result = excuteCypherSql(cypherSql);
  444. 			if (result.hasNext()) {
  445. 				Record record = result.next();
  446. 				for (Value value : record.values()) {
  447. 					if (value.type().name().equals("NODE")) {// 结果里面只要类型为节点的值
  448. 						Node noe4jNode = value.asNode();
  449. 						Map<String, Object> map = noe4jNode.asMap();
  450. 						for (Entry<String, Object> entry : map.entrySet()) {
  451. 							String key = entry.getKey();
  452. 							if (rss.containsKey(key)) {
  453. 								String oldValue = rss.get(key).toString();
  454. 								String newValue = oldValue + "," + entry.getValue();
  455. 								rss.replace(key, newValue);
  456. 							} else {
  457. 								rss.put(key, entry.getValue());
  458. 							}
  459. 						}
  460.  
  461. 					}
  462. 				}
  463. 			}
  464.  
  465. 		} catch (Exception e) {
  466. 			e.printStackTrace();
  467. 		}
  468. 		T model = hashMapToObjectItem(rss, type);
  469. 		return model;
  470. 	}
  471.  
  472. 	public HashMap<String, Object> getEntity(String cypherSql) {
  473. 		HashMap<String, Object> rss = new HashMap<String, Object>();
  474. 		try {
  475. 			StatementResult result = excuteCypherSql(cypherSql);
  476. 			if (result.hasNext()) {
  477. 				Record record = result.next();
  478. 				for (Value value : record.values()) {
  479. 					String t = value.type().name();
  480. 					if (value.type().name().equals("NODE")) {// 结果里面只要类型为节点的值
  481. 						Node noe4jNode = value.asNode();
  482. 						Map<String, Object> map = noe4jNode.asMap();
  483. 						for (Entry<String, Object> entry : map.entrySet()) {
  484. 							String key = entry.getKey();
  485. 							if (rss.containsKey(key)) {
  486. 								String oldValue = rss.get(key).toString();
  487. 								String newValue = oldValue + "," + entry.getValue();
  488. 								rss.replace(key, newValue);
  489. 							} else {
  490. 								rss.put(key, entry.getValue());
  491. 							}
  492. 						}
  493.  
  494. 					}
  495. 				}
  496. 			}
  497.  
  498. 		} catch (Exception e) {
  499. 			e.printStackTrace();
  500. 		}
  501. 		return rss;
  502. 	}
  503.  
  504. 	public Integer executeScalar(String cypherSql) {
  505. 		Integer count = 0;
  506. 		try {
  507. 			StatementResult result = excuteCypherSql(cypherSql);
  508. 			if (result.hasNext()) {
  509. 				Record record = result.next();
  510. 				for (Value value : record.values()) {
  511. 					String t = value.type().name();
  512. 					if (t.equals("INTEGER")) {
  513. 						count = Integer.valueOf(value.toString());
  514. 						break;
  515. 					}
  516. 				}
  517. 			}
  518.  
  519. 		} catch (Exception e) {
  520. 			e.printStackTrace();
  521. 		}
  522. 		return count;
  523. 	}
  524.  
  525. 	public HashMap<String, Object> getRelevantEntity(String cypherSql) {
  526. 		HashMap<String, Object> rss = new HashMap<String, Object>();
  527. 		try {
  528. 			StatementResult resultNode = excuteCypherSql(cypherSql);
  529. 			if (resultNode.hasNext()) {
  530. 				List<Record> records = resultNode.list();
  531. 				for (Record recordItem : records) {
  532. 					Map<String, Object> r = recordItem.asMap();
  533. 					String key = r.get("key").toString();
  534. 					if (rss.containsKey(key)) {
  535. 						String oldValue = rss.get(key).toString();
  536. 						String newValue = oldValue + "," + r.get("value");
  537. 						rss.replace(key, newValue);
  538. 					} else {
  539. 						rss.put(key, r.get("value"));
  540. 					}
  541. 				}
  542. 			}
  543. 		} catch (Exception e) {
  544. 			e.printStackTrace();
  545. 		}
  546. 		return rss;
  547. 	}
  548.  
  549.  
  550.  
  551. 	public String getFilterPropertiesJson(String jsonStr) {
  552. 		String propertiesString = jsonStr.replaceAll("\"(\\w+)\"(\\s*:\\s*)", "$1$2"); // 去掉key的引号
  553. 		return propertiesString;
  554. 	}
  555.  
  556. 	public <T>String getkeyvalCyphersql(T obj) {
  557. 		 Map<String, Object> map = new HashMap<String, Object>();
  558. 		 List<String> sqlList=new ArrayList<String>();
  559. 	        // 得到类对象
  560. 	        Class userCla = obj.getClass();
  561. 	        /* 得到类中的所有属性集合 */
  562. 	        Field[] fs = userCla.getDeclaredFields();
  563. 	        for (int i = 0; i < fs.length; i++) {
  564. 	            Field f = fs[i];
  565. 	            Class type = f.getType();
  566.  
  567. 	            f.setAccessible(true); // 设置些属性是可以访问的
  568. 	            Object val = new Object();
  569. 	            try {
  570. 	                val = f.get(obj);
  571. 	                if(val==null) {
  572. 	                	val="";
  573. 	                }
  574. 	                String sql="";
  575. 	                String key=f.getName();
  576. 	                log.info("key:"+key+"type:"+type);
  577. 	                if ( val instanceof   Integer ){
  578. 	                	// 得到此属性的值
  579. 		                map.put(key, val);// 设置键值
  580. 		                sql="n."+key+"="+val;
  581. 	    			}
  582. 	                else if ( val instanceof   String[] ){
  583. 	    				//如果为true则强转成String数组
  584. 	    				String [] arr = ( String[] ) val ;
  585. 	    				String v="";
  586. 	    				for ( int j = 0 ; j < arr.length ; j++ ){
  587. 	    					arr[j]="'"+ arr[j]+"'";
  588. 	    				}
  589. 	    				v=String.join(",", arr);
  590. 	    				sql="n."+key+"=["+val+"]";
  591. 	    			}
  592. 	                else if (val instanceof List){
  593. 	    				//如果为true则强转成String数组
  594. 	                	List<String> arr = ( ArrayList<String> ) val ;
  595. 	                	List<String> aa=new ArrayList<String>();
  596. 	    				String v="";
  597. 	    				for (String s : arr) {
  598. 	    					s="'"+ s+"'";
  599. 	    					aa.add(s);
  600. 						}
  601. 	    				v=String.join(",", aa);
  602. 	    				sql="n."+key+"=["+v+"]";
  603. 	    			}
  604. 	                else {
  605. 	                	// 得到此属性的值
  606. 		                map.put(key, val);// 设置键值
  607. 		                sql="n."+key+"='"+val+"'";
  608. 	                }
  609.  
  610. 	                sqlList.add(sql);
  611. 	            } catch (IllegalArgumentException e) {
  612. 	                e.printStackTrace();
  613. 	            } catch (IllegalAccessException e) {
  614. 	                e.printStackTrace();
  615. 	            }
  616. 	        }
  617. 	        String finasql=String.join(",",sqlList);
  618. 	        log.info("单个对象的所有键值==反射==" + map.toString());
  619. 		return finasql;
  620. 	}
  621. 	public <T> List<T> hashMapToObject(List<HashMap<String, Object>> maps, Class<T> type) {
  622. 		try {
  623. 			List<T> list = new ArrayList<T>();
  624. 			for (HashMap<String, Object> r : maps) {
  625. 				T t = type.newInstance();
  626. 				Iterator iter = r.entrySet().iterator();// 该方法获取列名.获取一系列字段名称.例如name,age...
  627. 				while (iter.hasNext()) {
  628. 					Entry entry = (Entry) iter.next();// 把hashmap转成Iterator再迭代到entry
  629. 					String key = entry.getKey().toString(); // 从iterator遍历获取key
  630. 					Object value = entry.getValue(); // 从hashmap遍历获取value
  631. 					if("serialVersionUID".toLowerCase().equals(key.toLowerCase()))continue;
  632. 					Field field = type.getDeclaredField(key);// 获取field对象
  633. 					if (field != null) {
  634. 						field.setAccessible(true);
  635. 						if (field.getType() == int.class || field.getType() == Integer.class) {
  636. 							if (value==null||StringUtils.isBlank(value.toString())) {
  637. 								field.set(t, 0);// 设置值
  638. 							} else {
  639. 								field.set(t, Integer.parseInt(value.toString()));// 设置值
  640. 							}
  641. 						}
  642. 						 else if (field.getType() == long.class||field.getType() == Long.class ) {
  643. 								if (value==null||StringUtils.isBlank(value.toString())) {
  644. 									field.set(t, 0);// 设置值
  645. 								} else {
  646. 									field.set(t, Long.parseLong(value.toString()));// 设置值
  647. 								}
  648.  
  649. 						}
  650. 						 else {
  651. 							field.set(t, value);// 设置值
  652. 						}
  653. 					}
  654.  
  655. 				}
  656. 				list.add(t);
  657. 			}
  658.  
  659. 			return list;
  660. 		} catch (Exception e) {
  661. 			throw new RuntimeException(e);
  662. 		}
  663. 	}
  664.  
  665. 	public <T> T hashMapToObjectItem(HashMap<String, Object> map, Class<T> type) {
  666. 		try {
  667. 			T t = type.newInstance();
  668. 			Iterator iter = map.entrySet().iterator();
  669. 			while (iter.hasNext()) {
  670. 				Entry entry = (Entry) iter.next();// 把hashmap转成Iterator再迭代到entry
  671. 				String key = entry.getKey().toString(); // 从iterator遍历获取key
  672. 				Object value = entry.getValue(); // 从hashmap遍历获取value
  673. 				if("serialVersionUID".toLowerCase().equals(key.toLowerCase()))continue;
  674. 				Field field = type.getDeclaredField(key);// 获取field对象
  675. 				if (field != null) {
  676. 					field.setAccessible(true);
  677. 					if (field.getType() == int.class || field.getType() == Integer.class) {
  678. 						if (value==null||StringUtils.isBlank(value.toString())) {
  679. 							field.set(t, 0);// 设置值
  680. 						} else {
  681. 							field.set(t, Integer.parseInt(value.toString()));// 设置值
  682. 						}
  683. 					}
  684. 					 else if (field.getType() == long.class||field.getType() == Long.class ) {
  685. 							if (value==null||StringUtils.isBlank(value.toString())) {
  686. 								field.set(t, 0);// 设置值
  687. 							} else {
  688. 								field.set(t, Long.parseLong(value.toString()));// 设置值
  689. 							}
  690.  
  691. 					}
  692. 					 else {
  693. 						field.set(t, value);// 设置值
  694. 					}
  695. 				}
  696.  
  697. 			}
  698. 			return t;
  699. 		} catch (Exception e) {
  700. 			throw new RuntimeException(e);
  701. 		}
  702. 	}
  703.  
  704. 	public List<String> getNodesLabelsEntityList(String cypherSql) {
  705. 		List<String> rss = new ArrayList<>();
  706. 		try {
  707. 			StatementResult resultNode = excuteCypherSql(cypherSql);
  708. 			if (resultNode.hasNext()) {
  709. 				List<Record> records = resultNode.list();
  710. 				for (Record recordItem : records) {
  711. 					Map<String, Object> r = recordItem.asMap();
  712. 					rss.add(r.get("label").toString());
  713. 				}
  714. 			}
  715. 		} catch (Exception e) {
  716. 			e.printStackTrace();
  717. 		}
  718. 		return rss;
  719. 	}
  720.  
  721. 	public List<String> getRelationshipTypeEntityList(String cypherSql) {
  722. 		List<String> rss = new ArrayList<>();
  723. 		try {
  724. 			StatementResult resultNode = excuteCypherSql(cypherSql);
  725. 			if (resultNode.hasNext()) {
  726. 				List<Record> records = resultNode.list();
  727. 				for (Record recordItem : records) {
  728. 					Map<String, Object> r = recordItem.asMap();
  729. 					rss.add(r.get("relationshipType").toString());
  730. 				}
  731. 			}
  732. 		} catch (Exception e) {
  733. 			e.printStackTrace();
  734. 		}
  735. 		return rss;
  736. 	}
  737. }

2.5 实现图库数据查询功能

2.5.1 controller

  1. package com.modules.project.controller;
  2.  
  3. import com.modules.common.utils.Neo4jUtil;
  4. import com.modules.common.web.BaseController;
  5. import com.modules.common.web.Result;
  6. import com.modules.project.entity.GraphQuery;
  7. import com.modules.project.service.GraphService;
  8. import io.swagger.annotations.Api;
  9. import io.swagger.annotations.ApiOperation;
  10. import lombok.extern.slf4j.Slf4j;
  11. import org.springframework.beans.factory.annotation.Autowired;
  12. import org.springframework.validation.annotation.Validated;
  13. import org.springframework.web.bind.annotation.GetMapping;
  14. import org.springframework.web.bind.annotation.RequestMapping;
  15. import org.springframework.web.bind.annotation.RestController;
  16.  
  17. import java.util.HashMap;
  18. import java.util.List;
  19.  
  20. /**
  21.  * neo4j图数据管理
  22.  *
  23.  * @author li'chao
  24.  */
  25.  
  26. @Api(tags = "neo4j图数据管理")
  27. @Slf4j
  28. @RestController
  29. @RequestMapping("/graph")
  30. public class GraphController extends BaseController {
  31.  
  32.     @Autowired
  33.     private Neo4jUtil neo4jUtil;
  34.  
  35.     @Autowired
  36.     private GraphService graphService;
  37.  
  38.     @ApiOperation(value = "执行Cypher查询", notes = "执行Cypher查询")
  39.     @GetMapping(value = "/getCypherResult")
  40.     public Result getCypherResult(String cypher) {
  41.         try {
  42.             HashMap<String, Object> graphData = neo4jUtil.getGraphNodeAndShip(cypher);
  43.             return success(graphData);
  44.         } catch (Exception e) {
  45.             log.error("执行Cypher查询异常：" + e.getMessage());
  46.            return error("执行Cypher查询异常");
  47.         }
  48.     }
  49.  
  50.     @ApiOperation(value = "查询图节点和关系", notes = "查询图节点和关系")
  51.     @GetMapping(value = "/getDomainGraph")
  52.     public Result getDomainGraph(@Validated GraphQuery query) {
  53.         try {
  54.             HashMap<String, Object> graphData = graphService.getDomainGraph(query);
  55.             return success(graphData);
  56.         } catch (Exception e) {
  57.             log.error("查询图节点和关系异常：" + e.getMessage());
  58.            return error("查询图节点和关系异常");
  59.         }
  60.     }
  61.  
  62.     @ApiOperation(value = "获取节点列表", notes = "获取节点列表")
  63.     @GetMapping(value = "/getDomainNodes")
  64.     public Result getDomainNodes(String domain, Integer pageIndex, Integer pageSize) {
  65.         try {
  66.             HashMap<String, Object> graphData = graphService.getDomainNodes(domain, pageIndex,pageSize);
  67.             return success(graphData);
  68.         } catch (Exception e) {
  69.             log.error("获取节点列表异常：" + e.getMessage());
  70.             return error("获取节点列表异常");
  71.         }
  72.     }
  73.  
  74.     @ApiOperation(value = "查询所有节点标签", notes = "查询所有的节点标签")
  75.     @GetMapping(value = "/getNodesLabels")
  76.     public Result getNodesLabels() {
  77.         try {
  78.             List<String> graphData = graphService.getNodesLabels();
  79.             return success(graphData);
  80.         } catch (Exception e) {
  81.             log.error("查询所有节点标签异常：" + e.getMessage());
  82.             return error("查询所有节点标签异常");
  83.         }
  84.     }
  85.  
  86.     @ApiOperation(value = "查询所有关系类型", notes = "查询所有关系类型")
  87.     @GetMapping(value = "/getRelationshipType")
  88.     public Result getRelationshipType() {
  89.         try {
  90.             List<String> graphData = graphService.getRelationshipType();
  91.             return success(graphData);
  92.         } catch (Exception e) {
  93.             log.error("查询所有关系类型异常：" + e.getMessage());
  94.             return error("查询所有关系类型异常");
  95.         }
  96.     }
  97. }

2.5.2 service

  1. package com.modules.project.service;
  2.  
  3. import com.modules.common.utils.StringUtils;
  4. import com.modules.project.entity.GraphQuery;
  5. import com.modules.project.repository.GraphRepository;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Service;
  8.  
  9. import java.util.HashMap;
  10. import java.util.List;
  11.  
  12. /**
  13.  * neo4j图库服务层
  14.  *
  15.  * @author li'chao
  16.  *
  17.  */
  18.  
  19. @Service
  20. public class GraphService {
  21.  
  22.     @Autowired
  23.     private GraphRepository graphRepository;
  24.  
  25.     /**
  26.      * 查询图节点和关系
  27.      *
  28.      * @param query
  29.      * @return
  30.      */
  31.     public HashMap<String, Object> getDomainGraph(GraphQuery query) {
  32.         if(StringUtils.isNotEmpty(query.getDomain())){
  33.             return graphRepository.getDomainGraph(query);
  34.         }else{
  35.             return graphRepository.getNodeNameGraph(query);
  36.         }
  37.     }
  38.  
  39.     /**
  40.      * 获取节点列表
  41.      * @param domain
  42.      * @param pageIndex
  43.      * @param pageSize
  44.      * @return
  45.      */
  46.     public HashMap<String, Object> getDomainNodes(String domain, Integer pageIndex, Integer pageSize){
  47.         return graphRepository.getDomainNodes(domain, pageIndex, pageSize);
  48.     }
  49.  
  50.     /**
  51.      * 查询所有节点标签
  52.      * @return
  53.      */
  54.     public List<String> getNodesLabels(){
  55.         return graphRepository.getNodesLabels();
  56.     }
  57.  
  58.     /**
  59.      * 查询所有关系类型
  60.      * @return
  61.      */
  62.     public List<String> getRelationshipType(){
  63.         return graphRepository.getRelationshipType();
  64.     }
  65. }

2.5.3 repository

  1. 	@Override
  2. 	public List<String> getNodesLabels() {
  3. 		String cypherSql = " CALL db.labels(); ";
  4. 		return neo4jUtil.getNodesLabelsEntityList(cypherSql);
  5. 	}
  6.  
  7. 	@Override
  8. 	public List<String> getRelationshipType() {
  9. 		String cypherSql = " CALL db.relationshipTypes(); ";
  10. 		return neo4jUtil.getRelationshipTypeEntityList(cypherSql);
  11. 	}
  12.  
  13. 	@Override
  14. 	public List<String> getNodesSchema() {
  15. 		String cypherSql = " CALL db.schema(); ";
  16. 		return neo4jUtil.getRelationshipTypeEntityList(cypherSql);
  17. 	}
  18.  
  19.  
  20. 	/**
  21. 	 * 查询图谱节点和关系
  22. 	 *
  23. 	 * @param query
  24. 	 * @return node relationship
  25. 	 */
  26. 	public HashMap<String, Object> getDomainGraph(GraphQuery query) {
  27. 		HashMap<String, Object> nr = new HashMap<String, Object>();
  28. 		try {
  29. 			String domain = query.getDomain();
  30. 			// MATCH (n:`症状`) -[r]-(m:症状) where r.name='治疗' or r.name='危险因素' return n,m
  31. 			if (!StringUtils.isBlank(domain)) {
  32. 				String cqr = "";
  33. 				List<String> lis = new ArrayList<String>();
  34. 				if (query.getRelation() != null && query.getRelation().length > 0) {
  35. 					for (String r : query.getRelation()) {
  36. 						String it = String.format("r.name='%s'", r);
  37. 						lis.add(it);
  38. 					}
  39. 					cqr = String.join(" or ", lis);
  40. 				}
  41. 				String cqWhere = "";
  42. 				if (!StringUtils.isBlank(query.getNodename()) || !StringUtils.isBlank(cqr)) {
  43.  
  44. 					if (!StringUtils.isBlank(query.getNodename())) {
  45. 						if (query.getMatchtype() == 1) {
  46. 							cqWhere = String.format("where n.name ='%s' ", query.getNodename());
  47.  
  48. 						} else {
  49. 							cqWhere = String.format("where n.name contains('%s')", query.getNodename());
  50. 						}
  51. 					}
  52. 					String nodeOnly = cqWhere;
  53. 					if (!StringUtils.isBlank(cqr)) {
  54. 						if (StringUtils.isBlank(cqWhere)) {
  55. 							cqWhere = String.format(" where ( %s )", cqr);
  56.  
  57. 						} else {
  58. 							cqWhere += String.format(" and ( %s )", cqr);
  59. 						}
  60.  
  61. 					}
  62. 					// 下边的查询查不到单个没有关系的节点,考虑要不要左箭头
  63. 					String nodeSql = String.format("MATCH (n:`%s`) <-[r]->(m) %s return * limit %s", domain, cqWhere,
  64. 							query.getPageSize());
  65. 					HashMap<String, Object> graphNode = neo4jUtil.getGraphNodeAndShip(nodeSql);
  66. 					Object node = graphNode.get("node");
  67. 					// 没有关系显示则显示节点
  68. 					if (node != null) {
  69. 						nr.put("node", graphNode.get("node"));
  70. 						nr.put("relationship", graphNode.get("relationship"));
  71. 					} else {
  72. 						String nodecql = String.format("MATCH (n:`%s`) %s RETURN distinct(n) limit %s", domain,
  73. 								nodeOnly, query.getPageSize());
  74. 						List<HashMap<String, Object>> nodeItem = neo4jUtil.getGraphNode(nodecql);
  75. 						nr.put("node", nodeItem);
  76. 						nr.put("relationship", new ArrayList<HashMap<String, Object>>());
  77. 					}
  78. 				} else {
  79. 					String nodeSql = String.format("MATCH (n:`%s`) %s RETURN distinct(n) limit %s", domain, cqWhere,
  80. 							query.getPageSize());
  81. 					List<HashMap<String, Object>> graphNode = neo4jUtil.getGraphNode(nodeSql);
  82. 					nr.put("node", graphNode);
  83. 					String domainSql = String.format("MATCH (n:`%s`)<-[r]-> (m) %s RETURN distinct(r) limit %s", domain,
  84. 							cqWhere, query.getPageSize());// m是否加领域
  85. 					List<HashMap<String, Object>> graphRelation = neo4jUtil.getGraphRelationShip(domainSql);
  86. 					nr.put("relationship", graphRelation);
  87. 				}
  88. 			}
  89. 		} catch (Exception e) {
  90. 			e.printStackTrace();
  91. 		}
  92. 		return nr;
  93. 	}
  94.  
  95. 	/**
  96. 	 * 查询图谱节点和关系（条件无节点标签）
  97. 	 *
  98. 	 * @param query
  99. 	 * @return node relationship
  100. 	 */
  101. 	public HashMap<String, Object> getNodeNameGraph(GraphQuery query) {
  102. 		HashMap<String, Object> nr = new HashMap<String, Object>();
  103. 		try {
  104. 			// MATCH (n) -[r]-(m:症状) where r.name='治疗' or r.name='危险因素' return n,m
  105. 			String cqr = "";
  106. 			List<String> lis = new ArrayList<String>();
  107. 			if (query.getRelation() != null && query.getRelation().length > 0) {
  108. 				for (String r : query.getRelation()) {
  109. 					String it = String.format("r.name='%s'", r);
  110. 					lis.add(it);
  111. 				}
  112. 				cqr = String.join(" or ", lis);
  113. 			}
  114. 			String cqWhere = "";
  115. 			if (!StringUtils.isBlank(query.getNodename()) || !StringUtils.isBlank(cqr)) {
  116.  
  117. 				if (!StringUtils.isBlank(query.getNodename())) {
  118. 					if (query.getMatchtype() == 1) {
  119. 						cqWhere = String.format("where n.name ='%s' ", query.getNodename());
  120.  
  121. 					} else {
  122. 						cqWhere = String.format("where n.name contains('%s')", query.getNodename());
  123. 					}
  124. 				}
  125. 				String nodeOnly = cqWhere;
  126. 				if (!StringUtils.isBlank(cqr)) {
  127. 					if (StringUtils.isBlank(cqWhere)) {
  128. 						cqWhere = String.format(" where ( %s )", cqr);
  129.  
  130. 					} else {
  131. 						cqWhere += String.format(" and ( %s )", cqr);
  132. 					}
  133. 				}
  134. 				// 下边的查询查不到单个没有关系的节点,考虑要不要左箭头
  135. 				String nodeSql = String.format("MATCH (n) <-[r]->(m) %s return * limit %s", cqWhere,
  136. 						query.getPageSize());
  137. 				HashMap<String, Object> graphNode = neo4jUtil.getGraphNodeAndShip(nodeSql);
  138. 				Object node = graphNode.get("node");
  139. 				// 没有关系显示则显示节点
  140. 				if (node != null) {
  141. 					nr.put("node", graphNode.get("node"));
  142. 					nr.put("relationship", graphNode.get("relationship"));
  143. 				} else {
  144. 					String nodecql = String.format("MATCH (n) %s RETURN distinct(n) limit %s",
  145. 							nodeOnly, query.getPageSize());
  146. 					List<HashMap<String, Object>> nodeItem = neo4jUtil.getGraphNode(nodecql);
  147. 					nr.put("node", nodeItem);
  148. 					nr.put("relationship", new ArrayList<HashMap<String, Object>>());
  149. 				}
  150. 			} else {
  151. 				String nodeSql = String.format("MATCH (n) %s RETURN distinct(n) limit %s", cqWhere,
  152. 						query.getPageSize());
  153. 				List<HashMap<String, Object>> graphNode = neo4jUtil.getGraphNode(nodeSql);
  154. 				nr.put("node", graphNode);
  155. 				String domainSql = String.format("MATCH (n)<-[r]-> (m) %s RETURN distinct(r) limit %s",
  156. 						cqWhere, query.getPageSize());// m是否加领域
  157. 				List<HashMap<String, Object>> graphRelation = neo4jUtil.getGraphRelationShip(domainSql);
  158. 				nr.put("relationship", graphRelation);
  159. 			}
  160. 		} catch (Exception e) {
  161. 			e.printStackTrace();
  162. 		}
  163. 		return nr;
  164. 	}

2.5.4 swagger界面

三 加载CSV文件，添加图库数据

3.1 准备CSV文件

3.2 上传CSV文件至import目录下

3.3 加载CSV文件

  1. 删除所有节点
  2. MATCH (n)
  3. OPTIONAL MATCH (n)-[r]-()
  4. DELETE n,r
  5.  
  6. 加载train CSV
  7. LOAD CSV WITH HEADERS FROM 'file:///train.csv' as line
  8. CREATE (:train {train_id:line.train_id,train_type:line.train_type,name:line.train_name,create_time:line.create_time})
  9.  
  10. 加载task CSV
  11. LOAD CSV WITH HEADERS FROM 'file:///task.csv' as line
  12. CREATE (:task {task_id:line.task_id,train_id:line.train_id,name:line.task_name,create_time:line.create_time})
  13.  
  14. 创建train和task关系
  15. LOAD CSV WITH HEADERS FROM "file:///tt.csv" AS line
  16. MATCH(a:train{train_id:line.train_id}),(b:task{task_id:line.task_id})
  17. MERGE(a) -[r:关联]->(b)
  18.  
  19. 创建索引
  20. CREATE INDEX ON :train(train_id)
  21. CREATE INDEX ON :task(task_id)

3.4 图库数据

四 前端界面

前端实现技术：

cytoscape.js 官方地址：https://js.cytoscape.org/

d3.js 官方地址：D3 by Observable | The JavaScript library for bespoke data visualization

vis.js 官方地址：vis.js

普通查询

高级查询

五 源码

码云源码地址：spring-boot2-neo4j: spring-boot2-neo4j是精简的图库项目，基于Spring Boot2和Neo4j实现。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/641559
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号