Montar una aplicación con Spring Data JPA

Buenas hace poco he descubierto que con Spring 3 los templates están pasados de moda para hacer los DAO. Directamente se usa los entityManager en los DAO pero que ahora hay incluso una forma mejor para realizar esta capa de la aplicación: Spring Data.

Empezaremos de abajo a arriba y al final pondremos los ficheros de configuración. Lo primero es que tus DTO esten hechos con las anotaciones de JPA.

@Entity
@Table(name = "libro", catalog = "almacen")
public class Libro implements java.io.Serializable {

 private static final long serialVersionUID = 1L;
 private Integer ident;
 private String nombre;
 private String autor;

 public Libro(final Integer ident) {
  this.ident = ident;
 }

 @Column(name = "AUTOR", length = 45)
 public String getAutor() {
  return autor;
 }

 @Id
 @GeneratedValue(strategy = GenerationType.AUTO)
 @Column(name = "IDENT", unique = true, nullable = false)
 public Integer getIdent() {
  return ident;
 }

 @Column(name = "NOMBRE", length = 45)
 public String getNombre() {
  return nombre;
 }

 public void setAutor(final String autor) {
  this.autor = autor;
 }

 public void setIdent(final Integer ident) {
  this.ident = ident;
 }

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

Ahora aquí es donde viene lo bueno. Lo siguiente sería hacer el DAO, primero creando las interfaz y luego una clase que implemente los métodos (si se quiere ahorrar código, crear una clase abstracta de la que herede la implementación con los métodos más comunes). Pero ya ni eso, solo tenemos que crear la interfaz, he indicar que extiende de una de las tres interfaces de ayuda incluidas en Spring Data. Las interfaces son las siguientes:

- CrudRepository: que como su propio nombre indica tiene las 4 funciones básicas. Crear, leer, actualizar y borrar.
- PagingAndSortingRepository: Que añade métodos que permitan generar búsquedas paginadas.
- JpaRepository: Que es la interfaz padre e incluye las otras dos.

Cuando nuestra interfaz DAO herede de una de estas, debemos indicarle cual es el objeto asociado a las operaciones y el tipo que dato de su identificador. Así que con esto tendriamos suficiente y nuestro ejemplo quedaría:

public interface BookRepository extends JpaRepository {
}

Y esto es todo amigos... así de simple. Con esto ya podríamos utilizarlo directamente. Pero a mí me gusta usar una capa de servicios como capa intermedia para realizar posibles operaciones de tratamiento de datos entre la vista y los DAOs. Este capa si será mas a la vieja usanza, con una interfaz y una clase que la implementa.

public interface LibroService {
 void create(final Libro entity);
 List findAll();
 Libro findById(final Integer id);
 void remove(final Libro entity);
 void update(final Libro entity);
}

La clase que la implemente contendrá la anotación de persistencia para que permita un rollback en caso de que ocurra alguna RunTimeException.

@Service
@Transactional
public class LibroServiceImpl implements LibroService {

 @Autowired
 private BookRepository dao;

 @Override
 public void create(final Libro entity) {
  dao.save(entity);
 }
 @Override
 public List findAll() {
  return dao.findAll();
 }
 @Override
 public Libro findById(final Integer id) {
  return dao.findOne(id);
 }
 @Override
 public void remove(final Libro entity) {
  // TODO Auto-generated method stub
  dao.delete(entity);
 }
 @Override
 public void update(final Libro entity) {
  dao.save(entity);
 }
}

Como veis es muy sencillo, solo tenemos que usar una de las interfaces de ayuda y ya tenemos un conjunto de métodos a nuestra disposición sin necesidad de implementar nada.

Ya solo queda la configuración que tampoco es poca cosa. Primero al tratarse de JPA necesitamos un fichero de configuración persistence.xml que este incluido en la carpeta META-INF/. He visto varios ejemplos donde se puede configurar de varias formas y dejar el persistence.xml practicamente vacío pero no me gusta incluir los datos de conexión en los ficheros propios de spring. Así queda el fichero:

En el fichero de configuración de spring declaramos el entityManager y escaneamos los paquetes del proyecto en busca de los repositorios y las clases con anotaciones:

Por último estas son las librerías usadas:

 
  mysql
  mysql-connector-java
  5.1.14
 
 
  org.springframework.data
  spring-data-jpa
  1.2.0.RELEASE
 
 
  org.hibernate
  hibernate-entitymanager
  4.1.4.Final
 
 
  log4j
  log4j
  1.2.16
 

Como me he apuntado a la moda de tenerlo todo en la nube aquí podéis ver el ejemplo completo y bajaros el código.