原標題：Spring認證中國教育管理中心-了解如何在 Neo4j 的 NoSQL 數據存儲中持久化對象和關系。（Spring中國教育管理中心）

本指南將引導您完成使用Spring Data Neo4j構建應用程序的過程，該應用程序在 Neo4j 中存儲數據并從中檢索數據，Neo4j是一個基于圖形的數據庫。

你將建造什么

您將使用 Neo4j 的NoSQL基于圖形的數據存儲來構建嵌入式 Neo4j 服務器、存儲實體和關系以及開發查詢。

你需要什么

• 約15分鐘
• 最喜歡的文本編輯器或 IDE
• JDK 1.8或更高版本
• Gradle 4+或Maven 3.2+
• 您還可以將代碼直接導入 IDE：彈簧工具套件 (STS)IntelliJ IDEA

如何完成本指南

像大多數 Spring入門指南一樣，您可以從頭開始并完成每個步驟，也可以繞過您已經熟悉的基本設置步驟。無論哪種方式，您最終都會得到工作代碼。

要從頭開始，請繼續從 Spring Initializr 開始。

要跳過基礎知識，請執行以下操作：

• 下載并解壓本指南的源代碼庫，或使用Git克隆它：git clone https://github.com/spring-guides/gs-accessing-data-neo4j.git
• 光盤進入gs-accessing-data-neo4j/initial
• 跳轉到定義一個簡單實體。

完成后，您可以對照中的代碼檢查結果
gs-accessing-data-neo4j/complete。

從 Spring Initializr 開始

您可以使用這個預先初始化的項目并單擊 Generate 下載 ZIP 文件。此項目配置為適合本教程中的示例。

手動初始化項目：

1. 導航到https://start.spring.io。該服務提取應用程序所需的所有依賴項，并為您完成大部分設置。
2. 選擇 Gradle 或 Maven 以及您要使用的語言。本指南假定您選擇了 Java。
3. 單擊Dependencies并選擇Spring Data Neo4j。
4. 單擊生成。
5. 下載生成的 ZIP 文件，該文件是根據您的選擇配置的 Web 應用程序的存檔。

如果您的 IDE 具有 Spring Initializr 集成，您可以從您的 IDE 完成此過程。

你也可以從 Github 上 fork 項目并在你的 IDE 或其他編輯器中打開它。

建立 Neo4j 服務器

在構建此應用程序之前，您需要設置 Neo4j 服務器。

Neo4j 有一個開源服務器，您可以免費安裝。

在安裝了 Homebrew 的 Mac 上，運行以下命令：

$釀造安裝neo4j

有關其他選項，請訪問
https://neo4j.com/download/community-edition/。

安裝后，通過運行以下命令以默認設置啟動它：

$ neo4j 開始

您應該會看到類似于以下內容的輸出：

啟動 Neo4j。
啟動 neo4j (pid 96416)。默認情況下，它位于 http://localhost:7474/
在服務器準備好之前可能會有短暫的延遲。
有關當前狀態，請參見 /usr/local/Cellar/neo4j/3.0.6/libexec/logs/neo4j.log。

默認情況下，Neo4j 的用戶名和密碼為neo4jand neo4j。但是，它需要更改新的帳戶密碼。為此，請運行以下命令：

curl -v -u neo4j:neo4j POST localhost:7474/user/neo4j/password -H "Content-type:application/json" -d "{"password":"secret"}"

這會將密碼從 更改neo4j為secret?- 在生產中不要做的事情！完成該步驟后，您應該準備好運行本指南的其余部分。

定義一個簡單的實體

Neo4j 捕獲實體及其關系，這兩個方面同等重要。想象一下，您正在為一個系統建模，您在其中存儲每個人的記錄。但是，您還想跟蹤一個人的同事（teammates在本例中）。使用 Spring Data Neo4j，您可以使用一些簡單的注釋來捕獲所有這些，如以下清單（in 中
src/main/java/com/example/accessingdataneo4j/Person.java）所示：

package com.example.accessingdataneo4j;

import java.util.Collections;
import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

import org.springframework.data.neo4j.core.schema.Id;
import org.springframework.data.neo4j.core.schema.Node;
import org.springframework.data.neo4j.core.schema.Property;
import org.springframework.data.neo4j.core.schema.Relationship;
import org.springframework.data.neo4j.core.schema.GeneratedValue;

@Node
public class Person {

  @Id @GeneratedValue private Long id;

  private String name;

  private Person() {
    // Empty constructor required as of Neo4j API 2.0.5
  };

  public Person(String name) {
    this.name = name;
  }

  /**
   * Neo4j doesn't REALLY have bi-directional relationships. It just means when querying
   * to ignore the direction of the relationship.
   * https://dzone.com/articles/modelling-data-neo4j
   */
  @Relationship(type = "TEAMMATE")
  public Set teammates;

