Пример различий между срочной и обычной соединениями 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 в много ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	/**
   *
   *   Срочное левые внешние соединения: особенность: если в левой таблице есть элементы, не удовлетворяющие условиям, они также возвращаются
   *    Ключевое слово LEFT JOIN FETCH означает стратегию срочного левого внешнего соединения
   *    Метод list() возвращает список ссылок на сущностные объекты, каждый набор Employee, связанный с Department, инициализирован
   *       Содержит все сущностные объекты, связанные с Employee
   *    В результате запроса могут содержаться повторяющиеся элементы, которые можно отфильтровать с помощью 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,
   *      Вы можете использовать ключевое слово SELECT в запросе HQL
   *    
   *    Результаты таких запросов могут содержать дубликаты:
   *      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, вы можете использовать ключевое слово SELECT в HQL-запросе
   *
   *
   *
   */
	@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 testLeftJoinFetch2(){
		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, надеюсь, что это поможет вам. Те, кто интересуется, могут продолжить читать на сайте:

Краткое рассмотрение проблемы срочной загрузки Hibernate (множественные внешние ключи)

Подробное описание кода операций вставки, удаления, обновления и выбора в Hibernate

Если вы найдете недостатки, пожалуйста, оставьте комментарий. Спасибо за поддержку сайта!

Объявление: содержание этой статьи взято из Интернета, авторские права принадлежат соответствующему автору, материалы предоставлены пользователями Интернета, сайт не имеет права собственности, материалы не были отредактированы вручную, и сайт не несет ответственности за связанные с этим юридические вопросы. Если вы обнаружите материалы,涉嫌侵犯版权， пожалуйста, отправьте письмо по адресу: notice#oldtoolbag.com (во время отправки письма, пожалуйста, замените # на @) для сообщения о нарушении,并提供 соответствующие доказательства. При обнаружении факта нарушения, сайт незамедлительно удаляет涉嫌侵权的内容。