Integración Spring y JAXB

El término JAXB significa Arquitectura Java para enlace XML. Los programadores de Java pueden usarlo para traducir clases de Java a representaciones XML. Los objetos de Java se pueden clasificar en XML y viceversa utilizando JAXB. Sun proporciona un marco OXM (asignación XML de objetos) o O/M.

Nota: La mayor y única ventaja de JAXB es que no es necesario desarrollar métodos de devolución de llamada ni crear un analizador SAX o DOM.

Implementación: integración de Spring y JAXB (calificación de objetos Java en XML)

La estructura del proyecto quedará de la siguiente manera: 

Creamos instancias de Marshaller y Unmarshaller usando la instancia de Jaxb2Marshaller. En Jaxb2Marshaller, establezca el atributo jaxb.formatted.output en verdadero para una buena impresión. Para asignar etiquetas y atributos XML a objetos Java, necesitamos construir un bean Java con propiedades que se asignan a etiquetas y atributos XML. Usando javax.xml.bind, anote las propiedades. XmlAttribute y XmlElement, por ejemplo, son anotaciones que vinculan elementos y atributos XML con las propiedades del bean Java.

Recuerde: Para ejecutar la aplicación, necesitamos el siguiente software como se indica: 

1. Java 7
2. gradle
3. Eclipse
4. Spring-Oxm:4.1.5.LIBERAR

Archivo Gradle para Spring OXM y Spring Boot Starter

Paso 1: busque el archivo Gradle para Spring OXM y Spring Boot Starter.

Archivo: build.xml

apply plugin: 'java'
apply plugin: 'eclipse'
archivesBaseName = 'geeksforgeeks'
version = '1'
repositories {
    mavenCentral()
}
dependencies {
    compile 'org.springframework.boot:spring-boot-starter:1.2.2.RELEASE'
    compile 'org.springframework:spring-oxm:4.1.5.RELEASE'
}

Archivo de configuración basado en anotaciones para Jaxb2Marshaller y Pretty Print

La instancia de Jaxb2Marshaller en Spring OXM se usa para construir instancias de Marshaller y Unmarshaller. 

Paso 2: En Jaxb2Marshaller, podemos configurar los ajustes para una buena impresión, codificación, etc. de XML. Para crear una hermosa impresión, siga las instrucciones a continuación.

map.put("jaxb.formatted.output", true);
jaxb2Marshaller.setMarshallerProperties(map); 

Archivo: AppConfig.java

// Java Program to Illustrate Configuration Class
 
package com.geeksforgeeks;
 
// Importing required classes
import java.util.HashMap;
import java.util.Map;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.oxm.jaxb.Jaxb2Marshaller;
 
// Annotation
@Configuration
// Class
public class AppConfig {
 
    // Method
    @Bean public Processor getHandler()
    {
        Processor handler = new Processor();
        handler.setMarshaller(getCastorMarshaller());
        handler.setUnmarshaller(getCastorMarshaller());
 
        return handler;
    }
 
    // Method
    @Bean public Jaxb2Marshaller getCastorMarshaller()
    {
        Jaxb2Marshaller jaxb2Marshaller
            = new Jaxb2Marshaller();
        jaxb2Marshaller.setPackagesToScan(
            "com.geeksforgeeks.bean");
        Map<String, Object> map
            = new HashMap<String, Object>();
        map.put("jaxb.formatted.output", true);
        jaxb2Marshaller.setMarshallerProperties(map);
 
        return jaxb2Marshaller;
    }
}

Java admite muchas anotaciones para el mapeo de objetos XML y Java, incluidos @XmlRootElement, @XmlAccessorType, @XmlAttribute y @XmlElement. 

Paso 3: use @XmlAttribute para adquirir propiedades Java como atributos XML y la anotación @XmlElement en las propiedades para recuperar subetiquetas XML.

Archivo: Empresa.java

// Java Program to Illustrate Bean for XML Mapping
 
package com.geeksforgeeks.bean;
 
// Importing required classes
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
 
// Annotation
@XmlRootElement(name = "company-info",
                namespace = "com.geeksforgeeks")
@XmlAccessorType(XmlAccessType.NONE)
 
// Class
public class Company {
 
    // Class data members
    @XmlAttribute(name = "id") private Integer id;
    @XmlElement(name = "company-name")
    private String companyName;
   
