Java - Jackson - How to NOT unescape &lt; to < character automatically when deserializing?

[bangph]

I have a simple XML containing escaped string for < character as <, then I wanted to deserialize these key-value elements as a map of <String, String> of an wrapper object by using Jackson XML deserialization. I have Jackson from Spring Boot version 2.7.10 and

        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
            <version>2.8.7</version>
        </dependency>

However, no matter what I tried, Jackson automatically unescape < to < in the deserialized string value. How can I stop this behavior? Thanks.

class WrapperClass {

   private Map<String, String> globalMetadataAttributesMap;

}

// Register the custom deserializer
SimpleModule module1 = new SimpleModule();
module1.addDeserializer(RasdamanCoverageMetadata.class, new CustomDeserializer());
xmlMapper.registerModule(module1);

// Here it has two keys-values in the map
// which should be added as it-is to globalMetadataAttributesMap.

metadataStr = "<ras:covMetadata>\n" +
        "<local_metadata_key>value_1</local_metadata_key>\n" +
        "<X>3 &lt; 7</X>\n" +
        "</ras:covMetadata>";

xmlMapper.readValue(metadataStr, WrapperClass.class);

 public static class CustomDeserializer extends JsonDeserializer<RasdamanCoverageMetadata> {
        @Override
        public WrapperClass deserialize(JsonParser p, DeserializationContext ctxt) {
        
            JsonNode node = p.getCodec().readTree(p);
            node.get("X") // prints 3 < 7. How to keep it as 3 &lt; 7?
            
        }
        
}

I hope Jackson has a simple annotation for that to keep read value for key in Map as it is instead of automatically unescaping the value.

NOTE: I don't want < is read as < by Jackson, and I don't want to write any customized Deserializer for this simple purpose.

[pjfanning]

< escaping is required by XML spec - parsers expect < to mean that you are starting an XML tag

[pjfanning]

also, Jackson 2.18.1 is the latest version - please use an up to date version of the lib

[bangph]

@pjfanning

Actually, what I wanted to do is like below

package jackson.serialzation;

import com.fasterxml.jackson.annotation.JsonAnySetter;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlElementWrapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) throws Exception {
        XmlMapper xmlMapper = new XmlMapper();
        System.out.println("Test 1");
        String test1 = "<Wrapper><a><b><c>3 &amp; 7 - 8 &lt; 9</c> </b></a></Wrapper>";

        Wrapper wrapper = xmlMapper.readValue(test1, Wrapper.class);
        System.out.println(wrapper.getMyMap().get("a"));
        String outputXML = xmlMapper.writeValueAsString(wrapper);
        System.out.println(outputXML);

        System.out.println("-----------------");

        System.out.println("Test 2");
        String test2 ="<Wrapper><a><![CDATA[<b><c>3 &amp; 7 - 8 &lt; 9</c> </b>]]></a></Wrapper>";

        wrapper = xmlMapper.readValue(test2, Wrapper.class);
        System.out.println(wrapper.getMyMap().get("a"));
        outputXML = xmlMapper.writeValueAsString(wrapper);
        System.out.println(outputXML);
    }
}

class Wrapper {
    private Map<String, String> myMap = new HashMap<>();

   @JsonAnyGetter
    public Map<String, String> getMyMap() {
        return myMap;
    }

    @JsonAnySetter
    @JacksonXmlProperty(localName = "myMap")
    @JacksonXmlElementWrapper(useWrapping = false)
    public void addToMap(String key, String value) {
        this.myMap.put(key, value);
    }
}

I wanted to read any child element of element <a> as String value of the key a of myMap in Wrapper class.

Output from the above code is:

Test 1

Test 1

<Wrapper><a></a></Wrapper>
-----------------
Test 2
<b><c>3 &amp; 7 - 8 &lt; 9</c> </b>
<Wrapper><a>&lt;b>&lt;c>3 &amp;amp; 7 - 8 &amp;lt; 9&lt;/c> &lt;/b></a></Wrapper>

Ideally, I hoped that Jackson has some annotation which allows this behavior in Test 1 (however, it just prints empty for value of key a which is not what I wanted).

Then, I tried with Test 2 with wrap CDATA around <b>...</b> so Jackson can deserialize <b>...</b> just as it is as String value. But when serializing wrapper object to String, it returns unwanted output to me.

It should be:

<Wrapper><a><b><c>3 &amp; 7 - 8 &lt; 9</c> </b></a></Wrapper>

NOT <Wrapper><a>&lt;b>&lt;c>3 &amp;amp; 7 - 8 &amp;lt; 9&lt;/c> &lt;/b></a></Wrapper>

