成为Java流大师–第5部分：将联接的数据库表转换为流

是否可以将联接的数据库表转换为Java Stream？答案是肯定的。既然我们已经多次提出这个问题，我们决定写另一篇动手实验文章，解释如何执行更高级的Stream Joins。因此，这里是第六篇中的第五篇，后面还有一个GitHub存储库，其中包含每个单元的说明和练习。

第1部分：创建流
第2部分：中级操作
第三部分：终端操作第4部分：数据库流 第5部分：将联接的数据库表转换为流 第6部分：使用流创建数据库应用程序

流加入

在上一篇文章中，我们指出了Streams与SQL构造之间的巨大相似之处。虽然，在一般情况下，SQL操作JOIN缺少自然映射。因此， Speedment利用自己的
JoinComponent以类型安全的方式连接最多10个表（使用INNER JOIN，RIGHT JOIN，LEFT JOIN或CROSS JOIN）。在更深入地介绍JoinComponent之前，我们将详细说明各个表与联接之间的相似性。

我们以前使用Speedment Manager作为数据库表的句柄。此过程如下所示：

管理器充当数据库表的句柄，并且可以充当流源。 在这种情况下，每一行都对应一个Film实例。

现在，我们希望从多个表中检索数据，仅凭Manager还是不够的。 SQL JOIN查询输出一个虚拟表，该虚拟表以不同方式（例如，取决于联接类型和WHERE子句）组合来自多个表的数据。在Speedment中，该虚拟表表示为Join<T>类型为T元组的Join<T>对象。

连接组件

要检索Join对象，我们需要前面提到的JoinComponent ，它使用了构建器模式。产生的Join对象是可重用的，并充当“虚拟联接表”的句柄，如下图所示：

JoinComponent创建一个Join对象，该对象充当虚拟表的句柄（联接的结果），并且可以充当流源。 在这种情况下，每一行都对应一个Tuple2的实例

现在，我们已经介绍了JoinComponent的概念，我们可以开始演示如何使用它。

多对一

我们从多对一关系开始，其中第一张表中的多行可以与第二张表中的同一行匹配。例如，在许多电影中可以使用一种语言。我们可以使用
JoinCompontent ：

 Join<Tuple2<Film, Language>> join = joinComponent .from(FilmManager.IDENTIFIER) .innerJoinOn(Language.LANGUAGE_ID).equal(Film.LANGUAGE_ID) .build(Tuples::of);

基本上，我们从Film表开始，然后在Language_id：s匹配的行上对Language表执行INNER JOIN。

然后，我们可以使用Join对象在生成的元组上流式传输并全部打印出来以供显示。与Streams一样，即使重用了相同的join-element，也不能保证元素的特定顺序。

 join.stream() .forEach(System.out::println);  Tuple2Impl {FilmImpl { filmId = 1 , title = ACADEMY DINOSAUR, ... }, LanguageImpl {  languageId = 1 , name = English, ... }}  Tuple2Impl {FilmImpl { filmId = 2 , title = ACE GOLDFINGER, ... }, LanguageImpl {  languageId = 1 , name = English, ... }}  Tuple2Impl {FilmImpl { filmId = 3 , title = ADAPTATION HOLES, ... }, LanguageImpl {  languageId = 1 , name = English, ... }}  …

多对多

多对多关系定义为两个表之间的关系，其中第一个表中的多个行可以与第二个表中的多个行匹配。通常使用第三张表来形成这些关系。例如，演员可以参加几部电影，而一部电影通常有几个演员。

Sakila中电影与演员之间的关系由
FilmActor表，该表使用外键引用电影和演员。因此，如果我们想将每个Film条目与该电影的主演演员联系起来，我们需要加入所有三个表：

 Join<Tuple3<FilmActor, Film, Actor>> join = joinComponent .from(FilmActorManager.IDENTIFIER) .innerJoinOn(Film.FILM_ID).equal(FilmActor.FILM_ID) .innerJoinOn(Actor.ACTOR_ID).equal(FilmActor.ACTOR_ID) .build(Tuples::of);

我们从描述电影与演员之间的关系的表开始，并分别在匹配FILM_ID：s和ACTOR_ID：s的情况下与Film和Actor进行表演和INNER JOIN。

收集加入流到地图

现在，我们的Join对象可用于创建与
带有主演Actor List的Film ：s。由于流中的元素是元组，因此我们需要指向所需的条目。这是使用零索引的吸气剂（引用FilmActor get0()等）完成的。

 Map<Film, List<Actor>> actorsInFilms = join.stream() .collect( groupingBy(Tuple3::get1, mapping(Tuple3::get2, toList()) ) );

