天天看點
傳回

Spring-Boot使用neo4j-java-driver-- 查找兩個節點之間關系的最短路徑

一、Cypher資料 

     
  1.  create (小北:朋友圈{姓名:"小北", 喜歡的書類:"Poetry"}),       
    2.       
  2.  (小菲:朋友圈{姓名:"小菲", 喜歡的書類:"Science Fiction"}),       
    3.       
  3.  (小鵬:朋友圈{姓名:"小鵬", 喜歡的書類:"Music"}),       
    4.       
  4.  (小穎:朋友圈{姓名:"小穎", 喜歡的書類:"Politics"}),       
    5.       
  5.  (小蘭:朋友圈{姓名:"小蘭", 喜歡的書類:"Music"}),       
    6.       
  6.  (小峰:朋友圈{姓名:"小峰", 喜歡的書類:"Travel"}),       
    7.       
  7.  (小訊:朋友圈{姓名:"小訊", 喜歡的書類:"Poetry"}),       
    8.       
  8.  (小東:朋友圈{姓名:"小東", 喜歡的書類:"Sequential Art"}),       
    9.       
  9.  (小唯:朋友圈{姓名:"小唯", 喜歡的書類:"Young Adult"}),       
    10.       
  10.  (小窦:朋友圈{姓名:"小窦", 喜歡的書類:"Poetry"}),       
    11.       
  11.  (小齊:朋友圈{姓名:"小齊", 喜歡的書類:"Default"}),       
    12.       
  12.  (小林:朋友圈{姓名:"小林", 喜歡的書類:"Poetry"}),       
    13.       
  13.  (小銳:朋友圈{姓名:"小銳", 喜歡的書類:"Default"}),       
    14.       
  14.  (小偉:朋友圈{姓名:"小偉", 喜歡的書類:"Young Adult"}),       
    15.       
  15.  (小玲:朋友圈{姓名:"小玲", 喜歡的書類:"Business"}),       
    16.       
  16.  (小訊)-[:認識]->(小窦),       
    17.       
  17.  (小訊)-[:認識]->(小齊),       
    18.       
  18.  (小訊)-[:認識]->(小林),       
    19.       
  19.  (小訊)-[:認識]->(小鵬),       
    20.       
  20.  (小訊)-[:認識]->(小偉),       
    21.       
  21.  (小訊)-[:認識]->(小峰),       
    22.       
  22.  (小菲)-[:認識]->(小鵬),       
    23.       
  23.  (小菲)-[:認識]->(小峰),       
    24.       
  24.  (小菲)-[:認識]->(小唯),       
    25.       
  25.  (小峰)-[:認識]->(小北),       
    26.       
  26.  (小峰)-[:認識]->(小蘭),       
    27.       
  27.  (小東)-[:認識]->(小林),       
    28.       
  28.  (小東)-[:認識]->(小銳),       
    29.       
  29.  (小東)-[:認識]->(小菲),       
    30.       
  30.  (小鵬)-[:認識]->(小穎),       
    31.       
  31.  (小北)-[:認識]->(小蘭),       
    32.       
  32.  (小穎)-[:認識]->(小東),       
    33.       
  33.  (小唯)-[:認識]->(小鵬),       
    34.       
  34.  (小唯)-[:認識]->(小銳),       
    35.       
  35.  (小偉)-[:認識]->(小玲)       
    36.

二、執行後，neo4j browser中查詢效果如下

Spring-Boot使用neo4j-java-driver-- 查找兩個節點之間關系的最短路徑

三、找出小訊和小銳之間的最短關系路徑

Spring-Boot使用neo4j-java-driver-- 查找兩個節點之間關系的最短路徑

        如上圖，假設給你兩個人，一個人是節點小訊，另一個人是節點小銳，問他們之間的關系最短路徑是什麼？ 或者換句話問，小訊怎麼用最少的步驟聯系到小銳？【前提是，小訊和小銳之間不存在任何關系，否則這種問題就沒有任何意義了，你倆都有關系了，我還問個毛啊，】

       如果你用肉眼觀察的話，你會找到很多種小訊到達小銳的路徑，比如：

1、小訊認識小峰，小菲認識小峰（如果不考慮關系的反向，則認為小峰也同樣認識小菲），小菲又認識小唯，小唯認識小銳

是以這種路徑下小訊聯系小銳的步驟為： 小訊--小峰--小菲--小唯--小銳，路徑長度4

2、同上，我們還可以找出一條長度等于3的路徑：小訊--小林--小東--小銳

...... 等等，如果光靠肉眼觀察的話，像這種資料少的話，勉強還可以捋下來，但是資料一多，就歇菜了，我們可以用neo4j自帶的方法來算出兩個節點之間存在關系的前提下的最短到達路徑Path，比如：

