Interroger les données de la base de données dans le framework Hibernate de Java

Hibernate Query Language (HQL) est un langage de requête orienté objet, similaire à SQL, mais au lieu d'opérer sur des tables et des colonnes, HQL convient aux objets persistants et à leurs propriétés. Les requêtes HQL sont converties par Hibernate en requêtes SQL traditionnelles, qui effectuent des opérations sur la base de données.

Bien qu'il soit possible d'utiliser des instructions SQL directement et Hibernate pour utiliser du SQL natif, il est recommandé d'utiliser HQL pour éviter autant que possible les problèmes de portabilité des bases de données et profiter des stratégies de génération SQL et de mise en cache d'Hibernate.

Les mots clés comme SELECT, FROM et WHERE ne sont pas sensibles à la casse, mais les attributs tels que les noms de table et les noms de colonnes sont sensibles à la casse en HQL.

Instruction FROM
Utilisez la clause FROM si vous souhaitez charger un objet persistant complet en mémoire. Voici une syntaxe simple utilisant la clause FROM :

String hql = "FROM Employee";
Query query = session.createQuery(hql);
List results = query.list();

Si vous devez qualifier entièrement un nom de classe en HQL, spécifiez simplement le package et le nom de la classe comme suit :

String hql = "FROM com.hibernatebook.criteria.Employee";
Query query = session.createQuery(hql);
List results = query.list();

Instruction AS La clause
AS peut être utilisée pour alias les requêtes HQL affectées aux classes, en particulier lorsqu'il y a des requêtes très longues. Par exemple, notre exemple simple précédent est le suivant :

String hql = "FROM Employee AS E";
Query query = session.createQuery(hql);
List results = query.list();

Le mot-clé AS est facultatif, et vous pouvez également spécifier un alias directement dans le nom de classe suivant, comme indiqué ci-dessous :

String hql = "FROM Employee E";
Query query = session.createQuery(hql);
List results = query.list();

Clause SELECT La clause
SELECT offre plus de contrôle sur l'ensemble de résultats que la clause FROM. Si vous souhaitez obtenir plusieurs propriétés d'un objet plutôt que l'objet entier, utilisez la clause SELECT. Voici une syntaxe simple qui utilise une instruction SELECT pour obtenir uniquement le champ FIRST_NAME d'un objet Employee :

String hql = "SELECT E.firstName FROM Employee E";
Query query = session.createQuery(hql);
List results = query.list();

Il est à noter qu'ici, Employee.firstName est une propriété de l'objet Employé, plutôt qu'un champ de la table EMPLOYEE.

Clause WHERE
Si vous souhaitez affiner les objets spécifiques renvoyés par le stockage, vous pouvez utiliser la clause WHERE. Voici une syntaxe simple utilisant la clause WHERE :

String hql = "FROM Employee E WHERE E.id = 10";
Query query = session.createQuery(hql);
List results = query.list();

Clause ORDER BY
Pour trier les résultats d'une requête HQL, vous devrez utiliser la clause ORDER BY. Vous pouvez trier les résultats dans l'ensemble de résultats par ordre croissant (ASC) ou décroissant (DESC) en fonction de n'importe quelle propriété de l'objet. Voici une syntaxe simple utilisant la clause ORDER BY :

String hql = "FROM Employee E WHERE E.id > 10 ORDER BY E.salary DESC";
Query query = session.createQuery(hql);
List results = query.list();

Si vous souhaitez trier selon plusieurs attributs, vous ajouterez simplement les attributs supplémentaires à la clause BY en utilisant une virgule. séparés à la fin de la commande comme indiqué ci-dessous :

String hql = "FROM Employee E WHERE E.id > 10 " +
       "ORDER BY E.firstName DESC, E.salary DESC ";
Query query = session.createQuery(hql);
List results = query.list();

GROUP BY CLAUSE
Cette clause permet à Hibernate de récupérer des bases de données et des groupes en fonction de la valeur de ses propriétés Extraire des informations et utilise généralement le résultat pour inclure une valeur totale. Voici une syntaxe très simple utilisant une clause GROUP BY :

String hql = "SELECT SUM(E.salary), E.firtName FROM Employee E " +
       "GROUP BY E.firstName";
Query query = session.createQuery(hql);
List results = query.list();

Utilisation de paramètres nommés
Hibernate prend en charge les paramètres nommés dans sa requête HQL. Cela facilite l'écriture de requêtes HQL qui acceptent les entrées de l'utilisateur sans avoir à se défendre contre les attaques par injection SQL. Voici une syntaxe simple utilisant des paramètres nommés :

String hql = "FROM Employee E WHERE E.id = :employee_id";
Query query = session.createQuery(hql);
query.setParameter("employee_id",10);
List results = query.list();

Clause UPDATE
Les mises à jour par lots sont nouvelles dans HQL avec Hibernate 3, et les suppressions fonctionnent différemment dans Hibernate 3. Identique à Hibernate2. L'interface Query contient désormais une méthode nommée executeUpdate() pour exécuter les instructions HQL UPDATE ou DELETE.

La clause UPDATE peut être utilisée pour mettre à jour une ou plusieurs propriétés dans un ou plusieurs objets. Voici une syntaxe simple utilisant la clause UPDATE :

String hql = "UPDATE Employee set salary = :salary " +
       "WHERE id = :employee_id";
Query query = session.createQuery(hql);
query.setParameter("salary", 1000);
query.setParameter("employee_id", 10);
int result = query.executeUpdate();
System.out.println("Rows affected: " + result);

Clause DELETE La clause DELETE peut être utilisée pour supprimer un ou plusieurs objets. Voici une syntaxe simple utilisant la clause DELETE :

String hql = "DELETE FROM Employee " +
       "WHERE id = :employee_id";
Query query = session.createQuery(hql);
query.setParameter("employee_id", 10);
int result = query.executeUpdate();
System.out.println("Rows affected: " + result);

Clause INSERT

HQL prend en charge la clause INSERT INTO uniquement lorsque des enregistrements peuvent être insérés d'un objet dans un autre objet. Voici une syntaxe simple pour utiliser la clause INSERT INTO :

String hql = "INSERT INTO Employee(firstName, lastName, salary)" +
       "SELECT firstName, lastName, salary FROM old_employee";
Query query = session.createQuery(hql);
int result = query.executeUpdate();
System.out.println("Rows affected: " + result);

Méthodes d'agrégation

HQL prend en charge plusieurs méthodes d'agrégation, similaires à SQL. Ils fonctionnent en HQL de la même manière en SQL et voici la liste des fonctions disponibles :

Le mot-clé DISTINCT ne compte que les valeurs uniques définies dans cette ligne. La requête suivante ne renverra que des décomptes uniques :

String hql = "SELECT count(distinct E.firstName) FROM Employee E";
Query query = session.createQuery(hql);
List results = query.list();

Pagination à l'aide de requêtes

Il existe deux méthodes pour l'interface de requête paginée.

Requête setFirstResult(int startPosition)

Requête setMaxResults(int maxResult)

En utilisant ensemble les deux méthodes ci-dessus, vous pouvez créer un composant de pagination dans un site Web ou une application Swing. Voici un exemple qui peut être étendu pour obtenir 10 lignes :

String hql = "FROM Employee";
Query query = session.createQuery(hql);
query.setFirstResult(1);
query.setMaxResults(10);
List results = query.list();

Conditions de requête

Hibernate fournit une manière alternative de manipuler les objets et les données séquentiellement disponibles dans les tables SGBDR. Une méthode est l'API standard, qui vous permet de créer un objet de requête standard par programme et d'appliquer des règles de filtrage et des conditions logiques.
L'interface Session d'Hibernate fournit un objet Criteria qui peut être utilisé pour créer une instance d'un objet persistant qui est renvoyé lorsque l'application exécute une requête conditionnelle sur une méthode createCriteria() d'un objet Criteria.

Ce qui suit est l'exemple le plus simple d'une requête conditionnelle qui renverra simplement chaque objet correspondant à la classe Employee.

Criteria cr = session.createCriteria(Employee.class);
List results = cr.list();

Restrictions et normes :

Vous pouvez utiliser la méthode add() pour ajouter des requêtes de restriction à l'objet Criteria. Vous trouverez ci-dessous un exemple pour ajouter une limite avec des enregistrements de salaire retournés égaux à 2000 :

Criteria cr = session.createCriteria(Employee.class);
cr.add(Restrictions.eq("salary", 2000));
List results = cr.list();

Voici quelques exemples couvrant différents scénarios et pouvant être utilisés selon les exigences :

Criteria cr = session.createCriteria(Employee.class);
 
// To get records having salary more than 2000
cr.add(Restrictions.gt("salary", 2000));
 
// To get records having salary less than 2000
cr.add(Restrictions.lt("salary", 2000));
 
// To get records having fistName starting with zara
cr.add(Restrictions.like("firstName", "zara%"));
 
// Case sensitive form of the above restriction.
cr.add(Restrictions.ilike("firstName", "zara%"));
 
// To get records having salary in between 1000 and 2000
cr.add(Restrictions.between("salary", 1000, 2000));
 
// To check if the given property is null
cr.add(Restrictions.isNull("salary"));
 
// To check if the given property is not null
cr.add(Restrictions.isNotNull("salary"));
 
// To check if the given property is empty
cr.add(Restrictions.isEmpty("salary"));
 
