Manejo de consultas nativas en Java: Cómo convertir Object[] a una clase (Sin Hibernate)

¡Hola a todos los programadores! 👨‍💻👩‍💻 En nuestro día a día, a menudo nos encontramos con situaciones donde necesitamos hacer consultas directas a la base de datos que no están mapeadas a una clase o entidad. Aunque frameworks como Hibernate o JPA hacen este trabajo de forma automática, a veces nos topamos con código legacy, clases de servicio complejas o consultas muy específicas que nos obligan a trabajar con resultados "crudos".

Si te ha pasado que una consulta nativa te devuelve un listado de Object[] y te preguntas cómo transformarlo en una clase Java que puedas usar fácilmente, ¡has llegado al lugar correcto! En este artículo, te mostraremos una solución práctica y temporal para este problema.

---

El problema: NativeQuery y sus resultados

Cuando realizamos una consulta nativa usando entityManager.createNativeQuery(), el resultado por defecto es una lista de objetos genéricos (List<Object[]>), donde cada Object[] representa una fila de la tabla. El reto es tomar esos arreglos y pasarlos a una clase de modelo, como nuestra clase Comite.

---

Paso a paso: La solución

Para abordar este desafío, te proponemos una estrategia simple y organizada, dividida en tres partes:

1. El método que ejecuta la consulta

Este es el punto de partida. Aquí, creamos un método que se conecta a la base de datos, ejecuta la consulta nativa y recibe el resultado. Luego, este resultado es pasado a un método auxiliar que se encargará de la conversión.

Ejemplo de código:

public List<Comite> getAllComites() {
  // 1. Construir la consulta SQL nativa
  StringBuilder sql = new StringBuilder();
  sql.append("SELECT * FROM comiteInfo");
  
  // 2. Ejecutar la consulta y obtener el resultado
  Query query = this.entityManager.createNativeQuery(sql.toString());
  List<Object[]> resultList = query.getResultList();
  
  // 3. Convertir la lista de Object[] a una lista de Comite
  return convertObjectComite(resultList);
}

2. El método que convierte los objetos

Esta función es el corazón de la solución. Recibe la List<Object[]> del método anterior y se encarga de iterar sobre cada fila. En cada iteración, crea una nueva instancia de la clase Comite y le asigna los valores del arreglo de objetos.

Ejemplo de código:

private List<Comite> convertObjectComite(List<Object[]> resultQuery) {
  List<Comite> resultConvert = new ArrayList<>();
  
  // 1. Iterar sobre cada fila (Object[]) del resultado
  for (Object[] data : resultQuery) {
    // 2. Crear un nuevo objeto Comite con los datos de la fila
    Comite objComite = new Comite(data);
    
    // 3. Agregar el objeto a la lista de resultados
    resultConvert.add(objComite);
  }
  
  return resultConvert;
}

3. El constructor de la clase de modelo

Aquí es donde ocurre la magia final. El constructor de la clase Comite está diseñado para recibir un arreglo de Object (Object... fields). Dentro de este constructor, tomamos cada elemento del arreglo y lo casteamos al tipo de dato correcto para asignarlo al atributo correspondiente. Es crucial que el orden y tipo de los campos en el SELECT coincidan con el orden en el constructor.

Ejemplo de código:

public class Comite {
  private Long idComite;
  private String nombreComite;
  private String indTipComite;
  
  // Constructor para la conversión de Object[]
  public Comite(final Object... fields) {
    super();
    this.idComite = (Long) fields[0];
    this.nombreComite = (String) fields[1];
    this.indTipComite = (String) fields[2];
  }
  
  // Getters y Setters
  // ...
}

Consideraciones y llamado a la acción

Aunque este método es muy útil para solucionar problemas puntuales, es importante recordar que no es la forma más recomendada a largo plazo. La mejor práctica es utilizar las herramientas que ofrecen los frameworks como JPA e Hibernate para mapear las consultas a entidades, ya que esto proporciona un código más limpio, robusto y fácil de mantener. Esta solución es ideal como un "parche" temporal o en escenarios donde la refactorización completa no es viable.

¿Te ha sido útil esta técnica? ¡Déjanos un comentario y cuéntanos en qué situación la has utilizado! Y no olvides compartir este artículo con otros desarrolladores que puedan necesitar esta solución. ¡Hasta la próxima! 🚀