使用JPQL和Hibernate嵌套提取连接

Question

我正在编写一个JPQL查询(使用Hibernate作为我的JPA提供程序)来获取实体Company及其几个关联.这适用于我的"简单"ManyToMany关联,如下所示:

@Entity
@Table(name = "company")
@NamedQueries({
        @NamedQuery(
                name = "Company.profile.view.byId",
                query = "SELECT c " +
                        "FROM Company AS c " +
                        "INNER JOIN FETCH c.city AS city " + <-- @ManyToOne
                        "LEFT JOIN FETCH c.acknowledgements " + <-- @ManyToMany
                        "LEFT JOIN FETCH c.industries " + <-- @ManyToMany
                        "WHERE c.id = :companyId"
        )
})
public class Company { ... }

Hibernate创建一个查询来获取上面的内容,这很好.然而,我的Company实体也有存储在中间表数据的许多一对多的关联,因此,这是为什么映射为@OneToMany与@ManyToOne三个实体之间的关联.

公司< - CompanyService - > Service

这些是我的代码中的三个实体.因此,Company实例具有一组CompanyService实体,每个实体都与Service实例有关系.我希望这是有道理的 - 否则请检查问题末尾的源代码.

现在我想通过修改上述查询来获取给定公司的服务.我提前读过JPA不允许嵌套的fetch连接甚至是连接的别名,但是有些JPA提供者确实支持它,所以我试试了Hibernate.我试图修改查询:

@Entity
@Table(name = "company")
@NamedQueries({
        @NamedQuery(
                name = "Company.profile.view.byId",
                query = "SELECT c " +
                        "FROM Company AS c " +
                        "INNER JOIN FETCH c.city AS city " +
                        "LEFT JOIN FETCH c.acknowledgements " +
                        "LEFT JOIN FETCH c.industries " +
                        "LEFT JOIN FETCH c.companyServices AS companyService " +
                        "LEFT JOIN FETCH companyService.service AS service " +
                        "WHERE c.id = :companyId"
        )
})
public class Company { ... }

现在,Hibernate不是创建单个查询,而是创建以下查询:

#1
select ...
from company company0_
inner join City city1_ on company0_.postal_code = city1_.postal_code
[...]
left outer join company_service companyser6_ on company0_.id = companyser6_.company_id
left outer join service service7_ on companyser6_.service_id = service7_.id
where company0_.id = ?

#2
select ...
from company company0_
inner join City city1_ on company0_.postal_code = city1_.postal_code
where company0_.id = ?

#3
select service0_.id as id1_14_0_, service0_.default_description as default_2_14_0_, service0_.name as name3_14_0_
from service service0_
where service0_.id = ?

#4
select service0_.id as id1_14_0_, service0_.default_description as default_2_14_0_, service0_.name as name3_14_0_
from service service0_
where service0_.id = ?

查询#1 我遗漏了不相关的连接,因为这些都没问题.它似乎选择了我需要的所有数据,包括服务和中间实体数据(CompanyService).

查询#2 此查询只是从数据库及其中获取公司City.急切地获取城市关联,但即使我将其更改为延迟提取,仍会生成查询.老实说,我不知道这个查询的用途.

查询#3 +查询#4 这些查询Service基于ID 查找实例,可能基于查询#1中提取的服务ID.我没有看到这个查询的需要,因为这个数据已经在Query#1中提取了(正如Query#2中的数据已经在Query#1中获取).此外,如果公司有许多服务,这种方法显然不能很好地扩展.

奇怪的是,似乎查询#1做了我想要的,或者至少它获取了我需要的数据.我只是不知道为什么Hibernate会创建查询#2,#3和#4.所以我有以下问题:

• 为什么Hibernate会创建查询#2,#3和#4？我可以避免吗？
• Hibernate是否支持嵌套关联提取,即使JPA没有？如果是这样,我将如何处理它？
• 这种行为是正常的,还是因为我试图做的事情不被支持,因此我得到了奇怪的结果？这看起来很奇怪,因为查询#1看起来非常好

