Spring Acceso a datos con Hibernate JPA

En los tutoriales previos de acceso a datos veíamos como la clase JdbcTemplate de Spring realiza gran parte del trabajo por nosotros, aun así, ya sea si utilizamos la API JDBC directamente o la clase JdbcTemplate siempre tenemos que convertir los datos obtenidos de la BD en objetos Java para manipularlos en nuestra aplicación y hacer el proceso inverso para almacenarlos nuevamente el la BD, para facilitarnos el trabajo existen frameworks que se encargan de realizar esta tarea, ello son los ORM.

spring orm hibernate jpa

Un ORM (Mapeo Objeto/Relacional) se refiere a la técnica de mapear una representación de datos desde un modelo de objeto a un modelo de datos relacionales con un esquema basado en SQL, existen muchos ORMs en el mercado actual, entre ellos Hibernate, ORM con el cual Spring se integra fácilmente.

La API de Persistencia de Java (JPA) es una especificación, es decir, es el estándar que define como se deben realizar las tareas de persistencia de datos en Java, por ello requerimos de un proveedor que implemente JPA, existen varios, como: Hibernate, EclipseLink, etc, para este tutoriales usaremos JPA con el ORM Hibernate, nos referimos a él como: Hibernate JPA.

Dependencias Spring Hibernate JPA

Como siempre creamos el proyecto Maven / Java Application y abrimos el archivo pom.xml para agregar las dependencias necesarias.

Las dependencias requeridas por Spring Framework son las siguientes:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.6.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>4.3.6.RELEASE</version>
</dependency>

Las dependencias necesarias para usar el ORM Hibernate JPA son:

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>4.3.11.Final</version>
</dependency>
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-entitymanager</artifactId>
    <version>4.3.11.Final</version>
</dependency>

Nuestros datos de prueba estarán en el motor HSQLDB, pera ello agregamos:

<dependency>
    <groupId>org.hsqldb</groupId>
    <artifactId>hsqldb</artifactId>
    <version>2.3.3</version>
    <scope>runtime</scope>
</dependency>

En los tutoriales de acceso a datos con JDBC anteriores usamos HSQLDB en modo servidor, teníamos que iniciar el servidor para probar la aplicación, esta vez veremos como Spring nos permite configurar una base de datos integrada que será iniciada al momento de ejecutar la aplicación.

Usar una base de datos integrada

Spring soporta tres motores de bases de datos integradas, (HSQLDB, H2, DERBY), usaremos el primero, para configurarlo primero debemos crear el DataSource y lo haremos por medio de la clase EmbeddedDatabaseBuilder, de la siguiente manera:

@Bean
public DataSource dataSource() {
    return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.HSQL)
            .addScript("classpath:schema.sql")
            .addScript("classpath:data.sql")
            .build();
}

Usamos setType(EmbeddedDatabaseType.HSQL) para indicar la base de datos a usar, otras opciones son H2 y DERBY, si deseas usar alguna de estas recuerda agregar las respectivas dependencias.

El método addScript() nos permite indicar los script SQL schema.sql y data.sql, el primero es usado para crear la estructura de la base de datos, las tablas y columnas, etc., el segundo añade datos a las tablas recién creadas, ambos archivos se encuentran en la raíz del classpath.

Archivo schema.sql para crear dos tablas, Customer y Product, ambos tomados de los datos de prueba de HSQLDB. 

CREATE TABLE Customer(
    ID INTEGER PRIMARY KEY, 
    FirstName VARCHAR(20),
    LastName VARCHAR(30), 
    Street VARCHAR(50), 
    City VARCHAR(25));

CREATE TABLE Product(
    ID INTEGER PRIMARY KEY, 
    Name VARCHAR(30), 
    Price DECIMAL);

Archivo data.sql que agrega datos a las tablas Customer y Product.

INSERT INTO Customer VALUES(0,'Laura','Steel','429 Seventh Av.','Dallas');
INSERT INTO Product  VALUES(0,'Iron Iron',54);
INSERT INTO Customer VALUES(1,'Susanne','King','366 - 20th Ave.','Olten');
INSERT INTO Product  VALUES(1,'Chair Shoe',248);
INSERT INTO Customer VALUES(2,'Anne','Miller','20 Upland Pl.','Lyon');
INSERT INTO Product  VALUES(2,'Telephone Clock',248);

Al iniciar la aplicación se ejecutan estos scripts, sobre una base de datos en memoria que será creada por Spring.

Configurar Hibernate JPA