  public void worksWith(Person person) {
    if (teammates == null) {
      teammates = new HashSet<>();
    }
    teammates.add(person);
  }

  public String toString() {

    return this.name + "'s teammates => "
      + Optional.ofNullable(this.teammates).orElse(
          Collections.emptySet()).stream()
            .map(Person::getName)
            .collect(Collectors.toList());
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }
}

在這里，您有一個Person只有一個屬性的類：name.

該類Person用 注釋@NodeEntity。Neo4j 存儲它時，會創建一個新節點。這個類也有一個id標記@GraphId。Neo4j@GraphId在內部使用來跟蹤數據。

下一個重要的部分是teammates. 它很簡單Set，但被標記為@Relationship。這意味著這個集合的每個成員都應該作為一個單獨的Person節點存在。注意方向是如何設置的UNDIRECTED。這意味著當您查詢TEAMMATE關系時，Spring Data Neo4j 會忽略關系的方向。

使用該worksWith()方法，您可以輕松地將人們聯系在一起。

最后，您有一個方便的toString()方法可以打印出該人的姓名和該人的同事。

創建簡單查詢

Spring Data Neo4j 專注于在 Neo4j 中存儲數據。但它繼承了 Spring Data Commons 項目的功能，包括派生查詢的能力。本質上，您不需要學習 Neo4j 的查詢語言。相反，您可以編寫一些方法并讓查詢為您編寫。

要了解其工作原理，請創建一個查詢Person節點的接口。以下清單 (in
src/main/java/com/example/accessingdataneo4j/PersonRepository.java) 顯示了這樣一個查詢：

package com.example.accessingdataneo4j;

import java.util.List;
import org.springframework.data.neo4j.repository.Neo4jRepository;

public interface PersonRepository extends Neo4jRepository {

  Person findByName(String name);
  List findByTeammatesName(String name);
},>

PersonRepository擴展Neo4jRepository接口并插入其操作的類型：Person. 該接口帶有許多操作，包括標準的 CRUD（創建、讀取、更新和刪除）操作。

但是您可以通過聲明它們的方法簽名來定義其他查詢。在這種情況下，您添加了findByName，它會查找類型節點Person并找到與 上匹配的節點name。您還有findByTeammatesName，它會尋找一個Person節點，深入到teammates字段的每個條目，并根據隊友的name.

訪問 Neo4j 的權限

Neo4j 社區版需要憑據才能訪問它。您可以通過設置幾個屬性（在 中
src/main/resources/application.properties）來配置這些憑據，如以下清單所示：

spring.neo4j.uri=bolt://localhost:7687
spring.data.neo4j.username=neo4j
spring.data.neo4j.password=secret

這包括默認用戶名 ( neo4j) 和我們之前選擇的新設置的密碼 ( secret)。

不要將真實憑據存儲在您的源存儲庫中。相反，使用Spring Boot 的 property overrides在運行時配置它們。

創建應用程序類

Spring Initializr 為應用程序創建一個簡單的類。以下清單顯示了 Initializr 為本示例創建的類（在 中
src/main/java/com/example/accessingdataneo4j/AccessingDataNeo4jApplication.java）：

package com.example.accessingdataneo4j;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AccessingDataNeo4jApplication {

  public static void main(String[] args) {
    SpringApplication.run(AccessingDataNeo4jApplication.class, args);
  }

}

@SpringBootApplication是一個方便的注釋，它添加了以下所有內容：

• @Configuration: 將類標記為應用程序上下文的 bean 定義源。
• @EnableAutoConfiguration：告訴 Spring Boot 根據類路徑設置、其他 bean 和各種屬性設置開始添加 bean。例如，如果spring-webmvc位于類路徑上，則此注釋將應用程序標記為 Web 應用程序并激活關鍵行為，例如設置DispatcherServlet.
• @ComponentScan: 告訴 Spring 在包中查找其他組件、配置和服務com/example，讓它找到控制器。

該main()方法使用 Spring Boot 的SpringApplication.run()方法來啟動應用程序。您是否注意到沒有一行 XML？也沒有web.xml文件。這個 Web 應用程序是 100% 純 Java，您不必處理任何管道或基礎設施的配置。

只要它們包含在@SpringBootApplication類的同一個包（或子包）中，Spring Boot 就會自動處理這些存儲庫。為了更好地控制注冊過程，您可以使用@EnableNeo4jRepositories注釋。

默認情況下，@EnableNeo4jRepositories掃描當前包以查找擴展 Spring Data 存儲庫接口之一的任何接口。basePackageClasses=MyRepository.class如果您的項目布局有多個項目并且找不到您的存儲庫，您可以使用它來安全地告訴 Spring Data Neo4j 按類型掃描不同的根包。

顯示記錄輸出。該服務應在幾秒鐘內啟動并運行。

