标签: jackson-dataformat-xml

我有两个 Spring Boot 项目 - A（带有 API 的主要较大项目）和B （由A作为 pom.xml 中的依赖项导入的库）

项目B的pom.xml ：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>

        <relativePath /> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.b.root</groupId>
    <artifactId>b</artifactId>
    <version>0.0.1</version>
    <packaging>jar</packaging>
    <name>b</name>
    <description>Importable Jar</description>

    <properties>
        <java.version>11</java.version>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <oauth2.version>2.1.1.RELEASE</oauth2.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
                <!-- Removing dependency for the embedded Tomcat -->
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-tomcat</artifactId>
                </exclusion>
                <!-- End -->
            </exclusions>
        </dependency>

        <!-- …

我正在尝试反序列化以下 XML：

<root>
    <foo name="AAA" />
    <bar name="BBB" />
    <foo name="CCC" />
</root>

我的杰克逊课程是：

@Data
public class Foo {
    @JacksonXmlProperty(isAttribute = true)
    private String name;
}

Bar 是相同的，只是类名不同。（在实际代码中它们是不同的，这只是一个示例）。

根类是

@Data
public class Root {
    @JacksonXmlProperty(localName = "foo")
    @JacksonXmlElementWrapper(useWrapping = false)
    private List<Foo> foos;
    @JacksonXmlProperty(localName = "bar")
    @JacksonXmlElementWrapper(useWrapping = false)
    private List<Bar> bars;
}

当我尝试反序列化 XML 时，使用此代码

System.out.println(new XmlMapper().readValue(theXml, Root.class));

结果是这样的（注意缺少“AAA”）：

Root(foos=[Foo(name=CCC)], bars=[Bar(name=BBB)])

但是，如果我移动 XML 中的字段，使两个foo标签彼此相邻，它会打印

Root(foos=[Foo(name=AAA), Foo(name=CCC)], bars=[Bar(name=BBB)])

我正在使用最新的jackson-dataformat-xml 2.11.1。

这里发生了什么，我该如何解决？

如何让 Jackson 的 XMLMapper 在反序列化时读取根 xml 元素的名称？

我将输入 XML 反序列化为通用 Java 类、LinkedHashMap，然后反序列化为 JSON。我想在反序列化到 LinkedHashMap 时动态读取输入 XML 的根元素。

代码

XmlMapper xmlMapper = new XmlMapper();
Map entries = xmlMapper.readValue(new File("source.xml"), LinkedHashMap.class);
ObjectMapper jsonMapper = new ObjectMapper();
String json = jsonMapper.writer().writeValueAsString(entries);
System.out.println(json);

输入 XML

<?xml version="1.0" encoding="ISO-8859-1"?>
<File>
  <NumLeases>1</NumLeases>
  <NEDOCO>18738</NEDOCO>
  <NWUNIT>0004</NWUNIT>
  <FLAG>SUCCESS</FLAG>
  <MESSAGE>Test Upload</MESSAGE>
  <Lease>
     <LeaseVersion>1</LeaseVersion>
     <F1501B>
        <NEDOCO>18738</NEDOCO>
        <NWUNIT>0004</NWUNIT>
        <NTRUSTRECORDKEY>12</NTRUSTRECORDKEY>
     </F1501B>
  </Lease>
</File>

实际产量

{"NumLeases":"1","NEDOCO":"18738","NWUNIT":"0004","FLAG":"SUCCESS","MESSAGE":"Test Upload","Lease":{"LeaseVersion":"1","F1501B":{"NEDOCO":"18738","NWUNIT":"0004","NTRUSTRECORDKEY":"12"}}}  

预期输出（注意：JSON 中有一个名为“File”的根元素）

{"File":{"NumLeases":"1","NEDOCO":"18738","NWUNIT":"0004","FLAG":"SUCCESS","MESSAGE":"Test Upload","Lease":{"LeaseVersion":"1","F1501B":{"NEDOCO":"18738","NWUNIT":"0004","NTRUSTRECORDKEY":"12"}}}}

可能有一些开关可以设置它。任何帮助将不胜感激。

我有一个要支持JSON和XML数据格式序列化/反序列化的XSD。

我使用xjc实用程序生成了Model类。

因此，到目前为止，我已经使用Jackson JSON库处理了JSON数据。

