Spring – Respuesta XML REST

La popularidad de la API REST aumenta día a día, ya que cumple con la arquitectura de una aplicación de manera conveniente. Una API REST es un acrónimo de ‘Transferencia de estado representacional’. También se denomina servicios web RESTful. También es un ‘Controlador’, pero con la diferencia de que Rest Controller devuelve Datos, mientras que Controller devuelve una Vista de la arquitectura ‘Modelo-Vista-Controlador’. REST API puede funcionar en todos los métodos HTTP como (GET, POST, PUT, PATCH, DELETE, etc.). Estos métodos corresponden a operaciones de creación, lectura, actualización y eliminación ( CRUD ), respectivamente. Puede devolver muchos tipos de datos. JSON se considera el formulario estándar para la transferencia de datos entre aplicaciones web. 

Los tipos de datos que la API REST puede devolver son los siguientes: 

1. JSON (Notación de objetos de JavaScript)
2. XML
3. HTML
4. XLT
5. Python
6. PHP
7. Texto sin formato

Requisito previo: aunque JSON es la forma estándar para transferir datos entre aplicaciones, tiene algunas desventajas que se superan en la transferencia de datos en formato XML.

Las ventajas de XML son las siguientes: 

1. Es un lenguaje de marcado extensible que utiliza etiquetas para la definición de datos.
2. Admite espacios de nombres.
3. Admite comentarios.
4. Admite varias codificaciones.
5. Por último, pero no menos importante, XML es más seguro que JSON.

Nota : 

• JSON es menos seguro debido a la ausencia de un analizador JSON en el navegador.
• JSONP es peligroso porque permite intercambios de datos de origen cruzado.

API REST: respuesta XML

• Cuando creamos un proyecto Spring Boot con la dependencia ‘Starter Web’, solo obtenemos soporte para devolver datos en formato JSON, con la ayuda de la biblioteca Jackson.
• Para incorporar soporte para devolver datos en formato XML, necesitamos dependencias de terceros.
• Hay muchas bibliotecas que admiten el formato de retorno XML, por ejemplo, Jackson, JAXB, etc.

Funcionamiento de la respuesta Rest XML

Estructura del proyecto – Maven

Camino 1: Usando Jackson 

La biblioteca Jackson ya está presente en el classpath del framework Spring para nuestra aplicación. Solo necesitamos agregar una extensión a la biblioteca Jackson que pueda funcionar con respuestas de datos XML. Para agregar la extensión, agregue la siguiente dependencia en la compilación del proyecto.

Experto – pom.xml

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
</dependency>

Después de agregar la dependencia anterior y actualizar el proyecto, la extensión XML de Jackson se agregará en la ruta de clase para que Spring MVC la recoja automáticamente para las respuestas XML.

A. Archivo: pom.xml (Configuración del proyecto)

Ejemplo:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" 
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>sia</groupId>
    <artifactId>GFG-RestXMLResponse</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>GFG-RestXMLResponse</name>
    <description>GeeksforGeeks</description>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
          
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
        </dependency>
          
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
  
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

B. Bootstrapping de la aplicación

Ejemplo: GfgRestXmlResponseApplication.java

// Java Program to Illustrate Bootstrapping of Application
  
package gfg;
  
// Importing required classes
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
  
// Annotation
@SpringBootApplication
  
// Class
public class GfgRestXmlResponseApplication {
  
    // Main driver method
    public static void main(String[] args)
    {
        SpringApplication.run(
            GfgRestXmlResponseApplication.class, args);
    }
}

 
C. Objeto a devolver como respuesta XML (EntityModel.java)

Esta clase actúa como un objeto de usuario (bean) cuyos campos se asignarán a etiquetas XML respectivamente. También requiere métodos Getter/Setter que se generan automáticamente usando la anotación ‘@Data’ de la biblioteca ‘Lombok’. Para incrustar la biblioteca de Lombok en el proyecto, agregue la siguiente dependencia en la compilación del proyecto.

Experto – pom.xml

<dependency>
     <groupId>org.projectlombok</groupId>
     <artifactId>lombok</artifactId>
     <optional>true</optional>
</dependency>

Ejemplo:

// Java Program Illustrating Object to be return as XML
// response
  
package gfg;
  
// Importing required classes
import lombok.Data;
  
// Annotation
@Data
  
// Class
public class EntityModel {
  
    // Class data members
    String ID;
    String NAME;
    String DOB;
    String PINCODE;
}

D. API REST que devuelve una respuesta XML (RestXMLResponseController.java)

Este controlador API REST está configurado para devolver datos específicamente en formato XML, utilizando el atributo Produce de la anotación @RequestMapping.

Ejemplo:

// Java Program Illustrating REST API returning XML response
  
package gfg;
  
// Importing required classes
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
  
// Annotations
@RestController
@RequestMapping(path = "/xml-output",
                produces = "application/xml")
  
// Class
public class RestXMLResponseController {
  
    @GetMapping("/get")
    public ResponseEntity<EntityModel> get()
    {
  
        EntityModel model = new EntityModel();
        model.setID("1");
        model.setNAME("Darshan.G.Pawar");
        model.setDOB("05-09-2001");
        model.setPINCODE("422 009");
  
        HttpHeaders hearders = new HttpHeaders();
        ResponseEntity<EntityModel> entityModel
            = new ResponseEntity<>(model, hearders,
                                   HttpStatus.CREATED);
  
        return entityModel;
    }
  