PersonRepository現在自動裝配您之前定義的實例。Spring Data Neo4j 動態實現該接口并插入所需的查詢代碼以滿足接口的義務。

該main方法使用 Spring BootSpringApplication.run()啟動應用程序并調用CommandLineRunner構建關系的方法。

在本例中，您將創建三個本地Person實例：Greg、Roy 和 Craig。最初，它們只存在于內存中。請注意，沒有人是任何人的隊友（目前）。

起初，你找到 Greg，表明他與 Roy 和 Craig 合作，然后再次堅持他。請記住，隊友關系被標記為UNDIRECTED（即雙向）。這意味著 Roy 和 Craig 也已更新。

這就是為什么當您需要更新 Roy 時。首先從 Neo4j 獲取該記錄至關重要。在將 Craig 添加到列表之前，您需要了解 Roy 隊友的最新狀態。

為什么沒有代碼可以獲取 Craig 并添加任何關系？因為你已經擁有了！格雷格早些時候將克雷格標記為隊友，羅伊也是如此。這意味著無需再次更新 Craig 的關系。當您遍歷每個團隊成員并將他們的信息打印到控制臺時，您可以看到它。

最后，查看您向后看的其他查詢，回答“誰與誰一起工作？”的問題。

以下清單顯示了完成的
AccessingDataNeo4jApplication類 (at
src/main/java/com/example/accessingdataneo4j/AccessingDataNeo4jApplication.java)：

package com.example.accessingdataneo4j;

import java.util.Arrays;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.data.neo4j.repository.config.EnableNeo4jRepositories;

@SpringBootApplication
@EnableNeo4jRepositories
public class AccessingDataNeo4jApplication {

	private final static Logger log = LoggerFactory.getLogger(AccessingDataNeo4jApplication.class);

	public static void main(String[] args) throws Exception {
		SpringApplication.run(AccessingDataNeo4jApplication.class, args);
		System.exit(0);
	}

	@Bean
	CommandLineRunner demo(PersonRepository personRepository) {
		return args -> {

			personRepository.deleteAll();

			Person greg = new Person("Greg");
			Person roy = new Person("Roy");
			Person craig = new Person("Craig");

			List team = Arrays.asList(greg, roy, craig);

			log.info("Before linking up with Neo4j...");

			team.stream().forEach(person -> log.info("\t" + person.toString()));

			personRepository.save(greg);
			personRepository.save(roy);
			personRepository.save(craig);

			greg = personRepository.findByName(greg.getName());
			greg.worksWith(roy);
			greg.worksWith(craig);
			personRepository.save(greg);

			roy = personRepository.findByName(roy.getName());
			roy.worksWith(craig);
			// We already know that roy works with greg
			personRepository.save(roy);

			// We already know craig works with roy and greg

			log.info("Lookup each person by name...");
			team.stream().forEach(person -> log.info(
					"\t" + personRepository.findByName(person.getName()).toString()));

			List teammates = personRepository.findByTeammatesName(greg.getName());
			log.info("The following have Greg as a teammate...");
			teammates.stream().forEach(person -> log.info("\t" + person.getName()));
		};
	}

}

構建一個可執行的 JAR

您可以使用 Gradle 或 Maven 從命令行運行應用程序。您還可以構建一個包含所有必要依賴項、類和資源的單個可執行 JAR 文件并運行它。構建可執行 jar 可以在整個開發生命周期、跨不同環境等中輕松地將服務作為應用程序交付、版本化和部署。

如果您使用 Gradle，則可以使用./gradlew bootRun. 或者，您可以使用構建 JAR 文件./gradlew build，然后運行 ?JAR 文件，如下所示：

java -jar build/libs/gs-accessing-data-neo4j-0.1.0.jar

如果您使用 Maven，則可以使用./mvnw spring-boot:run. 或者，您可以使用構建 JAR 文件，./mvnw clean package然后運行該 JAR 文件，如下所示：

java -jar 目標/gs-accessing-data-neo4j-0.1.0.jar

此處描述的步驟創建了一個可運行的 JAR。您還可以構建經典的 WAR 文件。

您應該會看到類似于以下列表的內容（還有其他內容，例如查詢）：

在與 Neo4j 連接之前...
	格雷格的隊友 => []
	羅伊的隊友 => []
	克雷格的隊友 => []

按姓名查找每個人...
	格雷格的隊友 => [羅伊，克雷格]
	羅伊的隊友 => [格雷格，克雷格]
	克雷格的隊友 => [羅伊，格雷格]

您可以從輸出中看到（最初）沒有人通過任何關系連接。然后，在您添加人員后，他們被捆綁在一起。最后，您可以看到根據隊友查找人員的便捷查詢。

總結

恭喜！您剛剛設置了一個嵌入式 Neo4j 服務器，存儲了一些簡單的相關實體，并開發了一些快速查詢。

審核編輯：符乾江