Hibernate Get vs. Load

No Hibernate, existe o conceito de busca de linha única. Para obter uma única linha na tabela de banco de dados correspondente, optaremos por get() ou load().

get()

get() sempre acede ao banco de dados.

Se o id serializável for encontrado, então obteremos os detalhes correspondentes.

Exemplo

SwingBowlers swingBowlers = (SwingBowlers) openSession.get(SwingBowlers.class,1);

O id serializável é 1 (jerSeyNo) –> Chave Primária

Se o id serializável não for encontrado, então obteremos o resultado como nulo.load()

load() sempre cria um objeto proxy.Se o id serializável for encontrado, então obteremos os detalhes correspondentes.        

Exemplo

SwingBowlers swingBowlers = (SwingBowlers) openSession.get(SwingBowlers.class,1);

System.out.println(swingBowlers);

O id serializável é 1 (jerSeyNo) –> Chave Primária

Se o id serializável estiver não encontrado, então obteremos um resultado de org.hibernate.ObjectNotFoundException.  

Verifique se ainda gera uma consulta, mesmo que estejamos usando o método load, pois estamos tentando imprimir detalhes do objeto. [System.out.println(swingBowlers);]. Mas está vindo apenas do Objeto Proxy[Objeto Dummy].

Vamos analisar isso praticamente.

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();

        }

}

Explicação: HibernateTutorialRun é uma classe para executar o aplicativo HibernateTutorial, e estamos usando-o sem um servidor. O Hibernate pode ser executado com um servidor e sem um servidor. Criamos o método principal, e nele, criamos um objeto para a classe correspondente SwingBowlersDaoImpl. Então, estamos apenas usando a referência desse objeto para chamar o 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();

        // usando o método load

        SwingBowlers swingBowlers = (SwingBowlers) openSession.load(SwingBowlers.class, 1);

        System.out.println(swingBowlers);

    }

}

Explicação: Acabamos de criar SwingBowlersDaoImpl classe e a implementamos com SwingBowlersDao e vamos sobrescrever o método correspondente. Estamos tentando chamar HibernateUtil classe método, ou seja, getSessionFactory método, vamos obter SessionFactory objeto, e com a SessionFactory referência de objeto, estamos chamando openSession método. Então vamos obter Session objeto. 

Uma vez que obtemos objeto de sessão com esta sessão, podemos usar o método load ou o método get, e apenas fazemos o casting para a classe respectiva devido ao método load ou método get retornar Object. Espero que você conheça o conceito de upcasting e downcasting em 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 + "]";

    }

}

Explicação: Como estamos mapeando campos para colunas de banco de dados. Se o nome do campo for o mesmo que o nome da coluna na tabela do banco de dados, então não é necessário escrever o valor do nome da coluna na anotação. Da mesma forma, o nome da tabela também é o mesmo que o nome da classe SwingBowlerspor isso não estamos anotados com @Table. Para torná-lo uma classe de domínio, estamos usando a anotação @Entity no topo da classe 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;

    }

}

Explicação: Acabamos de criar SessionFactory como uma classe 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>

Explicação: Neste, temos três seções: 

1. Propriedades relacionadas ao banco de dados
2. Propriedades relacionadas ao Hibernate
3. Classe de mapeamento

Como você sabe, não estamos usando um arquivo XML de mapeamento do Hibernate, é por isso que mencionamos apenas a classe de mapeamento.

dialect:É usado para a geração de consultas em relação ao banco de dados. Neste aplicativo, estamos usando o banco de dados MySQL.

show_sql:Ao gerar consultas, precisamos ver essas consultas, então precisamos mencioná-las como verdadeiras.

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>

Explicação:Acabamos de gerar a estrutura deste projeto Maven através do Eclipse IDE como um projeto Maven simples. Adicionamos dependências como hibernate-core, mysql-connector-java e utilizamos o Java 1.8 para observar no pom.xml na seção de propriedades o target e o source.

Detalhes do Banco de Dados

Conclusão

Se você deseja buscar (recuperar) uma única linha (único registro), então pode usar tanto o método get [ou] o método load.