Ejemplo de Hibernate usando XML en Eclipse

Hibernate es un marco que proporciona cierta 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. En este artículo , veamos un ejemplo de Hibernate usando XML junto con la base de datos MySQL en eclipse.

Requisitos:

• Eclipse 
• Experto
• Hibernar
• mysql
• JDK 6 en adelante

Ejemplo

Como vamos a verificar el tipo de proyecto maven, veamos el 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 
                             http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.geeksforgeeks</groupId>
  <artifactId>HibernateSampleExample</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>HibernateSampleExample</name>
  <url>http://maven.apache.org</url>
  <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>4.3.5.Final</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
  
    </dependencies>
  
  <build>
    <pluginManagement>
      <plugins>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.1</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                </configuration>          
        </plugin>
      </plugins>
    </pluginManagement>
    </build>
</project>

Para Hibernate, debemos mantener los detalles en el archivo » hibernate.cfg.xml » que especifica qué tipo de base de datos y sus credenciales, sus controladores necesarios, etc., se colocan. En este ejemplo, vamos a usar MySQL y por lo tanto 

hibernate.connection.driver_class = com.mysql.jdbc.Driver

La ventaja de hibernate es que creará un mapeo de una tabla de base de datos con un archivo de clase de aplicación Java. Eso también se especifica en un archivo XML. Primero creemos una tabla en MySQL

-- Here "geeksforgeeks" is the name of the database
-- "GeekUserDetails" is the name of the table
-- geekUserId  is the Primary Key
CREATE TABLE geeksforgeeks.GeekUserDetails (
 geekUserId INT (5) NOT NULL,
 geekUsername VARCHAR (20) NOT NULL,
 numberOfPosts INT(5) NOT NULL,
 CREATED_BY VARCHAR (20) NOT NULL,
 CREATED_DATE DATE NOT NULL,
 PRIMARY KEY ( geekUserId )
)

Veamos el archivo de mapeo en Hibernate. es decir, todas y cada una de las columnas deben asignarse entre una tabla y una clase. Primero, creemos POJO (clase de modelo) en Java para eso

import java.util.Date;
// We can check that column name in "GeekUserDetails" is
// matching with each and every field here. It is always good
// to have the same column name and field name here
public class GeekUserDetails {
    private int geekUserId;
    private String geekUsername;
    private int numberOfPosts;
    public int getNumberOfPosts() { return numberOfPosts; }
  
    public int getGeekUserId() { return geekUserId; }
  
    public void setGeekUserId(int geekUserId)
    {
        this.geekUserId = geekUserId;
    }
  
    public String getGeekUsername() { return geekUsername; }
  
    public void setGeekUsername(String geekUsername)
    {
        this.geekUsername = geekUsername;
    }
  
    public void setNumberOfPosts(int numberOfPosts)
    {
        this.numberOfPosts = numberOfPosts;
    }
  
    private String createdBy;
    private Date createdDate;
  
    public String getCreatedBy() { return createdBy; }
  
    public void setCreatedBy(String createdBy)
    {
        this.createdBy = createdBy;
    }
  
    public Date getCreatedDate() { return createdDate; }
  
    public void setCreatedDate(Date createdDate)
    {
        this.createdDate = createdDate;
    }
}

Ahora, el archivo de mapeo relacionado con el archivo POJO.

recursos/geekuser.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
      <!-- com.geeksforgeeks.GeekUserDetails 
         is the name of the java class
          GeekUserDetails is the name of the table -->
    <class name="com.geeksforgeeks.GeekUserDetails" table="GeekUserDetails">
        <id name="geekUserId" type="int" column="geekUserId">
            <generator class="assigned"/>
        </id>
        <property name="geekUsername">
            <column name="geekUsername"/>
        </property>
        <property name="numberOfPosts" type = "int">
            <column name="numberOfPosts"/>
        </property>
        <property name="createdBy">
            <column name="CREATED_BY"/>
        </property>
        <property name="createdDate" type="date">
            <column name="CREATED_DATE"/>
        </property>
    </class>
</hibernate-mapping>

Ahora, veamos el archivo de configuración principal

