Hibernate es un marco que proporciona una capa de abstracción, lo que significa que el programador no tiene que preocuparse por las implementaciones, Hibernate hace las implementaciones por usted internamente, como establecer una conexión con la base de datos, escribir consultas para realizar operaciones CRUD, etc.
Para obtener los datos disponibles en las tablas RDBMS, Hibernate sigue un método a través de Criteria API. Esto le ayudará a filtrar el conjunto de resultados como desee. es decir, exactamente cómo escribimos una cláusula «WHERE» para un SQL, de la misma manera que se puede manejar aquí mediante Criteria Query. La operación lógica, los conceptos de paginación, los conceptos de clasificación, los conceptos de agregación también son compatibles con Criteria Query.
Implementación: tomemos una tabla de muestra en MySQL para continuar
-- Here name of the database is geeksforgeeks -- Name of the table is geekEmployee create table geeksforgeeks.geekEmployee ( id INT NOT NULL auto_increment, firstName VARCHAR(20) default NULL, lastName VARCHAR(20) default NULL, salary INT default NULL, PRIMARY KEY (id) );
R: Archivo: GeekEmployee.java
Principalmente, definamos una clase POJO «GeekEmployee», un archivo de mapeo (asignación entre la clase POJO y la tabla geekEmployee), un archivo de configuración (informa sobre MySQL a medida que se toma la base de datos, las credenciales y el archivo de mapeo que debe buscarse).
Ejemplo:
Java
// Java Program to Illustrate GeekEmployee Class
// CLass
public class GeekEmployee {
// Class data members
private int id;
private String firstName;
private String lastName;
private int salary;
// All the four attributes must match with geekEmployee
// table and datatypes also should match
// Constructor
public GeekEmployee() {}
// Constructor
public GeekEmployee(String firstName, String lastName,
int salary)
{
// This keyword refers to current instance itself
this.firstName = firstName;
this.lastName = lastName;
this.salary = salary;
}
// Getters and Setters
public int getId() { return id; }
public void setId(int id) { this.id = id; }
public String getFirstName() { return firstName; }
public void setFirstName(String firstName)
{
this.firstName = firstName;
}
public String getLastName() { return lastName; }
public void setLastName(String lastName)
{
this.lastName = lastName;
}
public int getSalary() { return salary; }
public void setSalary(int salary)
{
this.salary = salary;
}
}
B: Archivo: geekEmployee.hbm.xml (Archivo de mapeo que conecta la clase POJO y la tabla MySQL)
XML
<?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> <!-- This is the place where GeekEmployee POJO class and geekEmployee table mapping --> <class name = "com.geeksforgeeks.GeekEmployee" table = "geekEmployee"> <meta attribute = "class-description"> This class contains the geekEmployee detail. This is optional </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>
C: Archivo: hibernate.cfg.xml (archivo de configuración de Hibernate)
XML
<?xml version="1.0" encoding="utf-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/geeksforgeeks</property> <property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password">XXX</property> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <property name="show_sql">true</property><!-- For criteria query to display , always make it as true --> <property name="format_sql">true</property> <property name="hbm2ddl.auto">update </property> <!-- We need to specify which hbm file we are going to use here --> <mapping resource="geekEmployee.hbm.xml" /> </session-factory> </hibernate-configuration>
Implementación: agreguemos algunos registros a la tabla para que podamos realizar operaciones de criterios en ella. Para agregar registros, hagámoslo desde Hibernate.
Ejemplo 1:
Java
public class GeekEmployeeCriteriaExample {
private static SessionFactory sessionFactory;
public static void main(String[] args)
{
//
try {
sessionFactory = new Configuration()
.configure()
.buildSessionFactory();
}
catch (Throwable ex) {
System.err.println(
"Failed to create sessionFactory object."
+ ex);
throw new ExceptionInInitializerError(ex);
}
GeekEmployeeCriteriaExample
geekEmployeeCriteriaObject
= new GeekEmployeeCriteriaExample();
/* As a sample let us add some 10 records so that we
* can see criteria example */
Integer empID1
= geekEmployeeCriteriaObject.addEmployee(
"GeekA", "GeekA", 1000);
Integer empID2
= geekEmployeeCriteriaObject.addEmployee(
"GeekB", "GeekB", 5000);
Integer empID3
= geekEmployeeCriteriaObject.addEmployee(
"GeekC", "GeekC", 10000);
Integer empID4
= geekEmployeeCriteriaObject.addEmployee(
"GeekD", "GeekD", 20000);
Integer empID5
= geekEmployeeCriteriaObject.addEmployee(
"GeekE", "GeekE", 25000);
Integer empID6
= geekEmployeeCriteriaObject.addEmployee(
"GeekF", "GeekF", 30000);
Integer empID7
= geekEmployeeCriteriaObject.addEmployee(
"GeekG", "GeekG", 40000);
Integer empID8
= geekEmployeeCriteriaObject.addEmployee(
"GeekH", "GeekH", 50000);
Integer empID9
= geekEmployeeCriteriaObject.addEmployee(
"GeekI", "GeekI", 35000);
Integer empID10
= geekEmployeeCriteriaObject.addEmployee(
"GeekJ", "GeekJ", 85000);
* /
System.out.println(
"Listing the data via criteria");
System.out.println("-----------------------------");
geekEmployeeCriteriaObject
.listGeekEmployeesByCriteria();
}
// This method List the geekEmployee data whose salary
// greater than 50000
public void listGeekEmployeesByCriteria()
{
Session session = sessionFactory.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
// This will simply return every object that
// corresponds to the GeekEmployee class.
Criteria geekEmployeeCriteria
= session.createCriteria(
GeekEmployee.class);
// As a list we can collect them and can iterate
List geekEmployeeList
= geekEmployeeCriteria.list();
for (Iterator iterator
= geekEmployeeList.iterator();
iterator.hasNext();) {
GeekEmployee employee
= (GeekEmployee)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 CREATE an employee in the database */
public Integer addEmployee(String fname, String lname,
int salary)
{
Session session = sessionFactory.openSession();
Transaction tx = null;
Integer employeeID = null;
try {
tx = session.beginTransaction();
GeekEmployee employee
= new GeekEmployee(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;
}
}
Salida: al ejecutar el código anterior, podemos ver la salida en la consola de la siguiente manera:
Para todos los 10 registros, los datos se insertan
En consola: Y también como hemos mostrado los registros a través de criterios.
Visualización de datos a través de criterios
Al mismo tiempo, también podemos ver que los datos se insertaron en la tabla MySQL
Usando los criterios, podemos manipular los datos de diferentes maneras.
Filtrado de datos en base a Salario. Necesitamos escribir los siguientes métodos para hacer eso. En SQL filtraremos el día añadiendo la cláusula “WHERE”. Aquí en hibernación, necesitamos usar el método add() disponible para el objeto Criteria y se ayuda a agregar restricciones para una consulta de criterios. Tendrá todas las operaciones de comparación como >,<,=, between, etc.
| Operador | Restricciones |
|---|---|
| > | Restricciones.gt |
| < | Restricciones.lt |
| = | Restricciones.eq |
| Entre | Restricciones.entre |
| Patrón comodín (como) | Restricciones.como |
Ejemplo 2:
Java
// List out all geekEmployees based on
// the filtering condition with salary
public void listGeekEmployeesBySalary(int salaryRange,
String conditionCheck)
{
Session session = sessionFactory.openSession();
Transaction tx = null;
// Try block to check for exceptions
try {
tx = session.beginTransaction();
// This will simply return every object that
// corresponds to the GeekEmployee class
Criteria geekEmployeeCriteria
= session.createCriteria(GeekEmployee.class);
// Depends upon the condition check, Restrictions
// are added
if (conditionCheck != null) {
if (conditionCheck.equals(">")) {
geekEmployeeCriteria.add(
Restrictions.gt("salary", salaryRange));
}
if (conditionCheck.equals("<")) {
geekEmployeeCriteria.add(
Restrictions.lt("salary", salaryRange));
}
if (conditionCheck.equals("=")) {
geekEmployeeCriteria.add(
Restrictions.eq("salary", salaryRange));
}
if (conditionCheck.equalsIgnoreCase(
"between")) {
geekEmployeeCriteria.add(
Restrictions.between("salary", 10000,
30000));
}
}
// As a list we can collect them and can iterate
List geekEmployeeList = geekEmployeeCriteria.list();
for (Iterator iterator
= geekEmployeeList.iterator();
iterator.hasNext();) {
GeekEmployee employee
= (GeekEmployee)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 block to handle the exceptions
catch (HibernateException e) {
if (tx != null)
tx.rollback();
e.printStackTrace();
}
// finally block that will execute for sure
finally {
// Closing sessions using close() method
session.close();
}
}
Podemos ejecutar el mismo llamando de diferentes maneras
Java
System.out.println( "Listing the geekEmployee data whose salary greater than 50000"); System.out.println( "--------------------------------------------------------------------"); // Here in the place of "salary" parameter, 50000 is passed // and in the place of "conditionCheck" , ">" is passed geekEmployeeCriteriaObject.listGeekEmployeesBySalary(50000, ">");
Salida: En la consola
salario > 50000
Java
System.out.println("Listing the geekEmployee data whose salary lesser than 50000");
System.out.println("--------------------------------------------------------------------");
geekEmployeeCriteriaObject.listGeekEmployeesBySalary(50000,"<");
Salida: En la consola
Java
System.out.println("Listing the geekEmployee data whose salary equal to 30000");
System.out.println("----------------------------------------------------------------");
geekEmployeeCriteriaObject.listGeekEmployeesBySalary(30000,"=");
Salida: En la consola
Java
System.out.println("Listing the geekEmployee data whose salary between 10000 and 30000");
System.out.println("-----------------------------------------------------------------------------");
geekEmployeeCriteriaObject.listGeekEmployeesBySalary(30000,"between");
Salida: En la consola
para entre
También podemos combinar las consultas con la condición «Y»/»O».
Ejemplo 3:
Java
// Java Program to Illustrate Combining Queries
// With And/Or
// Method
// List the geekEmployee data whose firstname like
// certain name and salary > certain value
// We can combine expressions using 'And','Or'
public void listGeekEmployeesByNameAndSalaryCriteria()
{
Session session = sessionFactory.openSession();
Transaction tx = null;
// Try block to check for exceptions
try {
tx = session.beginTransaction();
// This will simply return every object that
// corresponds to the GeekEmployee class.
Criteria geekEmployeeCriteria
= session.createCriteria(GeekEmployee.class);
// Here 2 expectations are there one with salary and
// second one is name. Both are expected to be
// present. Let us see how to do that
Criterion salaryExpectation
= Restrictions.gt("salary", 40000);
Criterion nameExpectation
= Restrictions.ilike("firstName", "Geek%");
// As we are combining 2 conditions and that two
// logically And, we need to add as Restrictions.and
// To get records matching with AND conditions we
// need to give below way
LogicalExpression logicalAndExpression
= Restrictions.and(salaryExpectation,
nameExpectation);
geekEmployeeCriteria.add(logicalAndExpression);
// As a list we can collect them and can iterate
List geekEmployeeList = geekEmployeeCriteria.list();
for (Iterator iterator
= geekEmployeeList.iterator();
iterator.hasNext();) {
GeekEmployee employee
= (GeekEmployee)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 block to handle exceptions
catch (HibernateException e) {
if (tx != null)
tx.rollback();
e.printStackTrace();
}
// Finally block which will execute for sure
finally {
// Closing sessions using close() method
session.close();
}
}
Java
System.out.println( "Listing the geekEmployee data By Name and Salary With Certain conditions"); System.out.println( "-----------------------------------------------------------------------------"); geekEmployeeCriteriaObject .listGeekEmployeesByNameAndSalaryCriteria();
Salida: En la consola
Ejemplo 4:
Java
// Java Program to Illustrate Pagination Concept
// Method
public void listPaginatedResultsUsingCriteria()
{
Session session = sessionFactory.openSession();
Transaction tx = null;
// Try block to check for exceptions
try {
tx = session.beginTransaction();
// This will simply return every object that
// corresponds to the GeekEmployee class.
Criteria geekEmployeeCriteria
= session.createCriteria(GeekEmployee.class);
// setFirstResult-> It takes an integer and it is
// represented as the first row in your result set,
// starting with row 0.
geekEmployeeCriteria.setFirstResult(1);
// setMaxResults->fixed number maxResults of objects
// are returned here
geekEmployeeCriteria.setMaxResults(3);
// As a list we can collect them and can iterate
List geekEmployeeList = geekEmployeeCriteria.list();
for (Iterator iterator
= geekEmployeeList.iterator();
iterator.hasNext();) {
GeekEmployee employee
= (GeekEmployee)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 block to handle exceptions
catch (HibernateException e) {
if (tx != null)
tx.rollback();
e.printStackTrace();
}
// Finally block which will execute for sure
finally {
// Closing the connections
// using close() methods
session.close();
}
}
Java
System.out.println("Displaying Paginated results");
System.out.println("-------------------------------");
geekEmployeeCriteriaObject.listPaginatedResultsUsingCriteria();
Salida: En la consola
Ejemplo 5:
Java
// Java Program to Sort Records using Criteria
// Method
public void listSortedResultsUsingCriteria()
{
Session session = sessionFactory.openSession();
Transaction tx = null;
// try block to check for exceptions
try {
tx = session.beginTransaction();
// This will simply return every object that
// corresponds to the GeekEmployee class.
Criteria geekEmployeeCriteria
= session.createCriteria(GeekEmployee.class);
geekEmployeeCriteria.add(
Restrictions.gt("salary", 20000));
// Display the results in descending order
geekEmployeeCriteria.addOrder(Order.desc("salary"));
// As a list we can collect them and can iterate
List geekEmployeeList = geekEmployeeCriteria.list();
for (Iterator iterator
= geekEmployeeList.iterator();
iterator.hasNext();) {
GeekEmployee employee
= (GeekEmployee)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 block to handle exceptions
catch (HibernateException e) {
if (tx != null)
tx.rollback();
// Display exceptions with line numbers
// using printStackTrace() method
e.printStackTrace();
}
// Finally block
// It will execute for sure
finally {
session.close();
}
}
System.out.println("Displaying sorted results");
System.out.println("---------------------------");
geekEmployeeCriteriaObject.listSortedResultsUsingCriteria();
Salida: En la consola
lista de datos en orden descendente
Las agregaciones son una parte muy útil de la preparación de informes. En Hibernate, puede ser posible por medio de Proyecciones
| Agregación | Modo Hibernate con Proyecciones |
|---|---|
| Obtener número de filas | Proyecciones.rowCount() |
| Obtener la suma del salario | Proyecciones.sum(“salario”) |
| Obtener promedio de salario | Proyecciones.avg(“salario”) |
| Obtenga el salario máximo | Proyecciones.max(“salario”) |
| Obtener salario mínimo | Proyecciones.min(“salario”) |
Ejemplo 6:
Java
// Java Program to Illustrate Aggregations
// Method
// to get total count, sum(salary),
// max(salary),min(salary),avg(salary)
public void displayAggregatedValuesUsingCriteria()
{
Session session = sessionFactory.openSession();
Transaction tx = null;
// Try block to check for exceptions
try {
tx = session.beginTransaction();
// This will simply return every object that
// corresponds to the GeekEmployee class.
Criteria geekEmployeeCriteria
= session.createCriteria(GeekEmployee.class);
// Get total number of records by using rowcount
geekEmployeeCriteria.setProjection(
Projections.rowCount());
List employeeRowCount = geekEmployeeCriteria.list();
System.out.println("Total row Count: "
+ employeeRowCount.get(0));
// Getting sum(salary)
geekEmployeeCriteria.setProjection(
Projections.sum("salary"));
List totalSalary = geekEmployeeCriteria.list();
System.out.println("Total Salary of GeekEmployees: "
+ totalSalary.get(0));
// Getting average(salary)
geekEmployeeCriteria.setProjection(
Projections.avg("salary"));
List averageSalary = geekEmployeeCriteria.list();
System.out.println(
"Average Salary of GeekEmployees: "
+ averageSalary.get(0));
// Getting max(salary)
geekEmployeeCriteria.setProjection(
Projections.max("salary"));
List maxSalary = geekEmployeeCriteria.list();
System.out.println(
"Maximum Salary among GeekEmployees: "
+ maxSalary.get(0));
// Getting min(salary)
geekEmployeeCriteria.setProjection(
Projections.min("salary"));
List minSalary = geekEmployeeCriteria.list();
System.out.println(
"Minimum salary among GeekEmployees: "
+ minSalary.get(0));
tx.commit();
}
// Catch block to handle exceptions
catch (HibernateException e) {
if (tx != null)
tx.rollback();
// Printing exceptions with line number
// using printStackTrace() method
e.printStackTrace();
}
// Finally block
finally {
// Closing connections
session.close();
}
}
// Display message only
System.out.println("Displaying Aggregated results");
// Display command for better readability of output
System.out.println("--------------------------------");
geekEmployeeCriteriaObject
.displayAggregatedValuesUsingCriteria();
Salida: En la consola
La explicación en video de los conceptos explicados para las consultas de criterios es la siguiente:
Conclusión: como se explica en los ejemplos anteriores, podemos realizar diferentes criterios y ayudarán a filtrar, paginar y ordenar los resultados según nuestras necesidades. Por lo tanto, son muy útiles en la programación.
Publicación traducida automáticamente
Artículo escrito por priyarajtt y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA