6

我正在使用 Postgre SQL 玩 R2DBC。我正在尝试的用例是通过 ID 以及语言、演员和类别获取电影。下面是架构

在此处输入图像描述

这是ServiceImpl中对应的一段代码

@Override
public Mono<FilmModel> getById(Long id) { 
    Mono<Film> filmMono = filmRepository.findById(id).switchIfEmpty(Mono.error(DataFormatException::new)).subscribeOn(Schedulers.boundedElastic());
    Flux<Actor> actorFlux = filmMono.flatMapMany(this::getByActorId).subscribeOn(Schedulers.boundedElastic());
    Mono<String> language = filmMono.flatMap(film -> languageRepository.findById(film.getLanguageId())).map(Language::getName).subscribeOn(Schedulers.boundedElastic());
    Mono<String> category = filmMono.flatMap(film -> filmCategoryRepository
                    .findFirstByFilmId(film.getFilmId()))
            .flatMap(filmCategory -> categoryRepository.findById(filmCategory.getCategoryId()))
            .map(Category::getName).subscribeOn(Schedulers.boundedElastic());

    return Mono.zip(filmMono, actorFlux.collectList(), language, category)
            .map(tuple -> {
                FilmModel filmModel = GenericMapper.INSTANCE.filmToFilmModel(tuple.getT1());
                List<ActorModel> actors = tuple
                        .getT2()
                        .stream()
                        .map(act -> GenericMapper.INSTANCE.actorToActorModel(act))
                        .collect(Collectors.toList());
                filmModel.setActorModelList(actors);
                filmModel.setLanguage(tuple.getT3());
                filmModel.setCategory(tuple.getT4());
                return filmModel;
            });
         }

日志显示 4 次拍摄电话

2021-12-16 21:21:20.026 DEBUG 32493 --- [ctor-tcp-nio-10] o.s.r2dbc.core.DefaultDatabaseClient     : Executing SQL statement [SELECT film.* FROM film WHERE film.film_id = $1 LIMIT 2]
2021-12-16 21:21:20.026 DEBUG 32493 --- [actor-tcp-nio-9] o.s.r2dbc.core.DefaultDatabaseClient     : Executing SQL statement [SELECT film.* FROM film WHERE film.film_id = $1 LIMIT 2]
2021-12-16 21:21:20.026 DEBUG 32493 --- [ctor-tcp-nio-12] o.s.r2dbc.core.DefaultDatabaseClient     : Executing SQL statement [SELECT film.* FROM film WHERE film.film_id = $1 LIMIT 2]
2021-12-16 21:21:20.026 DEBUG 32493 --- [actor-tcp-nio-7] o.s.r2dbc.core.DefaultDatabaseClient     : Executing SQL statement [SELECT film.* FROM film WHERE film.film_id = $1 LIMIT 2]
2021-12-16 21:21:20.162 DEBUG 32493 --- [actor-tcp-nio-9] o.s.r2dbc.core.DefaultDatabaseClient     : Executing SQL statement [SELECT language.* FROM language WHERE language.language_id = $1 LIMIT 2]
2021-12-16 21:21:20.188 DEBUG 32493 --- [actor-tcp-nio-7] o.s.r2dbc.core.DefaultDatabaseClient     : Executing SQL statement [SELECT film_actor.actor_id, film_actor.film_id, film_actor.last_update FROM film_actor WHERE film_actor.film_id = $1]
2021-12-16 21:21:20.188 DEBUG 32493 --- [ctor-tcp-nio-10] o.s.r2dbc.core.DefaultDatabaseClient     : Executing SQL statement [SELECT film_category.film_id, film_category.category_id, film_category.last_update FROM film_category WHERE film_category.film_id = $1 LIMIT 1]
2021-12-16 21:21:20.313 DEBUG 32493 --- [ctor-tcp-nio-10] o.s.r2dbc.core.DefaultDatabaseClient     : Executing SQL statement [SELECT category.* FROM category WHERE category.category_id = $1 LIMIT 2]
2021-12-16 21:21:20.563 DEBUG 32493 --- [actor-tcp-nio-7] o.s.r2dbc.core.DefaultDatabaseClient     : Executing SQL statement [SELECT actor.* FROM actor WHERE actor.actor_id = $1 LIMIT 2]

我不是在寻找 SQL 优化（连接等）。我绝对可以让它更高效。但问题是为什么我确实看到了对 Film 表的 4 个 SQL 查询。只是补充一下，我已经修复了代码。但无法理解核心原因。提前致谢。

4

2 回答 2

3

为什么我确实看到了对 Film 表的 4 个 SQL 查询。

原因很简单。您正在订阅Mono<Film>4 次：

Mono<Film> filmMono = filmRepository.findById(id);

Flux<Actor> actorFlux = filmMono.flatMapMany(...); (1)
Mono<String> language = filmMono.flatMap(...); (2)
Mono<String> category = filmMono.flatMap(...); (3)
Mono.zip(filmMono, actorFlux.collectList(), language, category) (4)

每次订阅都会filmMono触发一个新查询。请注意，您可以通过使用Mono#cache运算符将​​其更改filmMono为热源并为所有四个订阅者缓存结果。

于 2021-12-18T08:43:04.250 回答
0

我对你的堆栈不是很熟悉，所以这是一个高层次的回答你的“为什么”。在管道的某个地方（例如，可以确认此线程是否相关的人）将为您提供更具体的答案。

虽然我不是 Spring Daisy（或 Spring 开发人员），但您将一个表达式绑定到filmMono解析为 query select film.* from film....。您在不同的上下文中引用了该表达式四次，它被解析了四次。语句的排序可能是 lib 作者懒惰地评估您在本地绑定的表达式的部分成功尝试，以便它能够批处理四个意外相同的查询。您很可能通过收集到一个实际容器中来解决这个问题，然后映射到该容器而不是绑定到filmMono.

一般来说，这种情况是因为当语言本身不支持惰性求值时，库作者可用的选项并不好。因为任何操作都可能改变数据集，所以库作者必须在以下选项中做出选择：

  • A，构建足够的脚手架以完全记录所需的所有资源，复制数据集以进行任何需要以某种方式改变记录的操作，并希望他们能够检测到任何可能在预期解决的数据集时泄漏脚手架的边缘情况（做到这一点……很难）。
  • B，将每个级别的映射解析为一个查询，对于它出现的每个上下文，以免任何操作以可能使集成者（例如您）感到惊讶的方式改变数据集。
  • C，如上所述，除了复制原始请求之外，只需复制数据......在每一步。Pass-by-copy 在 JVM 上变得非常痛苦，而且像 Clojure 和 Scala 这样的语言通过让开发人员非常具体地确定他们是想要就地变异还是复制然后变异来处理这个问题。

在您的情况下，B 对编写该库的人来说最有意义。事实上，他们显然与 A 足够接近，以至于他们能够批量处理通过解析绑定到 filmMono 的表达式产生的所有查询（它们只是偶然相同），所以让我印象深刻。

可以重写许多访问模式以优化结果查询。您的里程数可能会有所不同……非常不同。熟悉原始 SQL，或者像 GraphQL 这样的专用语言，可以提供比关系映射器更一致的结果，但我更加欣赏良好的 IDE 支持，并且像这样混合域通常意味着放弃自动完成，上下文突出显示，语言服务器解决方案证明和 linting。

鉴于问题的范围是“为什么会发生这种情况？”，即使注意到我对您的堆栈不熟悉，答案是“在本机不支持它的语言中进行惰性评估真的很难。”

于 2021-12-17T07:24:23.703 回答