Hibernate中迫切連接與普通連接的區別是什么

今天就跟大家聊聊有關Hibernate中迫切連接與普通連接的區別是什么，可能很多人都不太了解，為了讓大家更加了解，小編給大家總結了以下內容，希望大家根據這篇文章可以有所收獲。

Hibernate 迫切連接和普通連接的區別

package com.baidu.test;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.baidu.leftJoin.Department;
import com.baidu.leftJoin.Employee;
public class TestHQL_LeftJoin {
	private SessionFactory sessionFactory;
	private Session session;
	private Transaction transaction;
	@Before
	  public void init(){
		Configuration configuration = new Configuration().configure();
		ServiceRegistry serviceRegistry = new ServiceRegistryBuilder()
		                    .applySettings(configuration.getProperties())
		                    .buildServiceRegistry();
		sessionFactory = configuration.buildSessionFactory(serviceRegistry);
		session = sessionFactory.openSession();
		transaction = session.beginTransaction();
	}
	@After
	  public void destroy(){
		transaction.commit();
		session.close();
		sessionFactory.close();
	}
	// ~~~~~~~~~~~~~~~~~~~~~~~~~~下面的例子是 從 1 對 多  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	/**
   *
   * 迫切左外連接: 特點是：如果左表有不滿足條件的，也返回左表不滿足條件
   *    1. LEFT JOIN FETCH 關鍵字表示迫切左外連接檢索策略.
   *    2. list() 方法返回的集合中存放實體對象的引用, 每個 Department 對象關聯的 Employee 集合都被初始化,
   *       存放所有關聯的 Employee 的實體對象.
   *    3. 查詢結果中可能會包含重復元素, 可以通過一個 HashSet 來過濾重復元素
   *
   *     去重：
   *       方法一:使用 distinct
   *         String hql = "SELECT DISTINCT d FROM Department d LEFT JOIN FETCH d.emps ";
   *        Query query = session.createQuery(hql);
   *
   *        List<Department> depts = query.list();
   *        System.out.println(depts.size());
   *       
   *       方法二
   *         String hql = "FROM Department d LEFT JOIN FETCH d.emps ";
   *        Query query = session.createQuery(hql);
   *
   *        List<Department> depts = query.list();
   *
   *        depts = new ArrayList<>(new LinkedHashSet(depts));
   *        System.out.println(depts.size());
   *        
   *        for(Department dept:depts){
   *          System.out.println(dept.getName() + "--" + dept.getEmps().size() );
   *        }
   *
   *
   */
	@Test
	  public void testLeftJoinFetch(){
		//    String hql = "SELECT DISTINCT d FROM Department d LEFT JOIN FETCH d.emps ";
		//    Query query = session.createQuery(hql);
		//    
		//    List<Department> depts = query.list();
		//    System.out.println(depts.size());
		//    
		String hql = "FROM Department d LEFT JOIN FETCH d.emps ";
		Query query = session.createQuery(hql);
		List<Department> depts = query.list();
		System.out.println(depts.size());
		depts = new ArrayList<>(new LinkedHashSet(depts));
		System.out.println(depts.size());
		for (Department dept:depts){
			System.out.println(dept.getName() + "--" + dept.getEmps().size() );
		}
	}
	/**
   * 左外連接:
   *    1. LEFT JOIN 關鍵字表示左外連接查詢.
   *    2. list() 方法返回的集合中存放的是對象數組類型
   *    3. 根據配置文件來決定 Employee 集合的檢索策略.
   *    4. 如果希望 list() 方法返回的集合中僅包含 Department 對象,
   *      可以在HQL 查詢語句中使用 SELECT 關鍵字
   *    
   *    這樣的語句查詢的結果有重復：
   *      String hql = "FROM Department d LEFT JOIN d.emps";
   *      Query query = session.createQuery(hql);
   *    
   *      List<Object[]> results = query.list();
   *      System.out.println(results.size());
   *  
   *     去重：
   *       僅能使用 distinct 的方法去除重復
   *   
   *       String hql = "SELECT DISTINCT d FROM Department d LEFT JOIN d.emps";
   *       Query query = session.createQuery(hql);
   *
   *       List<Department> depts = query.list();
   *       System.out.println(depts.size());
   *         
   *       for(Department dept:depts){
   *         System.out.println(dept.getName() + dept.getEmps().size());
   *       }
   *
   */
	@Test
	  public void testLeftJoin(){
		String hql = "SELECT DISTINCT d FROM Department d LEFT JOIN d.emps";
		Query query = session.createQuery(hql);
		List<Department> depts = query.list();
		System.out.println(depts.size());
		for (Department dept:depts){
			System.out.println(dept.getName() + dept.getEmps().size());
		}
	}
	/**
   * 迫切內連接: 特點是：不返回左表不滿足條件
   *    INNER JOIN FETCH 關鍵字表示迫切內連接, 也可以省略 INNER 關鍵字
   *    list() 方法返回的集合中存放 Department 對象的引用, 每個 Department
   *        對象的 Employee 集合都被初始化, 存放所有關聯的 Employee 對象
   *
   * 內連接:
   *    INNER JOIN 關鍵字表示內連接, 也可以省略 INNER 關鍵字
   *    list() 方法的集合中存放的每個元素對應查詢結果的一條記錄, 每個元素都是對象數組類型
   *    如果希望 list() 方法的返回的集合僅包含 Department 對象, 可以在 HQL 查詢語句中使用 SELECT 關鍵字
   *
   *
   *
   */
	@Test
	  public void testInnerJoinFetch(){
		//String hql = "SELECT DISTINCT d FROM Department d LEFT JOIN FETCH d.emps ";
		String hql = "FROM Department d INNER JOIN FETCH d.emps ";
		Query query = session.createQuery(hql);
		List<Department> depts = query.list();
		depts = new ArrayList<>(new LinkedHashSet(depts));
		System.out.println(depts.size());
		for (Department dept:depts){
			System.out.println(dept.getName() + "--" + dept.getEmps().size() );
		}
	}
	// ~~~~~~~~~~~~~~~~~~~~~~~~~~下面的例子是 從多 對 1  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	@Test
	  public void testLeftJoinFetch3(){
		String hql = "FROM Employee e LEFT JOIN FETCH e.dept";
		Query query = session.createQuery(hql);
		List<Employee> emps = query.list();
		System.out.println(emps.size());
		for (Employee emp:emps){
			System.out.println(emp + " -- " + emp.getDept());
		}
	}
}

看完上述內容，你們對Hibernate中迫切連接與普通連接的區別是什么有進一步的了解嗎？如果還想了解更多知識或者相關內容，請關注億速云行業資訊頻道，感謝大家的支持。