// To check if the given property is not empty
cr.add(Restrictions.isNotEmpty("salary"));
可以创建AND或OR使用LogicalExpression限制如下条件：
 
Criteria cr = session.createCriteria(Employee.class);
 
Criterion salary = Restrictions.gt("salary", 2000);
Criterion name = Restrictions.ilike("firstNname","zara%");
 
// To get records matching with OR condistions
LogicalExpression orExp = Restrictions.or(salary, name);
cr.add( orExp );
 
 
// To get records matching with AND condistions
LogicalExpression andExp = Restrictions.and(salary, name);
cr.add( andExp );
 
List results = cr.list();

Bien que toutes les conditions ci-dessus soient remplies, HQL peut être utilisé directement comme introduit dans le tutoriel précédent.

Normes d'utilisation de la pagination :

Il existe également des interfaces standard et deux méthodes de pagination.

Critères publics setFirstResult(int firstResult)

public Criteria setMaxResults(int maxResults)

采用上述两种方法一起，我们可以在我们的网站或Swing应用程序构建一个分页组件。下面是例子，可以扩展来每次获取10行：

Criteria cr = session.createCriteria(Employee.class);
cr.setFirstResult(1);
cr.setMaxResults(10);
List results = cr.list();

排序的结果：
标准的API提供了org.hibernate.criterion.Order类排序按升序或降序排列你的结果集，根据对象的属性。这个例子演示了如何使用Order类的结果集进行排序：

Criteria cr = session.createCriteria(Employee.class);
// To get records having salary more than 2000
cr.add(Restrictions.gt("salary", 2000));
 
// To sort records in descening order
crit.addOrder(Order.desc("salary"));
 
// To sort records in ascending order
crit.addOrder(Order.asc("salary"));
 
List results = cr.list();

预测与聚合：
该Criteria API提供了一个org.hibernate.criterion.Projections类可用于获取平均值，最大值或最小值的属性值。Projections类是类似于类限制，因为它提供了几个静态工厂方法用于获得Projection 实例。  provides the

以下是涉及不同的方案的一些例子，可按规定使用：

Criteria cr = session.createCriteria(Employee.class);
 
// To get total row count.
cr.setProjection(Projections.rowCount());
 
// To get average of a property.
cr.setProjection(Projections.avg("salary"));
 
// To get distinct count of a property.
cr.setProjection(Projections.countDistinct("firstName"));
 
// To get maximum of a property.
cr.setProjection(Projections.max("salary"));
 
// To get minimum of a property.
cr.setProjection(Projections.min("salary"));
 
// To get sum of a property.
cr.setProjection(Projections.sum("salary"));

Criteria Queries 例子：
考虑下面的POJO类：

public class Employee {
  private int id;
  private String firstName;
  private String lastName; 
  private int salary;
 
  public Employee() {}
  public Employee(String fname, String lname, int salary) {
   this.firstName = fname;
   this.lastName = lname;
   this.salary = salary;
  }
  public int getId() {
   return id;
  }
  public void setId( int id ) {
   this.id = id;
  }
  public String getFirstName() {
   return firstName;
  }
  public void setFirstName( String first_name ) {
   this.firstName = first_name;
  }
  public String getLastName() {
   return lastName;
  }
  public void setLastName( String last_name ) {
   this.lastName = last_name;
  }
  public int getSalary() {
   return salary;
  }
  public void setSalary( int salary ) {
   this.salary = salary;
  }
}

让我们创建下面的EMPLOYEE表来存储Employee对象：

create table EMPLOYEE (
  id INT NOT NULL auto_increment,
  first_name VARCHAR(20) default NULL,
  last_name VARCHAR(20) default NULL,
  salary   INT default NULL,
  PRIMARY KEY (id)
);

以下将被映射文件。

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
 "-//Hibernate/Hibernate Mapping DTD//EN"
 "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 
<hibernate-mapping>
  <class name="Employee" table="EMPLOYEE">
   <meta attribute="class-description">
     This class contains the employee detail.
   </meta>
   <id name="id" type="int" column="id">
     <generator class="native"/>
   </id>
   <property name="firstName" column="first_name" type="string"/>
   <property name="lastName" column="last_name" type="string"/>
   <property name="salary" column="salary" type="int"/>
  </class>
</hibernate-mapping>

最后，我们将创建应用程序类的main（）方法来运行，我们将使用Criteria查询的应用程序：

import java.util.List;
import java.util.Date;
import java.util.Iterator;
  
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.SessionFactory;
import org.hibernate.Criteria;
import org.hibernate.criterion.Restrictions;
import org.hibernate.criterion.Projections;
import org.hibernate.cfg.Configuration;
 
