在Spring Boot上创建存储库的最佳实践是什么？

Question

我想创建一对多的映射，就像Post有很多评论一样。我有两种添加评论的解决方案。第一种解决方案是为评论创建一个存储库，第二种解决方案是使用PostRepository并获取post并将评论添加到帖子中。每个解决方案都有自己的挑战。

在第一种解决方案中，为每个实体创建存储库会过多地增加存储库的数量，并且基于DDD，应该为Aggregate Roots创建存储库。

在第二个解决方案中，存在性能问题。若要加载、添加或删除嵌套实体，必须先加载根实体。若要添加实体，必须从用户存储库加载其他相关实体（如“注释实体”中的“用户实体”）。因此，这些额外的负载会导致速度和总性能下降。

加载、添加或移除嵌套实体的最佳实践是什么？

文件< code>Post.java

@Entity
@Table(name = "posts")
@Getter
@Setter
public class Post
{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Size(max = 250)
    private String description;

    @NotNull
    @Lob
    private String content;

    @OneToMany(mappedBy = "post", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    private Set<Comment> comments = new HashSet<>();

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    @JoinColumn(name = "user_id", nullable = false)
    @OnDelete(action = OnDeleteAction.CASCADE)
    private User user;
}

文件注释.java

@Entity
@Table(name = "comments")
@Getter
@Setter
public class Comment {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotNull
    @Lob
    private String text;

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    @JoinColumn(name = "post_id", nullable = false)
    @OnDelete(action = OnDeleteAction.CASCADE)
    private Post post;

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    @JoinColumn(name = "user_id", nullable = false)
    @OnDelete(action = OnDeleteAction.CASCADE)
    private User user;
}

@Entity
@Table(name = "Users")
@Getter
@Setter
public class User
{   
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id; 

    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    private Set<Comment> comments = new HashSet<>();

    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    private Set<Post> posts = new HashSet<>();
}

Answer 1

N 1问题:在循环中获取数据，如果你有2000个帖子和评论数据，你需要避免获取每个数据。

// Ex: 2000 posts is fetched
for(Post post: userRepository.findById("1").getPosts()) {
   // fetching in loop: you go to database for each post(2000) and get comments of posts.
   Set<Comment> comments = post.getComments();
}

解决方案：使用自定义存储库为Post和fetch创建存储库。有很多方法可以急切地获取。例如：EntityGraph，FetchType。渴望，JPQL。。。

@Query(value = "select p from Post p fetch left join p.comments c where p.id=:postId)
public Set<Post> postsWithComments(@Param("postId") Long postId)

Set<Post> posts = postRepository.postWithComments(1L);

即使您在急切地获取数据时也需要小心，如果发布时有很多评论，只需使用另一个存储库进行评论即可。

public Set<Comment> findByPostId(String postId);
Set<Comment> comments = commentRepository.findByPostId(1L);

即使一篇文章有60000条评论。您需要使用分页进行获取，这在关键时刻非常有用。

public Page<Comment> findByPostId(Long postId, Pageable pageable);
Page<Comment> comments = commentRepository.findByPostId(1L, PageRequest.of(2000));
int loopCounter = comments.getTotalElements() % 2000 == 0 ? comments.getTotalElements() / 2000 : comments.getTotalElements() / 2000 + 1;
int i=1;
do{

   // do something
   i++;
}while(i <= loopCounter);

对于其他事项，您需要使用缓存策略来提高性能。

您还需要定义什么是请求的响应时间，什么是实际响应时间。您可以将fetch与left join或简单的另一个请求一起使用。在长时间运行的流程中，您也可以使用异步操作。

Answer 2

“最佳”没有很好的定义。但这里可能被认为是Spring数据团队在这个问题上的规范立场。

您绝对不应该每个实体都有一个存储库（s.您应该在JPA中每个表都有一个存储库吗？）。

原因当然不是你必须有很多类/接口。在实现时和运行时创建类和接口的成本非常低廉。有这么多人有点困难，这带来了一个重大问题。如果是这样，实体已经会引起问题。

原因是存储库处理聚合，而不是实体。尽管，不可否认的是，在基于JPA的代码中很难看出区别。所以你的问题归结为：什么应该是聚合。

至少部分答案已经在你的问题中：

在第二个解决方案中，存在性能问题。若要加载、添加或删除嵌套实体，必须先加载根实体。若要添加实体，必须从用户存储库加载其他相关实体（如“注释实体”中的“用户实体”）。因此，这些额外的负载会导致速度和总性能下降。

聚合和存储库的概念在微服务社区中被广泛采用，因为它们具有良好的可伸缩性。这当然与“速度和总体性能”不同，但肯定是相关的。

那么，如何将这两种观点结合起来呢？安德烈·B·潘菲洛夫（Andrey B.Panfilov）发表了一些评论：

@OneToMany实际上是@OneToFew，就像“一个人可以通过几个电话号码联系到”。但它只是描述了一种启发。

真正的规则是：集合应该对需要始终一致的类进行分组。典型的例子是带有行项目的采购订单。行项目本身没有意义。如果您修改行项目（或添加/删除一个），您可能必须更新采购订单，例如为了更新总价或为了保持最大值等约束。因此采购订单应该是包含其行项目的集合。

这也意味着您需要完全加载聚合。这反过来意味着它不能太大，因为否则您会遇到性能问题。

在您的Post、Comment和User示例中，Post可能会与Comment形成聚合。但在大多数系统中，评论的数量接近无限并且可能很大。因此，我会投票支持将示例中的每个实体都作为自己的聚合。

有关聚合和存储库的更多信息，您可能会发现SpringDataJDBC、引用和聚合很有趣。这是关于Spring数据JDBC，而不是Spring数据JPA，但概念上的想法确实适用。