如何在加载Hibernate实体时优化Carstesian产品

Question

为了演示我的问题，我创建了一个简单的Spring Boot应用程序。它有一个实体，它有ID，两个String属性和两个Sets<String>集合。

package com.mk.cat.domain; 

import javax.persistence.*; 
import java.util.Set; 

@Entity 
@Table(name = "cat") 
public class Cat { 
    @Id 
    @GeneratedValue(strategy = GenerationType.IDENTITY) 
    @Column(name = "id") 
    private Long id; 

    @Column(name = "name") 
    private String name; 

    @Column(name = "sex") 
    private String sex; 

    @ElementCollection(fetch = FetchType.EAGER) 
    @Column(name = "color") 
    @CollectionTable(
      name = "cat_color", 
      joinColumns = @JoinColumn(name = "cat_id")) 
    private Set<String> colors; 

    @ElementCollection(fetch = FetchType.EAGER) 
    @Column(name = "nickname") 
    @CollectionTable(
      name = "cat_nickname", 
      joinColumns = @JoinColumn(name = "cat_id")) 
    private Set<String> nicknames; 

    public Long getId() { 
     return id; 
    } 

    public void setId(Long id) { 
     this.id = id; 
    } 

    public String getName() { 
     return name; 
    } 

    public void setName(String name) { 
     this.name = name; 
    } 

    public String getSex() { 
     return sex; 
    } 

    public void setSex(String sex) { 
     this.sex = sex; 
    } 

    public Set<String> getColors() { 
     return colors; 
    } 

    public void setColors(Set<String> colors) { 
     this.colors = colors; 
    } 

    public Set<String> getNicknames() { 
     return nicknames; 
    } 

    public void setNicknames(Set<String> nicknames) { 
     this.nicknames = nicknames; 
    } 
} 

还有一个简单的代码，它从数据库中持久存储并加载Cat实体。

package com.mk.cat; 

import com.google.common.collect.Sets; 
import com.mk.cat.domain.Cat; 
import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.boot.CommandLineRunner; 
import org.springframework.boot.SpringApplication; 
import org.springframework.boot.autoconfigure.SpringBootApplication; 

@SpringBootApplication 
public class CatApplication implements CommandLineRunner { 

    private final CatRepository catRepository; 

    private static final Logger LOGGER = LoggerFactory.getLogger(CatApplication.class); 

    @Autowired 
    public CatApplication(CatRepository catRepository) { 
     this.catRepository = catRepository; 
    } 

    public static void main(String[] args) { 
     SpringApplication.run(CatApplication.class, args); 
    } 

    @Override 
    public void run(String... args) throws Exception { 
     Cat cat = new Cat(); 
     cat.setName("Ben"); 
     cat.setSex("Male"); 
     cat.setNicknames(Sets.newHashSet("Fluffy", "Mr. Tomcat", "Catburger")); 
     cat.setColors(Sets.newHashSet("Black", "White")); 

     final Cat saved = catRepository.save(cat); 
     LOGGER.info("Cat saved={}", cat); 

     catRepository.findOne(saved.getId()); 
    } 
} 

我跟踪Hibernate和我发现，该Cat从DB通过这个SQL加载。

select cat0_.id as id1_0_0_, 
    cat0_.name as name2_0_0_, 
    cat0_.sex as sex3_0_0_, 
    colors1_.cat_id as cat_id1_1_1_, 
    colors1_.color as color2_1_1_, 
    nicknames2_.cat_id as cat_id1_2_2_, 
    nicknames2_.nickname as nickname2_2_2_ 
    from cat cat0_ 
    left outer join cat_color colors1_ on cat0_.id=colors1_.cat_id 
    left outer join cat_nickname nicknames2_ on cat0_.id=nicknames2_.cat_id 
where cat0_.id=1 

的休眠然后获取从cat表和两个表中的行，表示所述Cat#colors和Cat#nicknames设置该笛卡儿积。

id1_0_0_ name2_0_0_ sex3_0_0_ cat_id1_1_1_ color2_1_1_ cat_id1_2_2_ nickname2_2_2_ 
1 Ben Male 1 Black 1 Fluffy 
1 Ben Male 1 Black 1 Catburger 
1 Ben Male 1 Black 1 Mr. Tomcat 
1 Ben Male 1 White 1 Fluffy 
1 Ben Male 1 White 1 Catburger 
1 Ben Male 1 White 1 Mr. Tomcat 

然后Hibernate会遍历每一行，解析ResultSet的每个单项并创建实体。是否有可能优化这种方法？由于严重的性能问题，我想通过子选择选择Cat#colors和Cat#nicknames集。在真实情况下，我获取1500个具有复杂结构的实体，并不罕见，一个提取的实体在相应的ResultSet中生成25.000行，导致非常长的解析时间。

在我的情况下，延迟加载不是我想使用的选项，因为它会给代码带来混乱。据我所知，延迟加载的Collection必须通过第一次调用初始化，这在我的真实应用程序中付出了相当大的可用性价格。

我将不胜感激3个单独的选择，其中一个来自cat表，一个来自cat_color表和一个来自cat_nickname表。

Answer 1

我发现Hibernate的解决方案，@Fetch(FetchMode.SELECT)做了这项工作，因为它让Hibernate通过单独的select而不是join来选择昵称。

@Fetch(FetchMode.SELECT) 
@ElementCollection(fetch = FetchType.EAGER) 
@Column(name = "nickname") 
@CollectionTable(
     name = "cat_nickname", 
     joinColumns = @JoinColumn(name = "cat_id")) 
private Set<String> nicknames;