Neo4j客户端

Spring Data Neo4j 带有一个 Neo4j 客户端，在 Neo4j 的 Java 驱动程序之上提供了一个薄层。spring-doc.cn

虽然普通 Java 驱动程序是一个非常通用的工具，除了命令式和反应式版本之外，还提供异步 API，但它并不与 Spring 应用程序级事务集成。spring-doc.cn

SDN 通过惯用客户端的概念尽可能直接地使用驱动程序。spring-doc.cn

客户有以下主要目标spring-doc.cn

集成到 Springs 事务管理中，适用于命令式和反应式场景spring-doc.cn
必要时参与 JTA 交易spring-doc.cn
为命令式和反应式方案提供一致的 APIspring-doc.cn
不添加任何映射开销spring-doc.cn

SDN 依赖于所有这些功能，并使用它们来实现其实体映射功能。spring-doc.cn

查看 SDN 构建块，了解命令式和反应式 Neo4 客户端在我们的堆栈中的位置。spring-doc.cn

Neo4j 客户端有两种类型：spring-doc.cn

org.springframework.data.neo4j.core.Neo4jClientspring-doc.cn
org.springframework.data.neo4j.core.ReactiveNeo4jClientspring-doc.cn

虽然这两个版本都提供了使用相同词汇和语法的 API，但它们不兼容 API。两个版本都具有相同的 Fluent API 来指定查询、绑定参数和提取结果。spring-doc.cn

命令式还是反应式？

与 Neo4j 客户端的交互通常以调用spring-doc.cn

fetch().one()spring-doc.cn
fetch().first()spring-doc.cn
fetch().all()spring-doc.cn
run()spring-doc.cn

此时，命令式版本将与数据库交互，并获取请求的结果或摘要，包装在或 a 中。Optional<>Collectionspring-doc.cn

相反，反应式版本将返回请求类型的发布者。在订阅发布服务器之前，不会发生与数据库的交互和结果的检索。发布者只能订阅一次。spring-doc.cn

获取客户端的实例

与 SDN 中的大多数内容一样，两个客户端都依赖于配置的驱动程序实例。spring-doc.cn

创建命令式 Neo4j 客户端的实例

import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.Driver;
import org.neo4j.driver.GraphDatabase;

import org.springframework.data.neo4j.core.Neo4jClient;

public class Demo {

    public static void main(String...args) {

        Driver driver = GraphDatabase
            .driver("neo4j://localhost:7687", AuthTokens.basic("neo4j", "secret"));

        Neo4jClient client = Neo4jClient.create(driver);
    }
}

驱动程序只能打开针对 4.0 数据库的反应式会话，并且在任何较低版本上都会失败并出现异常。spring-doc.cn

创建反应式 Neo4j 客户端的实例

import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.Driver;
import org.neo4j.driver.GraphDatabase;

import org.springframework.data.neo4j.core.ReactiveNeo4jClient;

public class Demo {

    public static void main(String...args) {

        Driver driver = GraphDatabase
            .driver("neo4j://localhost:7687", AuthTokens.basic("neo4j", "secret"));

        ReactiveNeo4jClient client = ReactiveNeo4jClient.create(driver);
    }
}

请确保对客户端使用与用于提供或启用事务的相同驱动程序实例。如果您使用驱动程序的另一个实例，则客户端将无法同步事务。Neo4jTransactionManagerReactiveNeo4jTransactionManager

我们的 Spring Boot Starters提供了适合环境（命令式或反应式）的 Neo4j 客户端的即用型 bean，您通常不必配置自己的实例。spring-doc.cn

用法

选择目标数据库

Neo4j 客户端已经为与 Neo4j 4.0 的多数据库功能一起使用做好了充分的准备。除非您另有指定，否则客户端将使用 default 数据库。客户端的 Fluent API 允许在声明要执行的查询后指定目标数据库一次。选择目标数据库与反应式客户端一起演示它：spring-doc.cn

选择目标数据库

Flux<Map<String, Object>> allActors = client
	.query("MATCH (p:Person) RETURN p")
	.in("neo4j") (1)
	.fetch()
	.all();

1	选择要在其中执行查询的目标数据库。

指定查询

