personalizzazione serializzazione delle collezioni Java utilizzando xstream

Question

Ho un oggetto che deve essere serializzato come XML, che contiene il seguente campo:

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

XStream serialises proprio bene (dopo alcuni alias) in questo modo:

Questo va bene così com'è, ma mi piacerebbe poter rinominare gli elementi <string>, ad esempio, <tag>. Non riesco a vedere un modo ovvio per farlo dalla documentazione degli alias sul sito XStream. Mi manca qualcosa di ovvio?

Answer 1

Io suggerirei di cambiare il List<String> ad un List<Tag>, dove Tag è un oggetto di dominio che essenzialmente solo contiene una stringa. Quindi dici:

xstream.alias("tag", org.goring.Tag.class); 

e ottieni esattamente ciò che desideri. Questo evita di dover girare il tuo convertitore.

Answer 2

Aggiungere alias per la classe java.util.String. Ok, questo potrebbe rompere qualcos'altro altrove, ma in questo caso esatto dovrebbe essere sufficiente.

Se non si desidera eseguire l'operazione precedente, è possibile creare convertitori personalizzati (see this handy tutorial) che consentiranno di raggiungere il proprio obiettivo. E non aver paura di creare il tuo convertitore, sono davvero facili da implementare.

Answer 3

Per interesse, ho provato a farlo senza scrivere il mio convertitore. Fondamentalmente mi limito a registrare una versione speciale di CollectionConverter per un determinato campo in una determinata classe.

Rilevante frammento:

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

conclamato esempio:

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)); 
    } 
} 

---

Non testato, ma questo dovrebbe funzionare. No?

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

Answer 4

@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));     
    } 
} 

risultato xml:

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

Answer 5

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

e in 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"); 
} 

} 

Answer 6

per me funziona con il codice qui sotto, utilizzando le stringhe:

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>