Utilisation de JAXB pour démarshaliser/marshaliser une liste<string>.

Question

J'essaie de créer un serveur REST très simple. J'ai juste une méthode de test qui renvoie une liste de chaînes de caractères. Voici le code :

@GET
@Path("/test2")
public List test2(){
    List list=new Vector();
    list.add("a");
    list.add("b");
    return list;
}

Il donne l'erreur suivante :

SEVERE: A message body writer for Java type,
class java.util.Vector, and MIME media type,
application/octet-stream, was not found

J'espérais que JAXB avait un paramètre par défaut pour les types simples tels que String, Integer, etc. Je suppose que non. Voici ce que j'ai imaginé :

<Strings>
  <String>a</String>
  <String>b</String>
</Strings>

Quel est le moyen le plus simple de faire fonctionner cette méthode ?

Answer 1

J'ai utilisé l'exemple de @LiorH et l'ai étendu à :

@XmlRootElement(name="List")
public class JaxbList<T>{
    protected List<T> list;

    public JaxbList(){}

    public JaxbList(List<T> list){
        this.list=list;
    }

    @XmlElement(name="Item")
    public List<T> getList(){
        return list;
    }
}

Notez qu'il utilise des génériques et que vous pouvez donc l'utiliser avec d'autres classes que String. Maintenant, le code de l'application est simplement :

    @GET
    @Path("/test2")
    public JaxbList test2(){
        List list=new Vector();
        list.add("a");
        list.add("b");
        return new JaxbList(list);
    }

Pourquoi cette classe simple n'existe-t-elle pas dans le paquetage JAXB ? Quelqu'un a vu quelque chose de semblable ailleurs ?

Answer 2

@GET
@Path("/test2")
public Response test2(){
   List<String> list=new Vector<String>();
   list.add("a");
   list.add("b");

   final GenericEntity<List<String>> entity = new GenericEntity<List<String>>(list) { };
   return Response.ok().entity(entity).build();
}

Answer 3

Si l'un d'entre vous veut écrire un wrapper de liste pour des listes contenant des éléments de plusieurs classes et souhaite donner à un XmlElement individuel un nom en fonction du type de classe sans écrire de classes Wrapper X, vous pouvez utiliser la méthode suivante @XmlMixed l'annotation. Ce faisant, JAXB nomme les éléments de la liste en fonction de la valeur définie par l'annotation @XmlRootElement . Pour ce faire, vous devez spécifier les classes qui pourraient éventuellement figurer dans la liste en utilisant la commande @XmlSeeAlso

Exemple :

Classes possibles dans la liste

@XmlRootElement(name="user")
public class User {/*...*/}

@XmlRootElement(name="entry")
public class LogEntry {/*...*/}

Classe enveloppante

@XmlRootElement(name="records")
@XmlSeeAlso({User.class, LogEntry.class})
public static class JaxbList<T>{

    protected List<T> records;

    public JaxbList(){}

    public JaxbList(List<T> list){
        this.records=list;
    }

    @XmlMixed 
    public List<T> getRecords(){
        return records;
    }
}

Exemple :

List l = new List();
l.add(new User("userA"));
l.add(new LogEntry(new UserB()));

XStream xStream = new XStream();
String result = xStream.toXML(l);

Résultat :

<records>
    <user>...</user>
    <entry>...</entry>
</records>

Sinon, vous pouvez spécifier les noms des éléments Xml directement dans la classe wrapper en utilisant l'attribut @XmlElementRef annotation

@XmlRootElement(name="records")
@XmlSeeAlso({User.class, LogEntry.class})
public static class JaxbList<T>{

    protected List<T> records;

    public JaxbList(){}

    public JaxbList(List<T> list){
        this.records=list;
    }

    @XmlElementRefs({
        @XmlElementRef(name="item", type=Object.class),
        @XmlElementRef(name="user", type=User.class),
        @XmlElementRef(name="entry", type=LogEntry.class)
    })
    public List<T> getRecords(){
        return records;
    }
}

Answer 4

Cela peut être fait BEAUCOUP plus facile grâce à l'utilisation de merveilleux XStream bibliothèque. Pas d'emballage, pas d'annotations.

XML cible

<Strings>
  <String>a</String>
  <String>b</String>
</Strings>

Sérialisation

( String peut être évité en utilisant des minuscules string mais j'ai utilisé le code de l'OP)

List <String> list = new ArrayList <String>();
list.add("a");
list.add("b");

XStream xStream = new XStream();
xStream.alias("Strings", List.class);
xStream.alias("String", String.class);
String result = xStream.toXML(list);

Désérialisation

Désérialisation en ArrayList

XStream xStream = new XStream();
xStream.alias("Strings", ArrayList.class);
xStream.alias("String", String.class);
xStream.addImplicitArray(ArrayList.class, "elementData");
List <String> result = (List <String>)xStream.fromXML(file);

Désérialisation en String[]

XStream xStream = new XStream();
xStream.alias("Strings", String[].class);
xStream.alias("String", String.class);
String[] result = (String[])xStream.fromXML(file);

Notez que l'instance XStream est thread-safe et peut être préconfigurée, ce qui réduit la quantité de code à une ligne.

XStream peut également être utilisé comme mécanisme de sérialisation par défaut pour le service JAX-RS. Vous trouverez un exemple de l'intégration de XStream dans Jersey à l'adresse suivante aquí

Answer 5

J'ai rencontré ce modèle à plusieurs reprises, j'ai trouvé que la manière la plus simple est de définir une classe interne avec des annotations JaxB. (de toute façon, vous voudrez probablement définir le nom de la balise Root)

donc votre code ressemblerait à quelque chose comme ceci

@GET
@Path("/test2")
public Object test2(){
   MyResourceWrapper wrapper = new MyResourceWrapper();
   wrapper .add("a");
   wrapper .add("b");
   return wrapper ;
}

@XmlRootElement(name="MyResource")
private static class MyResourceWrapper {
       @XmlElement(name="Item")
       List<String> list=new ArrayList<String>();
       MyResourceWrapper (){}

       public void add(String s){ list.add(s);}
 }

si vous travaillez avec javax.rs (jax-rs), je renverrais l'objet Response avec le wrapper comme entité.