Para acceder a la base de datos JPA utiliza la interface EntityManager, esta puede ser creada de varias maneras, en este tutorial usaremos la clase LocalContainerEntityManagerFactoryBean otra opción, por ejemplo, sería crearla a partir de JDNI para ello usaríamos JndiObjectFactoryBean.

Para finalizar debemos crear un bean de tipo JpaVendorAdapter que nos sirve para definir cual es el proveedor que utilizaremos, nosotros estamos usando Hibernate por lo que creamos este bean con la clase HibernateJpaVendorAdapter para otros proveedores tenemos las correspondientes clases: EclipseLinkJpaVendorAdapter y OpenJpaVendorAdapter.

@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
    LocalContainerEntityManagerFactoryBean factoryBean
            = new LocalContainerEntityManagerFactoryBean();
    factoryBean.setDataSource(dataSource());
    factoryBean.setJpaVendorAdapter(jpaVendorAdapter());
    factoryBean.setPackagesToScan("carmelo.spring.jpa.model");
    factoryBean.setPersistenceUnitName("pun-hibernate-jpa");
    return factoryBean;
}

@Bean
public JpaVendorAdapter jpaVendorAdapter() {
    HibernateJpaVendorAdapter jpaVendorAdapter = new HibernateJpaVendorAdapter();
    jpaVendorAdapter.setGenerateDdl(false);
    jpaVendorAdapter.setDatabase(Database.HSQL);
    return jpaVendorAdapter;
}

Le prestamos atención al código: setPackagesToScan("carmelo.spring.jpa.model") con él indicamos en que paquete se encuentran las clases anotadas para JPA, con las correspondientes anotaciones indicamos como se mapea la clase contra la base de datos, para la tabla PRODUCT tenemos la clase: 

package carmelo.spring.jpa.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "PRODUCT")
public class Product {

    @Id
    @Column(name = "ID")
    private Integer id;
    
    @Column(name = "NAME")
    private String name;
    
    @Column(name = "PRICE")
    private Double price;

}

Podemos ver las siguientes anotaciones:

  • @Entity establece que la clase Product representa una entidad.
  • @Table nos permite definir el nombre de la tabla representada por esta entidad.
  • @Column indica que el campo representa una columna de la tabla.
  • @Id esta columna es la clave primaria.

name = "..." indica el nombre de la tabla o columna, según la anotación.

Lo siguiente que vamos a hacer es implementar la interface ProductDao esta vez la implementación será con JPA, debemos tener presente que las consultas se hacen utilizando JPQL lenguaje de consultas usado por JPA, no utilizamos SQL como en los cursos anteriores.  

@Repository("productDaoJpa")
public class ProductDaoJpaImpl implements ProductDao {

    private EntityManager entityManager;

    @PersistenceContext
    public void setEntityManager(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    @Override
    public List<Product> todos() {
        String query = "from Product";
        return entityManager.createQuery(query).getResultList();
    }

   //...//
}

Usamos la anotación @PersistenceContext para inyectar el EntityManager que requerimos para comunicarnos con la base de datos, lo siguiente que vemos es la implementación del método todos() que devuelve la lista de todos los productos en la BD, esta vez implementado con JPA. 

En la siguiente imagen podemos apreciar el código que teníamos anteriormente y la mejora utilizando un ORM con JPA, no debemos mapear datos de la tabla a objetos java ni viceversa, de esto se encarga el ORM Hibernate. 

spring hibernate jpa

Vemos ahora la implementación de los demás métodos del la interface.

Para buscar un producto por su ID usaremos el método find() indicamos primero el tipo y luego el ID que deseamos localizar, si no lo encuentra devolverá un valor nulo.

public Product buscar(Integer id) {
    return entityManager.find(Product.class, id);
}

Antes de continuar con los demás métodos de la interface ProductDao vamos a habilitar el administrador de transacciones, con él Spring administrará las transacciones por nosotros, nos olvidamos de los commit, rollback, etc.

@Configuration
@ComponentScan(basePackages = "carmelo.spring.jpa.dao")
@EnableTransactionManagement
public class SpringConfiguration {

    @Bean
    public DataSource dataSource() { ... }

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory() { ... }

    @Bean
    public JpaVendorAdapter jpaVendorAdapter() { ... }

    @Bean
    @Autowired
    public PlatformTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(entityManagerFactory);
        return transactionManager;
    }
}

Usamos la clase JpaTransactionManajer para crear el PlatformTransactionManager a este debemos asociarle el EntityManagerFactory, para ello usamos @Autowired para inyectarlo, también es necesario agregar la anotación @EnableTransactionManager para activar esta característica.