recursos/hibernate.cfg.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">
<!-- Main configuration file -->
<hibernate-configuration>
    <session-factory>
        <!-- As we are connecting MySQL, com.mysql.jdbc.
             Driver is required(JDBC driver class) -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
         
          <!-- Here geeksforgeeks is the name of the database 
             that we are connecting(JDBC URL) -->
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/geeksforgeeks</property>
          
          <!-- Username to connect to MySQL -->
        <property name="hibernate.connection.username">root</property>
          
          <!-- Password to connect to MySQL, Provide your correct password -->
        <property name="hibernate.connection.password">XXXX</property>
          
          <!-- Dialect required between hibernate and MySQL -->
         <!-- This property makes Hibernate generate the
              appropriate SQL for MySQL here -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>
        <property name="hbm2ddl.auto">update </property>
          
          <!-- We need to provide the exact mapping file 
             which we have created earlier -->
        <mapping resource="geekuser.hbm.xml" />
    </session-factory>
</hibernate-configuration>

Después de crear el mapeo entre la tabla MySQL y la clase Java a través de «geekuser.hbm.xml» y «hibernate.cfg.xml», intentemos hacer una simple inserción de un registro en la tabla. Intentemos ejecutar eso a través de un archivo de aplicación java. Necesitamos mirar ciertos archivos como HibernateUtil.java. Necesitamos crear SessionFactory desde hibernate.cfg.xml. Por lo tanto, primero se deben cumplir todas las entradas en este XML antes de ingresar al código principal. De lo contrario, debe proporcionar el código requerido para lanzar la excepción.

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
  
public class HibernateUtil {
    private static final SessionFactory sessionFactory
        = buildSessionFactory();
    private static SessionFactory buildSessionFactory()
    {
        try {
            // We need to create the SessionFactory from
            // hibernate.cfg.xml
            return new Configuration()
                .configure()
                .buildSessionFactory();
        }
        catch (Throwable ex) {
            // Make sure you log the exception, as it might
            // be swallowed
            // In case of any exception, it has to be
            // indicated here
            System.err.println(
                "SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }
    public static SessionFactory getSessionFactory()
    {
        return sessionFactory;
    }
    public static void shutdown()
    {
        // Close caches and connection pools
        getSessionFactory().close();
    }
}

GeekUserDetailsTest.java -> La sesión se crea utilizando HibernateUtil.java. Hibernate SessionFactory tiene tres métodos, a saber, getCurrentSession(), openSession() y openStatelessSession(). En nuestro código, estamos usando openSession(). Si no se proporciona, entraremos en excepción como Excepción en el subproceso «principal» org.hibernate.HibernateException: ¡No se configuró el CurrentSessionContext! Para openSession(), siempre abrirá una nueva sesión y debe cerrarse

import java.util.Date;
  
import org.hibernate.Session;
  
public class GeekUserDetailsTest {
    public static void main(String[] args) {
  
        // open the session
        Session session = HibernateUtil.getSessionFactory().openSession();
  
        // For doing any CRUD operation, 
        // let us start a transaction
        session.beginTransaction();
  
        // Create an object of GeekUserDetails
        GeekUserDetails geekUser = new GeekUserDetails();
  
        // Set all the details required 
        // to insert into the table
        geekUser.setGeekUserId(1);
        geekUser.setGeekUsername("GeekUser1");
        geekUser.setNumberOfPosts(100);
        geekUser.setCreatedBy("GeekUser1");
        geekUser.setCreatedDate(new Date());
  
        // Just a save statement is enough which 
        // automatically creates an insert statement
        session.save(geekUser);
  
        // commit will help to complete
        // the changes in the table
        session.getTransaction().commit();
  
        // close the session
        session.close();
    }
}

Una vez que este archivo se ejecuta como una «aplicación Java», podemos ver que se inserta un registro en la tabla «GeekUserDetails».

Video explicación sobre el código:

Conclusión

Usando hibernate.cfg.xml (archivo XML principal que define los detalles JDBC de la base de datos, dialectos SQL, etc.), un archivo de mapeo que mapea las columnas de una tabla y una clase POJO. (Aquí está geekuser.hbm.xml) podemos hacer todas las operaciones CRUD fácilmente en Hibernate.