原標題：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 http://github.com/spring-guides/gs-accessing-data-neo4j.git
• 光碟進入gs-accessing-data-neo4j/initial
• 跳轉到定義一個簡單實體。

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

從 Spring Initializr 開始

您可以使用這個預先初始化的專案並單擊 Generate 下載 ZIP 檔案。此專案配置為適合本教程中的示例。

手動初始化專案：

1. 導航到http://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

有關其他選項，請訪問
http://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.
   * http://dzone.com/articles/modelling-data-neo4j
   */
  @Relationship(type = "TEAMMATE")
  public Set<Person> 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, Long> {

  Person findByName(String name);
  List<Person> 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<Person> 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<Person> 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 伺服器，儲存了一些簡單的相關實體，並開發了一些快速查詢。