与 Client 端的交互从查询开始。查询可以由 plain 或 . 供应商将尽可能晚地进行评估，并且可以由任何查询生成器提供。StringSupplier<String>spring-doc.cn

指定查询

Mono<Map<String, Object>> firstActor = client
	.query(() -> "MATCH (p:Person) RETURN p")
	.fetch()
	.first();

检索结果

如前面的清单所示，与 Client 端的交互总是以调用 And what many results will be received 结束。反应式和命令式客户端产品/服务fetchspring-doc.cn

one(): 预期查询只有一个结果spring-doc.cn
first(): 预期结果并返回第一条记录spring-doc.cn
all(): 检索返回的所有记录spring-doc.cn

命令式客户端分别返回 and，而反应式客户端返回 and ，后者仅在订阅时执行。Optional<T>Collection<T>Mono<T>Flux<T>spring-doc.cn

如果您不希望查询获得任何结果，请在指定查询后使用 use。run()spring-doc.cn

以反应方式检索结果摘要

Mono<ResultSummary> summary = reactiveClient
    .query("MATCH (m:Movie) where m.title = 'Aeon Flux' DETACH DELETE m")
    .run();

summary
    .map(ResultSummary::counters)
    .subscribe(counters ->
        System.out.println(counters.nodesDeleted() + " nodes have been deleted")
    ); (1)

1	通过订阅发布者，在此处触发实际查询。

请花点时间比较两个列表，并了解触发实际查询时的差异。spring-doc.cn

以命令式方式检索结果摘要

ResultSummary resultSummary = imperativeClient
	.query("MATCH (m:Movie) where m.title = 'Aeon Flux' DETACH DELETE m")
	.run(); (1)

SummaryCounters counters = resultSummary.counters();
System.out.println(counters.nodesDeleted() + " nodes have been deleted")

1	此时，将立即触发查询。

映射参数

查询可以包含命名参数（），并且 Neo4j 客户端可以轻松地将值绑定到它们。$someNamespring-doc.cn

客户端不检查是否绑定了所有参数，或者值是否过多。这留给Drivers了。但是，客户端会阻止您使用参数名称两次。

您可以绑定 Java 驱动程序无需转换即可理解的简单类型，也可以绑定复杂类。对于复杂的类，您需要提供一个 Binder 函数，如下面的清单所示。请查看驱动程序手册，了解支持哪些 simple 类型。spring-doc.cn

映射简单类型

Map<String, Object> parameters = new HashMap<>();
parameters.put("name", "Li.*");

Flux<Map<String, Object>> directorAndMovies = client
	.query(
		"MATCH (p:Person) - [:DIRECTED] -> (m:Movie {title: $title}), (p) - [:WROTE] -> (om:Movie) " +
			"WHERE p.name =~ $name " +
			"  AND p.born < $someDate.year " +
			"RETURN p, om"
	)
	.bind("The Matrix").to("title") (1)
	.bind(LocalDate.of(1979, 9, 21)).to("someDate")
	.bindAll(parameters) (2)
	.fetch()
	.all();

1	有一个用于绑定简单类型的 Fluent API。
2	或者，可以通过命名参数的 map 来绑定参数。

SDN 执行许多复杂的映射，并且它使用可从客户端使用的相同 API。spring-doc.cn

你可以为任何给定的域对象（如 Example 中的自行车所有者）提供域类型给 Neo4j Client，以将这些域对象映射到驾驶员可以理解的参数。Function<T, Map<String, Object>>spring-doc.cn

域类型的示例

public class Director {

    private final String name;

    private final List<Movie> movies;

    Director(String name, List<Movie> movies) {
        this.name = name;
        this.movies = new ArrayList<>(movies);
    }

    public String getName() {
        return name;
    }

    public List<Movie> getMovies() {
        return Collections.unmodifiableList(movies);
    }
}

public class Movie {

    private final String title;

    public Movie(String title) {
        this.title = title;
    }

    public String getTitle() {
        return title;
    }
}

映射函数必须填写查询中可能出现的所有命名参数，例如使用映射函数绑定域对象显示：spring-doc.cn

使用映射函数绑定域对象

Director joseph = new Director("Joseph Kosinski",
        Arrays.asList(new Movie("Tron Legacy"), new Movie("Top Gun: Maverick")));