最后，我们打印条目以显示电影和演员的姓名。

 actorsInFilms.forEach((f, al) -> System.out.format( "%s : %s%n" , f.getTitle(), al.stream() .sorted(Actor.LAST_NAME) .map(a -> a.getFirstName() + " " + a.getLastName()) .collect(joining( ", " ) ) )  );

 WONDERLAND CHRISTMAS : HARRISON BALE, CHRIS BRIDGES, HUMPHREY GARLAND, WOODY JOLIE, CUBA OLIVIER  BUBBLE GROSSE : VIVIEN BASINGER, ROCK DUKAKIS, MENA HOPPER  OPUS ICE : DARYL CRAWFORD, JULIA FAWCETT, HUMPHREY GARLAND, SEAN WILLIAMS  …

筛选表

如果我们最初知道我们只对
Film条目，在定义Join摆脱这些实例会更有效。这是使用.where（）运算符完成的，该运算符等效于流上的filter() （并映射到SQL关键字WHERE）。作为筛选器，它使用评估为true或false的Predicate ，并应使用Speedment Fields进行表达以进行优化。在这里，我们要查找标题以“ A”开头的电影的语言：

 Join<Tuple2<Film, Language>> join = joinComponent .from(FilmManager.IDENTIFIER) .where(Film.TITLE.startsWith(“A”)) .innerJoinOn(Language.LANGUAGE_ID).equal(Film.LANGUAGE_ID) .build(Tuples::of);

如果需要进一步过滤，则可以将任意数量的.where（）操作与幕后的SQL关键字AND组合在一起。

专业建筑商

Sofar我们不得不处理元组的相当抽象的getter（get0，get1等）。尽管在构建连接对象时，我们可以为特殊对象提供任何构造函数。在上面显示的示例中，我们对电影的名称和演员的名字感兴趣。这使我们可以定义自己的对象
TitleActorName ：

 final class TitleActorName {     private final String title; private final String actorName; TitleActorName(Film film, Actor actor) { this .title = film.getTitle(); this .actorName = actor.getFirstName() + actor.getLastName(); } public String title() { return title; } public String actorName() { return actorName; } @Override public String toString() { return "TitleLanguageName{" + "title=" + title + ", actorName=" + actorName + '}' ; }  }

然后，我们将自己的对象的构造函数提供给Join构造函数，并丢弃链接的FilmActor实例，因为它没有被使用：

 Join<TitleActorName> join = joinComponent .from(FilmActorManager.IDENTIFIER) .innerJoinOn(Film.FILM_ID).equal(FilmActor.FILM_ID) .innerJoinOn(Actor.ACTOR_ID).equal(FilmActor.ACTOR_ID) .build((fa, f, a) -> new TitleActorName(f, a));

这极大地提高了涉及所产生的Join对象的任何操作的可读性。

 Map<String, List<String>> actorsInFilms = join.stream() .collect( groupingBy(TitleActorName::title, mapping(TitleActorName::actorName, toList()) ) ); actorsInFilms.forEach((f, al) -> System.out.format( "%s : %s%n" , f, al) );

简化类型

当连接大量表时，编写Java类型可能很Tuple5<...> （例如Tuple5<...> ）。如果您使用Java的最新版本，则可以像下面这样简单地忽略局部变量的类型：

 var join = joinComponent .from(FilmManager.IDENTIFIER) .where(Film.TITLE.startsWith(“A”)) .innerJoinOn(Language.LANGUAGE_ID).equal(Film.LANGUAGE_ID) .build(Tuples::of);

在这种情况下，Java将自动将类型推断为Join<Tuple2<Film, Language>>

如果您使用的是Java的旧版本，则可以像这样内联连接声明和流运算符：

 joinComponent .from(FilmManager.IDENTIFIER) .where(Film.TITLE.startsWith(“A”)) .innerJoinOn(Language.LANGUAGE_ID).equal(Film.LANGUAGE_ID) .build(Tuples::of) .stream() .forEach(System.out::println);

练习题

本周的练习将需要先前所有单元的综合知识，因此可以作为先前单元的重要后续课程。云中仍存在到Sakila数据库实例的连接，因此不需要设置Speedment。像往常一样，这些练习可以在此GitHub存储库中找到。本文的内容足以解决名为MyUnit5Extra的第五个单元。相应的Unit5Extra接口包含JavaDocs，它们描述了以下方法的预期实现。
MyUnit5Extra 。

 public interface Unit5Extra {  /** * Creates and returns a new Map with Actors as keys and * a List of Films in which they appear as values. * <p> * The result might look like this: * * ActorImpl { actorId = 126, firstName = FRANCES, lastName = TOMEI, ... }=[FilmImpl { filmId = 21, title = AMERICAN CIRCUS, ...}, ...] * … * * @param joinComponent for data input * @return a new Map with Actors as keys and *        a List of Films in which they appear as values */  Map<Actor, List<Film>> filmographies(JoinComponent joinComponent);

提供的测试（例如Unit5ExtraTest ）将充当自动评分工具，让您知道您的解决方案是否正确。