问如何在fasterXml Jackson XmlMapper中保留xml属性？

EN

<dependency>
    <groupId>org.xmlunit</groupId>
    <artifactId>xmlunit-core</artifactId>
    <!-- version transitive in spring-boot-starter-parent 2.6.7 -->
    <version>2.8.4</version>
    <scope>test</test>
</dependency>

import org.apache.commons.lang3.StringUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.net.URL;

public class ResourceUtil {
    private static final DocumentBuilderFactory XML_DOCUMENT_BUILDER_FACTORY = DocumentBuilderFactory.newInstance();
    private static final XPathFactory X_PATH_FACTORY = XPathFactory.newInstance();

    private ResourceUtil() {}

    /** Reads an xml file named after the testcase class (e.g. MyTestcase.class
      * -> MyTestcase.xml) and parses the data at the supplied xPath expression. */
    public static String xmlData(Class<?> testClass, String xPathExpression) {
        return getXmlDocumentAsString(testClass, testClass.getSimpleName() + ".xml", xPathExpression);
    }

    /** Reads the specified xml file and parses the data at the supplied xPath
      * expression. The xml file is expected in the same package/directory as
      * the testcase class. */
    private static String getXmlDocumentAsString(Class<?> ctxtClass, String fileName, String xPathExpression) {
        Document xmlDocument = getXmlDocument(ctxtClass, fileName);
        XPath xPath = X_PATH_FACTORY.newXPath();

        try {
            Node subNode = (Node)xPath.compile(xPathExpression).evaluate(xmlDocument, XPathConstants.NODE);
            return nodeToString(subNode.getChildNodes());
        } catch (TransformerException | XPathExpressionException var6) {
            throw new IllegalArgumentException("Unable to read value of '" + xPathExpression + "' from file " + fileName, var6);
        }
    }

    /** Reads the specified xml file and returns a Document instance of the
      * xml data. The xml file is expected in the same package/directory as
      * the testcase class. */
    private static Document getXmlDocument(Class<?> ctxtClass, String xmlFileName) {
        InputStream inputStream = getResourceFile(ctxtClass, xmlFileName);

        try {
            DocumentBuilder builder = XML_DOCUMENT_BUILDER_FACTORY.newDocumentBuilder();
            return builder.parse(inputStream);
        } catch (SAXException | IOException | ParserConfigurationException var4) {
            throw new IllegalStateException("Unable to read xml content from file '" + xmlFileName + "'.", var4);
        }
    }

    /** Returns an InputStream of the specified xml file. The xml file is
      * expected in the same package/directory as the testcase class. */
    private static InputStream getResourceFile(Class<?> ctxtClass, String fileName) {
      String pkgPath = StringUtils.replaceChars(ctxtClass.getPackage().getName(), ".", "/");
      String filePath = "/" + pkgPath + "/" + fileName;
      URL url = ctxtClass.getResource(filePath);
      if (url == null) {
          throw new IllegalArgumentException("Resource file not found: " + filePath);
      }
      return ResourceTestUtil.class.getResourceAsStream(filePath);
    }

    /** Deserializes a NodeList to a String with (formatted) xml. */
    private static String nodeToString(NodeList nodeList) throws TransformerException {
        StringWriter buf = new StringWriter();
        Transformer xform = TransformerFactory.newInstance().newTransformer(getXsltAsResource());
        xform.setOutputProperty("omit-xml-declaration", "yes");
        xform.setOutputProperty("indent", "no");

        for(int i = 0; i < nodeList.getLength(); ++i) {
            xform.transform(new DOMSource(nodeList.item(i)), new StreamResult(buf));
        }

        return buf.toString().trim();
    }

    /** Returns a Source of an XSLT file for formatting xml data */
    private static Source getXsltAsResource() {
        return new StreamSource(ResourceTestUtil.class.getResourceAsStream("xmlstylesheet.xslt"));
    }

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:strip-space elements="*"/>
    <xsl:output method="xml" encoding="UTF-8"/>

    <xsl:template match="@*|node()">
        <xsl:copy>
            <xsl:apply-templates select="@*|node()"/>
        </xsl:copy>
    </xsl:template>

</xsl:stylesheet>

import org.xmlunit.builder.DiffBuilder;
import org.xmlunit.diff.DefaultNodeMatcher;
import org.xmlunit.diff.Diff;
import org.xmlunit.diff.ElementSelectors;

import static ResourceUtil.xmldata;

public class MyTestcase {
    @Test
    void testcase1() {
        // Execute logic to generate xml
        String xml = ...
       
        assertXmlEquals(xmlData(getClass(), "/test/testcase1/result"), xml);
    }

    /** Compare xml using XmlUnit assertion. Expected and actual xml need
      * to be equal in content (ignoring whitespace and xml tag order) */
    void assertXmlEquals(String expectedXml, String testXml) {
        Diff diff = DiffBuilder.compare(expectedXml)
                .withTest(testXml)
                .ignoreWhitespace()
                .checkForSimilar()
                .withNodeMatcher(new DefaultNodeMatcher(ElementSelectors.byNameAndText, ElementSelectors.byName))
                .build();
        assertFalse(diff.fullDescription(), diff.hasDifferences());
    }

}

<test>
    <testcase1>
        <result>
            <myData>
                ...
            </myData>
        </result>
    </testcase1>
</test>