JAXB Marshalling Unmarshalling con CDATA

Estoy tratando de hacer referencias con JAXB.

mi salida es como

  <![CDATA[<h1>kshitij</h1>]]> <h1>solanki</h1> <h1>1</h1>  

pero necesito salida como

   <![CDATA[

kshitij

]]> <![CDATA[

solanki

]]>

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 comstackr 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 = "

kshitij

"; String surname = "

solanki

"; String id = "

1

"; 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 { @Override public String marshal(String arg0) throws Exception { return ""; } @Override public String unmarshal(String arg0) throws Exception { return arg0; } } 

Usted podría hacer lo siguiente:

AdaptadorCDATA

 package forum14193944; import javax.xml.bind.annotation.adapters.XmlAdapter; public class AdapterCDATA extends XmlAdapter { @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"?>  < ![CDATA[

kshitij]]> < ![CDATA[

solanki]]> < ![CDATA[0]]>

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"?>  < ![CDATA[

kshitij]]> < ![CDATA[

solanki]]> < ![CDATA[0]]>

Para más información

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); } });
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 :


     la clase pública CDataAwareUtfEncodedXmlCharacterEscapeHandler implementa CharacterEscapeHandler {

         private static char final [] cDataPrefix = "< ! [CDATA [". toCharArray ();
         private static char final [] cDataSuffix = "]]>". toCharArray ();

         public static final CDataAwareUtfEncodedXmlCharacterEscapeHandler instance = new CDataAwareUtfEncodedXmlCharacterEscapeHandler ();

         private CDataAwareUtfEncodedXmlCharacterEscapeHandler () {
         }

         @Anular
         public void escape (char [] ch, int start, int length, boolean isAttVal, Writer out) arroja IOException {
             boolean isCData = length> cDataPrefix.length + cDataSuffix.length;
             if (isCData) {
                 for (int i = 0, j = start; i  = 0; --i, --j) {
                         if (cDataSuffix [i]! = ch [j]) {
                             isCData = falso;
                             descanso;
                         }
                     }
                 }
             }
             if (isCData) {
                 out.write (ch, inicio, longitud);
             } else {
                 MinimumEscapeHandler.theInstance.escape (ch, start, length, isAttVal, out);
             }
         }
     }

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

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("<", "< ").replaceAll(">", ">"); } catch(JAXBException e){ throw new RuntimeException(e); } } 
  @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 = "

Jorge & Mary

"; 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"?> <p>Jorge & Mary</p> */

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 tags 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 tags 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"?>  < ![CDATA[]]>