Exemplo detalhado da diferença entre conexão agressiva e conexão normal no Hibernate

Diferença entre conexão agressiva e conexão comum do Hibernate

As introduções e explicações detalhadas estão anotadas no código, podem ser consultadas.

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();
	}
	// ~~~~~~~~~~~~~~~~~~~~~~~~~~The following example is from 1 On multiple ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	/**
   *
   * Eager left outer join: The feature is: if there are unsatisfactory conditions in the left table, it also returns the left table that does not meet the conditions
   *    1. The LEFT JOIN FETCH keyword represents an eager left outer join retrieval strategy
   *    2. The list() method returns a collection of entity object references, each Department object's associated Employee collection is initialized
   *       . Stores all associated Employee entity objects
   *    3. Duplicate elements may be included in the query results, which can be filtered out using a HashSet
   *
   *     Remoção de duplicatas:
   *       Method one: using 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());
   *       
   *       Method two
   *         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() );
		}
	}
	/**
   * Left outer join:
   *    1. The LEFT JOIN keyword represents a left outer join query
   *    2. The collection returned by the list() method contains object arrays
   *    3. The retrieval strategy for the Employee collection is determined by the configuration file
   *    4. If you want the list() method to return a collection containing only Department objects
   *      You can use the SELECT keyword in HQL query statements
   *    
   *    A consulta de tal frase tem resultados duplicados:
   *      String hql = "FROM Department d LEFT JOIN d.emps";
   *      Query query = session.createQuery(hql);
   *    
   *      List<Object[]> results = query.list();
   *      System.out.println(results.size());
   *  
   *     Remoção de duplicatas:
   *       Apenas o método distinct pode ser usado para remover duplicatas
   *   
   *       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());
		}
	}
	/**
   * Junção interna antecipada: características: não retorna a tabela esquerda que não atende aos requisitos
   *    A palavra-chave INNER JOIN FETCH representa a junção interna antecipada, também pode omitir a palavra-chave INNER
   *    A coleção retornada pelo método list() contém referências aos objetos Department, cada Department
   *        As coleções Employee dos objetos são inicializadas, contendo todos os objetos Employee associados
   *
   * Junção interna:
   *    A palavra-chave INNER JOIN representa a junção interna, também pode omitir a palavra-chave INNER
   *    Cada elemento da coleção do método list() corresponde a um registro da consulta, cada elemento é do tipo array de objetos
   *    Se desejar que o método list() retorne apenas objetos Department, você pode usar a palavra-chave SELECT na consulta 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() );
		}
	}
	// ~~~~~~~~~~~~~~~~~~~~~~~~~~Os exemplos a seguir são de muitos para muitos 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());
		}
	}
}

Resumo

Isso é tudo sobre a explicação detalhada da diferença entre a conexão aguda e a conexão comum no Hibernate. Espero que ajude a todos. Os amigos interessados podem continuar a consultar nosso site:

Breve análise do problema de carregamento agressivo do Hibernate (associação de chave estrangeira múltipla)

Explicação detalhada das operações de consulta, criação, atualização e exclusão no Hibernate

Se houver algo que possa ser melhorado, por favor, deixe um comentário. Agradecemos o apoio dos amigos ao site!

Declaração: O conteúdo deste artigo foi extraído da internet, pertence ao respectivo autor. O conteúdo foi contribuído e carregado voluntariamente pelos usuários da internet. Este site não possui direitos de propriedade, não foi editado manualmente e não assume responsabilidade legal relevante. Se você encontrar conteúdo suspeito de violação de direitos autorais, por favor, envie um e-mail para: notice#w.3Aviso: Este conteúdo foi extraído da internet, pertence ao respectivo autor. O conteúdo foi contribuído e carregado voluntariamente pelos usuários da internet. Este site não possui direitos de propriedade, não foi editado manualmente e não assume responsabilidade legal relevante. Se você encontrar conteúdo suspeito de violação de direitos autorais, por favor, envie um e-mail para: notice#w, fornecendo provas relevantes. Se confirmado, o conteúdo suspeito será removido imediatamente.