java - 子选择提取导致看似不相关的代码行之间发生意外交互

Question

我有一个使用 Hibernate 的 Tomcat Web 应用程序。在对象模型的一个非常简化的版本中，我有三个类:Employee、Foo 和 Bar。 Employee 与 Foo 和 Bar 都具有一对多关系。 Foo 与系统中许多其他未命名对象具有多对一关系。

在处理特定页面请求时，我的应用程序将(全部在单个 Hibernate session 中):

Employee emp = session.get(Employee.class, id);
List<Foo> foos = session.createCriteria(Foo.class).add(eq("emp", emp)).list();
for (Bar bar : emp.getBars()) bar.doStuff();

实际上，这三行相距很远，并且实际上位于不同的源文件中。特别是，第 1 行针对每个请求运行(它获取登录用户)，第 2 行获取有问题页面的感兴趣数据，第 3 行获取侧边栏中每个页面上显示的一些数据。

另请注意，bar.doStuff() 实际上在对象图中遍历了远离 Bar 的几个级别(每个员工实际上被分配给一些拥有某些资源的客户)具有某些任务的项目)。

在第 2 行中，一切都运行顺利，并且当我们迭代 emp.getBars() 时生成的 SQL 非常好且简单，只需选择 Bar.empID = ? 的内容。对 Bar 子级的进一步子选择确实有越来越多的子查询，但客观上并没有花费大量时间，我认为 MySQL 足够聪明来优化它们。

但是，当第 2 行在第 1 行和第 3 行之间执行时，第 3 行需要很长的时间。查看生成的 SQL 后，我确信这与子选择行为以及 Foo 有如此多的 *ToOne 关系有关。

第 2 行的查询有大量的外连接和内连接，因为 Hibernate 实际上不支持 *ToOne 关系上的子选择获取。当第 2 行查询运行时，它必须再次检索 emp。当然，Hibernate注意到它已经检索了emp，因此实际上并没有构造一个新的Employee对象，而是分配已经创建的Employee对象每个 Foo 内字段的实例。

问题是，现在“检索”的最新查询emp是一个带有大量连接的丑陋的大查询。因此，当我们尝试获取其所有 Bar 时，生成的 SQL 现在的形式为: select stuff from Bar where Bar.empID in (select Foo.empID from Foo join 许多表)。

当然，当我们从 Bar 深入了解对象图时，这个问题会重复几次。最终结果是页面加载时间将近三十秒。

我可以通过提前强制初始化 emp.getBars() 来解决这个特定实例中的问题，但这似乎是一个糟糕的解决方案，因为:

1. 它很老套且不明显
2. 我们可能会在另一个类或领域再次遇到问题，并且必须重新诊断

我真的对处理这个问题的正确方法感到困惑。有其他人遇到过这个问题并想出一个好的解决方案吗？

编辑:这里的每个请求是我的映射(的风格化版本):

@Entity
public class Employee
{
    @OneToMany(mappedBy = "emp")
    @Fetch(FetchMode.SUBSELECT)
    private Set<Bar> bars = new HashSet<>();
}

@Entity
public class Foo
{
    @ManyToOne(optional = false)
    @JoinColumn(name = "empID")
    private Employee emp;

    @ManyToOne
    @JoinColumn(name = "class1_ID")
    private Class1 class1;
    // repeat for Class2, 3, 4, etc.
    // some are nullable, others not
}

@Entity
public class Bar // Bar represents an employee being assigned to a client
{
    @ManyToOne(optional = false)
    @JoinColumn(name = "empID")
    private Employee emp;

    @ManyToOne(optional = false)
    @JoinColumn(name = "clientID")
    private Client client;
    // Client itself has-many Projects which have-many Tasks
    // which are all themselves mapped entities and the objects we ultimately want
}

Answer 1

1. 鉴于您的 Foo 和 Bar 有很多多对一关系，我建议尝试使用延迟获取，请注意下面使用 fetch=LAZY:

   @Entity公共(public)课 Foo{ @ManyToOne(fetch=LAZY, 可选= false) @JoinColumn(名称 = "empID") 私有(private)雇员 emp；

   @ManyToOne(fetch=LAZY)
   @JoinColumn(name = "class1_ID")
   private Class1 class1;
   // repeat for Class2, 3, 4, etc.
   // some are nullable, others not
   

   }

2. 通过映射字段​​获取和遍历关系的性能更好的替代方案是直接 JPA/Hibirante 查询，以获取进一步处理所需的内容。这就是为什么 hibernate 不必努力构建对象树，而是通过单个查询即可获得所需的内容。例如，使用伪代码:

   List resultSet = session.createQuery("从 Bar b 中选择 b.employee.name, b.employee.phone，其中 b.client.name = ?).setString(0, "blah").list();

3. 我还建议启用二级缓存和查询缓存。

希望这有帮助。

问候，

斯拉瓦·伊梅舍夫