查詢出所有小訊到小銳的關系最短路徑，語句如下：

MATCH n=allshortestPaths((a:朋友圈{姓名:"小訊"})-[*]-(b:朋友圈{姓名:"小銳"})) return n

查詢出的graph效果如下：

下圖示注的序号正是上面我們提到的長度等于3的一條路徑：小訊--小林--小東--小銳

Spring-Boot使用neo4j-java-driver-- 查找兩個節點之間關系的最短路徑

如果我們隻查出最短的一條路徑，我們使用shortestPath的時候隻會查出一條結果，不管結果怎麼樣，反正都是最短路徑！

語句如下：

MATCH n=shortestPath((a:朋友圈{姓名:"小訊"})-[*]-(b:朋友圈{姓名:"小銳"})) return n

Spring-Boot使用neo4j-java-driver-- 查找兩個節點之間關系的最短路徑

四、找出小訊和小銳之間的深度等于4的路徑Path

MATCH (a:朋友圈{姓名:"小訊"}),(b:朋友圈{姓名:"小銳"})

return (a)-[*4]-(b) as p

Spring-Boot使用neo4j-java-driver-- 查找兩個節點之間關系的最短路徑

如果你查找length（path） = 8的結果會怎麼樣呢？

Spring-Boot使用neo4j-java-driver-- 查找兩個節點之間關系的最短路徑

五、demo實作最短路徑資訊輸出

Spring-Boot pom依賴

     
  1.  <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"       
    2.       
  2.  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">       
    3.       
  3.  <modelVersion>4.0.0</modelVersion>       
    4.       
  4.  <groupId>com.appleyk</groupId>       
    5.       
  5.  <artifactId>Spring-Boot-Neo4jAPI</artifactId>       
    6.       
  6.  <version>0.0.1-SNAPSHOT</version>       
    7.       
  7.  <packaging>war</packaging>       
    8.       
  8.  <description>Spring-Boot 內建Neo4j，實作原生JavaAPI的節點、關系操作</description>       
    9.       
  9.  <parent>       
    10.       
  10.  <groupId>org.springframework.boot</groupId>       
    11.       
  11.  <artifactId>spring-boot-starter-parent</artifactId>       
    12.       
  12.  <version>1.5.12.RELEASE</version>       
    13.       
  13.  </parent>       
    14.       
  14.  <properties>       
    15.       
  15.  <java.version>1.8</java.version>       
    16.       
  16.  <janino.version>3.0.8</janino.version>       
    17.       
  17.  </properties>       
    18.       
  18.  <dependencies>       
    19.       
  19.  <dependency>       
    20.       
  20.  <groupId>org.springframework.boot</groupId>       
    21.       
  21.  <artifactId>spring-boot-starter-web</artifactId>       
    22.       
  22.  </dependency>       
    23.       
  23.  <!-- 添加熱部署 devtools：監聽檔案變動 -->       
    24.       
  24.  <!-- 當Java檔案改動時，Spring-boo會快速重新啟動 -->       
    25.       
  25.  <!-- 最簡單的測試，就是随便找一個檔案Ctrl+S一下，就可以看到效果 -->       
    26.       
  26.  <dependency>       
    27.       
  27.  <groupId>org.springframework.boot</groupId>       
    28.       
  28.  <artifactId>spring-boot-devtools</artifactId>       
    29.       
  29.  <!-- optional=true,依賴不會傳遞 -->       
    30.       
  30.  <!-- 本項目依賴devtools；若依賴本項目的其他項目想要使用devtools，需要重新引入 -->       
    31.       
  31.  <optional>true</optional>       
    32.       
  32.  </dependency>       
    33.       
  33.  <!-- Spring 單元測試 -->       
    34.       
  34.  <dependency>       
    35.       
  35.  <groupId>org.springframework.boot</groupId>       
    36.       
  36.  <artifactId>spring-boot-starter-test</artifactId>       
    37.       
  37.  <scope>test</scope>       
    38.       
  38.  </dependency>       
    39.       
  39.  <!-- JUnit單元測試 -->       
    40.       
  40.  <dependency>       
    41.       
  41.  <groupId>junit</groupId>       
    42.       
  42.  <artifactId>junit</artifactId>       
    43.       
  43.  </dependency>       
    44.       
  44.  <!-- https://mvnrepository.com/artifact/org.neo4j.driver/neo4j-java-driver -->       
    45.       
  45.  <dependency>       
    46.       
  46.  <groupId>org.neo4j.driver</groupId>       
    47.       
  47.  <artifactId>neo4j-java-driver</artifactId>       
    48.       
  48.  <version>1.6.1</version>       
    49.       
  49.  </dependency>       
    50.       
  50.  </dependencies>       
    51.       
  51.  </project>       
    52.