So if Jackson could deserialize the String in Test 1, then it could serialize to a string exactly like String test1 is what I wanted to have.

[pjfanning]

We still won't make any changes to ancient releases. Try the latest release and if that does not support what you want, we can consider changes.

[bangph]

@pjfanning I tested with the latest version which you asked and it printed the unwanted output in my java testing code.

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.18.1</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.18.1</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.18.1</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
            <version>2.18.1</version>
            <scope>compile</scope>
        </dependency>

In my opinion, with a new annotation for what I've asked, this would be great for other Jackson' users. I think this will take long time for consideration, but at least, I could see that you think this make sense to have that supported.

The use case for this feature is, I wanted to deserialize a valid XML from client as Map of key:String, value:String (value is a random XML), then I do something with the Map in java (for example, I add some new keys-values to it), and finally, serialize the Wrapper object containing the Map with the String value from the client in the Map as it is in the original value.

[cowtowncoder]

I wonder if you may have misunderstood role of CDATA marker in XML -- it is something that helps embed content that contains entities like < that otherwise would need to be escaped. But it does not change semantics in any way, and XML parser exposes contents as regular text, same as if regular escapes were used. So if you enclose elements/tags within CDATA, they are encoded/decoded as text, not as elements.
And as such, when output, text must also be encoded either as escaped text, or CDATA enclosed. But regardless of which notation is used, output is semantically equivalent.
Jackson does offer annotation @JacksonXmlCData which can be added to properties to enclose values in CDATA section, but I don't think it works with @JsonAnyGetter unfortunately. Still, I am not sure it would help you do what you try to do (... whatever it is :) )

One problem is that I do not find "tests" where the idea is to print out things and ask us to "have a look". to be useful: it is very difficult to get an idea of what exactly is requested.
Instead, tests should assert things that are expected to be true; to show intended behavior. That is much easier to follow and discuss.
Instead of having to copy code to run, have a look at what is printed, and how it might (or might not) do what is being described. Real tests can be viewed, to see the idea without having to run code.
And there are too many ways these descriptions can be ambiguous.

So I understand the high-level wish to process content as Maps (or, perhaps, as JsonNodes -- bit more convenient). But not explanation of what is not working.

For what it is worth, I would recommend looking at doing something like:

JsonNode doc = xmlMapper.readTree(input);

and modifying resulting ObjectNode. Despite its name JsonNode is not really JSON-specific; XML module supports it (although with some limitations wrt "mixed content", where child elements and text segments occur at same level; as well as not retaining information on whether something is an Attribute value).
And it retains same set of information as binding to Map (or any setter).

[bangph]

@cowtowncoder I'm glad hearing from Jackson's creator.

I could agreed with you about that it is better to have some JUnit tests instead of checking code and compare outputs (I'm old school style so I know print).

However, I would be appreciated if Jackson could provide an annotation specifically dedicated to my issue.
In simple words, Jackson will not change anything both when serializing / deserializing from the value of key1 in a Map of String, String:

   <Wrapper>
       <key1>
               <!-- consider anything below is just a String, don't escape / unescape anything -->
                <value1>
                         <randomXML>...</randomXML
                </value1>
       </key1>
  </Wrapper>

Also, my Wrapper class in reality is much more complicated than in the code example at #253 (reply in thread) so I really would not write any custom serializer / deserializer for this simple purpose.

I hope you and the team can discuss about my request. If you could support it, it will be appreciated, otherwise, I will need to work with some ugly hacking ways out of Jackson (that is a just workaround with String replacements), but I'd really like to use with Jackson tool instead.

[cowtowncoder]

My problem is that I am not sure I understand the request. But if I am right, you'd want to somehow disable XML parsing of content/sub-tree -- there is no way to do that. XML parsers do not really expose raw underlying undecoded content; they must parse documents. There's no way to get around that.
So it's not a question of annotations, it's that Stax XML parsers will always produce element/tag value1, CDATA for white space, element/tag randomXML and so on.
So if that is the request there is nothing we can do, unfortunately.

On output side, however, there is an annotation @JsonRawValue, which can be used to inject pre-encoded content direclty into output stream. So if you had content known to be well-formed XML, you could add that and by-pass escaping process.

[bangph]

Unfortunately, this JsonRawValue can be annotated only for String, but it doesn't work with Map<String, String>.
But I got your reply with details that StarXML parsers does not support the feature which I requested.
Thanks.

[cowtowncoder]

Yes, "raw" must be exact String to use, not something to serialize (those are not raw).