我无法修改Java类，因此我配置ObjectMapper了Mix-In annotations和其他功能PropertyNamingStrategy（如更改字段名），SerializationFeature.WRAP_ROOT_VALUE以通过代码在我的序列化过程中提供配置。

现在，我想对XML序列化过程做同样的事情。

我已经在线阅读了各种选择：

1. 杰克斯
2. 杰克逊图书馆+ Jackson-dataformat-xml.jar
3. XStream的

哪一种最适合我的情况（不能编辑带注释的POJO，仅允许代码配置）？

通过我所做的所有搜索,我理解使用混合内容的jackson序列化/反序列化xml是有问题的.有没有人知道使用Java处理以下xml的方法？

<xmlsample>
    <title>Yada yada yada <a href=\"component:tcm:757-228001\" id=\"Link_1492103133595\" title=\"yada\" name=\"Link_1492103133595\" xmlns=\"xhtml\">yada</a> yada</title>
    <link>test</link>
</xmlsample>

我使用以下POJO:

@JacksonXmlRootElement(localName="xmlsample")
public class XmlSample{

    private String title;
    private String link;

    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getLink() {
        return link;
    }
    public void setLink(String link) {
        this.link = link;
    }
}

如果节点具有混合内容,如上例所示,我将收到以下错误:

java.io.IOException: Expected END_ELEMENT, got event of type 1

如果节点具有纯文本,则反序列化有效.

我已经尝试使用JsonNode,TextNode,ObjectNode,Object而不是String作为数据类型.我尝试过自定义序列化程序和反序列化程序,但错误仍然存​​在.实际上,如果节点中有html,则处理不会到达自定义反序列化器.

这个xml来自第三方系统(SDL Tridion),我无法改变.

任何帮助将不胜感激!

编辑:我需要澄清该节点可能包含标记或可能包含纯文本,因此我不能创建一个代表标记的POJO,就像你在上面的xml中看到的那样.而且标记也可能比上面的例子复杂得多.这就是为什么我只是想把它强制成一个String.我不需要操作它,我只需要在POJO中保存它,这样它就可以不加改变地返回到数据库.

我有一个 pojo，我正在使用 com.fasterxml.jackson.dataformat.xml.XmlMapper 序列化它。

我有一个用多个字符串值定义的 Java 类。

@JacksonXmlRootElement(namespace = "http://www.firstnamespace.com", localName = "Student")    
public class Student {
    @JacksonXmlProperty(namespace = "http://www.firstnamespace.com",localName = "ID")
    public final String id;
    @JacksonXmlProperty(namespace = "http://www.firstnamespace.com",localName = "Name")
    public final String name;
    @JacksonXmlProperty(namespace = "http://www.firstnamespace.com",localName = "Address")
    public Address address;
}

地址定义如下，地址的元素位于不同的命名空间中

public class Address {
    @JacksonXmlProperty(namespace = "http://www.secondnamespace.com",localName = "StreetNumber")
    public final String streetNumber;
    @JacksonXmlProperty(namespace = "http://www.secondnamespace.com",localName = "StreetName")
    public final String steetName;
}

当我用 Jackson 序列化 Student 时，我最终得到了地址对象的一堆重复的命名空间。

<Student xmlns="http://www.firstnamespace.com">
    <ID>1234</ID>
    <Name>Ken</Name>
    <Address>
        <wstxns1:StreetNumber xmlns:wstnxs1="http://www.secondnamespace.com">Ken</wstxns1:StreetNumber> …

所以我用杰克逊JSON序列化/反序列化成功地uptil现在，现在我也在努力将其用于XML序列化/反序列化使用它jackson-dataformat-xml-2.3.0.jar。

我用过了

objectmapper.reader(Student.class).withRootName("prefix:student").readValue(jsonString)

将我的 JSON（具有带前缀的根名称）反序列化为Student成功运行的类。

现在，我试图将我的 XML 字符串（具有带前缀的根名称）反序列化为Student：

XML：

<prefix:student>
  <name>
    Jack Jones
  </name>
  <id>1</id>
</prefix:student>

我的POJO：

    @XmlAccessorType(XmlAccessType.FIELD)
    @XmlType(name = "", propOrder = {
        "name",
        "id",
        ....
    })
    @XmlRootElement(name = "student")
    public class Student
    {

        protected String name;
        BigInteger id;  
..........................
    }

我desrializing此使用XmlMapper的jackson-dataformat-xml是这样的：

xmlMapper.reader(Student.class).withRootName("prefix:student").readValue(xmlString)

我收到以下异常：

java.io.IOException: com.ctc.wstx.exc.WstxParsingException: Undeclared namespace prefix "prefix"
 at [row,col {unknown-source}]: [1,9]
    at com.fasterxml.jackson.dataformat.xml.util.StaxUtil.throwXmlAsIOException(StaxUtil.java:24)
    at com.fasterxml.jackson.dataformat.xml.XmlFactory._createParser(XmlFactory.java:473)
    at com.fasterxml.jackson.dataformat.xml.XmlFactory._createParser(XmlFactory.java:26)
    at com.fasterxml.jackson.core.JsonFactory.createParser(JsonFactory.java:844)
    at com.fasterxml.jackson.databind.ObjectMapper.readValue(ObjectMapper.java:2091)

Caused …

@JsonIgnoreProperties(ignoreUnknown=false) 不适用于 spring 4.2.0 和更高版本的 spring。但它适用于 4.0.4 和 4.0.1 。我正在使用 spring 4.2.8 并使用 Jackson 依赖项

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.6.3</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.6.3</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.6.3</version>
</dependency>

如果我发送带有无效字段的 json 请求，那么它会作为有效请求接受。但它应该给出错误的请求作为响应。例如：如果我有课

public class Student{ 
    private String id; 
    private String name; 
}

如果发送有效的相应 json 请求，它应该是这样的

{ 
   "id": "123", 
   "name": "test" 
}

但即使我发送带有无效字段的 json 请求，如下所示，它仍然接受。

{ 
    "id": "123", 
    "name": "test", 
    "anyinvalidkey": "test" 
}

但它应该给出错误的请求作为响应

我有一个XML文档,我需要将其转换(反序列化)到Java POJO中.我无法更改 XML文档的结构.我使用Java 8和Jackson框架进行映射. Gradle依赖项:

dependencies {
    compile('com.fasterxml.jackson.dataformat:jackson-dataformat-xml')
    compile('org.springframework.boot:spring-boot-starter-freemarker')
    compile('org.springframework.boot:spring-boot-starter-web')
    providedRuntime('org.springframework.boot:spring-boot-starter-tomcat')
    testCompile('org.springframework.boot:spring-boot-starter-test')
}

包装XML文档:

@JacksonXmlRootElement(localName = "rates_response")
public class RatesResponse implements Serializable{
    private static final long serialVersionUID = 3254688495454519L;

    @JacksonXmlProperty(isAttribute = true)
    private String b_number = "";

    @JacksonXmlProperty(isAttribute = true)
    private String l_premium = "";

    @JacksonXmlProperty(isAttribute = true)
    private String currency = "";

    @XmlElement(required = false)
    @JacksonXmlProperty
    private String c_b_relationship = null;

    @JacksonXmlProperty(isAttribute = true)
    private String n_of_p_loans = null;

    /*
     * Key: status_code
     * Key: …

我的 Spring Boot 应用程序想要使用 Webclient 发出 http 请求（XML 请求正文）并接收 XML 响应。因此，我使用 jackson-dataformat-xml 创建了另一个 Spring Boot 应用程序，并创建了一个端点来接收和返回 XML，如下所示。

spring-boot-version=2.2.5
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
  <groupId>com.fasterxml.jackson.dataformat</groupId>
  <artifactId>jackson-dataformat-xml</artifactId>
</dependency>

@PostMapping(value = "/api",
            consumes = MediaType.APPLICATION_XML_VALUE,
            produces = MediaType.APPLICATION_XML_VALUE)
public ResponseEntity<MyXmlResponse> trip(@RequestBody MyXmlRequest request) throws Exception {
   MyXmlResponse response = new MyXmlResponse();
   response.setStatus("SUCCESS");
   response.setTripID(request.getTripID());
   return ResponseEntity.ok().body(response);
}

它工作完美，显然不需要 JaxB 注释，因为我使用 jackson-dataformat-xml。此外，请求 XML 可以不区分大小写。

现在，在我的第一个应用程序中，我想通过 Web 客户端使用此 API。我读到 Spring webflux 还不支持 Jackson-dataformat-xml 。因此我必须使用 Jaxb 注释来注释我的类。

spring-boot-version=2.2.5
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

webClient.post() …