任何错误的指针或完成我想要的替代解决方案将非常感激.下面是我的代码(排除了getter和setter).非常感谢提前!

公司实体

@Entity
@Table(name = "company")
@NamedQueries({
        @NamedQuery(
                name = "Company.profile.view.byId",
                query = "SELECT c " +
                        "FROM Company AS c " +
                        "INNER JOIN FETCH c.city AS city " +
                        "LEFT JOIN FETCH c.acknowledgements " +
                        "LEFT JOIN FETCH c.industries " +
                        "LEFT JOIN FETCH c.companyServices AS companyService " +
                        "LEFT JOIN FETCH companyService.service AS service " +
                        "WHERE c.id = :companyId"
        )
})
public class Company {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column
    private int id;

    // ...

    @ManyToOne(fetch = FetchType.EAGER, targetEntity = City.class, optional = false)
    @JoinColumn(name = "postal_code")
    private City city;

    @ManyToMany(fetch = FetchType.LAZY)
    @JoinTable(name = "company_acknowledgement", joinColumns = @JoinColumn(name = "company_id"), inverseJoinColumns = @JoinColumn(name = "acknowledgement_id"))
    private Set<Acknowledgement> acknowledgements;

    @ManyToMany(fetch = FetchType.LAZY)
    @JoinTable(name = "company_industry", joinColumns = @JoinColumn(name = "company_id"), inverseJoinColumns = @JoinColumn(name = "industry_id"))
    private Set<Industry> industries;

    @OneToMany(fetch = FetchType.LAZY, mappedBy = "company")
    private Set<CompanyService> companyServices;
}

CompanyService实体

@Entity
@Table(name = "company_service")
@IdClass(CompanyServicePK.class)
public class CompanyService implements Serializable {
    @Id
    @ManyToOne(targetEntity = Company.class)
    @JoinColumn(name = "company_id")
    private Company company;

    @Id
    @ManyToOne(targetEntity = Service.class)
    @JoinColumn(name = "service_id")
    private Service service;

    @Column
    private String description;
}

服务实体

@Entity
@Table(name = "service")
public class Service {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column
    private int id;

    @Column(length = 50, nullable = false)
    private String name;

    @Column(name = "default_description", nullable = false)
    private String defaultDescription;
}

获取数据

public Company fetchTestCompany() {
    TypedQuery<Company> query = this.getEntityManager().createNamedQuery("Company.profile.view.byId", Company.class);
    query.setParameter("companyId", 123);

    return query.getSingleResult();
}

Answer 1

好吧，看来我已经明白了。通过将获取类型设置为FetchType.LAZYin CompanyService，Hibernate 停止生成所有基本上再次获取相同数据的冗余查询。这是该实体的新版本：

@Entity
@Table(name = "company_service")
@IdClass(CompanyServicePK.class)
public class CompanyService implements Serializable {
    @Id
    @ManyToOne(fetch = FetchType.LAZY, targetEntity = Company.class)
    @JoinColumn(name = "company_id")
    private Company company;

    @Id
    @ManyToOne(fetch = FetchType.LAZY, targetEntity = Service.class)
    @JoinColumn(name = "service_id")
    private Service service;

    @Column
    private String description;
}

JPQL 查询保持不变。

然而，在我的实体具有大量关联的特定情况下Company，我收到了大量重复的数据，因此让 Hibernate 执行额外的查询会更有效。我通过从 JPQL 查询中删除两个连接获取并将查询代码更改为以下内容来实现此目的。

@Transactional
public Company fetchTestCompany() {
    TypedQuery<Company> query = this.getEntityManager().createNamedQuery("Company.profile.view.byId", Company.class);
    query.setParameter("companyId", 123);

    try {
        Company company = query.getSingleResult();
        Hibernate.initialize(company.getCompanyServices());

        return company;
    } catch (NoResultException nre) {
        return null;
    }
}

通过初始化companyServices关联，Hibernate 执行另一个查询来获取服务。在我的特定用例中，这比通过一个查询获取大量冗余数据要好。

我希望这可以帮助别人。如果有人有更好的解决方案/改进，那么我当然很乐意听到。