demo示範：

     
  1.  import java.util.HashMap;       
    2.       
  2.  import java.util.List;       
    3.       
  3.  import java.util.Map;       
    4.           
  4.  import org.junit.Test;       
    5.       
  5.  import org.neo4j.driver.v1.AuthTokens;       
    6.       
  6.  import org.neo4j.driver.v1.Driver;       
    7.       
  7.  import org.neo4j.driver.v1.GraphDatabase;       
    8.       
  8.  import org.neo4j.driver.v1.Record;       
    9.       
  9.  import org.neo4j.driver.v1.Session;       
    10.       
  10.  import org.neo4j.driver.v1.StatementResult;       
    11.       
  11.  import org.neo4j.driver.v1.Value;       
    12.       
  12.  import org.neo4j.driver.v1.types.Node;       
    13.       
  13.  import org.neo4j.driver.v1.types.Path;       
    14.       
  14.  import org.neo4j.driver.v1.types.Relationship;       
    15.           
  15.  public class Neo4jBatchTest {       
    16.           
  16.  Driver driver = GraphDatabase.driver("bolt://localhost:7687", AuthTokens.basic("neo4j", "n123"));       
    17.       
  17.  private Session session = driver.session();       
    18.           
  18.  /**       
    19.       
  19.  * 批量建立       
    20.       
  20.  *       
    21.       
  21.  * @throws Exception       
    22.       
  22.  */       
    23.       
  23.  @Test       
    24.       
  24.  public void shortEstPath() throws Exception {       
    25.       
  25.  try {       
    26.       
  26.  String cmdSql = "MATCH n=shortestPath((a:朋友圈{姓名:'小訊'})-[*]-"       
    27.       
  27.  + "(b:朋友圈{姓名:'小銳'})) return n";       
    28.       
  28.  StatementResult result = session.run(cmdSql);       
    29.       
  29.  while (result.hasNext()) {       
    30.       
  30.  Record record = result.next();       
    31.       
  31.  List<Value> values = record.values();       
    32.       
  32.  Map<Long, Node> nodesMap = new HashMap<>();       
    33.       
  33.  for (Value value : values) {       
    34.       
  34.  if (value.type().name().equals("PATH")) {       
    35.       
  35.  Path p = value.asPath();       
    36.       
  36.  System.out.println("小訊和小銳之間的關系最短路徑長度為：" + p.length());       
    37.       
  37.  System.out.println("====================================");       
    38.       
  38.  Iterable<Node> nodes = p.nodes();       
    39.       
  39.  for (Node node : nodes) {       
    40.       
  40.  nodesMap.put(node.id(), node);       
    41.       
  41.  }       
    42.           
  42.  /**       
    43.       
  43.  * 列印最短路徑裡面的關系 == 關系包括起始節點的ID和末尾節點的ID，以及關系的type類型       
    44.       
  44.  */       
    45.       
  45.  Iterable<Relationship> relationships = p.relationships();       
    46.       
  46.  for (Relationship relationship : relationships) {       
    47.       
  47.  Long startID = relationship.startNodeId();       
    48.       
  48.  Long endID = relationship.endNodeId();       
    49.       
  49.  String rType = relationship.type();       
    50.       
  50.  /**       
    51.       
  51.  * asMap 相當于 節點的properties屬性資訊       
    52.       
  52.  */       
    53.       
  53.  System.out.println(       
    54.       
  54.  nodesMap.get(startID).asMap() + "-" + rType + "-"       
    55.       
  55.  + nodesMap.get(endID).asMap());       
    56.       
  56.  }       
    57.       
  57.  }       
    58.       
  58.  }       
    59.       
  59.  }       
    60.       
  60.  } catch (Exception e) {       
    61.       
  61.  System.err.println(e.getClass() + "," + e.getMessage());       
    62.       
  62.  }       
    63.       
  63.  }       
    64.           
  64.  }       
    65.

運作方法效果如下：

Spring-Boot使用neo4j-java-driver-- 查找兩個節點之間關系的最短路徑

如果多條的話就：

String cmdSql = "MATCH n=allshortestPaths((a:朋友圈{姓名:'小訊'})-[*]-(b:朋友圈{姓名:'小銳'})) return n";

執行結果：

Spring-Boot使用neo4j-java-driver-- 查找兩個節點之間關系的最短路徑

對比下，在neo4j中查詢的結果

Spring-Boot使用neo4j-java-driver-- 查找兩個節點之間關系的最短路徑

原文位址：https://blog.csdn.net/Appleyk/article/details/80437746

java經驗集錦 通用實踐 db sql Oracle mysql neo4j 圖庫 NoSQL
上一篇: 資料庫模型設計——曆史與版本設計
下一篇: 一文搞定資料倉庫之拉連結清單，流水表，全量表，增量表

繼續閱讀