java中 yapi xml配置 xmlserializer java

转载

mob64ca13f937ae 2023-10-19 09:52:00

文章标签 java中 yapi xml配置 xstream 序列化 Data XML 文章分类 Java 后端开发

序列化与反序列化

序列化：把Java对象转换为字节序列的过程。
作用：1. 进行持久化操作，写入硬盘中

用于网络传输

反序列化：把字节序列恢复为Java对象的过程。
而在Java中，如果一个对象想要实现序列化，就必须实现两个接口之一：Serializable 、Externalizable

一、使用XSteam将Java对象序列化为XML

首先需要导入XSteam依赖

<!--XML反序列化xstream-->
        <dependency>
            <groupId>com.thoughtworks.xstream</groupId>
            <artifactId>xstream</artifactId>
            <version>1.4.4</version>
        </dependency>

最基本使用
Person实体类——实现Serializable接口，否则无法序列化：

package com.pantech.cloud.message.handler.osccaac.controller;

import lombok.Data;

import java.io.Serializable;

/**
 * @author lkh
 * @date 2020/9/24 18:29
 * @description
 */

@Data
public class Person implements Serializable {
    private String name;
    private int age;
}

序列化方法：

public void test() {
        try {
            Person person = new Person();
            person.setName("张三");
            person.setAge(18);

            // 将employee对象序列化为XML
            XStream xStream = new XStream(new DomDriver());
            String xmlData = xStream.toXML(person);

            log.info(xmlData);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

输出结果：

<com.pantech.cloud.message.handler.osccaac.controller.Person>
  <name>张三</name>
  <age>18</age>
</com.pantech.cloud.message.handler.osccaac.controller.Person>

序列化结果中实体默认都带有包名，如果不想让其显示类全名，只要给该类起个别名即可
修改后的序列化方法：

public void test() {
        try {
            Person person = new Person();
            person.setName("张三");
            person.setAge(18);

            // 将employee对象序列化为XML
            XStream xStream = new XStream(new DomDriver());

            // 设置Person类的别名,第一个参数要重命名的名称，第二个参数为实体类
            xStream.alias("person", Person.class);//这里的名称就是XML根节点的名称，可任意命名
            
            String xmlData = xStream.toXML(person);

            log.info(xmlData);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

输出结果：

<person>
  <name>张三</name>
  <age>18</age>
</person>

可修改序列化生成的标签名——两种方法

//对属性取别名
 xStream.aliasField("姓名", Person.class,"name");

@XStreamAlias("姓名") // 自定义标签
private String name;

输出结果：

<person>
  <姓名>张三</姓名>
  <age>18</age>
</person>

如果此时实体中有些属性不想要序列化为 XML 节点，就可设置忽略属性
第一种方法是在实体属性上使用 transient 关键字

@Data
public class Person implements Serializable {
    private String name;

    /**
     * 使用transient关键字，表示该字段不序列化
     */
    private transient int age;
}

第二种方法是使用 xStream.omitField(Person .class,“age”); 第一个参数是传递的类，第二个参数是想要忽略的属性名

// 设置Person类的别名,第一个参数要重命名的名称，第二个参数为实体类
            xStream.alias("person", Person.class);
            // 忽略实体属性
            xStream.omitField(Person .class,"age");
            String xmlData = xStream.toXML(person);

第三种方法是在属性字段上加上注解

@XStreamOmitField // 忽略该字段
private int age;

实体中的属性可以是另一实体
Friend实体：

@Data
public class Friend {
    private String name;
    private int age;
}

Person实体：

@Data
public class Person implements Serializable {
    private String name;
    
    private int age;

    private Friend friend;
}

序列化方法：

public void test() {
        try {
            Friend friend = new Friend();
            friend.setName("李四");
            friend.setAge(18);

            Person person = new Person();
            person.setName("张三");
            person.setAge(18);
            person.setFriend(friend);

            // 将employee对象序列化为XML
            XStream xStream = new XStream(new DomDriver());

            // 设置Person类的别名,第一个参数要重命名的名称，第二个参数为实体类
            xStream.alias("person", Person.class);

            String xmlData = xStream.toXML(person);

            log.info(xmlData);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

输出结果：

<person>
  <name>张三</name>
  <age>18</age>
  <friend>
    <name>李四</name>
    <age>18</age>
  </friend>
</person>

属性中可以是实体的list
Person实体：

private List<Friend> friends;

序列化方法：

public void test() {
       
           Friend friendA = new Friend();
           friendA.setName("李四");
           friendA.setAge(18);

           Friend friendB = new Friend();
           friendB.setName("王五");
           friendB.setAge(23);

           List<Friend> friendList = new ArrayList<>();
           friendList.add(friendA);
           friendList.add(friendB);

           Person person = new Person();
           person.setName("张三");
           person.setAge(18);
           person.setFriends(friendList);

           // 将employee对象序列化为XML
           XStream xStream = new XStream(new DomDriver());

           // 设置Person类的别名,第一个参数要重命名的名称，第二个参数为实体类
           xStream.alias("person", Person.class);
           xStream.alias("friend", Friend.class);

           String xmlData = xStream.toXML(person);

           log.info(xmlData);
   }

输出结果：

<person>
  <name>张三</name>
  <age>18</age>
  <friends>
    <friend>
      <name>李四</name>
      <age>18</age>
    </friend>
    <friend>
      <name>王五</name>
      <age>23</age>
    </friend>
  </friends>
</person>

若想去掉集合标签

xStream.addImplicitCollection(Person.class, "friends"); // 去掉集合标签

或者使用注解：

@XStreamImplicit(itemFieldName="friend") // 去掉集合标签
private List<Friend> friends;

输出结果：

<person>
  <name>张三</name>
  <age>18</age>
  <friend>
    <name>李四</name>
    <age>18</age>
  </friend>
  <friend>
    <name>王五</name>
    <age>23</age>
  </friend>
</person>

二、XML反序列化为Java对象

将XML反序列化为Java对象时，需要注意节点与实体属性的对应
xStream的属性设置与序列化是一样的。
原XML数据：

<person>
  <姓名>张三</姓名>
  <age>18</age>
  <address>解放路</address>
  <friend>
    <name>李四</name>
    <age>18</age>
  </friend>
  <friend>
    <name>李四</name>
    <age>18</age>
  </friend>
  <friend>
    <name>王五</name>
    <age>23</age>
  </friend>
</person>

转换为上面的Person类
转换方法：

// 忽略某些节点,作用是 某些不需要的节点时不会报错,如：<address>标签
        XStream xStream = new XStream() {
            @Override
            protected MapperWrapper wrapMapper(MapperWrapper next){
                return new MapperWrapper(next) {
                    @Override
                    public boolean shouldSerializeMember(Class definedIn, String fieldName){
                        if (definedIn == Object.class){
                            try {
                                return this.realClass(fieldName) != null;
                            } catch (Exception e){
                                return false;
                            }
                        } else {
                            return super.shouldSerializeMember(definedIn, fieldName);
                        }
                    }
                };
            }
        };
        xStream.alias("person", Person.class);// 这里对类的重命名一定是根节点名称
        xStream.alias("friend", Friend.class);// 不重命名会报错

        // 属性重命名
        xStream.aliasField("姓名", Person.class,"name");

        // 去掉集合标签
        xStream.addImplicitCollection(Person.class, "friends");
        Person person = (Person) xStream.fromXML(xmlMessage);

        log.info(person.toString());

输出结果：
Person(name=张三, age=18, friends=[Friend(name=李四, age=18), Friend(name=李四, age=18), Friend(name=王五, age=23)])

总结：

对类重命名，去除完整包名
- xStream.alias(“person”, Person.class);
- @XStreamAlias(“person”) // 直接加在类上
修改序列化生成的标签名

xStream.aliasField(“姓名”, Person.class,“name”);
在类属性上使用注解：@XStreamAlias(“姓名”) // 自定义标签

忽略类的某些属性

在类属性上使用 transient 关键字
xStream.omitField(Person .class,“age”);
注解@XStreamOmitField // 忽略该字段

去除集合标签

xStream.addImplicitCollection(Person.class, “friends”); // 去掉集合标签
@XStreamImplicit(itemFieldName=“friend”) // 去掉集合标签

反序列化时，若忽略某些节点，则可以使用：

XStream xStream = new XStream() {
            @Override
            protected MapperWrapper wrapMapper(MapperWrapper next){
                return new MapperWrapper(next) {
                    @Override
                    public boolean shouldSerializeMember(Class definedIn, String fieldName){
                        if (definedIn == Object.class){
                            try {
                                return this.realClass(fieldName) != null;
                            } catch (Exception e){
                                return false;
                            }
                        } else {
                            return super.shouldSerializeMember(definedIn, fieldName);
                        }
                    }
                };
            }
        };

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。