Java Generic Repository y JPA
El concepto de Java Generic Repository es muy habitual cuanto trabajamos con tecnologías
de persistencia. El concepto de Repository como clase que se encarga de gestionar todas las
operaciones de persistencia contra una tabla de la base de datos es hace ya mucho tiempo
un clásico.
La mayor parte de los lenguajes de programación soportan el uso de clases Genéricas .
Estas permiten avanzar en el uso del patrón Repository y generar repositorios genéricos que
reducen de forma significativa el código que tenemos que construir. Todos nuestros
repositorios extenderán del repositorio genérico y añadirán más operaciones.
[Link]
Java Generic Repository y JPA
Un Ejemplo de Java Generic Repository
Vamos a construir un ejemplo de Java Generic Repository utilizando JPA . Para ello
construiremos un proyecto de Maven con Eclipse y añadiremos las dependencias
necesarias.
<dependency>
<groupId>[Link]</groupId>
<artifactId>hibernate-jpa-2.1-api</artifactId>
[Link]
Java Generic Repository y JPA
<version>[Link]</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>hibernate-core</artifactId>
<version>[Link]</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>6.0.6</version>
</dependency>
Una vez añadidas las dependencias vamos a construir el fichero [Link] que nos
configura los parametros de acceso a la base de datos.
<persistence xmlns="[Link]
xmlns:xsi="[Link]
xsi:schemaLocation="[Link]
[Link]
version="2.0">
<persistence-unit name="mislibros">
<properties>
<property name="[Link]"
value="[Link].MySQL5Dialect"/>
<property name="[Link]" value="create-
drop"/>
[Link]
Java Generic Repository y JPA
<property name="[Link]"
value="[Link]"/>
<property name="[Link]"
value="jdbc:mysql://localhost:8889/mibasedatos"/>
<property name="[Link]"
value="root"/>
<property name="[Link]"
value="root "/>
</properties>
</persistence-unit>
</persistence>
El siguiente paso es construir nuestra Entidad
package bo;
import [Link];
import [Link];
@Entity
public class Libro {
@Id
private String titulo;
private String autor;
private int paginas;
private String categorias;
public Libro() {
super();
}
[Link]
Java Generic Repository y JPA
public Libro(String titulo, String autor, int paginas, String
categorias) {
super();
[Link] = titulo;
[Link] = autor;
[Link] = paginas;
[Link] = categorias;
}
public String getTitulo() {
return titulo;
}
public void setTitulo(String titulo) {
[Link] = titulo;
}
public String getAutor() {
return autor;
}
public void setAutor(String autor) {
[Link] = autor;
}
public int getPaginas() {
return paginas;
}
public void setPaginas(int paginas) {
[Link] = paginas;
}
public String getCategorias() {
return categorias;
}
public void setCategorias(String categorias) {
[Link] = categorias;
[Link]
Java Generic Repository y JPA
}
}
Es momento de construir el Java Generic Repository del cual el resto de nuestras clases se
va a apoyar junto con su interface.
package [Link];
public interface GenericRepository<T>{
T create(T t);
void delete(T t);
T find(T t);
T update(T t);
Iterable<T> findAll();
}
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
[Link]
Java Generic Repository y JPA
import [Link];
import [Link];
import [Link];
public class GenericRepositoryJPA<T> implements GenericRepository<T>{
protected EntityManager entityManager;
private Class<T> type;
public EntityManager getEntityManager() {
return entityManager;
}
@PersistenceContext
public void setEntityManager(EntityManager entityManager) {
[Link] = entityManager;
}
public GenericRepositoryJPA() {
Type t = getClass().getGenericSuperclass();
ParameterizedType pt = (ParameterizedType) t;
type = (Class) [Link]()[0];
}
public T create(final T t) {
[Link](t);
return t;
}
[Link]
Java Generic Repository y JPA
public void delete(final Object objeto) {
[Link]([Link](objeto));
}
public T find(final Object id) {
return (T) [Link](type, id);
}
public T update(final T t) {
return [Link](t);
}
public Iterable<T> findAll() {
CriteriaBuilder cb =
[Link]();
CriteriaQuery<T> criteriaQuery =
[Link](type);
Root<T> root = [Link](type);
[Link](root);
TypedQuery<T> query =
[Link](criteriaQuery);
return [Link]();
}
}
Creada la clase Genérica nos queda extender de ella y construir nuestro repositorio para la
clase Libro. En este caso es muy sencillo ya que no vamos a añadir métodos adicionales
[Link]
Java Generic Repository y JPA
package [Link];
import [Link];
public class LibroRepository extends GenericRepositoryJPA<Libro> {
[Link]
Java Generic Repository y JPA
Es momento de usar nuestro Repositorio de Libro e insertar datos en la base de datos
usando sus capacidades de herencia
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
public class Principal {
public static void main(String[] args) {
// TODO Auto-generated method stub
EntityManagerFactory
emf=[Link]("mislibros");
EntityManager em=[Link]();
LibroRepository lr= new LibroRepository();
[Link](em);
[Link](new Libro ("el juego de ender","Orson Scott
Card",500,"Cienciaficcion"));
}
Acabamos de insertar en la base de datos . Hemos construido un Java Generic Repository.
[Link]
Java Generic Repository y JPA
1. JPA Lazy fetching proxies y rendimiento
2. JPA DTO (Data Transfer Object) y JPQL
3. JPA Criteria API , un enfoque diferente
4. Un ejemplo de JPA Entity Graph
5. JPA Wiki
[Link]