Comment utiliser la stratégie de requête et la stratégie d'exploration dans Java Hibernate

L'accès à la base de données à l'aide de méthodes orientées objet est fourni par Hibernate, un framework ORM populaire. Dans Hibernate, nous pouvons utiliser diverses méthodes de requête pour récupérer des données, notamment la requête OID, la récupération de navigation d'objets, la récupération HQL, la récupération QBC et la récupération SQL.

OID Query

OID (Object Identifier) ​​​​est l'identifiant unique de chaque objet persistant dans Hibernate. Vous pouvez utiliser des requêtes OID pour récupérer un objet persistant spécifique. Lors de l'utilisation d'une requête OID, nous devons utiliser la méthode load() ou get(). La différence entre ces deux méthodes est que la méthode load() chargera l'objet lorsque cela est nécessaire, tandis que la méthode get() chargera l'objet immédiatement. Voici un exemple d'utilisation de la méthode get() : load()或get()方法。这两个方法的区别在于，load()方法会在需要时才加载对象，而get()方法会立即加载对象。下面是一个使用get()方法的例子：

Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
Student student = (Student) session.get(Student.class, 1);
session.getTransaction().commit();

在上面的例子中，我们使用get()方法检索了一个ID为1的Student对象。

对象导航检索

对象导航检索允许我们通过对象之间的关系来检索数据。例如，如果我们有一个Student类和一个Address类，它们之间是一对一的关系，我们可以使用对象导航检索来检索一个特定的Student对象的地址。下面是一个使用对象导航检索的例子：

Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
Student student = (Student) session.get(Student.class, 1);
Address address = student.getAddress();
session.getTransaction().commit();

在上面的例子中，我们通过检索一个Student对象，并使用getAddress()方法来获取该学生的地址。

HQL检索

HQL（Hibernate Query Language）是一种基于对象的查询语言，它类似于SQL，但是更加面向对象。HQL使用Hibernate映射文件中的类和属性来构建查询。以下是一个使用HQL查询所有Student对象的例子：

Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
Query query = session.createQuery("from Student");
List<Student> students = query.list();
session.getTransaction().commit();

在上面的例子中，我们使用createQuery()方法创建一个HQL查询，然后使用list()方法获取结果列表。

QBC检索

QBC（Query By Criteria）是一种基于对象的查询方式，它使用Criteria API来构建查询。使用Criteria API可以避免一些常见的查询错误，因为它是一种类型安全的查询方式。下面是一个使用QBC查询所有Student对象的例子：

Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
Criteria criteria = session.createCriteria(Student.class);
List<Student> students = criteria.list();
session.getTransaction().commit();

在上面的例子中，我们使用createCriteria()方法创建一个Criteria对象，并使用list()方法获取结果列表。

SQL检索

尽管Hibernate支持多种基于对象的查询方式，但有些情况下我们可能需要执行一些复杂的SQL查询。在这种情况下，我们可以使用SQL查询来检索数据。以下是一个使用SQL查询所有Student对象的例子：

Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
SQLQuery query = session.createSQLQuery("select * from Student");
query.addEntity(Student.class);
List<Student> students = query.list();
session.getTransaction().commit();

在上面的例子中，我们使用createSQLQuery()方法创建一个SQL查询，并使用addEntity()方法将结果映射到Student类。

抓取策略

抓取策略是Hibernate用来处理对象关系的机制。Hibernate提供了三种数据提取方式：立即提取、延迟提取和批量提取。

立即抓取

当检索一个对象时，立即抓取是指Hibernate会立即检索该对象的所有关联对象。这种抓取策略会导致性能问题，因为它可能会导致大量的数据传输。以下是一个使用立即抓取的例子：

@ManyToOne(fetch = FetchType.EAGER)
private Address address;

在上面的例子中，我们将fetch属性设置为EAGER，表示使用立即抓取。

延迟抓取

Hibernate的延迟抓取指的是只检索实体本身，并不会检索关联实体。当我们需要访问相关对象时，Hibernate将再次查询这些对象。这种抓取策略可以提高性能，因为它避免了不必要的数据传输。以下是一个使用延迟抓取的例子：

@ManyToOne(fetch = FetchType.LAZY)
private Address address;

在上面的例子中，我们将fetch属性设置为LAZY，表示使用延迟抓取。

批量抓取

批量抓取是一种抓取策略，它允许我们一次性检索多个对象的关联对象。这种抓取策略可以提高性能，因为它减少了多次检索的次数。以下是一个使用批量抓取的例子：

@OneToMany(mappedBy = "student", fetch = FetchType.LAZY)
@BatchSize(size = 10)
private List<Grade> grades;

在上面的例子中，我们将@BatchSize注解添加到@OneToMany注解中，表示使用批量抓取。

延迟加载

Hibernate中的延迟加载意味着只有在需要时才会加载与对象相关联的其他对象。这种机制可以减少不必要的数据传输，提高性能。以下是一个使用延迟加载的例子：

Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
Student student = (Student) session.load(Student.class, 1);
Address address = student.getAddress();
session.getTransaction().commit();

在上面的例子中，我们使用load()方法检索一个ID为1的Student对象，并使用getAddress()rrreee

