【头歌实训】SpringBoot 整合 Neo4j 实战_头歌springboot

第1关：认识 Spring DATA Neo4J

任务描述

本关任务：了解关于 Neo4j 在 SpringBoot 中的关系和联系。

相关知识

为了完成本关任务，你需要掌握： 1.Spring DATA Neo4J - 简介； 2.Spring DATA Neo4J - 结构。

Spring DATA Neo4J - 简介

Spring是开源框架，很容易开发基于企业 Java 的应用程序。 它用Java语言编写。

Spring Framework 提供了以下模块来处理基于 Java 的应用程序的 DAO 层：

• Spring JDBC
• Spring ORM
• Spring DATA

如果我们观察任何基于 Java 的 n 层应用程序，我们通常会找到以下层。

层次结构

这里DAO（数据访问对象）层负责实现数据库操作。

我们需要为每个实体（Say one Database Table）实现两套工件。

例如：

如果我们在我们的数据库中有一个PROFILE表，那么我们需要提供一个 Profile Entity 类（POJO）。 然后我们需要提供一个 DAO 接口和一个 DAO 实现类。

这里我们需要选择 Spring JDBC 或 Spring ORM 来实现这些工件。

选择类

Spring JDBC / Spring ORM 模块的缺点：

• 大量的 boiler plate 代码来执行简单的数据库操作；
• 增加了大量 DAO 层工件的维护；
• 增加实现大量 DAO 图构件的开发时间。

Spring 数据模块的优点：

• 消除 DAO 层中的 boiler plate 代码；
• DAO 层中的工件少；
• 易于开发和维护；
• 改进开发过程。

Spring 数据模块功能：

• 支持基于XML的实体映射；
• 支持基于注释的实体映射；
• 支持分页；
• 支持事务；
• 更少的 DAO 层工件-实现存储库；
• Spring DATA Neo4j 模块具有与上述相同的优点和特点。

Spring DATA Neo4j 模块的附加功能：

• 支持Neo4j属性图模块；
• 支持Neo4j Lucence索引；
• 支持Neo4j CQL；
• Neo4jTemplate。

Spring DATA Neo4j - 结构

Spring DATA Neo4j 模块

Spring DATA 模块适用于为各种数据库实现 DAO 层。 它通过避免一些不需要的工件（DAO 实现）来改进应用程序开发过程。

关系数据库（Oracle，MySQL 等等）。 没有 SQL 数据库（MongoDB，Redis，Apache Cassandra 等） 无 SQL 图形数据库（Neo4j 等）。 在本实训中，我们将讨论 Spring DATA Neo4j 模块架构。 这个架构几乎类似于上面提到的所有类型的数据库。 它仅在几个组件名称不同。

Spring DATA Neo4j 架构

在开始 Spring DATA Neo4j 开发之前，首先我们将了解这个模块的架构。

下图显示了Spring DATA Neo4j 模块的体系结构。

Spring DATA Neo4j 存储库

它提供了不同的 API 来支持不同的场景。

• GraphRepository：它用于执行 Basic Neo4j DB 操作。
• GraphTemplate：像其他模块一样，它是执行 Neo4j DB 操作的 Spring 模板。
• CrudRepository：它用于使用 Cypher 查询语言（CQL）执行 Neo4j CRUD 操作。
• PaginationAndSortingRepository：它用于执行 Neo4j CQL 查询结果的分页和排序。 这些是 Java 类。 每个具有执行 Neo4j 数据库操作的特定目的。

Neo4j 驱动程序：当我们使用 Spring DATA Neo4j 模块 API 来执行一些数据库操作时，Spring DATA Neo4j Jars 在内部使用这些驱动程序 Jars 来交互和执行 Neo4j 数据库操作。

本关要求

根据相关知识完成右侧选择题。

测试说明

若选择题答案与正确答案一致则可通关。

题目答案

1、下面属于 Spring JDBC 模块的缺点的是：C
A、少量的 boiler plate 代码来执行简单的数据库操作
B、减少了大量 DAO 层工件的维护
C、增加实现大量 DAO 图构件的开发时间
D、DAO 层中的工件少

