Hibernate - Anotaciones
Hasta ahora, ha visto cómo Hibernate usa un archivo de mapeo XML para la transformación de datos de POJO a tablas de base de datos y viceversa. Las anotaciones de Hibernate son la forma más nueva de definir asignaciones sin el uso de archivos XML. Puede utilizar anotaciones además de o como reemplazo de los metadatos de mapeo XML.
Hibernate Annotations es la forma poderosa de proporcionar los metadatos para el mapeo de objetos y tablas relacionales. Todos los metadatos se agrupan en el archivo java POJO junto con el código, esto ayuda al usuario a comprender la estructura de la tabla y POJO simultáneamente durante el desarrollo.
Si va a hacer que su aplicación sea portátil a otras aplicaciones ORM compatibles con EJB 3, debe usar anotaciones para representar la información de mapeo, pero aún así, si desea una mayor flexibilidad, entonces debería optar por mapeos basados en XML.
Configuración del entorno para la anotación de hibernación
En primer lugar, debe asegurarse de que está utilizando JDK 5.0; de lo contrario, debe actualizar su JDK a JDK 5.0 para aprovechar el soporte nativo para anotaciones.
En segundo lugar, deberá instalar el paquete de distribución de anotaciones de Hibernate 3.x, disponible en sourceforge: ( Descargar anotación de Hibernate ) y copiarhibernate-annotations.jar, lib/hibernate-comons-annotations.jar y lib/ejb3-persistence.jar de la distribución de anotaciones de Hibernate a su CLASSPATH.
Ejemplo de clase anotada
Como mencioné anteriormente mientras trabajaba con Hibernate Annotation, todos los metadatos se agrupan en el archivo POJO java junto con el código, esto ayuda al usuario a comprender la estructura de la tabla y POJO simultáneamente durante el desarrollo.
Considere que vamos a usar la siguiente tabla EMPLOYEE para almacenar nuestros objetos:
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)
);
A continuación se muestra el mapeo de la clase Employee con anotaciones para mapear objetos con la tabla EMPLOYEE definida:
import javax.persistence.*;
@Entity
@Table(name = "EMPLOYEE")
public class Employee {
@Id @GeneratedValue
@Column(name = "id")
private int id;
@Column(name = "first_name")
private String firstName;
@Column(name = "last_name")
private String lastName;
@Column(name = "salary")
private int salary;
public Employee() {}
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;
}
}
Hibernate detecta que la anotación @Id está en un campo y asume que debe acceder a las propiedades de un objeto directamente a través de los campos en tiempo de ejecución. Si colocó la anotación @Id en el método getId (), habilitaría el acceso a las propiedades a través de los métodos getter y setter de forma predeterminada. Por lo tanto, todas las demás anotaciones también se colocan en campos o métodos de obtención, siguiendo la estrategia seleccionada.
La siguiente sección explicará las anotaciones utilizadas en la clase anterior.
@Anotación de entidad
Las anotaciones estándar EJB 3 se encuentran en el javax.persistencepaquete, por lo que importamos este paquete como primer paso. Segundo, usamos el@Entity anotación a la clase Empleado, que marca esta clase como un bean de entidad, por lo que debe tener un constructor sin argumentos que sea visible con al menos un alcance protegido.
@Anotación de tabla
La anotación @Table le permite especificar los detalles de la tabla que se utilizará para conservar la entidad en la base de datos.
La anotación @Table proporciona cuatro atributos, lo que le permite anular el nombre de la tabla, su catálogo y su esquema, y aplicar restricciones únicas en las columnas de la tabla. Por ahora, estamos usando solo el nombre de la tabla, que es EMPLEADO.
Anotaciones @Id y @GeneratedValue
Cada bean de entidad tendrá una clave primaria, que anotarás en la clase con el @Idanotación. La clave principal puede ser un campo único o una combinación de varios campos, según la estructura de la tabla.
De forma predeterminada, la anotación @Id determinará automáticamente la estrategia de generación de clave primaria más apropiada que se utilizará, pero puede anular esto aplicando la @GeneratedValue anotación, que toma dos parámetros strategy y generatorque no voy a discutir aquí, así que usemos solo la estrategia de generación de claves predeterminada. Dejar que Hibernate determine qué tipo de generador usar hace que su código sea portátil entre diferentes bases de datos.
@Anotación de columna
La anotación @Column se utiliza para especificar los detalles de la columna a la que se asignará un campo o propiedad. Puede utilizar la anotación de columna con los siguientes atributos más utilizados:
name El atributo permite especificar explícitamente el nombre de la columna.
length El atributo permite el tamaño de la columna utilizada para asignar un valor, en particular para un valor de cadena.
nullable El atributo permite que la columna se marque como NOT NULL cuando se genera el esquema.
unique El atributo permite que la columna se marque como conteniendo solo valores únicos.
Crear clase de aplicación
Finalmente, crearemos nuestra clase de aplicación con el método main () para ejecutar la aplicación. Usaremos esta aplicación para guardar algunos registros de empleados y luego aplicaremos operaciones CRUD en esos registros.
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.cfg.AnnotationConfiguration;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class ManageEmployee {
private static SessionFactory factory;
public static void main(String[] args) {
try {
factory = new AnnotationConfiguration().
configure().
//addPackage("com.xyz") //add package if used.
addAnnotatedClass(Employee.class).
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", 1000);
Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
Integer empID3 = ME.addEmployee("John", "Paul", 10000);
/* List down all the employees */
ME.listEmployees();
/* Update employee's records */
ME.updateEmployee(empID1, 5000);
/* Delete an employee from the database */
ME.deleteEmployee(empID2);
/* List down new list of the employees */
ME.listEmployees();
}
/* 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();
employee.setFirstName(fname);
employee.setLastName(lname);
employee.setSalary(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 */
public void listEmployees( ){
Session session = factory.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
List employees = session.createQuery("FROM Employee").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 UPDATE salary for an employee */
public void updateEmployee(Integer EmployeeID, int salary ){
Session session = factory.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
Employee employee = (Employee)session.get(Employee.class, EmployeeID);
employee.setSalary( salary );
session.update(employee);
tx.commit();
} catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
} finally {
session.close();
}
}
/* Method to DELETE an employee from the records */
public void deleteEmployee(Integer EmployeeID){
Session session = factory.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
Employee employee = (Employee)session.get(Employee.class, EmployeeID);
session.delete(employee);
tx.commit();
} catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
} finally {
session.close();
}
}
}
Configuración de la base de datos
Ahora vamos a crear hibernate.cfg.xml archivo de configuración para definir los parámetros relacionados con la base de datos.
<?xml version = "1.0" encoding = "utf-8"?>
<!DOCTYPE hibernate-configuration SYSTEM
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name = "hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</property>
<property name = "hibernate.connection.driver_class">
com.mysql.jdbc.Driver
</property>
<!-- Assume students is the database name -->
<property name = "hibernate.connection.url">
jdbc:mysql://localhost/test
</property>
<property name = "hibernate.connection.username">
root
</property>
<property name = "hibernate.connection.password">
cohondob
</property>
</session-factory>
</hibernate-configuration>
Compilación y ejecución
Estos son los pasos para compilar y ejecutar la aplicación mencionada anteriormente. Asegúrese de haber configurado PATH y CLASSPATH correctamente antes de continuar con la compilación y ejecución.
Elimine el archivo de mapeo Employee.hbm.xml de la ruta.
Cree el archivo fuente Employee.java como se muestra arriba y compílelo.
Cree el archivo fuente ManageEmployee.java como se muestra arriba y compílelo.
Ejecute el binario ManageEmployee para ejecutar el programa.
Obtendría el siguiente resultado y los registros se crearían en la tabla EMPLEADO.
$java ManageEmployee
.......VARIOUS LOG MESSAGES WILL DISPLAY HERE........
First Name: Zara Last Name: Ali Salary: 1000
First Name: Daisy Last Name: Das Salary: 5000
First Name: John Last Name: Paul Salary: 10000
First Name: Zara Last Name: Ali Salary: 5000
First Name: John Last Name: Paul Salary: 10000
Si revisa su tabla EMPLEADO, debe tener los siguientes registros:
mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 29 | Zara | Ali | 5000 |
| 31 | John | Paul | 10000 |
+----+------------+-----------+--------+
2 rows in set (0.00 sec
mysql>