public class ManageEmployee {
  private static SessionFactory factory;
  public static void main(String[] args) {
   try{
     factory = new Configuration().configure().buildSessionFactory();
   }catch (Throwable ex) {
     System.err.println("Failed to create sessionFactory object." + ex);
     throw new ExceptionInInitializerError(ex);
   }
   ManageEmployee ME = new ManageEmployee();
 
   /* Add few employee records in database */
   Integer empID1 = ME.addEmployee("Zara", "Ali", 2000);
   Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
   Integer empID3 = ME.addEmployee("John", "Paul", 5000);
   Integer empID4 = ME.addEmployee("Mohd", "Yasee", 3000);
 
   /* List down all the employees */
   ME.listEmployees();
 
   /* Print Total employee's count */
   ME.countEmployee();
 
   /* Print Toatl salary */
   ME.totalSalary();
  }
  /* Method to CREATE an employee in the database */
  public Integer addEmployee(String fname, String lname, int salary){
   Session session = factory.openSession();
   Transaction tx = null;
   Integer employeeID = null;
   try{
     tx = session.beginTransaction();
     Employee employee = new Employee(fname, lname, salary);
     employeeID = (Integer) session.save(employee);
     tx.commit();
   }catch (HibernateException e) {
     if (tx!=null) tx.rollback();
     e.printStackTrace();
   }finally {
     session.close();
   }
   return employeeID;
  }
 
  /* Method to READ all the employees having salary more than 2000 */
  public void listEmployees( ){
   Session session = factory.openSession();
   Transaction tx = null;
   try{
     tx = session.beginTransaction();
     Criteria cr = session.createCriteria(Employee.class);
     // Add restriction.
     cr.add(Restrictions.gt("salary", 2000));
     List employees = cr.list();
 
     for (Iterator iterator =
              employees.iterator(); iterator.hasNext();){
      Employee employee = (Employee) iterator.next();
      System.out.print("First Name: " + employee.getFirstName());
      System.out.print(" Last Name: " + employee.getLastName());
      System.out.println(" Salary: " + employee.getSalary());
     }
     tx.commit();
   }catch (HibernateException e) {
     if (tx!=null) tx.rollback();
     e.printStackTrace();
   }finally {
     session.close();
   }
  }
  /* Method to print total number of records */
  public void countEmployee(){
   Session session = factory.openSession();
   Transaction tx = null;
   try{
     tx = session.beginTransaction();
     Criteria cr = session.createCriteria(Employee.class);
 
     // To get total row count.
     cr.setProjection(Projections.rowCount());
     List rowCount = cr.list();
 
     System.out.println("Total Coint: " + rowCount.get(0) );
     tx.commit();
   }catch (HibernateException e) {
     if (tx!=null) tx.rollback();
     e.printStackTrace();
   }finally {
     session.close();
   }
  }
 /* Method to print sum of salaries */
  public void totalSalary(){
   Session session = factory.openSession();
   Transaction tx = null;
   try{
     tx = session.beginTransaction();
     Criteria cr = session.createCriteria(Employee.class);
 
     // To get total salary.
     cr.setProjection(Projections.sum("salary"));
     List totalSalary = cr.list();
 
     System.out.println("Total Salary: " + totalSalary.get(0) );
     tx.commit();
   }catch (HibernateException e) {
     if (tx!=null) tx.rollback();
     e.printStackTrace();
   }finally {
     session.close();
   }
  }
}

编译和执行：
下面是步骤来编译并运行上述应用程序。请确保您已在进行的编译和执行之前，适当地设置PATH和CLASSPATH。

创建hibernate.cfg.xml配置文件中配置章节解释。

创建Employee.hbm.xml映射文件，如上图所示。

创建Employee.java源文件，如上图所示，并编译它。

创建ManageEmployee.java源文件，如上图所示，并编译它。

执行ManageEmployee二进制运行程序.

会得到以下结果，并记录将创建在EMPLOYEE表中。

$java ManageEmployee

.......VARIOUS LOG MESSAGES WILL DISPLAY HERE........
 
First Name: Daisy Last Name: Das Salary: 5000
First Name: John Last Name: Paul Salary: 5000
First Name: Mohd Last Name: Yasee Salary: 3000
Total Coint: 4
Total Salary: 15000

如果检查EMPLOYEE表，它应该记录如下：

mysql> select * from EMPLOYEE;

+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 14 | Zara    | Ali    |  2000 |
| 15 | Daisy   | Das    |  5000 |
| 16 | John    | Paul   |  5000 |
| 17 | Mohd    | Yasee   |  3000 |
+----+------------+-----------+--------+
4 rows in set (0.00 sec)

更多在Java的Hibernate框架中对数据库数据进行查询操作相关文章请关注PHP中文网！