加載休眠實體時如何優化笛卡爾積

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是通過此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

然后，Hibernate從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的每一項並創建Entity。 是否可以通過某種方式優化此方法？ 由於嚴重的性能問題，我想通過子選擇來選擇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;