2、下面属于 Spring 数据模块的优点是：ABCD
A、消除 DAO 层中的 boiler plate 代码
B、DAO 层中的工件少
C、易于开发和维护
D、改进开发过程

3、Spring DATA Neo4j 存储库 提供了哪些不同的 API 来支持不同的场景。ABCD
A、GraphRepository
B、GraphTemplate
C、CrudRepository
D、PaginationAndSortingRepository

4、Spring 是▁▁▁框架，很容易开发基于企业 Java 的应用程序。
填空1答案：开源

5、Spring DATA 模块仅适用于为 Neo4j 数据库实现 DAO 层。
错误
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

第2关：Spring DATA Neo4J

任务描述

本关任务：基于 SpringBoot 查询 Neo4j 中的信息。

相关知识

为了完成本关任务，你需要掌握：

1. Spring DATA Neo4J 环境；
2. Spring DATA Neo4j 示例。

Spring DATA Neo4J 环境

在 Pom 文件中添加需要的依赖。

Spring DATA Neo4j 模块 Jar 文件：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-neo4j</artifactId>
        </dependency>
1
2
3
4

这个依赖是最重要的，里面包含了 Neo4j 所需的所有 Jar 文件。

基于 SpringBoot 所需要的完整 pom 文件为：

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-neo4j</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

配置 ：

# 连接的 Neo4j 数据库地址
spring.data.neo4j.uri= bolt://localhost:11002
# username
spring.data.neo4j.username=neo4j
# password
spring.data.neo4j.password=123456
1
2
3
4
5
6

Spring DATA Neo4j 示例

Spring DATA Neo4j 模块注释

我们将使用以下 Spring Framework 注释来开发此应用程序。

实现 Spring DATA Neo4j 应用程序的简要步骤：

• 开发图表实体或域或 POJO 类；
• 开发 DAO 或存储库；
• 开发服务层（如果需要）；
• Spring DATA Neo4j XML 配置。

Entity 实体类模块

需要创建一个 entity 包，存放实体类。 在包下创建一个实体类 Person 类：

import lombok.Data;
import org.neo4j.ogm.annotation.GeneratedValue;
import org.neo4j.ogm.annotation.Id;
import org.neo4j.ogm.annotation.NodeEntity;
import org.neo4j.ogm.annotation.Property;
import java.io.Serializable;
@Data
// 设置节点标签
@NodeEntity(label = "person")
// 序列化
public class Person implements Serializable {
    // 自动生成 id
    @Id
    @GeneratedValue
    private Long id;
    // 设置属性
    @Property
    private String name;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

关键注释：

• @Data：自动创建 Get、Set 方法;
• @NodeEntity(label = "person")：设置节点实体的标签;
• @Id、@GeneratedValue：自动生成节点 id；
• @Property：设置节点属性。

开发 Spring DATA Neo4j 存储库

Spring DATA Neo4j 将在内部为此接口提供实现。 为我们的 Person 类定义一个存储库或 DAO 接口：PersonRepository，接口需要继承 Neo4jRepository<T,ID>接口。（T 为你要传入的实体类） PersonRepository：

public interface PersonRepository extends Neo4jRepository<Person,Long> {
    
}
1
2
3

创建完后我们就可以直接对 PersonRepository 接口进行实例化，直接调用，我们所需要的方法即可。 可以实现的数据库操作为：

• 增：save(Entity)

  // 创建实体类
  Person person = new Person();
  // 设置实体类属性
  person.setName("玉皇大帝");
  // 使用接口创建节点
  personRepository.save(person);
  1
  2
  3
  4
  5
  6

• 删：deleteAll()、deleteByID()、delete() deleteAll()：删除所有节点； deleteByID(id)：传入所需要删除节点的 Id，即可删除其节点； delete(entity)：传入一个实体类，即可删除与这个实体类相同的属性的节点。

• 查：findAll()、findById() findById(id)：通过节点的 Id 对节点进行查询； findAll()：查询所有节点暑假。、； findAll(int i)：查询关系深度； findAll(Sort sort)：选择排序方式进行查询所有节点信息。

• 改：可以通过结合前面三中方法进行操作。

编程要求

根据提示，在右侧编辑器补充代码， 完成四个文件代码文件的内容补充：PersonRepository.java、testController.java、Person.java、application.properties。

1. 创建 Person 类：属性为 name：演员姓名、born：出生年份，节点标签为：person；

2. 配置 Neo4j 数据库连接配置；Neo4j 数据库的端口号为：7687

3. 使用接口和实体类进行创建节点，创建 3 个节点节点属性如下：

