使用@OneToOne和@OneToMany时，如何使Hibernate外部联接

Question

假设我有一个名为雇员的表，其字段为employee_id，name和supervisor_id和employee_supervisor，其字段为supervisor_id和name。雇员和employee_supervisor表与supervisor_id列之间存在外键关系。

如果我在雇员类中执行多对一注释映射，如何确保Hibernate使用LEFT OUTER JOIN加入关联实体？

Answer 1

这完全取决于您的业务逻辑，也就是说，如果您希望拥有员工记录employee_supervisorid是强制性的，那么请使用内连接，否则请使用左连接。更多你可以在这里阅读：左连接和内连接的区别

Answer 2

employee_supervisor{
      id, 
      name
}

employee{
      id, 
      name,
 ManyToOne 
      supervisor_id
}

 select supervisor FROM Employee e 
 left outer JOIN e.supervisor_id supervisor 
 WHERE e.id = :id 

Answer 3

在我的测试中，Hibernate默认使用了LEFT OUTER JOIN。但是，您可以确保它始终使用带有注释的LEFT OUTER JOIN。我花了一些时间来模拟你的情况，使用我模板中的双向一到多映射作为基础，然后改变类名来匹配你的情况。

我想出的类如下：

员工主管级别：

@Entity(name="EMPLOYEE_SUPERVISOR")
public class EmployeeSupervisor {
    @Id
    @GenericGenerator(name = "gen", strategy = "increment")
    @GeneratedValue(generator = "gen")
    @Column(name = "id")
    private int supervisorId;

    @Column
    private String name;

    @OneToMany(mappedBy = "supervisor")
    private List<Employee> employees;
    ....
}

员工类别：

@Entity
public class Employee {
    @Id
    @GenericGenerator(name = "gen", strategy = "increment")
    @GeneratedValue(generator = "gen")
    @Column(name = "id")
    private int employeeId;

    @Column
    private String name;

    @ManyToOne
    @Fetch(FetchMode.JOIN)
    @JoinColumn(name = "supervisorId")
    private EmployeeSupervisor supervisor;
    ....
}

确保始终使用左外部联接的注释是@Fetch（FetchMode.JOIN注释。这告诉Hibernate使用左外部联接在同一select语句中加载相关记录（请参阅文档了解其他类型的FetchMode，以及每种类型的作用）.

然后，我在jUnit中模拟了数据库，将Hibernate配置为在log4j中打印所有生成的SQL

log4j.logger.org.hibernate.SQL=DEBUG
log4j.logger.org.hibernate.type=TRACE

进行了一个非常基本的单元测试。

public class EmployeeDAOTest extends SpringTest{

    @Autowired
    private EmployeeDAO dao;

    private Employee testLinkedEmployee;
    private Employee testUnlinkedEmployee;
    private EmployeeSupervisor testSupervisor;

    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
        System.out.println("Starting DAO Test");
    }

    @AfterClass
    public static void tearDownAfterClass() throws Exception {
        System.out.println("Finished DAO Test");
    }

    @Before
    public void setUp() throws Exception {
        //Irrelevant horrible setup code snipped.
        /* Set up 2 employees and a EmployeeSupervisor in the database.
         * Link one employee to the EmployeeSupervisor and not the other
         */
    }

    @Test
    @Transactional
    public void test() {
        Employee actualLinkedEmployee = dao.getEmployee(testLinkedEmployee.getEmployeeId());
        Employee actualUnlinkedEmployee = dao.getEmployee(testUnlinkedEmployee.getEmployeeId());

        assertNotNull("The linked employee's supervisor didn't get selected.", actualLinkedEmployee.getSupervisor());
        assertNull("The unlinked employee's supervisor was not null.", actualUnlinkedEmployee.getSupervisor());
    }
}

我的刀非常简陋：

@Repository
public class EmployeeDAOImpl implements EmployeeDAO {

    @Autowired
    private SessionFactory sessionFactory;

    @Override
    public Employee getEmployee(int id) {
        Criteria query = sessionFactory.getCurrentSession().createCriteria(Employee.class);
        query.add(Restrictions.idEq(id));
        return (Employee) query.uniqueResult();
    }
}

SQL输出如下：

[junit]     /* criteria query */ select
[junit]         this_.id as id1_1_1_,
[junit]         this_.name as name2_1_1_,
[junit]         this_.supervisorId as supervis3_1_1_,
[junit]         employeesu2_.id as id1_0_0_,
[junit]         employeesu2_.name as name2_0_0_ 
[junit]     from
[junit]         Employee this_ 
[junit]     left outer join
[junit]         EMPLOYEE_SUPERVISOR employeesu2_ 
[junit]             on this_.supervisorId=employeesu2_.id 
[junit]     where
[junit]         this_.id = ? 01:23:54:0.668 
[junit] binding parameter [1] as [INTEGER] - 5 01:23:54:0.671 

[junit]     /* criteria query */ select
[junit]         this_.id as id1_1_1_,
[junit]         this_.name as name2_1_1_,
[junit]         this_.supervisorId as supervis3_1_1_,
[junit]         employeesu2_.id as id1_0_0_,
[junit]         employeesu2_.name as name2_0_0_ 
[junit]     from
[junit]         Employee this_ 
[junit]     left outer join
[junit]         EMPLOYEE_SUPERVISOR employeesu2_ 
[junit]             on this_.supervisorId=employeesu2_.id 
[junit]     where
[junit]         this_.id = ? 01:23:54:0.704 
[junit] binding parameter [1] as [INTEGER] - 6 01:23:54:0.704 

应该注意的是，默认情况下，Hibernate似乎急切地获取这些实体，并使用左外部连接来实现。但是，如果尝试将默认获取类型设置为FetchType。LAZY然后连接类型更改为获取模式。选择，只为员工发出一个选择，而不选择主管。

设置FetchType。惰性与@Fetch（FetchMode.JOIN）但是，会覆盖你的惰性抓取，并使用一个连接来急切地抓取你的主管。