¿Te gustaría Java desde cero?
Tenemos los diplomados que necesitas.¡Haz clic aquí!

La conversión de Entity a DTO es una de las conversiones más habituales que tenemos cuando programamos en el día a día en Java. Vamos a ver un par de ejemplos habituales y como podemos usar Java 8 para simplificar la transformación. Supongamos que partimos de la clase Persona.

  1. package com.arquitecturajava;
  2. public class Persona {
  3. private String nombre;
  4. private String apellidos;
  5. private int edad;
  6. public String getNombre() {
  7. return nombre;
  8. }
  9. public void setNombre(String nombre) {
  10. this.nombre = nombre;
  11. }
  12. public String getApellidos() {
  13. return apellidos;
  14. }
  15. public void setApellidos(String apellidos) {
  16. this.apellidos = apellidos;
  17. }
  18. public int getEdad() {
  19. return edad;
  20. }
  21. public void setEdad(int edad) {
  22. this.edad = edad;
  23. }
  24. public Persona(String nombre, String apellidos, int edad) {
  25. super();
  26. this.nombre = nombre;
  27. this.apellidos = apellidos;
  28. this.edad = edad;
  29. }
  30. }

Esta clase es la que va a realizar las funciones de Entidad. Mientras que vamos a tener otra muy parecida que hará las funciones de DTO.

  1. package com.arquitecturajava;
  2. public class PersonaDTO {
  3. public PersonaDTO(String nombre, String apellidos) {
  4. super();
  5. this.nombre = nombre;
  6. this.apellidos = apellidos;
  7. }
  8. private String nombre;
  9. private String apellidos;
  10. public String getNombre() {
  11. return nombre;
  12. }
  13. public void setNombre(String nombre) {
  14. this.nombre = nombre;
  15. }
  16. public String getApellidos() {
  17. return apellidos;
  18. }
  19. public void setApellidos(String apellidos) {
  20. this.apellidos = apellidos;
  21. }
  22. public PersonaDTO(Persona persona) {
  23. super();
  24. this.nombre= persona.getNombre();
  25. this.apellidos=persona.getApellidos();
  26. }
  27. }

Entity to DTO y constructores

En este caso las dos clases son muy parecidas y hemos obligado a la clase que es un DTO a recibir como parámetro una Persona a la hora de instanciarla por supuesto puede soportar otros tipos de constructores sin problemas.

La forma más sencilla de utilizarla creando un objeto DTO que recibe como parámetro la Persona.

  1. package com.arquitecturajava;
  2. public class Principal {
  3. public static void main(String[] args) {
  4. Persona p = new Persona(“pepe”, “perez”, 30);
  5. PersonaDTO dto = new PersonaDTO(p);
  6. System.out.println(dto.getNombre());
  7. System.out.println(dto.getApellidos());
  8. }
  9. }

El resultado saldrá por la consola sin ningún problema acabamos de realizar una transformación.

Entidades y Listas

En muchas ocasiones no solo necesitamos convertir una Entidad a un DTO sino que ademas necesitamos hacerlo con una lista de elementos de este tipo de entidades.

  1. package com.arquitecturajava;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. public class Principal2 {
  5. public static void main(String[] args) {
  6. Persona p= new Persona (“pepe”,”perez”,30);
  7. Persona p1 = new Persona(“ana”, “sanchez”, 40);
  8. List<Persona> lista = new ArrayList<Persona>();
  9. lista.add(p);
  10. lista.add(p1);
  11. List<PersonaDTO> listaDTO = new ArrayList<PersonaDTO>();
  12. for (Persona persona : lista) {
  13. listaDTO.add(new PersonaDTO(persona));
  14. }
  15. for (PersonaDTO undto : listaDTO) {
  16. System.out.println(undto.getNombre());
  17. System.out.println(undto.getApellidos());
  18. }
  19. }
  20. }

En este caso creamos una lista y añadimos objetos persona a ella . Una vez que tenemos la lista rellena el siguiente paso es utilizar un bucle forEach y generar una nueva lista de DTOs la cual imprimimos por la consola.

Como su puede observar este código es bastante sencillo pero también bastante extenso a la hora de utilizarlo . ¿Como podemos simplificar las cosas para que todo sea más natural con Java 8?

Java 8 constructor Reference Entity to DTO

La solución pasa por hacer uso de una de las capacidades que tiene Java 8 a nivel de métodos de referencia y manejo de constructores.

Veamos su código:

  1. package com.arquitecturajava;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. import java.util.stream.Collectors;
  5. public class Principal3 {
  6. public static void main(String[] args) {
  7. Persona p= new Persona (“pepe”,”perez”,30);
  8. Persona p1 = new Persona(“ana”, “sanchez”, 40);
  9. List<Persona> lista = new ArrayList<Persona>();
  10. lista.add(p);
  11. lista.add(p1);
  12. List<PersonaDTO> listaDTO=lista.stream().map(PersonaDTO::new).collect(Collectors.toList());
  13. for (PersonaDTO undto : listaDTO) {
  14. System.out.println(undto.getNombre());
  15. System.out.println(undto.getApellidos());
  16. }
  17. }
  18. }

El resultado será el mismo pero mucho más compacto y nos ahorraremos el bucle for inicial. Recordemos que los Java constructor reference siempre nos aportan flexibilidad y en este caso los usamos para hacer una transformación de Entity to DTO.

Te esperamos en los siguientes artículos en donde hablaremos mas acerca de estos temas, los cuales hoy en día son de vital importancia en el mundo de la tecnología.

¿Te gustaría Java desde cero?
Tenemos los diplomados que necesitas.¡Haz clic aquí!

About Author

NGuerrero

0 0 votos
Article Rating
Suscribir
Notificar de
guest
0 Comments
Comentarios.
Ver todos los comentarios
0
¿Te gusta este articulo? por favor comentax
()
x
Abrir chat
¿Quieres aprender a programar?
Hola 👋,
¿Te interesa información de nuestros cursos?