En Hibernate, existe el concepto de recuperación de una sola fila. Para obtener una sola fila en la tabla de la base de datos correspondiente, optaremos por get() o load().
get()
get() siempre accede a la base de datos.
Si se encuentra el id serializable, entonces obtendremos los detalles correspondientes.
Ejemplo
SwingBowlers swingBowlers = (SwingBowlers) openSession.get(SwingBowlers.class,1);
El id serializable es 1 (jerSeyNo) –> Clave Primaria
Si el id serializable no se encuentra, entonces obtendremos el resultado como null.
cargar()
cargar() siempre crea un objeto proxy.Si el id serializable se encuentra, entonces obtendremos los detalles correspondientes.
Ejemplo
SwingBowlers swingBowlers = (SwingBowlers) openSession.get(SwingBowlers.class,1);
System.out.println(swingBowlers);
El id serializable es 1 (jerSeyNo) –> Clave Primaria
Si el id serializable no se encuentra, entonces obtendremos un resultado de org.hibernate.ObjectNotFoundException.
Verificar si aún genera una consulta, aunque estamos usando el método de carga porque estamos intentando imprimir detalles del objeto. [System.out.println(swingBowlers);]. Pero proviene solo del Objeto Proxy[Objeto Dummy].
Veámoslo prácticamente.
HibernateTutorialRun.java
package com.blogspot.javacodebypj;
import com.blogspot.javacodebypj.dao.SwingBowlersDaoImpl;
public class HibernateTutorialRun {
public static void main(String[] args) {
SwingBowlersDaoImpl sbdi = new SwingBowlersDaoImpl();
sbdi.getSwingBowlers();
}
}Explicación: HibernateTutorialRun es una clase para ejecutar la aplicación HibernateTutorial, y la estamos utilizando sin un servidor. Hibernate puede funcionar con un servidor y sin él. Creamos el método principal, y en ese método, simplemente creamos un objeto para la clase correspondiente SwingBowlersDaoImpl. Luego, solo estamos utilizando esa referencia de objeto para llamar al método respectivo.
SwingBowlersDao.java
package com.blogspot.javacodebypj.dao;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import com.blogspot.javacodebypj.domain.SwingBowlers;
import com.blogspot.javacodebypj.util.HibernateUtil;
public class SwingBowlersDaoImpl implements SwingBowlersDao {
@Override
public void getSwingBowlers() {
SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
Session openSession = sessionFactory.openSession();
// utilizando el método load
SwingBowlers swingBowlers = (SwingBowlers) openSession.load(SwingBowlers.class, 1);
System.out.println(swingBowlers);
}
}Explicación: Acabamos de crear SwingBowlersDaoImpl clase e implementarlo con SwingBowlersDao y vamos a anular el método respectivo. Estamos tratando de llamar al método de la clase HibernateUtil , es decir, getSessionFactory , obtendremos SessionFactory objeto, y con la referencia del objeto SessionFactory , estamos llamando al método openSession . Entonces obtendremos Session objeto.
Una vez que obtenemos Objeto de Sesión con esta sesión, podemos llamar al usar el método de carga o al método obtener y simplemente hacemos un casting a la clase respectiva debido al método de carga o al método obtener que devuelve un Objeto. Espero que conozcas el concepto de upcasting y downcasting en Java.
SwingBowlers.java
package com.blogspot.javacodebypj.domain;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
public class SwingBowlers {
@Id
@Column(length = 3)
private int jerseyNo;
@Column(length = 15)
private String bowlerName;
@Column(length = 10)
private String country;
public int getJerseyNo() {
return jerseyNo;
}
public void setJerseyNo(int jerseyNo) {
this.jerseyNo = jerseyNo;
}
public String getBowlerName() {
return bowlerName;
}
public void setBowlerName(String bowlerName) {
this.bowlerName = bowlerName;
}
public String getCountry() {
return country;
}
public void setCountry(String country) {
this.country = country;
}
@Override
public String toString() {
return "SwingBowlers [jerseyNo=" + jerseyNo + ", bowlerName=" + bowlerName + ", country=" + country + "]";
}
}Explicación: Ya que estamos asignando campos a columnas de la base de datos. Si el nombre del campo es el mismo que el nombre de la columna en la tabla de la base de datos, entonces no es necesario escribir el valor del nombre de la columna en el nivel de anotación. Del mismo modo, el nombre de la tabla también es el mismo que el nombre de la clase SwingBowlerspor eso no estamos anotados con @Table. Para convertirlo en una clase de dominio, estamos usando la anotación @Entity en la parte superior de la clase respectiva.
HibernateUtil.java
package com.blogspot.javacodebypj.util;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtil {
private static SessionFactory sessionFactory;
private HibernateUtil() {
}
public static SessionFactory getSessionFactory() {
if (sessionFactory == null) {
Configuration conf = new Configuration().configure();
sessionFactory = conf.buildSessionFactory();
}
return sessionFactory;
}
}Explicación: Acabamos de crear SessionFactory como una clase singleton.
hibernate.cfg.xml
<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="connection.driver_class">com.mysql.jdbc.Driver
</property>
<property name="connection.url">jdbc:mysql://localhost:3306/cricketer</property>
<property name="connection.username">root</property>
<property name="connection.password">myRoot4*</property>
<property name="dialect">org.hibernate.dialect.MySQL8Dialect</property>
<property name="show_sql">true</property>
<property name="hbm2ddl.auto">update</property>
<mapping class="com.blogspot.javacodebypj.domain.SwingBowlers" />
</session-factory>
</hibernate-configuration>Explicación: En este, tenemos tres secciones:
- Propiedades relacionadas con la base de datos
- Propiedades relacionadas con Hibernate
- Clase de mapeo
Como saben, no estamos utilizando un archivo XML de mapeo de Hibernate, por eso mencionamos solo la clase de mapeo.
dialecto:Se utiliza para la generación de consultas en relación con la base de datos. En esta aplicación, estamos usando la base de datos MySQL.
show_sql:Una vez que se generan consultas, necesitamos ver esas consultas, por lo que debemos mencionarlas como true.
pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.blogspot.javacodebypj</groupId>
<artifactId>HibernateTutorial</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>HibernateTutorial</name>
<description>HibernateTutorial by Ponnam Jay</description>
<properties>
<maven.compiler.target>1.8</maven.compiler.target>
<maven.compiler.source>1.8</maven.compiler.source>
</properties>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.6.14.Final</version>
</dependency>
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.28</version>
</dependency>
</dependencies>
</project>Explicación: Acabamos de generar la estructura de este proyecto Maven a través del IDE de Eclipse como un proyecto Maven simple. Agregamos dependencias como hibernate-core, mysql-connector-java y utilizamos Java 1.8 para observar en el pom.xml en la sección de propiedades el target y el source.
Detalles de la base de datos
Conclusión
Si deseas obtener (recuperar) una sola fila (un solo registro), entonces puedes utilizar el método get [o] el método load.