Puis-je la force de JAXB de ne pas convertir " en ", par exemple, lors de la sérialisation en XML?

Solution de mon coéquipier trouvé:

PrintWriter printWriter = new PrintWriter(new FileWriter(xmlFile));
DataWriter dataWriter = new DataWriter(printWriter, "UTF-8", DumbEscapeHandler.theInstance);
marshaller.marshal(request, dataWriter);

Au lieu de passer le xmlFile de maréchal(), passer le DataWriter qui connaît à la fois l'encodage et une évasion gestionnaire, le cas échéant.

Remarque: Depuis DataWriter et DumbEscapeHandler sont à la fois au sein de la com.soleil.xml.interne.bind.marshaller package, vous devez bootstrap javac.

J'ai été jouer avec votre exemple un peu et le débogage de l'JAXB code. Et il semble que c'est quelque chose de spécifique au sujet de l'encodage UTF-8 utilisé. Le escapeHandler propriété de MarshallerImpl semble être réglé correctement. Cependant, il est utilisé non pas dans chaque contexte. Si j'ai cherché pour les appels de MarshallerImpl.createEscapeHandler() j'ai trouvé:

public XmlOutput createWriter( OutputStream os, String encoding ) throws JAXBException {
    //UTF8XmlOutput does buffering on its own, and
    //otherwise createWriter(Writer) inserts a buffering,
    //so no point in doing a buffering here.

    if(encoding.equals("UTF-8")) {
        Encoded[] table = context.getUTF8NameTable();
        final UTF8XmlOutput out;
        if(isFormattedOutput())
            out = new IndentingUTF8XmlOutput(os,indent,table);
        else {
            if(c14nSupport)
                out = new C14nXmlOutput(os,table,context.c14nSupport);
            else
                out = new UTF8XmlOutput(os,table);
        }
        if(header!=null)
            out.setHeader(header);
        return out;
    }

    try {
        return createWriter(
            new OutputStreamWriter(os,getJavaEncoding(encoding)),
            encoding );
    } catch( UnsupportedEncodingException e ) {
        throw new MarshalException(
            Messages.UNSUPPORTED_ENCODING.format(encoding),
            e );
    }
}

Note que, dans votre programme d'installation de la section supérieure (...equals("UTF-8")...) est pris en considération. Mais celui-ci ne prend pas la escapeHandler. Toutefois, si vous définissez le codage de toutes les autres, la partie inférieure de cette méthode est appelée (createWriter(OutputStream, String)) et celui-ci utilise escapeHandler, alors HEIN joue son rôle.
Donc, l'ajout de...

    marshaller.setProperty(Marshaller.JAXB_ENCODING, "ASCII");

rend votre personnalisé CharacterEscapeHandler être appelé.
Pas vraiment sûr, mais je suppose que c'est le genre de bug dans JAXB.

Je dirais que la meilleure façon de le faire est par substitution de CharacterEscapeHandler :

marshaller.setProperty("com.sun.xml.bind.characterEscapeHandler", new CharacterEscapeHandler() {
    @Override
    public void escape(char[] ch, int start, int length, boolean isAttVal,
                       Writer out) throws IOException {
        out.write(ch, start, length);
    }
});

Semble que c'est possible avec Du soleil JAXB mise en œuvre, bien que je ne l'ai pas fait moi-même.

Cela fonctionne pour moi, après la lecture d'autres posts:

javax.xml.bind.JAXBContext jc = javax.xml.bind.JAXBContext.newInstance(object);
marshaller = jc.createMarshaller();         marshaller.setProperty(javax.xml.bind.Marshaller.JAXB_FORMATTED_OUTPUT, true);
marshaller.setProperty(javax.xml.bind.Marshaller.JAXB_ENCODING, "UTF-8");                   marshaller.setProperty(CharacterEscapeHandler.class.getName(), new CustomCharacterEscapeHandler());
public static class CustomCharacterEscapeHandler implements CharacterEscapeHandler {
/**
* Escape characters inside the buffer and send the output to the Writer.
* (prevent <b> to be converted &lt;b&gt; but still ok for a<5.)
*/
public void escape(char[] buf, int start, int len, boolean isAttValue, Writer out) throws IOException {
if (buf != null){
StringBuilder sb = new StringBuilder();
for (int i = start; i < start + len; i++) {
char ch = buf[i];
//by adding these, it prevent the problem happened when unmarshalling
if (ch == '&') {
sb.append("&amp;");
continue;
}
if (ch == '"' && isAttValue) {
sb.append("&quot;");
continue;
}
if (ch == '\'' && isAttValue) {
sb.append("&apos;");
continue;
}
//otherwise print normally
sb.append(ch);
}
//Make corrections of unintended changes
String st = sb.toString();
st = st.replace("&amp;quot;", "&quot;")
.replace("&amp;lt;", "&lt;")
.replace("&amp;gt;", "&gt;")
.replace("&amp;apos;", "&apos;")
.replace("&amp;amp;", "&amp;");
out.write(st);
}
}
}

La façon la plus simple, lors de l'utilisation du soleil Marshaller mise en œuvre est de fournir à votre propre mise en œuvre de la CharacterEscapeEncoder qui n'échappe pas à quoi que ce soit.

    Marshaller m = jcb.createMarshaller();
m.setProperty(
"com.sun.xml.bind.marshaller.CharacterEscapeHandler",
new NullCharacterEscapeHandler());

Avec

public class NullCharacterEscapeHandler implements CharacterEscapeHandler {
public NullCharacterEscapeHandler() {
super();
}
public void escape(char[] ch, int start, int length, boolean isAttVal, Writer writer) throws IOException {
writer.write( ch, start, length );
}
}

Je vous déconseillons d'utiliser CharacterEscapeHandler pour les raisons mentionnées ci-dessus (c'est une classe interne). Au lieu de cela, vous pouvez utiliser Woodstox et de fournir votre propre EscapingWriterFactory à un XMLStreamWriter. Quelque chose comme:

XMLOutputFactory2 xmlOutputFactory = (XMLOutputFactory2)XMLOutputFactory.newFactory();
xmlOutputFactory.setProperty(XMLOutputFactory2.P_TEXT_ESCAPER, new EscapingWriterFactory() {
@Override
public Writer createEscapingWriterFor(Writer w, String enc) {
return new EscapingWriter(w);
}
@Override
public Writer createEscapingWriterFor(OutputStream out, String enc) throws UnsupportedEncodingException {
return new EscapingWriter(new OutputStreamWriter(out, enc));
}
});
marshaller.marshal(model, xmlOutputFactory.createXMLStreamWriter(out);

Un exemple de la façon d'écrire une EscapingWriter peut être vu dans CharacterEscapingTest.