Hibernate EntityManager

http://docs.jboss.org/ejb3/app-server/HibernateEntityManager/reference/en/html_single/index.html

Mapeo objeto-relacional

Es una técnica de programación para convertir datos entre el sistema de tipos utilizado en un lenguaje de programación orientado a objetos y el utilizado en una base de datos relacional

JPA Java persistent api (JPA)

La API de persistencia JPA es el estándar de Java para mapear objetos Java a una base de datos relacional.

Es una API de persistencias de POJOS, el mapeo se hacen en la misma clase de la entidad a través de anotaciones.

El objetivo que persigue el diseño de esta API es no perder las ventajas de la orientación a objetos al interactuar con una base de datos,

Hay muchas implementaciones de JPA de proveedores utilizadas dentro de la comunidad de desarrolladores de Java. Hibernate es la implementación más popular. Hibernate utiliza ficheros de mapeo (en formato XML que tienen extensión .hbm.xml.) o anotaciones JPA para relacionar tablas con objetos Java.

Entre estas dos opciones, se recomienda utilizar las anotaciones JPA.

Criteria

Criteria Query nos permite definir consultas con un estilo orientado a objetos, muy distinto al clásico SQL o HQ

Su código es más complicado que el de HQL ya que necesita un análisis más detallado ya que utiliza objetos.

Una de las ventajas de Criteria es que puede montar consultas dinámicas más fácil, como por ejemplo, si queremos que tenga un where con varias opciones:

Criteria criteria = session.createCriteria(Coche.class);
if (nombre != null) {
criteria.add(Restrictions.eq("color", color));
}
if (edad != null) {
criteria.add(Restrictions.eq("puertas", puertas));
}

List coches = criteria.list();

Y en HQL tendriamos que concatenar string y esto puede inducir errores:
String query = "from Coche where color like 'Rojo%' and puertas > 2;";
List coches = sess.createQuery(query).list();

Cómo sabe Hibernate que algo ha cambiado

Las tablas de la base de datos tiene 2 campos un @Id y el otro @Version.
Cada vez que se cambia algo la version se incrementa en 1.
Asi se sabe cuando se ha cambiado los datos y que 2 usuarios no puedan cambiar los datos a la vez.

Más sobre Hibernate

Al arrancar la aplicacion se crea un objeto de SessionFactory(fábrica de sesiones) de ámbito application que a través del método configure() lee las configuraciones de persistencia,pueden estar en archivos xml,hibernate.properties,@anotaciones o podemos configurar hibernate para que al arrancar lea el archivo import.sql.
El tiempo de arranque dependerá del numero de clases persistentes que haya en la aplicación.

Una vez arrancado,se crea un objeto de session que es el que inyectamos en nuestros componentes persistentes a través de la etiqueta @In del EntityManager.

Para que los datos que la session ha creado,eliminado,modificado quede bien reflejado y guardado en la base de datos se tiene que hacer dentro de una transacion hay que abrirla mediante el método session.beginTransaction(); y se cerrará con la sentencia tx.commit();.
Mientras no se cierre la transacción, ésta se considera "caliente" y el programador podra realizar cambios en ella sin preocuparse de la Base de Datos, ya que hibernate las modificará y actualizará automáticamente.

Hibernate asociaciones-relaciones

Aquí tengo un enlace que lo he cogido del blog del profesor.
Documentación de configuración de relaciones de entidades en hibernate utilizando xml
http://www.hibernate.org/hib_docs/reference/en/html/associations.html

Tengo que profundizar más en esto y ya lo iré explicando con mis propias palabras.

Herencia e Hibernate

Para explicarlo bien,vamos a utilizar un ejemplo:
Vamos a utilizar la clase padre Empleado y las subclases Tecnico y Desarrollador.
Para hacer el mapeo de estas relaciones se pueden utilizar 3 formas:

1. Una sola tabla,donde se guarda la jerarquia de clase.Es la mejor opción ya que sólo hay que acceder a una sola tabla.
   
2. Una tabla para la Padre con las cosas comunes y dos tablas para cada hija con las cosas más concretas.Tiene el incoveniente de que para acceder a la información hay que utilizar los join.Pero la ventaja de que se puede crear tablas para cada nuevo tipo,son mas flexibles,ya que si hay que cambiar algún atributo se hace a la tabla correspondiente.
3. Una tabla independiente para cada clase,pero los atributos de la clase Padre tiene que estar en cada tabla Hija.

A continuación presentamos un ejemplo de uso que vale para cualquiera de las tres estrategias. Con esto se demuestra que podemos cambiar la configuración, pero que la lógica de negocio sigue intacta.

@Test
public void addEmpleado() {
        log.info("\n\n*** añadiendo Emppleado ***\n");
              
        try {
                Empleado empleado = new Employee("nombre"
              
                session.persist(empleado);
      
                log.debug("La clave del nuevo empleado es: " + empleado.getId());
                      
              
                Tecnico tecnico = new Tecnico();
                tecnico.setName("nombre tecnico");
               ttecnico.setExperienceYears(24);
                session.save(tecnico);
                log.debug("La clave del nuevo tecnico es: " + tecnico.getId());
                      
               
              
        } catch (Exception e) {
                log.error(e);
       }
}

Hibernate

Hoy en dia las base de datos más frecuentes son las base de datos relacionales,que se basan en las relaciones entre las entidades.
Este framework nos permite el mapeo de atributos entre clases y bases de datos a través de XML.
Con ello conseguimos un código más limpio al no tener que utilizar sentencias sql.
Por ejemplo:
Tenemos una clase
public class Libro{

private String nombre;
private String foto;
private Double precio;
private Long id;

public Long getId()
{
return id;
}

public void setId(Long id)
{
this.id = id;
}

public String getNombre()
{
return nombre;
}

public void setNombre(String nombre)
{
this.nombre = nombre;
}

public Double getPrecio()
{
return precio;
}
public void setPrecio(Double precio)
{
this.precio= precio;
}
public String getFot()
{
return foto;
}

public void setFoto(String foto)
{
this.foto= foto;
}

}

Para que el hibernate reconozca este objeto tenemos que hacer el mapeo de esta clase
creandonos un archivo llamado Cliente.hbm.xml para que nos cree la relacion entre objeto y tabla

Luego para configurar la conexion que va a usar hibernate utilizamos el archivo hibernate.cfg.xml(esta es la forma más sencilla se pueden hacer de otras o eso es lo que he leido por ahi)

Vamos hacer una prueba para ver como funciona esto:
package es.cea.juego;

import org.hibernate.SessionFactory;
import org.hibernate.classic.Session;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

import es.cea.juego.util.HibernateUtil;

public class JugadorTest {
SessionFactory sessionFactory;
@BeforeClass
public void iniciarFactoria(){
sessionFactory = HibernateUtil.getSessionFactory();
}

@Test
public void pruebaArranqueHibernate(){
SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
Cliente cliente=new Cliente();
cliente.setNombre("noelia");

Session sesion = sessionFactory.getCurrentSession();

sesion.beginTransaction();

sesion.save(cliente);

sesion.getTransaction().commit();
}

}

Todo el codigo que hayy entre sesion.beginTransaction() y sesion.getTransaction().commit(); lo ejecuta el hibernate.

Al hacer esto se crea un cliente en nuestra base de datos.

Si queremos obtener de la base de datos un dato en cocrerto se hace:

Cliente cliente1= (Cliente) sesion.get(Cliente.class,1);

Con esto le estas diciendo al hibernate que saque los datos de la tabla cliente con id=1

Vamos a ver las distintas formas que se pueden utilizar para hacer consultas con hibernate:

• Criteria y SimpleExpression

Session session = sessionFactory.getCurrentSession();

Criteria criteria = session.createCriteria(Cliente.class);

SimpleExpression expression=Expression.eq("nombre", "noelia");

criteria.add(expression);
Cliente noelia=(Cliente) criteria.uniqueResult();

Con esto le decimos al hibernate exctamente lo que querems buscar con que condiciones,aqui por ejemplo el nombre que sea noelia,solo nos saca uno puesto que le hemos puesto la condicion de uniqueResult();

• Example--> este nos permite crear búsquedas a partir de una instancia dada.

Session session = sessionFactory.getCurrentSession();

Cliente cliente = new Cliente();
cliente.setNombre("noelia");

List results = session.createCriteria(Cliente.class)
.add( Example.create(cliente) )
.list();