|
此版本仍在开发中，尚不被认为是稳定的。对于最新的稳定版本，请使用 Spring Data Neo4j 7.5.2！ |
Neo4j客户端
Spring Data Neo4j 附带一个 Neo4j 客户端，在 Neo4j 的 Java 驱动程序之上提供了一个薄层。
虽然普通 Java 驱动程序是一个非常通用的工具，除了命令式和响应式版本之外，它还提供异步 API，但它不与 Spring 应用程序级事务集成。
SDN 通过惯用客户端的概念尽可能直接地使用驱动程序。
客户有以下主要目标
-
集成到 Springs 事务管理中，适用于命令式和响应式场景
-
如有必要，参与 JTA 交易
-
为命令式和响应式方案提供一致的 API
-
不要添加任何映射开销
SDN 依赖于所有这些功能，并使用它们来实现其实体映射功能。
查看 SDN 构建块，了解命令式和响应式 Neo4 客户端在我们堆栈中的位置。
Neo4j 客户端有两种风格：
-
org.springframework.data.neo4j.core.Neo4jClient -
org.springframework.data.neo4j.core.ReactiveNeo4jClient
虽然两个版本都提供了使用相同词汇和语法的 API，但它们与 API 不兼容。 两个版本都具有相同、流畅的 API 来指定查询、绑定参数和提取结果。
命令式还是被动式？
与 Neo4j 客户端的交互通常以调用
-
fetch().one() -
fetch().first() -
fetch().all() -
run()
命令式版本此时将与数据库交互并获取请求的结果或摘要，包装在Optional<>或Collection.
相反，响应式版本将返回请求类型的发布者。 在订阅发布者之前，不会与数据库交互和检索结果。 发布者只能订阅一次。
获取客户端的实例
与 SDN 中的大多数内容一样，两个客户端都依赖于配置的驱动程序实例。
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 数据库打开响应式会话，并且在任何较低版本上都会失败并出现异常。
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);
}
}确保为客户端使用与提供Neo4jTransactionManager或ReactiveNeo4jTransactionManager如果您启用了交易。
如果使用驱动程序的另一个实例，客户端将无法同步事务。 |
我们的 Spring Boot Starters提供了一个适合环境（命令式或响应式）的 Neo4j 客户端的即用型 bean，您通常不必配置自己的实例。
用法
选择目标数据库
Neo4j 客户端已做好充分准备，可与 Neo4j 4.0 的多数据库功能一起使用。除非另有指定，否则客户端将使用默认数据库。 客户端的流畅 API 允许在声明要执行的查询后只指定一次目标数据库。选择目标数据库会使用响应式客户端进行演示：
Flux<Map<String, Object>> allActors = client
.query("MATCH (p:Person) RETURN p")
.in("neo4j") (1)
.fetch()
.all();| 1 | 选择要在其中执行查询的目标数据库。 |
指定查询
与客户的交互从查询开始。
查询可以由普通String或Supplier<String>.
提供商将尽可能晚地进行评估，并且可以由任何查询生成器提供。
Mono<Map<String, Object>> firstActor = client
.query(() -> "MATCH (p:Person) RETURN p")
.fetch()
.first();检索结果
如前面的列表所示，与客户端的交互总是以调用fetch以及将收到多少结果。
被动和命令式客户报价
one()-
期望查询只得到一个结果
first()-
期望结果并返回第一条记录
all()-
检索返回的所有记录
命令式客户端返回Optional<T>和Collection<T>，而响应式客户端返回Mono<T>和Flux<T>，后者仅在订阅时执行。
如果您不期望查询获得任何结果，请使用run()指定查询后。
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 | 实际查询在这里通过订阅发布者来触发。 |
请花点时间比较两个列表，并了解触发实际查询时的差异。
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 | 在这里，查询会立即触发。 |
映射参数
查询可以包含命名参数 （$someName），Neo4j 客户端可以轻松地将值绑定到它们。
| 客户端不会检查是否绑定了所有参数，或者值是否过多。 这留给了Drivers。 但是，客户端会阻止您两次使用参数名称。 |
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 | 有一个流畅的 API 用于绑定简单类型。 |
| 2 | 或者，可以通过命名参数的映射来绑定参数。 |
SDN 执行了许多复杂的映射，并且它使用您可以从客户端使用的相同 API。
您可以提供一个Function<T, Map<String, Object>>对于任何给定的域对象，例如域类型示例中的自行车所有者，将这些域对象映射到驱动程序可以理解的参数。
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;
}
}映射函数必须填写查询中可能出现的所有命名参数，例如使用映射函数绑定域对象显示：
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 | 这with方法允许指定 binder 函数。 |
使用结果对象
两个客户端都返回地图的集合或发布者 （Map<String, Object>).
这些映射与查询可能生成的记录完全对应。
此外，您可以插入自己的BiFunction<TypeSystem, Record, T>通过fetchAs以重现您的域对象。
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 驱动程序用于填充记录的类型。
使用域感知映射函数
如果您知道查询结果将包含应用程序中具有实体定义的节点，
您可以使用注射剂MappingContext检索其映射函数并在映射期间应用它们。
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();使用托管事务时直接与驱动程序交互
如果您不想要或不喜欢约定优于配置的“客户”方法Neo4jClient或ReactiveNeo4jClient，您可以让客户端将与数据库的所有交互委托给您的代码。
委派后的交互与客户端的命令式和响应式版本略有不同。
命令式版本采用Function<StatementRunner, Optional<T>>作为回调。
返回一个空的可选选项是可以的。
StatementRunnerOptional<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 | 选择目标数据库中所述的数据库选择是可选的。 |
响应式版本会收到一个RxStatementRunner.
RxStatementRunnerMono<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说明滑轨的类型只是为了给本手册的读者提供更清晰的信息。