# Muss ich bei JAXB immer noch eine zusaetzliche List-Wrapper Klasse erstellen wenn ich mehrere Objekte serialisieren will..?



## sirbender (22. Nov 2019)

Hi,

ich habe viele Klassen (z.B. Person.class) von denen ich manchmal gerne auch ganze Listen von Objekten ausschreiben wuerde.

Das Serialisieren von Person.class klappt problemlos. Nur wuerde ich es mir gerne sparen eine Wrapper-Klasse schreiben zu muessen die dann List<Person> enthaelt und sonst keinem Zweck dient als mehrere Personen in einem XML abspeichern zu koennen.

Gibt es da einen einfachen Trick wie man JAXB dazu bringt auch ohne Wrapper das zu schaffen..?


----------



## mihe7 (22. Nov 2019)

Hier mal eine leicht abgewandelte Variante von https://stackoverflow.com/questions/13272288/is-it-possible-to-programmatically-configure-jaxb

```
import java.io.StringWriter;
import javax.xml.namespace.QName;
import javax.xml.bind.*;
import javax.xml.bind.annotation.*;
import java.util.*;
import java.util.stream.*;
import static java.util.stream.Collectors.*;

public class Test {

    public static class Wrapper<T> {
        @XmlAnyElement(lax=true)
        private final List<T> items;

        private final String listName;
 
        public Wrapper(List<T> items, String listName) {
            this.items = items;
            this.listName = listName;
        }

        public String getListName() { return listName; }
    }

    @XmlRootElement(name="person")
    public static class Person {
        @XmlElement
        String name;

        public Person() {}

        public Person(String name) { this.name = name; }
    }

    @XmlRootElement(name="animal")
    public static class Animal {
        @XmlElement
        String name;

        public Animal() {}
        public Animal(String name) {
            this.name = name;
        }
    }

    public static void main(String[] args) throws Exception {
        List<Person> persons = Stream.of("Hans", "Lisl", "Franz", "Susi")
                .map(Person::new).collect(toList());

        System.out.println(toXml(persons, Person.class, "persons"));

        List<Animal> cats = Stream.of("Purr", "Murr", "Furr")
                .map(Animal::new).collect(toList());

        System.out.println(toXml(cats, Animal.class, "cats"));

    }

    private static <T> String toXml(List<T> list, Class<T> clazz, 
            String elemName) throws JAXBException {
        return toXml(new Wrapper<T>(list, elemName), clazz);
    }

    private static <T> String toXml(Wrapper<T> wrapper, Class<T> clazz) 
            throws JAXBException {       
        JAXBContext ctx = JAXBContext.newInstance(Wrapper.class, clazz);
        Marshaller m = ctx.createMarshaller();
        JAXBElement<Wrapper> root = new JAXBElement<>(
                new QName(wrapper.getListName()), Wrapper.class, wrapper);
        StringWriter writer = new StringWriter();
        m.marshal(root, writer);
        return writer.toString();
    }
 
}
```


----------