   born,name
   1996,汤姆-赫兰德
   1998,赵露思
   2001,张子枫
   1999,吴磊
   1
   2
   3
   4
   5

测试说明

平台会对你编写的代码进行测试：

测试输入：无； 预期输出：

创建成功
n
(:person {name: "汤姆-赫兰德", born: "1996"})
(:person {name: "赵露思", born: "1998"})
(:person {name: "张子枫", born: "2001"})
(:person {name: "吴磊", born: "1999"})
1
2
3
4
5
6

答案

PersonRepository.java

package com.example.comstartneo4j.dao;

import com.example.comstartneo4j.entity.Person;
import org.springframework.data.neo4j.repository.Neo4jRepository;
import org.springframework.stereotype.Repository;
/********** Begin **********/
@Repository
public interface PersonRepository extends Neo4jRepository<Person, Long> {

}
/********** End **********/
1
2
3
4
5
6
7
8
9
10
11

testController.java

package com.example.comstartneo4j.controller;

import com.example.comstartneo4j.dao.PersonRelationshipRepository;
import com.example.comstartneo4j.dao.PersonRepository;
import com.example.comstartneo4j.entity.Person;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.Optional;

@RestController
public class testController {
    /********** Begin **********/
    @Resource
    private PersonRepository personRepository;

    @GetMapping("create")
    public String create() {
        // 创建实体类，并设置实体类属性
        Person proson1 = new Person("汤姆-赫兰德", "1996");
        Person proson2 = new Person("赵露思", "1998");
        Person proson3 = new Person("张子枫", "2001");
        Person proson4 = new Person("吴磊", "1999");
        // 使用接口创建节点
        personRepository.save(proson1);
        personRepository.save(proson2);
        personRepository.save(proson3);
        personRepository.save(proson4);
        
        return "创建成功\n";
    }
    /********** End **********/
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

Person.java

package com.example.comstartneo4j.entity;

import lombok.Data;
import org.neo4j.ogm.annotation.GeneratedValue;
import org.neo4j.ogm.annotation.Id;
import org.neo4j.ogm.annotation.NodeEntity;
import org.neo4j.ogm.annotation.Property;

import java.io.Serializable;
/********** Begin **********/
@Data
// 设置节点标签
@NodeEntity(label = "person")
// 序列化
public class Person implements Serializable {
    // 自动生成 id
    @Id
    @GeneratedValue
    private Long id;
    // 设置属性
    @Property
    private String name;
    private String born;
    
    public Person(String name, String born) {
        this.name = name;
        this.born = born;
    }
}
/********** End **********/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

application.properties

# 应用名称
spring.application.name=com.start.neo4j
# 应用服务 WEB 访问端口
server.port=8081

# neo4j配置信息
/********** Begin **********/
# 连接的 Neo4j 数据库地址
spring.data.neo4j.uri=bolt://localhost:7687
# username
spring.data.neo4j.username=neo4j
# password
spring.data.neo4j.password=123456
/********** End **********/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

注解

下述定义注解如果使用 @Autowired 会报错

@Resource
private PersonRepository personRepository;
1
2

可能是因为 Spring 框架没有可注入的 PersonRepository Bean。在使用 @Resource 注解时，Spring 会尝试找到与所注入 Bean 的名字相匹配的 Bean。如果找不到匹配的 Bean， @Resource 注解会容忍这个缺失，而不会抛出异常。然而，@Autowired 注解需要找到精确匹配的 Bean，否则会抛出异常（"Bean"是指 Spring 容器中的对象实例）。