Otro increíble blog dedicado a Java: octubre 2019

En esta ocasión mostraré un ejemplo usando Java SE 11 de como mapear una clase no entidad (un POJO) a partir de los datos que existen en la base de datos y que representan a una entidad utilizando ConstructorResult, Projection y una construcción "manual" con JPA. Las pruebas serán realizadas usando Testcontainers junto a Postgresql como base de datos.

El procedimiento es el siguiente (se omiten los metodos/imports/anotaciones que no son relevantes y usaré lombok solo para getter/setter):

1- La Entidad
Representa la entidad que mantendrá datos en la base de datos y de la cual extraeremos algunos de sus campos para nuestro pojo.

@Entity
@Table(schema = "jpa", name = "persona")
public class Persona {
    @Id
    private int id;
    private String nombre;
    private String apellido;
}

2- El POJO

Requiere tener un constructor con los argumentos que la query utilizará:

public class PersonaPOJO {
    private String nn;
    private String aa;
    
    public PersonaPOJO() {}

    public PersonaPOJO(String nn, String aa) {
        this.nn = nn;
        this.aa = aa;
    }
}

Los atributos pueden tener el nombre que estimen conveniente.

3- Definir el ConstructorResult

@SqlResultSetMapping(name = "personapojo",
  classes = {
    @ConstructorResult(targetClass = PersonaPOJO.class,
      columns = {
        @ColumnResult(name = "nn", type = String.class),
        @ColumnResult(name = "aa", type = String.class)})})

personapojo: es el nombre que utilizaremos para hacer referencia a él

targetClass: nuestra clase objetivo (el POJO)

columns: definicion del resultado de la query a las propiedades que serán mapeadas a nuestro POJO usando el constructor

Para que sea reconocida en nuestro contexto de persistencia, personapojo tiene que ser escanenada por Hibernate y como PersonaPOJO.java no es una entidad no sería analizada si la definimos en ella. Por este motivo la dejaremos en Persona:

@SqlResultSetMapping(name = "personapojo",
  classes = {
    @ConstructorResult(targetClass = PersonaPOJO.class,
      columns = {
        @ColumnResult(name = "nn", type = String.class),
        @ColumnResult(name = "aa", type = String.class)})})
@Entity
@Table(schema = "jpa", name = "persona")
public class Persona {
    @Id
    private int id;
    private String nombre;
    private String apellido;
}

4- persistence.xml

El archivo persistence.xml hay que dejarlo dentro de META-INF con el siguiente contenido:

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.2"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_2.xsd">
    <persistence-unit name="em"
                      transaction-type="RESOURCE_LOCAL">
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <exclude-unlisted-classes>false</exclude-unlisted-classes>
    </persistence-unit>
</persistence>

Definimos el nombre de nuestra unidad de persistencia (em) e indicamos con RESOURCE_LOCAL que nosotros administramos la creación de los EntityManager y que las transacciones serán administrados localmente y no por alguna implementacion JTA (es lo que necesitamos para nuestro ejemplo).

5- Contexto de Persistencia

Lo primero que hay que hacer es crear el EntityManagerFactory:

private static EntityManagerFactory emf
    = Persistence.createEntityManagerFactory("em", cargarPropiedades());

private static Map<String, String> cargarPropiedades() {
      return Map.of(
        "javax.persistence.jdbc.driver", System.getProperty("jdbc_driver"),
        "javax.persistence.jdbc.url", System.getProperty("jdbc_url"),
        "javax.persistence.jdbc.user", System.getProperty("jdbc_user"),
        "javax.persistence.jdbc.password", System.getProperty("jdbc_password"),
        "hibernate.hbm2ddl.auto", "validate"
      );
}

usando el metodo cargarPropiedades() definimos programaticamente como será el acceso a la base de datos y no utilizamos el archivo persistence.xml para este propósito.

Luego para obtener el EntityManager:

public static EntityManager obtener() {
 return emf.createEntityManager();
}

6- Test

Para los tests usaré el siguiente script que permitirá tener datos precargados:

create schema jpa;

create table jpa.persona (
   id int primary key,
   nombre varchar default null,
   apellido varchar default null
);

insert into jpa.persona (id, nombre, apellido) values (1, 'Sebastián', 'Ávila');

Ahora las pruebas... El objetivo es sacar los datos disponibles para Persona (puede ser cualquier dato, no es necesario que esté asociado a la entidad) y usarlos para construir una instancia de PersonaPOJO (no es @Entity) utilizando JPA:

// obtener el contexto de persistencia
final var em = ContextoPersistencia.obtener();

// obtener una entidad que ya existe en la base de datos (solo por entretención)
final var persona = em.find(Persona.class, 1);
validarPersona(persona);

// Método 1: utilizar ConstructorResult junto a NativeQuery
List<PersonaPOJO> personas = em
  .createNativeQuery("select nombre nn, apellido aa from jpa.persona", "personapojo")
  .getResultList();
assertThat(personas.size()).isEqualTo(1);
validarPersona(personas.get(0));

// Método 2: utilizando JPQL y el constructor del POJO para la proyección
personas = em
  .createQuery("select new com.sebastian.pojojpa.dominio.PersonaPOJO(p.nombre, p.apellido) from Persona p")
  .getResultList();
validarPersona(personas.get(0));

// Método 3: obtener un List<Object[]> y hacer la transformación “manual”
final List<Object[]> obj = em
  .createNativeQuery("select nombre nn, apellido aa from jpa.persona")
  .getResultList();
validarPersona(obj.get(0));

em.close();

Los métodos de validación:

private void validarPersona(final Object[] persona) {
    final var pj = new PersonaPOJO();
    pj.setNn((String) persona[0]);
    pj.setAa((String) persona[1]);
    validarPersona(pj);
}
    
private void validarPersona(final Persona p) {
    assertThat(p).isNotNull();
    assertThat(p.getId()).isEqualTo(1);
    assertThat(p.getNombre()).isEqualTo("Sebastián");
    assertThat(p.getApellido()).isEqualTo("Ávila");
}

private void validarPersona(final PersonaPOJO p) {
    assertThat(p).isNotNull();
    assertThat(p.getNn()).isEqualTo("Sebastián");
    assertThat(p.getAa()).isEqualTo("Ávila");
}

Estructura del proyecto:

Y eso es todo☺el código está disponible en GitHub para ver el detalle de la implementación ✌.

JPA-Hibernate + POJO + Projection + ConstructorResult + NativeQuery + Testcontainers + PostgreSQL