Anotamos la clase ProductDaoJpaImpl con @Transactional para indicar que la misma utilizara el administrador de transacciones que acabamos de crear.

Hecho esto ya podemos ver los siguiente métodos que nos quedan por implementar, entre ellos, agregar un producto a la base de datos.

public void insertar(Product product) {
    entityManager.persist(product);
}

Aprovecharemos el método eliminar para ver como introducir parámetros a nuestra consultas JPQL, para indicar un parámetro dentro de una consulta usamos “:” seguido del nombre que le daremos.  

public void eliminar(Integer id) {
    String jpql = "select p from Product p where p.id = :id";
    Query query = entityManager.createQuery(jpql);
    query.setParameter("id", id);
    Product p = (Product) query.getSingleResult();
    
    entityManager.remove(p);
}

Primero buscamos el producto con el ID indicado, si vemos la consulta al final tenemos el parámetro :id para indicar el valor de este parámetro usamos setParameter() donde indicamos el nombre luego el valor, en este caso el ID.

Para actualizar un producto existente, por ejemplo, cambiar su precio.

public void actualizar(Product product) {
    entityManager.merge(product);
}

Finalizamos con método que cuenta la cantidad de productos presentes en la base de datos.

public Integer cantidad() {
     return entityManager
             .createQuery("select count(p) from Product p", Long.class)
             .getSingleResult().intValue();
 }

Quedamos aquí, por ahora, hemos podido ver como podemos aprovechar los beneficios de utilizar un ORM como Hibernate con la implementación de JPA, si comparamos el código de los tutoriales anteriores veremos como hemos logrado reducir el código repetitivo.

Categorías:

Comentarios

Publicar un comentario

Temas relacionados

Entradas populares de este blog

tkinter Grid

Imagen
El método grid nos permite posicionar los widgets en una celda en especifico, indicamos la celda usando el índice de fila y columna correspondiente, el ancho y la altura de cada celda son configurables, además un widget puede ocupar varias celdas si lo deseamos, usando grid podemos crear fácilmente interfaces gráficas de usuario tipo formulario.
SIGUE LEYENDO

Conectar SQL Server con Java

Imagen
Conectar Java con SQL Server : una vez hayamos creado nuestra base de datos, seguramente necesitamos conectarla con una aplicación que realizaremos en un lenguaje de nuestra preferencia, si elegimos Java para conectar la base de datos debemos hacer lo siguientes pasos para conectarnos a la base de datos: Para realizar la conexión con una base de datos MySQL visita: Conectar Java con MySQL . Conectar Java con SQL Server Primero descargamos el controlador JDBC para SQL Server, nos dirigimos al siguiente enlace: descargar JDBC . Una vez ingresemos a la página indicada, tenemos dos versiones para descargar, una .exe y otro .tar.gz , ambos son iguales solo que el archivo .exe se extraerá automáticamente al darle doble clic. Una vez lo tengamos descargado, los descomprimimos y guardamos en una carpeta de nuestra preferencia. Creamos nuestra aplicación Java, en mi caso usaré el IDE Netbeans 8.x. Para conectarnos necesitaremos en siguiente código java: DB_Name es el nombre de la base de d
Sigue leyendo

Histogramas OpenCV Python

Imagen
Un histograma es una gráfica en donde se muestra la frecuencia con las que aparecen los distintos niveles de intensidad de una imagen a escala de grises, normalmente el nivel de intensidad está en el rango de 0 a 255, en donde el valor 0 representa los color negro y 255 el color blanco, utilizando el histograma de una imagen podemos modificar sus características, por ejemplo, el brillo y contraste, existen además otras aplicaciones que veremos más adelante.
SIGUE LEYENDO

tkinter Canvas

Imagen
El widget canvas en tkinter nos brinda una superficie sobre la que podemos dibujar distintas figuras, imágenes, texto, etc., para cada uno de ellos tenemos un método de la forma: canvas.create_* , por ejemplo para dibujar una línea tenemos: canvas.create_line o canvas.create_image para dibujar una imagen en el canvas.
SIGUE LEYENDO

JavaFX Uso de ComboBox

Imagen
Un ComboBox en uno de los controles comúnmente usados en la creación de interfaces gráficas de usuario, es un control diseñado para desplegar una lista de elementos del los cuales el usuario podrá seleccionar el deseado, un ComboBox puede ser editable o no, también podemos cambiar la forma como se presentan los datos. 
SIGUE LEYENDO