Dans l'exemple ci-dessus, nous avons utilisé la méthode get() pour récupérer un objet Student avec l'ID 1. . 🎜🎜Récupération de navigation d'objet🎜🎜La récupération de navigation d'objet nous permet de récupérer des données à travers les relations entre les objets. Par exemple, si nous avons une classe Student et une classe Address, et qu'il existe une relation un-à-un entre elles, nous pouvons utiliser la récupération de navigation d'objet pour récupérer l'adresse d'un objet Student spécifique. Voici un exemple de récupération à l'aide de la navigation d'objets : 🎜rrreee🎜Dans l'exemple ci-dessus, nous récupérons un objet Student et utilisons la méthode getAddress() pour obtenir l'adresse de l'étudiant. 🎜🎜Récupération HQL🎜🎜HQL (Hibernate Query Language) est un langage de requête basé sur les objets, similaire à SQL, mais plus orienté objet. HQL utilise les classes et les propriétés des fichiers de mappage Hibernate pour créer des requêtes. Voici un exemple d'interrogation de tous les objets Student à l'aide de HQL : 🎜rrreee🎜 Dans l'exemple ci-dessus, nous utilisons la méthode createQuery() pour créer une requête HQL, puis utilisons la list( )Méthode pour obtenir une liste de résultats. 🎜🎜QBC Retrieval🎜🎜QBC (Query By Criteria) est une méthode de requête basée sur les objets qui utilise l'API Criteria pour créer des requêtes. L’utilisation de l’API Criteria peut éviter certaines erreurs de requête courantes, car il s’agit d’un moyen d’interrogation sécurisé. Voici un exemple d'interrogation de tous les objets Student à l'aide de QBC : 🎜rrreee🎜Dans l'exemple ci-dessus, nous utilisons la méthode createCriteria() pour créer un objet Criteria et utilisons la list() code > Méthode pour obtenir une liste de résultats. 🎜🎜Récupération SQL🎜🎜Bien qu'Hibernate prenne en charge une variété de méthodes de requête basées sur les objets, dans certains cas, nous pouvons avoir besoin d'effectuer des requêtes SQL complexes. Dans ce cas, nous pouvons utiliser une requête SQL pour récupérer les données. Voici un exemple d'interrogation de tous les objets Student à l'aide de SQL : 🎜rrreee🎜Dans l'exemple ci-dessus, nous créons une requête SQL en utilisant la méthode <code>createSQLQuery() et utilisons addEntity() La méthode mappe le résultat à la classe Student. 🎜🎜Stratégie de récupération🎜🎜La stratégie de récupération est le mécanisme utilisé par Hibernate pour gérer les relations d'objet. Hibernate propose trois méthodes d'extraction de données : l'extraction immédiate, l'extraction différée et l'extraction par lots. 🎜🎜Récupérer immédiatement🎜🎜Lors de la récupération d'un objet, la récupération immédiate signifie qu'Hibernate récupérera immédiatement tous les objets associés à l'objet. Cette stratégie d'analyse peut entraîner des problèmes de performances, car elle peut entraîner le transfert de grandes quantités de données. Voici un exemple d'utilisation de la récupération immédiate : 🎜rrreee🎜Dans l'exemple ci-dessus, nous définissons l'attribut fetch sur EAGER, ce qui signifie utiliser la récupération immédiate. 🎜🎜Récupération différée🎜🎜La récupération retardée d'Hibernate signifie qu'il récupère uniquement l'entité elle-même et ne récupère pas les entités associées. Lorsque nous devons accéder aux objets associés, Hibernate interrogera à nouveau ces objets. Cette stratégie d'exploration améliore les performances car elle évite les transferts de données inutiles. Voici un exemple d'utilisation de la récupération différée : 🎜rrreee🎜Dans l'exemple ci-dessus, nous définissons l'attribut fetch sur LAZY, indiquant l'utilisation de la récupération différée. 🎜🎜Exploration par lots🎜🎜L'exploration par lots est une stratégie d'exploration qui nous permet de récupérer les objets associés à plusieurs objets à la fois. Cette stratégie d'analyse améliore les performances car elle réduit le nombre de récupérations multiples. Voici un exemple d'utilisation de la récupération par lots : 🎜rrreee🎜Dans l'exemple ci-dessus, nous ajoutons l'annotation @BatchSize à l'annotation @OneToMany, indiquant l'utilisation de la récupération par lots . 🎜🎜Chargement paresseux🎜🎜Le chargement paresseux dans Hibernate signifie que les autres objets associés à un objet ne sont chargés qu'en cas de besoin. Ce mécanisme peut réduire la transmission de données inutiles et améliorer les performances. Voici un exemple d'utilisation du chargement paresseux : 🎜rrreee🎜Dans l'exemple ci-dessus, nous utilisons la méthode load() pour récupérer un objet Student avec l'ID 1, et utilisons getAddress() méthode code> code> pour obtenir l'adresse de l'étudiant. Puisque nous utilisons le chargement différé, Hibernate ne chargera l'objet d'adresse qu'en cas de besoin. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!