Mono<ResultSummary> summary = client
    .query(""
        + "MERGE (p:Person {name: $name}) "
        + "WITH p UNWIND $movies as movie "
        + "MERGE (m:Movie {title: movie}) "
        + "MERGE (p) - [o:DIRECTED] -> (m) "
    )
    .bind(joseph).with(director -> { (1)
        Map<String, Object> mappedValues = new HashMap<>();
        List<String> movies = director.getMovies().stream()
            .map(Movie::getTitle).collect(Collectors.toList());
        mappedValues.put("name", director.getName());
        mappedValues.put("movies", movies);
        return mappedValues;
    })
    .run();

1	该方法允许指定 binder 函数。`with`

使用结果对象

两个客户端都返回 maps （）的集合或 publisher。这些映射与查询可能生成的记录完全对应。Map<String, Object>spring-doc.cn

此外，您可以插入自己的 through 来重现您的域对象。BiFunction<TypeSystem, Record, T>fetchAsspring-doc.cn

使用映射函数读取域对象

Mono<Director> lily = client
    .query(""
        + " MATCH (p:Person {name: $name}) - [:DIRECTED] -> (m:Movie)"
        + "RETURN p, collect(m) as movies")
    .bind("Lilly Wachowski").to("name")
    .fetchAs(Director.class).mappedBy((TypeSystem t, Record record) -> {
        List<Movie> movies = record.get("movies")
            .asList(v -> new Movie((v.get("title").asString())));
        return new Director(record.get("name").asString(), movies);
    })
    .one();

TypeSystem提供对底层 Java 驱动程序用于填充记录的类型的访问权限。spring-doc.cn

使用域感知映射函数

如果您知道查询结果将包含在应用程序中具有实体定义的节点，你可以使用 injectable 来检索它们的 mapping 函数，并在 mapping 期间应用它们。MappingContextspring-doc.cn

使用现有映射函数

BiFunction<TypeSystem, MapAccessor, Movie> mappingFunction = neo4jMappingContext.getRequiredMappingFunctionFor(Movie.class);
Mono<Director> lily = client
    .query(""
        + " MATCH (p:Person {name: $name}) - [:DIRECTED] -> (m:Movie)"
        + "RETURN p, collect(m) as movies")
    .bind("Lilly Wachowski").to("name")
    .fetchAs(Director.class).mappedBy((TypeSystem t, Record record) -> {
        List<Movie> movies = record.get("movies")
            .asList(movie -> mappingFunction.apply(t, movie));
        return new Director(record.get("name").asString(), movies);
    })
    .one();

使用托管事务时直接与驱动程序交互

如果您不想或不喜欢或 the 的固执己见的“客户端”方法，您可以让客户端将与数据库的所有交互委托给您的代码。委托后的交互与 Client 端的命令式和反应式版本略有不同。Neo4jClientReactiveNeo4jClientspring-doc.cn

命令式版本将 a 作为回调。返回空 optional 是可以的。Function<StatementRunner, Optional<T>>spring-doc.cn

将数据库交互委托给命令式StatementRunner

Optional<Long> result = client
    .delegateTo((StatementRunner runner) -> {
        // Do as many interactions as you want
        long numberOfNodes = runner.run("MATCH (n) RETURN count(n) as cnt")
            .single().get("cnt").asLong();
        return Optional.of(numberOfNodes);
    })
    // .in("aDatabase") (1)
    .run();

1	选择目标数据库中所述的数据库选择是可选的。

反应式版本接收一个 .RxStatementRunnerspring-doc.cn

将数据库交互委托给反应式RxStatementRunner

Mono<Integer> result = client
    .delegateTo((RxStatementRunner runner) ->
        Mono.from(runner.run("MATCH (n:Unused) DELETE n").summary())
            .map(ResultSummary::counters)
            .map(SummaryCounters::nodesDeleted))
    // .in("aDatabase") (1)
    .run();

1	目标数据库的可选选择。

请注意，在将数据库交互委托给命令式 StatementRunner 和将数据库交互委托给反应式 RxStatementRunner 中，仅说明了运行程序的类型，以便为本手册的读者提供更清晰的信息。spring-doc.cn