la personnalisation de la sérialisation java des collections à l'aide xstream

J'ai un objet qui doit être sérialisé en XML, qui contient les champs suivants:

List<String> tags = new List<String>();

XStream serialises c'est très bien (après quelques alias) comme ceci:

<tags>
  <string>tagOne</string>
  <string>tagTwo</string>
  <string>tagThree</string>
  <string>tagFour</string>
</tags>

C'est OK comme il va, mais j'aimerais être capable de renommer le <string> éléments à, disons, <tag>. Je ne peux pas voir un moyen évident de le faire à partir de l'alias de la documentation sur le XStream site. Ai-je raté quelque chose d'évident?

OriginalL'auteur Will Goring | 2009-11-24

5

Je te suggère de changer le List<String> à un List<Tag>, où la Balise est un objet de domaine essentiellement contient une Chaîne de caractères. Ensuite, vous dites:
```
xstream.alias("tag", org.goring.Tag.class);
```
et vous obtenez exactement ce que vous voulez. Cela évite d'avoir à rouler votre propre Convertisseur.

C'est exactement ce que j'ai fait environ une demi-heure. Travaillé un régal. 🙂
Pourriez-vous préciser comment les class de la Balise pourrait être? Si je garde une variable de chaîne (dire tagValue), j'obtiens quelque chose comme <tags><tag><tagValue>tagOne</tagValue></tag><tag><tagValue>tagTwo</tagValue></tag></tags>. Merci à l'avance.
Comme Jonna dit ci-dessus, je ne pense pas que cela vous donnera le résultat que vous voulez, à moins que je me manque quelque chose. Je l'ai juste essayé et trouvé les mêmes que Jonna. La solution ci-dessous à l'aide de la CollectionConverter et ClassAliasingMapper fait ce que j'avais en seulement 3 lignes de code.

OriginalL'auteur

Intérêt, j'ai essayé de le faire sans avoir à écrire de ma propre convertisseur. Fondamentalement, j'ai juste un registre spécial chargé version de CollectionConverter pour un certain champ dans une certaine classe.

Pertinentes extrait de:

ClassAliasingMapper mapper = new ClassAliasingMapper(xstream.getMapper());
mapper.addClassAlias("tag", String.class);
xstream.registerLocalConverter(
    Test.class,
    "tags",
    new CollectionConverter(mapper)
);

Complet exemple:

import com.thoughtworks.xstream.*;
import com.thoughtworks.xstream.converters.collections.*;
import com.thoughtworks.xstream.mapper.*;
import java.util.*;

public class Test {
    public List<String> tags = new ArrayList<String>();
    public List<String> notags = new ArrayList<String>();
    public Test(String tag, String tag2) {
        tags.add(tag); tags.add(tag2);
        notags.add(tag); notags.add(tag2);
    }
    public static void main(String[] args) {
        Test test = new Test("foo", "bar");
        XStream xstream = new XStream();

        ClassAliasingMapper mapper = new ClassAliasingMapper(xstream.getMapper());
        mapper.addClassAlias("tag", String.class);
        xstream.registerLocalConverter(
            Test.class,
            "tags",
            new CollectionConverter(mapper)
        );

        System.out.println(xstream.toXML(test));
    }
}

Pas encore testé mais cela devrait fonctionner. Non?

xstream.alias("tag", java.lang.String.class);

Il fonctionne (je l'ai juste essayé,) mais il les récupère et les alias les membres de la <em>autres</em> Collection de Chaînes dans la classe. Malheureusement, dans ma classe réelle (à la différence de l'exemple) il n'y a plus d'une telle Collection.
Cette solution fonctionne parfaitement. Testé sur XStream 1.3.1. Will > comment est-il possible? ce genre d'aliasing se fait uniquement sur le champ "tags" de la classe de Test et tous les autres de la collection dans la classe de Test est un alias par défaut des paramètres de XStream les contributeurs (ie. ils ont la même représentation xml comme vous l'écrivez dans votre post initial -> <balises> <string>...</string></tags>).
Va Gorings commentaire se rapporte à la première version de ma réponse. Qui est le oneliner au-dessous de la ligne horizontale

OriginalL'auteur

@XStreamAlias("example")
public class A {
private B myList;
public A(){
this.myList = new B();
}
public A clone(){
A a = new A();
a.myList = this.myList;
return a;
}
public B getMyList() {
return myList;
}
public void setMyList(B myList) {
this.myList = myList;
}   
}
public class B {
@XStreamImplicit(itemFieldName = "myField")
ArrayList<String> myFieldlist;
public B(){
this.myFieldlist = new ArrayList<String>();
}
public B clone(){
B b = new B();
b.myFieldlist = this.myFieldlist;
return b;
}
public ArrayList<String> getMyFieldlist() {
return myFieldlist;
}
public void setMyFieldlist(ArrayList<String> myFieldlist) {
this.myFieldlist = myFieldlist;
}
}
public class Test {
public static void main(String[] args) {
A a = new A();
a.getMyList().getMyFieldlist().add("aa");
a.getMyList().getMyFieldlist().add("bb");       
XStream xs = new XStream(new DomDriver());  
xs.processAnnotations(A.class);
xs.processAnnotations(B.class);     
System.out.println(xs.toXML(a));                
}
}

résultat xml:

<example>
<myList>
<myField>aa</myField>
<myField>bb</myField>
</myList>
</example>

OriginalL'auteur

1

Ajouter un alias pour le java.util.String classe. Bon, qui peuvent se transformer en quelque chose d'autre ailleurs, mais dans ce cas précis cela devrait être suffisant.

Si vous ne voulez pas faire la chose ci-dessus, vous pouvez faire votre propre convertisseurs (voir ce tutoriel pratique) qui vous aidera à atteindre votre objectif. Et n'ayez pas peur de faire votre propre convertisseur soit, ils sont vraiment facile à mettre en œuvre.

Gotcha. Je l'avais espéré pour éviter d'écrire mon propre Convertisseur, depuis la classe en question a une tonne de champs, mais si c'est ce que je dois faire... Merci. 🙂

OriginalL'auteur

@XStreamConverter(value=ListToStringXStreamConverter.class, strings={"tag"})
List<String> tags = new List<String>();

et dans ListToStringXStreamConverter.java

public class ListToStringXStreamConverter implements Converter {
private String alias;
public ListToStringXStreamConverter(String alias) {
super();
this.alias = alias;
}
@SuppressWarnings("rawtypes")
@Override
public boolean canConvert(Class type) {
return true;
}
@Override
public void marshal(Object source, HierarchicalStreamWriter writer, MarshallingContext context) {
@SuppressWarnings("unchecked")
List<String> list = (List<String>)source;
for (String string : list) {
writer.startNode(alias);
writer.setValue(string);
writer.endNode();
}
}
@Override
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
throw new UnsupportedOperationException("ListToStringXStreamConverter does not offer suport for unmarshal operation");
}
}

OriginalL'auteur

pour moi fonctionne avec le code ci-dessous, à l'aide de Cordes:

xStream.alias("myTag", Person.class);
xStream.addImplicitCollection(Person.class, "myTag", "myTag", String.class);

public class Person{
private ArrayList<String> myTag;
//...
}

<Person>
<myTag>atrcxb2102</myTag>
<myTag>sub3</myTag>
</Person>

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.