    @XmlElement(name = "ceo-name") private String ceoName;
    @XmlElement(name = "no-emp") private Integer noEmp;
 
    // Getters and setters
    public Integer getId() { return id; }
    public void setId(Integer id)
    {
        // this keyword refers to current itself
        this.id = id;
    }
 
    // Getter and Setter
    public String getCompanyName() { return companyName; }
    public void setCompanyName(String companyName)
    {
        this.companyName = companyName;
    }
 
    // Getter and Setter
    public String getCeoName() { return ceoName; }
    public void setCeoName(String ceoName)
    {
        this.ceoName = ceoName;
    }
 
    // Getter and Setter
    public Integer getNoEmp() { return noEmp; }
    public void setNoEmp(Integer noEmp)
    {
        this.noEmp = noEmp;
    }
}

Definir método para Marshaller y Unmarshaller

Paso 4: encuentre un método de utilidad en el que llamemos Marshaller y Unmarshaller.

Archivo: Procesador.java

// Java Program Defining Method for
// Marshaller and Unmarshaller
 
package com.geeksforgeeks;
 
// Importing required classes
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
 
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
 
import org.springframework.oxm.Marshaller;
import org.springframework.oxm.Unmarshaller;
 
// Class
public class Processor {
   
    // Class data members
    private Marshaller marshaller;
    private Unmarshaller unmarshaller;
 
     // Setter
    public void setMarshaller(Marshaller marshaller) {
        this.marshaller = marshaller;
    }
 
    public void setUnmarshaller(Unmarshaller unmarshaller) {
        this.unmarshaller = unmarshaller;
    }
    // Converting Object to XML file
    public void objectToXML(String fileName, Object graph) throws IOException {
        FileOutputStream fos = null;
       
      // Try block to check for exceptions
      try {
            fos = new FileOutputStream(fileName);
            marshaller.marshal(graph, new StreamResult(fos));
        }
       
      // finally block that will execute for sure
      finally {
         
          // Closing the connections
            fos.close();
        }
    }
     // Method
    // To Convert XML to Java Object
    public Object xmlToObject(String fileName) throws IOException {
         
      FileInputStream fis = null;
       
      // Try block to check for exceptions
      try {
            fis = new FileInputStream(fileName);
            return unmarshaller.unmarshal(new StreamSource(fis));
        }
       
       // finally block that will execute for sure
      finally {
         
        // Closing the connections
            fis.close();
        }
    }
}

Paso 5: Ejecute la aplicación

Ahora, para probar el programa, podemos crear un objeto bean, convertirlo a XML y luego transformar ese XML nuevamente en un objeto Java.

Archivo: RunApplication.java

// Java Program to Illustrate Application Class
 
package com.geeksforgeeks;
 
// Importing required classes
import com.geeksforgeeks.bean.Company;
import java.io.IOException;
import org.springframework.beans.BeansException;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
// Application/Main Class
public class RunApplication {
 
    // Main driver method
    public static void main(String[] args)
        throws IOException
    {
 
        // Try block to check for exceptions
        try (AnnotationConfigApplicationContext ctx
             = new AnnotationConfigApplicationContext()) {
            ctx.register(AppConfig.class);
            ctx.refresh();
            Processor processor
                = ctx.getBean(Processor.class);
 
            // Perform Marshalling
            Company company = new Company();
            company.setId(1000);
            company.setCompanyName("XYZ");
            company.setCeoName("ABCD");
            company.setNoEmp(100);
            processor.objectToXML("country.xml", company);
 
            // Display message only
            System.out.println("Marshalling performed");
 
            // Perform UnMarshalling
            company = (Company)processor.xmlToObject(
                "country.xml");
 
            // Display message only
            System.out.println(
                "After UnMarshalling Data is: id:"
                + company.getId() + ", CountryName:"
                + company.getCompanyName());
        }
 
        // Catch block to handle exceptions
        catch (BeansException | IllegalStateException e) {
 
            // Display exceptions along with line number
            // using printStackTrace() method
            e.printStackTrace();
        }
    }
}

Salida: el objeto Java a XML es el siguiente: 

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<ns2:company-info xmlns:ns2="com.geeksforgeeks" id="100">
   <company-name>XYZ</company-name>
   <ceo-name>ABCD</ceo-name>
   <no-emp>100</no-emp>
</ns2:company-info>

Salida: el objeto XML a Java es el siguiente: