Generar XML a partir de un archivo de texto (.txt) usando XSLT en Java

[Lind L. Tailor]

Hola, amigos.

Tengo el siguiente archivo de texto (.txt)

XX000000000000000111Example
OO001Test

Donde cada valor de cada linea tiene un limite de caracteres, de acuerdo al ID que se valla leyendo primeramente; es decir, si el ID es igual a XX entonces debe leer los caracteres especificados de acuerdo a ese ID, si el ID es OO entonces leera los especificados para ese ID.

*Producto:
Id (2 caracteres): XX
Codigo(18 caracteres): 000000000000000111
Descripcion(10 caracteres): Example

*Usuario:
Id (2 caracteres): OO
Numero(3 caracteres): 001
Nombre(40 caracteres): Test

Tengo mi aplicacion Java Standalone en donde realizo precisamente esas validaciones correspondientes, como los recupera de una base de datos, los voy cortando si es mayor o si es muy corto lo relleno con espacios o ceros segun sea el caso, por lo tanto, el limite de los valores por cada ID sera fijo.

Me gustaria leer ese archivo y convertirlo a un archivo XML, donde la creacion del archivo XML lo hago con Saxon, mediante la siguiente forma.

try {
Processor proc = new Processor(false);
XsltCompiler comp = proc.newXsltCompiler();
XsltExecutable exp = comp.compile(new StreamSource(new File("archivos/xsl/convertir.xsl")));
Serializer out = new Serializer();
out.setOutputProperty(Serializer.Property.METHOD, "xml");
out.setOutputProperty(Serializer.Property.INDENT, "yes");
out.setOutputFile(new File("archivos/xml/canada.xml"));
XsltTransformer trans = exp.load();
trans.setInitialTemplate(new QName("main"));
trans.setDestination(out);
trans.transform();
} catch (SaxonApiException sae) {
sae.printStackTrace();
}

Si se corre el siguiente codigo me crea el archivo correspondiente, de acuerdo al archivo .xsl que yo eh definido, para este caso hice algo sencillo como se muestra a continuación.

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output omit-xml-declaration="yes" indent="yes"/>
<xsl:template name="main" match="/">
<producto>
<codigo>8</codigo>
</producto>
</xsl:template>
</xsl:stylesheet>

Ahora, serian tan amables de ayudarme como hago que lea mi archivo de texto para posteriormente ir obteniendo la salida correspondiente.

<producto>
<identificador>XX</identificador>
<codigo>000000000000000111</codigo>
<descripcion>Example</descripcion>
</producto>
<usuario>
<identificador>OO</identificador>
<codigo>001</codigo>
<descripcion>Test</descripcion>
</usuario>

De antemano, muchas gracias por su ayuda.

[Usuario Invitado]

¿Por qué no usas el API de Java para manejo de XML?. Te pongo un ejemplo:

User.java

Código (java) [Seleccionar] Expandir

package com.company.model.entities;

public class User {
private Integer id;
private Integer code;
private String name;

public User() {}

public User(Integer id, Integer code, String name) {
super();
this.id = id;
this.code = code;
this.name = name;
}

public Integer getId() {
return id;
}

public void setId(Integer id) {
this.id = id;
}

public Integer getCode() {
return code;
}

public void setCode(Integer code) {
this.code = code;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}


}

Product.java

Código (java) [Seleccionar] Expandir

package com.company.model.entities;

public class Product {
private Integer id;
private Long code;
private String description;

public Product() {}

public Product(Integer id, Long code, String description) {
super();
this.id = id;
this.code = code;
this.description = description;
}

public Integer getId() {
return id;
}

public void setId(Integer id) {
this.id = id;
}

public Long getCode() {
return code;
}

public void setCode(Long code) {
this.code = code;
}

public String getDescription() {
return description;
}

public void setDescription(String description) {
this.description = description;
}


}

Report.java

Código (java) [Seleccionar] Expandir

package com.company.model.jaxb;

import java.util.List;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

import com.company.model.entities.Product;
import com.company.model.entities.User;

@XmlRootElement(name="report")
@XmlAccessorType(XmlAccessType.FIELD)
public class Report {
@XmlElement(name="user")
private List<User> users;
@XmlElement(name="product")
private List<Product> products;

public Report() {}

public List<User> getUsers() {
return users;
}

public void setUsers(List<User> users) {
this.users = users;
}

public List<Product> getProducts() {
return products;
}

public void setProducts(List<Product> products) {
this.products = products;
}


}

ReportMarshaller.java

Código (java) [Seleccionar] Expandir

package com.company.model.jaxb;
import java.io.File;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;

import com.company.model.jaxb.Report;


public class ReportMarshaller<T> {
private static JAXBContext jaxbContext;

public ReportMarshaller() throws JAXBException {
jaxbContext = JAXBContext.newInstance(Report.class);
}

public void marshal(Report report, File output) throws JAXBException {
Marshaller marshaller = jaxbContext.createMarshaller();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
marshaller.marshal(report, output);
}

public Report unmarshal(File input) throws JAXBException {
Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
Report report = (Report) unmarshaller.unmarshal(input);
return report;
}

}

Main.java

Código (java) [Seleccionar] Expandir

package com.company.main;

import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import javax.xml.bind.JAXBException;

import com.company.model.entities.Product;
import com.company.model.entities.User;
import com.company.model.jaxb.Report;
import com.company.model.jaxb.ReportMarshaller;

public class Main {

public static void main(String[] args) {
List<User> users = new ArrayList<>();
List<Product> products = new ArrayList<>();
Report report = new Report();
ReportMarshaller<Report> marshaller = null;

Collections.addAll(users,
new User(20, 001, "John Doe"),
new User(30, 002, "Homer Simpson"),
new User(40, 003, "Peter Griffin")
);
Collections.addAll(products,
new Product(10, 123456789123456789L, "Jabón antibacterial"),
new Product(20, 987654321987654321L, "Shampoo control caspa")
);
report.setUsers(users);
report.setProducts(products);

try {
marshaller = new ReportMarshaller<Report>();
marshaller.marshal(report, new File("D://test.xml"));
System.out.println("Leyendo el XML...");
System.out.println();
report = null;
report = marshaller.unmarshal(new File("D://test.xml"));
System.out.println("Usuarios:\n");
for(User user : report.getUsers()) {
System.out.println(user.getId());
System.out.println(user.getCode());
System.out.println(user.getName());
}
                       System.out.println("\nProductos:\n");
for(Product product : report.getProducts()) {
System.out.println(product.getId());
System.out.println(product.getCode());
System.out.println(product.getDescription());
}
} catch (JAXBException e) {
e.printStackTrace();
}

}

}




XML generado:

Código (XML) [Seleccionar] Expandir

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<report>
   <user>
       <code>1</code>
       <id>20</id>
       <name>John Doe</name>
   </user>
   <user>
       <code>2</code>
       <id>30</id>
       <name>Homer Simpson</name>
   </user>
   <user>
       <code>3</code>
       <id>40</id>
       <name>Peter Griffin</name>
   </user>
   <product>
       <code>123456789123456789</code>
       <description>Jabón antibacterial</description>
       <id>10</id>
   </product>
   <product>
       <code>987654321987654321</code>
       <description>Shampoo control caspa</description>
       <id>20</id>
   </product>
</report>

Lectura del XML:

Código [Seleccionar] Expandir

Leyendo el XML...

Usuarios:

20
1
John Doe
30
2
Homer Simpson
40
3
Peter Griffin

Productos:

10
123456789123456789
Jabón antibacterial
20
987654321987654321
Shampoo control caspa





El código es sencillo. El método marshal de Marshaller recibe dos parámetros:

1) El objeto anotado con XmlRootElement
2) Un objeto File de salida.

El método unmarshal recibe:

1) El objeto File que apunta al fichero XML a leer.

XmlRootElement indica que dicha clase es el primer nivel de la jerarquía XML. XmlElement indica que dicha propiedad o clase es un elemento dentro de la jerarquía (un tag).

Cualquier duda, comentas.

[Lind L. Tailor]

Muchas gracias, Gus Garsaky.

De hecho eso fue lo primero que realice, sin embargo, la actividad tiene que ser realizada mediante el uso de plantillas XLST eh ahí la razón del porque tengo un archivo .xsl y uso Saxon para la creación del archivo.

Desgraciadamente me rechazaron la propuesta en donde implemento el API de Java para manejo de archivos XML.

Muchas gracias por tu ayuda; completo, entendible y funcional (Aunque le hice unos cambios xD), pero necesito implementar el XLST, ¿Alguna idea de como?

[Usuario Invitado]

Se puede transformar un XML con un schema. Aquí tienes un ejemplo:

Link: Transformar XML con XLST