Question

我有一个可与其他几个信息系统互操作的Java应用程序

根据目标信息系统

，可以在不同的XML文件中映射相同的对象

我的问题是：是否有Java解决方案在同一个对象上执行多个XML映射/绑定

与Bean验证组类似的东西，可以使用不同的验证配置文件验证对象

在JAXB样式中，它可能类似于：例如：

// pseudocode
@XmlRootElement(name="person", , profile="profile1")
@XmlRootElement(name="individual", profile="profile2")
@XmlRootElement(name="human", profile="profile3")
public class Person {

    @XmlElement(name = "lastName", profile="profile1")
    @XmlElement(name = "surname", profile="profile2")
    @XmlElement(name = "famillyName", profile="profile3")
    private String lastName;

    //...
}

然后

    // pseudocode
    File file = new File("C:\\file.xml");
    JAXBContext jaxbContext = JAXBContext.newInstance(Person.class);
    Marshaller jaxbMarshaller = jaxbContext.createMarshaller("profile1");
    jaxbMarshaller.marshal(person, file);

    //...

    File file = new File("C:\\file.xml");
    JAXBContext jaxbContext = JAXBContext.newInstance(Person.class);
    Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller("profile1");
    Person person = (Person) jaxbUnmarshaller.unmarshal(file);

可能用JAXB做这样的事情但我不知道

修改

@Martin Serrano的回应为我提供了一些利用JAXB优化事物的线索。

一个抽象类来统治它们：

@XmlTransient
public abstract class APerson {

    protected String lastname;

    public APerson() {
    }

    public APerson(APerson p) {
        lastname = p.lastname;
    }

    public abstract String getLastname();

    public void setLastname(String lastname) {
        this.lastname = lastname;
    }

    @Override
    public String toString() {
        return this.getClass().getSimpleName() + "{" + lastname + "}";
    }
}

并混合进行映射的类：

默认映射的类Person：

@XmlRootElement
public class Person extends APerson {

    public Person() {
    }

    public Person(APerson p) {
        super(p);
    }

    @Override
    public String getLastname() {
        return lastname;
    }
}

其他替代映射类：

@XmlRootElement
public class Human extends APerson {

    public Human() {
    }

    public Human(APerson p) {
        super(p);
    }

    @Override
    @XmlElement(name = "famillyName")
    public String getLastname() {
        return lastname;
    }
}


@XmlRootElement
public class Individual extends APerson{   

    public Individual() {
    }

    public Individual(APerson p) {
        super(p);
    }    

    @Override
    @XmlElement(name = "surname")
    public String getLastname() {
        return lastname;
    }
}

并测试：

public class Main {

    public static void main(String[] args) throws Exception {
        Person person = new Person();
        person.setLastname("Doe");

        String fileName = "person.xml";
        marshal(person, fileName);
        person = unmarshal(Person.class, fileName);
        System.out.println(person);

        fileName = "human.xml";
        Human human = new Human(person);
        marshal(human, fileName);
        human = unmarshal(Human.class, fileName);
        System.out.println(human);
        person = new Person(human);
        System.out.println(person);

        fileName = "individual.xml";
        Individual individual = new Individual(person);
        marshal(individual, fileName);
        individual = unmarshal(Individual.class, fileName);
        System.out.println(individual);
        person = new Person(individual);
        System.out.println(person);
    }

    private static <P extends APerson> void marshal(P person, String fileName) throws JAXBException {
        File file = new File(fileName);
        JAXBContext context = JAXBContext.newInstance(person.getClass());
        Marshaller marshaller = context.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
        marshaller.marshal(person, file);
        marshaller.marshal(person, System.out);
    }

    private static <P extends APerson> P unmarshal(Class<P> cl, String fileName) throws JAXBException {
        File file = new File(fileName);
        JAXBContext context = JAXBContext.newInstance(cl);
        Unmarshaller unmarshaller = context.createUnmarshaller();
        P person = (P) unmarshaller.unmarshal(file);
        return person;
    }

}

结果：

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<person>
    <lastname>Doe</lastname>
</person>
Person{Doe}
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<human>
    <famillyName>Doe</famillyName>
</human>
Human{Doe}
Person{Doe}
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<individual>
    <surname>Doe</surname>
</individual>
Individual{Doe}
Person{Doe}

我找到的最佳解决方案具有不同的映射并避免代码重复，因此我们只需要使用映射实现getter。

让我们看看它是否正在解决更大的问题！

但是，虽然它比3个删除类更好，但在同一个类中它仍然不是3个映射...

Answer 1

执行此类操作的最简单方法是为每个系统使用不同的外观。这将允许您更改JAXB de / serialize对象的方式。它还允许您根据相关系统进行其他转换和调整。基础Person类将具有您的默认序列化，并且每个系统可以在必要时使用适合它的外观。这基本上是关于mapping interfaces的非官方jaxb指南中概述的方法。

可以为每个系统注册这样的外观，允许您将系统特定的配置文件保留在每个核心类型的代码之外。

使用您的示例，核心接口将是：

@XmlRootElement(name="person")
public interface Person {
  @XmlElement(name = "lastName")
  private String lastName;
}

然后对于System1，您将拥有：

@XmlRootElement(name="individual")
public class Individual implements Person {
}

另一个系统可能有：

@XmlRootElement(name="human")
public class Human implements Person {
}

在同一Java对象上进行不同的XML映射/绑定

1 个答案: