原标题：Spring认证中国教育管理中心-了解如安在 Neo4j 的 NoSQL 数据存储中耐久化目标和联系。（Spring中国教育管理中心）

了解如何在 Neo4j 的 NoSQL 数据存储中持久化对象和关系

本攻略将引导您完结运用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 github.com/spring-guid…
  • 光盘进入gs-accessing-data-neo4j/initial
  • 跳转到界说一个简单实体。

完结后，您能够对照中的代码检查结果
gs-accessing-data-neo4j/complete。

从 Spring Initializr 开端

您能够运用这个预先初始化的项目并单击 Generate 下载 ZIP 文件。此项目装备为适合本教程中的示例。

手动初始化项目：

  1. 导航到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

有关其他选项，请访问
neo4j.com/download/co…

装置后，经过运转以下指令以默许设置发动它：

$ 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<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 服务器，存储了一些简单的相关实体，并开发了一些快速查询。