    // Annotation
    @GetMapping("/get/{id}")
  
    // Class
    public ResponseEntity<EntityModel>
    getById(@PathVariable("id") String id)
    {
  
        EntityModel model = new EntityModel();
        model.setID(id);
        model.setNAME("Darshan.G.Pawar");
        model.setDOB("05-09-2001");
        model.setPINCODE("422 009");
  
        HttpHeaders hearders = new HttpHeaders();
        ResponseEntity<EntityModel> entityModel
            = new ResponseEntity<>(model, hearders,
                                   HttpStatus.CREATED);
  
        return entityModel;
    }
}

Salida 1:

Respuesta XML devuelta por el método get()

Salida 2:

Respuesta XML devuelta por el método getById()

E. ConsumeXMLResponse.java (Obtenga la respuesta de la API REST)

• Los datos devueltos en formato XML por la API REST deben consumirse y ponerse en uso.
• Spring Framework proporciona una forma conveniente de consumir respuestas REST con la ayuda de ‘RestTemplate’ de Spring.
• Nos beneficia al evitar la necesidad de escribir código repetitivo.
• RestTemplate nos proporciona métodos que son específicos de los métodos HTTP.
• Aquí, para la solicitud GET HTTP, se usa el método ‘getForEntity()’ que acepta la URL para el método @GetMapping, una clase a la que se asignará la respuesta y parámetros de objeto adicionales a la URL.
• Este método devolverá un objeto ResponseEntity<>.

// Java Program Illustrating Getting REST API Response
  
package gfg;
  
// Importing required classes 
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;
  
// Class 
public class ConsumeXMLResponse {
   
    RestTemplate rest = new RestTemplate();
      
    public ResponseEntity<EntityModel> get(String id) {
          
        return rest.getForEntity("http://localhost:8080/xml-output/get/{id}", 
                  EntityModel.class, id);
          
    }
}

F. Archivo: OutputController.java (controlador normal)

Este controlador MVC usa la clase anterior para obtener la respuesta XML devuelta por la API REST. Además, tras obtener los datos nos devuelve una vista modificada ( View.html)

Ejemplo:

// Java Program to Illustrate Regular controller
  
package gfg;
  
// Importing required classes
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
  
// Annotation
@Controller
@RequestMapping("View")
  
// Class
public class OutputController {
  
    // Annotation
    @GetMapping("/get/{id}")
  
    public String
    getXMLOutput(@PathVariable("id") String id, Model model)
    {
  
        ConsumeXMLResponse response
            = new ConsumeXMLResponse();
        ResponseEntity<EntityModel> responseEntity
            = response.get(id);
  
        EntityModel entity = responseEntity.getBody();
        HttpHeaders headers = responseEntity.getHeaders();
  
        model.addAttribute("xml", entity);
        model.addAttribute("XMLheaders", headers);
  
        return "View";
    }
}

G. Archivo: View.html (Mostrar la respuesta XML)

<!DOCTYPE html>
<html xmlns = " http://www.w3.org/1999/xhtml "
      xmlns:th = " http://www.thymeleaf.org " >
 <head>
 <title> GeeksforGeeks </title>
 <style>
 h2 {
    width      : 200px ;
    display    : inline-block ;
    text-align :right;
}
 h1 {
    color   : forestgreen ;
    display : inline-block ;
}
h3 {
    width : 650px ;
    color : forestgreen ;
}
</style>
</head>
<body>
<h1> Hello Geek : REST XML Response </h1> </br>
  
<h2> Id : </h2>            <h1 th:text = " ${xml.ID} " > Replaceable text </h1 > </br>
<h2> Name : </h2>          <h1 th:text = " ${xml.NAME} " > Replaceable text </h1 > </br>
<h2> Date Of Birth : </h2> <h1 th:text = " ${xml.DOB} " > Replaceable text </h1 > </br>
<h2> Pincode : </h2>       <h1 th:text = " ${xml.PINCODE} " > Replaceable text </h1 > </br>
  
<h4> Headers : </h4>
<h3 th:text = " ${XMLheaders} " ></h3>
</body>
</html>

Producción:

Respuesta REST XML en HTML

Camino 2: Usando JAXB

Para usar la biblioteca JAXB, agregue la siguiente dependencia en el proyecto construido.

Archivo: Maven – pom.xml

<dependency>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>jaxb2-maven-plugin</artifactId>
    <version>2.5.0</version>
</dependency>

Para que funcione, debe usar la anotación @XmlRootElement de la misma biblioteca en un objeto que se asignará a la respuesta XML.

Ejemplo: EntityModel.java

package gfg;
  
import javax.xml.bind.annotation.XmlRootElement;
  
import lombok.Data;
  
@XmlRootElement
@Data
public class EntityModel {
   
    String ID;
    String NAME;
    String DOB;
    String PINCODE;
}

Nota : también puede usar la dependencia de Jersey para desarrollar API RESTful. La principal ventaja de usarlo es que ya tiene una biblioteca JAX-RS que eventualmente usa bibliotecas JAXB.