unmarshal - parse xml java jaxb

JAXB Marshalling Unmarshalling con CDATA

Question

Estoy tratando de hacer referencias con JAXB.

mi salida es como

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<root>
    <name>&lt;![CDATA[&lt;h1&gt;kshitij&lt;/h1&gt;]]&gt;</name>
    <surname>&lt;h1&gt;solanki&lt;/h1&gt;</surname>
    <id>&lt;h1&gt;1&lt;/h1&gt;</id>
</root>

pero necesito salida como

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <root>
        <name><![CDATA[<h1>kshitij</h1>]]></name>
        <surname><![CDATA[<h1>solanki</h1>]]></surname>
        <id><![CDATA[0]]></id>
    </root>

Estoy usando el siguiente código para hacer esto. y si elimino el código, obtengo la excepción de enlace de propiedad. Sin él, puedo compilar pero no obtengo el resultado exacto requerido.

  package com.ksh.templates;

import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;
import com.sun.xml.bind.marshaller.CharacterEscapeHandler;

public class MainCDATA {
    public static void main(String args[])
    {
        try
        {
            String name = "<h1>kshitij</h1>";
            String surname = "<h1>solanki</h1>";
            String id = "<h1>1</h1>";

            TestingCDATA cdata = new TestingCDATA();
            cdata.setId(id);
            cdata.setName(name);
            cdata.setSurname(surname);

            JAXBContext jaxbContext = JAXBContext.newInstance(TestingCDATA.class);
            Marshaller marshaller = jaxbContext.createMarshaller();
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

            marshaller.setProperty(CharacterEscapeHandler.class.getName(), new CharacterEscapeHandler() { 
                public void escape(char[] ac, int i, int j, boolean flag,
                Writer writer) throws IOException {
                writer.write( ac, i, j ); }
                });
            StringWriter stringWriter = new StringWriter(); 
            marshaller.marshal(cdata, stringWriter);
            System.out.println(stringWriter.toString());
        }
        catch (Exception e) 
        {
            System.out.println(e);
        }       
    }
}

y mi bean lokks me gusta

 package com.ksh.templates;

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 javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import com.sun.xml.txw2.annotation.XmlCDATA;

@XmlRootElement(name = "root")
@XmlAccessorType(XmlAccessType.FIELD)
public class TestingCDATA {

    @XmlElement
    @XmlJavaTypeAdapter(value = AdaptorCDATA.class)
    private String name;
    @XmlElement
    @XmlJavaTypeAdapter(value = AdaptorCDATA.class)
    private String surname;

    @XmlCDATA
    public String getName() {
        return name;
    }
    @XmlCDATA
    public void setName(String name) {
        this.name = name;
    }
    @XmlCDATA
    public String getSurname() {
        return surname;
    }
    @XmlCDATA
    public void setSurname(String surname) {
        this.surname = surname;
    }
}

Clase de adaptador

public class AdaptorCDATA extends XmlAdapter<String, String> {

    @Override
    public String marshal(String arg0) throws Exception {
        return "<![CDATA[" + arg0 + "]]>";
    }
    @Override
    public String unmarshal(String arg0) throws Exception {
        return arg0;
    }
}

Answer 1

Aterricé en esta página tratando de encontrar una solución a un problema similar, encontré otro enfoque para resolver esto. Una forma de resolver este problema es enviar XML como eventos SAX2 a un controlador, luego escribir la lógica en el controlador para agregar las etiquetas CDATA al XML. Este enfoque no requiere ninguna anotación para ser agregado. Útil en escenarios donde las clases que se calcularán se generan a partir de XSD.

Supongamos que tiene un campo String en una clase generada a partir de XSD que se calculará y el campo String contiene caracteres especiales que se colocarán dentro de una etiqueta CDATA.

@XmlRootElement
public class TestingCDATA{
    public String xmlContent;

}

Comenzaremos buscando una clase adecuada cuyo método se puede anular en nuestro controlador de contenido. Una clase de este tipo es XMLWriter que se encuentra en el paquete com.sun.xml.txw2.output, está disponible en jdk 1.7 y 1.8

import com.sun.xml.txw2.output.XMLWriter;
import org.xml.sax.SAXException;

import java.io.IOException;
import java.io.Writer;
import java.util.regex.Pattern;

public class CDATAContentHandler extends XMLWriter {
    public CDATAContentHandler(Writer writer, String encoding) throws IOException {
        super(writer, encoding);
    }

    // see http://www.w3.org/TR/xml/#syntax
    private static final Pattern XML_CHARS = Pattern.compile("[<>&]");

    public void characters(char[] ch, int start, int length) throws SAXException {
        boolean useCData = XML_CHARS.matcher(new String(ch, start, length)).find();
        if (useCData) {
            super.startCDATA();
        }
        super.characters(ch, start, length);
        if (useCData) {
            super.endCDATA();
        }
    }
}

Estamos anulando el método de los personajes, usando expresiones regulares para verificar si hay caracteres especiales contenidos. Si se encuentran, colocamos etiquetas CDATA a su alrededor. En este caso, XMLWriter se encarga de agregar la etiqueta CDATA.

Utilizaremos el siguiente código para calcular referencias:

public String addCDATAToXML(TestingCDATA request) throws FormatException {
    try {
        JAXBContext jaxbContext = JAXBContext.newInstance(TestingCDATA.class);
        Marshaller jaxbMarshaller = jaxbContext.createMarshaller();
        StringWriter sw = new StringWriter();
        CDATAContentHandler cDataContentHandler = new CDATAContentHandler(sw, "UTF-8");
        jaxbMarshaller.marshal(request, cDataContentHandler);
        return sw.toString();
    } catch (JAXBException | IOException e) {
        throw new FormatException("Unable to add CDATA for request", e);
    }
}

Esto clasificaría el objeto y devolvería XML, si pasamos una solicitud para ser clasificado como se menciona a continuación.

TestingCDATA request=new TestingCDATA();
request.xmlContent="<?xml>";

System.out.println(addCDATAToXML(request)); // Would return the following String

Output- 

<?xml version="1.0" encoding="UTF-8"?>
<testingCDATA>
<xmlContent><![CDATA[<?xml>]]></xmlContent>
</testingCDATA>

Answer 2

Perdón por descubrir esta pregunta y publicar una nueva respuesta (mi representante aún no es lo suficientemente alto para comentar ...). Me encontré con el mismo problema, probé la respuesta de Blaise Doughan, pero de mis pruebas, o no cubre todos los casos, o bien estoy haciendo algo mal en alguna parte.

    marshaller.setProperty(CharacterEscapeHandler.class.getName(),
                    new CharacterEscapeHandler() {
                        @Override
                        public void escape(char[] ac, int i, int j, boolean flag,
                                Writer writer) throws IOException {
                            writer.write(ac, i, j);
                        }
                    });

Según mis pruebas, este código elimina todos los @XmlJavaTypeAdapter(AdapterCDATA.class) , sin importar si está utilizando la @XmlJavaTypeAdapter(AdapterCDATA.class) en su atributo ...

Para solucionar ese problema, implementé el siguiente CharacterEscapeHandler :

public class CDataAwareUtfEncodedXmlCharacterEscapeHandler implements CharacterEscapeHandler { private static final char[] cDataPrefix = "<![CDATA[".toCharArray(); private static final char[] cDataSuffix = "]]>".toCharArray(); public static final CDataAwareUtfEncodedXmlCharacterEscapeHandler instance = new CDataAwareUtfEncodedXmlCharacterEscapeHandler(); private CDataAwareUtfEncodedXmlCharacterEscapeHandler() { } @Override public void escape(char[] ch, int start, int length, boolean isAttVal, Writer out) throws IOException { boolean isCData = length > cDataPrefix.length + cDataSuffix.length; if (isCData) { for (int i = 0, j = start; i < cDataPrefix.length; ++i, ++j) { if (cDataPrefix[i] != ch[j]) { isCData = false; break; } } if (isCData) { for (int i = cDataSuffix.length - 1, j = start + length - 1; i >= 0; --i, --j) { if (cDataSuffix[i] != ch[j]) { isCData = false; break; } } } } if (isCData) { out.write(ch, start, length); } else { MinimumEscapeHandler.theInstance.escape(ch, start, length, isAttVal, out); } } }

Si su codificación no es UTF *, puede que no desee llamar a MinimumEscapeHandler sino a NioEscapeHandler o incluso a DumbEscapeHandler.

Answer 3

Usted podría hacer lo siguiente:

AdaptadorCDATA

package forum14193944;

import javax.xml.bind.annotation.adapters.XmlAdapter;

public class AdapterCDATA extends XmlAdapter<String, String> {

    @Override
    public String marshal(String arg0) throws Exception {
        return "<![CDATA[" + arg0 + "]]>";
    }
    @Override
    public String unmarshal(String arg0) throws Exception {
        return arg0;
    }

}

Raíz

La anotación @XmlJavaTypeAdapter se usa para especificar que se debe usar XmlAdapter .

package forum14193944;

import javax.xml.bind.annotation.*;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class Root {

    @XmlJavaTypeAdapter(AdapterCDATA.class)
    private String name;

    @XmlJavaTypeAdapter(AdapterCDATA.class)
    private String surname;

    @XmlJavaTypeAdapter(AdapterCDATA.class)
    private String id;

}

Manifestación

Tuve que ajustar System.out en un OutputStreamWriter para obtener el efecto deseado. También tenga en cuenta que configurar un CharacterEscapeHandler significa que es responsable de todo el manejo de escape para ese Marshaller .

package forum14193944;

import java.io.*;
import javax.xml.bind.*;
import com.sun.xml.bind.marshaller.*;

public class Demo {

    public static void main(String[] args) throws Exception {
        JAXBContext jc = JAXBContext.newInstance(Root.class);

        Unmarshaller unmarshaller = jc.createUnmarshaller();
        File xml = new File("src/forum14193944/input.xml");
        Root root = (Root) unmarshaller.unmarshal(xml);

        Marshaller marshaller = jc.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
        marshaller.setProperty(CharacterEscapeHandler.class.getName(),
                new CharacterEscapeHandler() {
                    @Override
                    public void escape(char[] ac, int i, int j, boolean flag,
                            Writer writer) throws IOException {
                        writer.write(ac, i, j);
                    }
                });
        marshaller.marshal(root, new OutputStreamWriter(System.out));
    }

}

input.xml / Salida

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<root>
    <name><![CDATA[<h1>kshitij</h1>]]></name>
    <surname><![CDATA[<h1>solanki</h1>]]></surname>
    <id><![CDATA[0]]></id>
</root>

Answer 4

com.sun.internal no funciona con play2, pero esto funciona

private static String marshal(YOurCLass xml){
    try{
        StringWriter stringWritter = new StringWriter();
        Marshaller marshaller = JAXBContext.newInstance(YourCLass.class).createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
        marshaller.setProperty(Marshaller.JAXB_ENCODING, "ISO-8859-1");
        marshaller.marshal(xml, stringWritter);
        return stringWritter.toString().replaceAll("&lt;", "<").replaceAll("&gt;", ">");
    }
    catch(JAXBException e){
        throw new RuntimeException(e);
    }
}

Answer 5

Tenga en cuenta: soy el líder de EclipseLink JAXB (MOXy) y miembro del grupo de expertos JAXB (JSR-222) .

Si usa MOXy como su proveedor JAXB (JSR-222), puede aprovechar la extensión @XmlCDATA para su caso de uso.

Raíz

La anotación @XmlCDATA se usa para indicar que desea que el contenido de un campo / propiedad esté en una sección CDATA. La anotación @XmlCDATA se puede usar en combinación con @XmlElement .

package forum14193944;

import javax.xml.bind.annotation.*;
import org.eclipse.persistence.oxm.annotations.XmlCDATA;

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class Root {

    @XmlCDATA
    private String name;

    @XmlCDATA
    private String surname;

    @XmlCDATA
    private String id;

}

jaxb.properties

Para usar MOXy como su proveedor JAXB, necesita agregar un archivo llamado jaxb.properties con la siguiente entrada.

javax.xml.bind.context.factory=org.eclipse.persistence.jaxb.JAXBContextFactory

Manifestación

A continuación se muestra un código de demostración para demostrar que todo funciona.

package forum14193944;

import java.io.File;
import javax.xml.bind.*;

public class Demo {

    public static void main(String[] args) throws Exception {
        JAXBContext jc = JAXBContext.newInstance(Root.class);

        Unmarshaller unmarshaller = jc.createUnmarshaller();
        File xml = new File("src/forum14193944/input.xml");
        Root root = (Root) unmarshaller.unmarshal(xml);

        Marshaller marshaller = jc.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
        marshaller.marshal(root, System.out);
    }

}

input.xml / Salida

A continuación se muestra la entrada y salida de ejecutar el código de demostración.

<?xml version="1.0" encoding="UTF-8"?>
<root>
   <name><![CDATA[<h1>kshitij</h1>]]></name>
   <surname><![CDATA[<h1>solanki</h1>]]></surname>
   <id><![CDATA[0]]></id>
</root>

Para más información

• http://blog.bdoughan.com/2010/07/cdata-cdata-run-run-data-run.html
• http://blog.bdoughan.com/2011/05/specifying-eclipselink-moxy-as-your.html

Answer 6

    @Test
    public void t() throws Exception {
        JAXBContext jc = JAXBContext.newInstance(Root.class);
        Marshaller marshaller = jc.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
        Root root = new Root();
        root.name = "<p>Jorge & Mary</p>";
        marshaller.marshal(root, System.out);
    }
    @XmlRootElement
    @XmlAccessorType(XmlAccessType.FIELD)
    public static class Root {
        @XmlCDATA
        private String name;
    }
    /* WHAT I SEE IN THE CONSOLE
     * 
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<root>
    <name>&lt;p&gt;Jorge &amp; Mary&lt;/p&gt;</name>
</root>
     */