JAXB Marshalling Mit CDATA unmarshalling

Bitte beachten Sie: Ich bin der EclipseLink JAXB (MOXy) Lead und Mitglied der Expertengruppe JAXB (JSR-222) .

Wenn Sie MOXy als JAXB-Provider (JSR-222) verwenden, können Sie die Erweiterung @XmlCDATA für Ihren Anwendungsfall nutzen.

Wurzel

Die Annotation @XmlCDATA gibt an, dass der Inhalt eines Felds/einer Eigenschaft in einem CDATA-Abschnitt eingeschlossen werden soll. Die Annotation @XmlCDATA kann in Kombination mit @XmlElement verwendet werden.

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

Um MOXy als JAXB-Provider zu verwenden, müssen Sie die Datei jaxb.properties mit dem folgenden Eintrag hinzufügen.

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

Demo

Nachfolgend finden Sie einige Demo-Codes, um zu beweisen, dass alles funktioniert.

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/Ausgabe

Nachfolgend finden Sie die Eingabe und Ausgabe des Demo-Codes.

<?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>

Für mehr Informationen

• 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

Tut mir leid, dass ich diese Frage herausgegraben und eine neue Antwort gepostet habe (mein Vertreter ist noch nicht hoch genug, um einen Kommentar abzugeben ...) ... Ich bin auf dieselbe Frage gestoßen und habe die Antwort von Blaise Doughan ausprobiert es deckt nicht alle Fälle ab, entweder mache ich irgendwo etwas falsch.

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

Bei meinen Tests entfernt dieser Code alle Escapezeichen, unabhängig davon, ob Sie die @XmlJavaTypeAdapter(AdapterCDATA.class)-Anmerkung für Ihr Attribut verwenden ...

Um dieses Problem zu beheben, habe ich folgende CharacterEscapeHandler implementiert:

 public class CDataAwareUtfEncodedXmlCharacterEscapeHandler implementiert den CharacterEscapeHandler {

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

 public static final CDataAwareUtfEncodedXmlCharacterEscapeHandler-Instanz = new CDataAwareUtfEncodedXmlCharacterEscapeHandler (); 

 private CDataAwareUtfEncodedXmlCharacterEscapeHandler () {
 } 

 @Override 
 public void escape (char [] ch, int start, int length, boolean isAttVal, Writer out) gibt IOException {.__ aus. 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; 
 brechen;
 } 
 } 
 if (isCData) {
 für (int i = cDataSuffix.length - 1, j = Start + Länge - 1; i> = 0; --i, --j) {
 if (cDataSuffix [i]! = ch [j]) {
 isCData = false; 
 brechen;
 } 
 } 
 } 
 } 
 if (isCData) {
 out.write (ch, start, length); 
 } else {
 MinimumEscapeHandler.theInstance.escape (ch, start, length, isAttVal, out); } 
 } 
 } 

Wenn Ihre Kodierung nicht UTF * ist, sollten Sie nicht MinimumEscapeHandler aufrufen, sondern NioEscapeHandler oder sogar DumbEscapeHandler.

com.Sun.internal funktioniert nicht mit play2, aber das funktioniert

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

    @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>
     */

Ich bin auf dieser Seite gelandet und habe versucht, ein ähnliches Problem zu lösen. Ich habe einen anderen Ansatz gefunden, um das Problem zu lösen. Eine Möglichkeit, dieses Problem zu lösen, besteht darin, XML als SAX2-Ereignisse an einen Handler zu senden und dann die Logik in den Handler zu schreiben, um die CDATA-Tags zum XML hinzuzufügen. Dieser Ansatz erfordert nicht, dass eine Anmerkung hinzugefügt wird. Nützlich in Szenarien, in denen Klassen, die gemarshallt werden sollen, aus XSDs generiert werden.

Angenommen, Sie haben ein String-Feld in einer aus XSD generierten Klasse, das gemarshallt werden soll, und das String-Feld enthält Sonderzeichen, die in ein CDATA-Tag eingefügt werden sollen. 

@XmlRootElement
public class TestingCDATA{
    public String xmlContent;

}

Wir beginnen mit der Suche nach einer geeigneten Klasse, deren Methode in unserem Content-Handler überschrieben werden kann. Eine solche Klasse ist XMLWriter im Paket com.Sun.xml.txw2.output. Es ist in jdk 1.7 und 1.8 verfügbar

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

Wir überschreiben die Zeichenmethode und verwenden Regex, um zu überprüfen, ob Sonderzeichen enthalten sind. Wenn sie gefunden werden, setzen wir CDATA-Tags um sie herum. In diesem Fall sorgt XMLWriter für das Hinzufügen des CDATA-Tags.

Wir verwenden den folgenden Code für das Marshalling: 

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

Dies würde das Objekt marshallieren und XML zurückgeben, wenn wir die Anforderung zum Marshallen übergeben, wie unten beschrieben.

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>