English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
La différence entre la connexion pressée de Hibernate et la connexion ordinaire
Les explications et les introductions pertinentes sont déjà commentées dans le code, vous pouvez les consulter.
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();
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~L'exemple suivant est de 1 Pour plusieurs ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/**
*
* Jointure externe gauche pressée : caractéristiques : si la table de gauche ne satisfait pas les conditions, elle renvoie également les éléments non satisfaisants de la table de gauche
* 1. Le mot-clé LEFT JOIN FETCH représente une stratégie de recherche externe gauche pressée
* 2. La méthode list() renvoie des références d'objets, chaque ensemble de Department associé à un Employee est initialisé
* . Contient les objets实体 des Employee associés.
* 3. Les résultats de la requête peuvent contenir des éléments répétés, qui peuvent être filtrés par un HashSet
*
* Suppression des doublons :
* Méthode une : utiliser 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());
*
* Méthode deux
* 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() );
}
}
/**
* Jointure externe gauche :
* 1. Le mot-clé LEFT JOIN représente une jointure externe gauche
* 2. L'ensemble renvoyé par la méthode list() contient un type d'array d'objets
* 3. La stratégie de recherche de l'ensemble Employee est déterminée par le fichier de configuration
* 4. Si vous souhaitez que la méthode list() renvoie un ensemble contenant uniquement des objets Department
* Il est possible d'utiliser le mot-clé SELECT dans une requête HQL
*
* Les résultats de cette expression de requête contiennent des doublons :
* String hql = "FROM Department d LEFT JOIN d.emps";
* Query query = session.createQuery(hql);
*
* List<Object[]> results = query.list();
* System.out.println(results.size());
*
* Suppression des doublons :
* Seul le méthode distinct peut être utilisé pour supprimer les doublons
*
* 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());
}
}
/**
* Connexion interne urgente : caractéristiques : ne retourne pas la table de gauche qui ne satisfait pas les conditions
* Le mot-clé INNER JOIN FETCH représente la connexion interne urgente, le mot-clé INNER peut être omis
* La collection retournée par la méthode list() contient des références à des objets Department, chaque Department
* Les collections Employee des objets sont initialisées, contenant tous les objets Employee associés
*
* Connexion interne :
* Le mot-clé INNER JOIN représente la connexion interne, le mot-clé INNER peut être omis
* Chaque élément de la collection de la méthode list() correspond à une enregistrement de résultat de la requête, chaque élément est de type tableau d'objets
* Si vous souhaitez que le retour de la méthode list() contienne uniquement des objets Department, vous pouvez utiliser le mot-clé SELECT dans l'expression 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() );
}
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~L'exemple suivant est une relation de plusieurs à plusieurs 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());
}
}
}
Résumé
Voici l'explication détaillée de la différence entre la connexion urgente et la connexion normale dans Hibernate, que j'espère aider. Les amis intéressés peuvent continuer à consulter ce site :
A brief discussion on the eager loading problem of Hibernate (multiple foreign key associations)
Détails du code d'ajout, de suppression, de modification et de consultation de Session dans Hibernate
Bienvenue pour laisser un commentaire si vous trouvez des insuffisances. Merci de votre soutien à ce site !
Déclaration : le contenu de cet article est issu d'Internet, et appartient aux propriétaires respectifs. Le contenu est apporté par les utilisateurs d'Internet et téléversé spontanément. Ce site ne détient pas de droits de propriété, n'a pas été traité par l'éditeur humain et n'assume aucune responsabilité juridique connexe. Si vous trouvez du contenu suspect de violation de droits d'auteur, vous êtes invité à envoyer un e-mail à : notice#oldtoolbag.com (veuillez remplacer # par @ lors de l'envoi d'un e-mail pour signaler une violation, et fournir des preuves pertinentes. Une fois vérifié, ce site supprimera immédiatement le contenu suspect de violation de droits d'auteur.)