XStream - Kurzanleitung

XStream ist eine einfache Java-basierte Bibliothek zum Serialisieren von Java-Objekten in XML und umgekehrt.

Eigenschaften

• Easy to use - Die XStream-API bietet eine übergeordnete Fassade zur Vereinfachung gängiger Anwendungsfälle.

• No need to create mapping - Die XStream-API bietet eine Standardzuordnung für die meisten zu serialisierenden Objekte.

• Performance - XStream ist schnell und hat einen geringen Speicherbedarf, der für große Objektgraphen oder -systeme geeignet ist.

• Clean XML - XStream erzeugt eine saubere und kompakte XML-Ausgabe, die leicht zu lesen ist.

• Object modification not required- XStream serialisiert interne Felder wie private und endgültige Felder und unterstützt nicht öffentliche und innere Klassen. Der Standardkonstruktor ist keine zwingende Voraussetzung.

• Full object graph support - XStream ermöglicht die Verwaltung doppelter Referenzen im Objektmodell und unterstützt auch Zirkelreferenzen.

• Customizable conversion strategies - Benutzerdefinierte Strategien können registriert werden, damit die Anpassung eines bestimmten Typs als XML dargestellt werden kann.

• Security framework - XStream bietet eine faire Kontrolle über nicht gemarshallte Typen, um Sicherheitsprobleme mit manipulierten Eingaben zu vermeiden.

• Error messages - Wenn aufgrund von fehlerhaftem XML eine Ausnahme auftritt, werden detaillierte Diagnosen zur Behebung des Problems bereitgestellt.

• Alternative output format - XStream unterstützt andere Ausgabeformate wie JSON und Morphing.

Allgemeine Verwendungen

• Transport - XML ​​ist eine Textdarstellung eines Objekts und kann verwendet werden, um Objekte unabhängig von den verwendeten Serialisierungs- / Deserialisierungstechniken über den Draht zu transportieren.

• Persistence - Objekte können als XML in Datenbanken beibehalten und bei Bedarf gemarshallt / nicht gemarshallt werden.

• Configuration- XML ​​ist selbsterklärend und wird häufig zum Definieren von Konfigurationen verwendet. Objekte können auch zu Konfigurationszwecken verwendet werden, nachdem sie in eine XML-Darstellung konvertiert wurden.

• Unit Tests - Die XStream-API ist JUnit-kompatibel und kann zur Verbesserung des Komponententests von Anwendungsmodulen verwendet werden.

In diesem Kapitel werden die verschiedenen Aspekte der Einrichtung einer kongenialen Umgebung für Java erläutert.

Einrichtung der lokalen Umgebung

Wenn Sie Ihre Umgebung für die Programmiersprache Java einrichten möchten, wird in diesem Abschnitt erläutert, wie Sie Java auf Ihren Computer herunterladen und einrichten. Führen Sie die folgenden Schritte aus, um Ihre Java-Umgebung einzurichten.

Java SE kann kostenlos über den Link heruntergeladen werden -

Laden Sie Java herunter .

Befolgen Sie die Anweisungen, um Java herunterzuladen und auszuführen .exeum Java auf Ihrem Computer zu installieren. Sobald Sie Java auf Ihrem Computer installiert haben, müssen Sie die Umgebungsvariablen so einstellen, dass sie auf die richtigen Installationsverzeichnisse verweisen.

Einrichten des Pfads für Windows 2000 / XP

Angenommen, Sie haben Java im Verzeichnis c: \ Programme \ java \ jdk installiert -

• Klicken Sie mit der rechten Maustaste auf "Arbeitsplatz" und wählen Sie "Eigenschaften".

• Klicken Sie auf der Registerkarte "Erweitert" auf die Schaltfläche "Umgebungsvariablen".

• Ändern Sie die Variable 'Path' so, dass sie auch den Pfad zur ausführbaren Java-Datei enthält. Wenn der Pfad derzeit auf "C: \ WINDOWS \ SYSTEM32" festgelegt ist, ändern Sie Ihren Pfad in "C: \ WINDOWS \ SYSTEM32; c: \ Programme \ java \ jdk \ bin".

Einrichten des Pfads für Windows 95/98 / ME

Angenommen, Sie haben Java im Verzeichnis c: \ Programme \ java \ jdk installiert -

• Bearbeiten Sie die Datei 'C: \ autoexec.bat' und fügen Sie am Ende die folgende Zeile hinzu:

  'SET PATH =% PATH%; C: \ Programme \ java \ jdk \ bin'

Einrichten des Pfads für Linux, UNIX, Solaris, FreeBSD

Die Umgebungsvariable PATH sollte so eingestellt sein, dass sie darauf verweist, wo die Java-Binärdateien installiert wurden. Informationen hierzu finden Sie in Ihrer Shell-Dokumentation.

Wenn Sie beispielsweise bash als Shell verwenden, fügen Sie am Ende Ihrer '.bashrc: export PATH = / path / to / java: $ PATH' die folgende Zeile hinzu.

Beliebte Java-Editoren

Zum Schreiben von Java-Programmen benötigen Sie einen Texteditor. Es gibt noch ausgefeiltere IDEs auf dem Markt. Im Moment können Sie jedoch eine der folgenden Möglichkeiten in Betracht ziehen:

• Notepad - Unter Windows können Sie einen einfachen Texteditor wie Notepad (für dieses Tutorial empfohlen) oder TextPad verwenden.

• Netbeans - Es ist eine Java-IDE, die kostenlos ist und von heruntergeladen werden kann https://www.netbeans.org/index.html.

• Eclipse - Es ist auch eine Java-IDE, die von der Open-Source-Community von eclipse entwickelt wurde und von heruntergeladen werden kann https://www.eclipse.org/.

Laden Sie das XStream-Archiv herunter

Laden Sie die neueste Version der XStream-JAR-Datei von xstream-1.4.7.jar herunter. Zum Zeitpunkt des Schreibens dieses Tutorials haben wir xstream-1.4.7.jar heruntergeladen und in den Ordner C: \> XStream kopiert.

Betriebssystem	Archivname
Windows	xstream-1.4.7.jar
Linux	xstream-1.4.7.jar
Mac	xstream-1.4.7.jar

Stellen Sie die XStream-Umgebung ein

Stellen Sie die XStream_HOMEUmgebungsvariable, die auf den Speicherort des Basisverzeichnisses verweist, in dem xstream jar auf Ihrem Computer gespeichert ist. Die folgende Tabelle zeigt, wie Sie die XStream-Umgebung unter Windows, Linux und Mac festlegen, vorausgesetzt, wir haben xstream-1.4.7.jar im XStream-Ordner extrahiert.

Sr.Nr.	Betriebssystem & Beschreibung
1	Windows Setzen Sie die Umgebungsvariable XStream_HOME auf C: \ XStream
2	Linux export XStream_HOME = / usr / local / XStream
3	Mac export XStream_HOME = / Library / XStream

Setzen Sie die Variable CLASSPATH

Stellen Sie die CLASSPATHUmgebungsvariable, die auf den XStream-JAR-Speicherort verweist. Die folgende Tabelle zeigt, wie Sie die Variable CLASSPATH unter Windows, Linux und Mac festlegen, vorausgesetzt, wir haben xstream-1.4.7.jar im XStream-Ordner gespeichert.

Sr.Nr.	Betriebssystem & Beschreibung
1	Windows Setzen Sie die Umgebungsvariable CLASSPATH auf% CLASSPATH%;% XStream_HOME% \ xstream-1.4.7.jar;
2	Linux export CLASSPATH = $ CLASSPATH: $ XStream_HOME / xstream-1.4.7.jar;
3	Mac export CLASSPATH = $ CLASSPATH: $ XStream_HOME / xstream-1.4.7.jar;

Bevor wir uns mit den Details der XStream-Bibliothek befassen, sehen wir uns eine Anwendung in Aktion an. In diesem Beispiel haben wir Schüler- und Adressklassen erstellt. Wir erstellen ein Schülerobjekt und serialisieren es dann in eine XML-Zeichenfolge. De-serialisieren Sie dann dieselbe XML-Zeichenfolge, um das Schülerobjekt zurückzugewinnen.

Erstellen Sie eine Java-Klassendatei mit dem Namen XStreamTester in C: \> XStream_WORKSPACE.

File: XStreamTester.java

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

import javax.xml.transform.OutputKeys;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.stream.StreamResult;
import org.xml.sax.InputSource;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.StaxDriver;

public class XStreamTester {

   public static void main(String args[]) {
      XStreamTester tester = new XStreamTester();
      XStream xstream = new XStream(new StaxDriver());
      
      Student student = tester.getStudentDetails();
      
      //Object to XML Conversion
      String xml = xstream.toXML(student);
      System.out.println(formatXml(xml));
      
      //XML to Object Conversion
      Student student1 = (Student)xstream.fromXML(xml);
      System.out.println(student1);
   }
   
   private Student getStudentDetails() {
   
      Student student = new Student();
      student.setFirstName("Mahesh");
      student.setLastName("Parashar");
      student.setRollNo(1);
      student.setClassName("1st");

      Address address = new Address();
      address.setArea("H.No. 16/3, Preet Vihar.");
      address.setCity("Delhi");
      address.setState("Delhi");
      address.setCountry("India");
      address.setPincode(110012);

      student.setAddress(address);
      return student;
   }
   
   public static String formatXml(String xml) {
   
      try {
         Transformer serializer = SAXTransformerFactory.newInstance().newTransformer();
         
         serializer.setOutputProperty(OutputKeys.INDENT, "yes");
         serializer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
         
         Source xmlSource = new SAXSource(new InputSource(
            new ByteArrayInputStream(xml.getBytes())));
         StreamResult res =  new StreamResult(new ByteArrayOutputStream());            
         
         serializer.transform(xmlSource, res);
         
         return new String(((ByteArrayOutputStream)res.getOutputStream()).toByteArray());
         
      } catch(Exception e) {
         return xml;
      }
   }
}

class Student {
   private int rollNo;
   private String firstName;
   private String lastName;
   private String className;
   private Address address;

   public String getFirstName() {
      return firstName;
   }
   
   public void setFirstName(String firstName) {
      this.firstName = firstName;
   }
   
   public String getLastName() {
      return lastName;
   }
   
   public void setLastName(String lastName) {
      this.lastName = lastName;
   }
   
   public int getRollNo() {
      return rollNo;
   }
   
   public void setRollNo(int rollNo) {
      this.rollNo = rollNo;
   }
   
   public String getClassName() {
      return className;
   }
   
   public void setClassName(String className) {
      this.className = className;
   }
   
   public Address getAddress() {
      return address;
   }
   
   public void setAddress(Address address) {
      this.address = address;
   }
   
   public String toString() {
      StringBuilder stringBuilder = new StringBuilder();
      
      stringBuilder.append("Student [ ");
      stringBuilder.append("\nfirstName: ");
      stringBuilder.append(firstName);
      stringBuilder.append("\nlastName: ");
      stringBuilder.append(lastName);
      stringBuilder.append("\nrollNo: ");
      stringBuilder.append(rollNo);
      stringBuilder.append("\nclassName: ");
      stringBuilder.append(className);
      stringBuilder.append("\naddress: ");
      stringBuilder.append(address);
      stringBuilder.append(" ]");
      
      return stringBuilder.toString();
   }
}

class Address {
   private String area;
   private String city;
   private String state;
   private String country;
   private int pincode;

   public String getArea() {
      return area;
   }

   public void setArea(String area) {
      this.area = area;
   }

   public String getCity() {
      return city;
   }

   public void setCity(String city) {
      this.city = city;
   }

   public String getState() {
      return state;
   }

   public void setState(String state) {
      this.state = state;
   }

   public String getCountry() {
      return country;
   }

   public void setCountry(String country) {
      this.country = country;
   }

   public int getPincode() {
      return pincode;
   }

   public void setPincode(int pincode) {
      this.pincode = pincode;
   }

   public String toString() {

      StringBuilder stringBuilder = new StringBuilder();

      stringBuilder.append("\nAddress [ ");
      stringBuilder.append("\narea: ");
      stringBuilder.append(area);
      stringBuilder.append("\ncity: ");
      stringBuilder.append(city);
      stringBuilder.append("\nstate: ");
      stringBuilder.append(state);
      stringBuilder.append("\ncountry: ");
      stringBuilder.append(country);
      stringBuilder.append("\npincode: ");	
      stringBuilder.append(pincode);
      stringBuilder.append(" ]");

      return stringBuilder.toString();
   }
}

Verify the Result

Kompilieren Sie die Klassen mit javac Compiler wie folgt -

C:\XStream_WORKSPACE>javac XStreamTester.java

Führen Sie nun den XStreamTester aus, um das Ergebnis anzuzeigen -

C:\XStream_WORKSPACE>java XStreamTester

Verify the output as follows

<?xml version = "1.0" encoding = "UTF-8"?>
<Student>
   <firstName>Mahesh</firstName>
   <lastName>Parashar</lastName>
   <rollNo>1</rollNo>
   <className>1st</className>
   <address>
      <area>H.No. 16/3, Preet Vihar.</area>
      <city>Delhi</city>
      <state>Delhi</state>
      <country>India</country>
      <pincode>110012</pincode>
   </address>
</Student>

Student [ 
   firstName: Mahesh
   lastName: Parashar
   rollNo: 1
   className: 1st
   address: 
   Address [ 
      area: H.No. 16/3, Preet Vihar.
      city: Delhi
      state: Delhi
      country: India
      pincode: 110012
   ] 
]

Schritte zum Erinnern

Im Folgenden sind die wichtigen Schritte aufgeführt, die hier zu berücksichtigen sind.

Schritt 1: Erstellen Sie ein XStream-Objekt

Erstellen Sie ein XStream-Objekt, indem Sie ihm einen StaxDriver übergeben. StaxDriver verwendet den Stax Pull Parser (verfügbar ab Java 6) und ist ein schneller XML-Parser.

XStream xstream = new XStream(new StaxDriver());

Schritt 2: Serialisieren Sie das Objekt in XML

Verwenden Sie die toXML () -Methode, um die XML-Zeichenfolgendarstellung des Objekts abzurufen.

//Object to XML Conversion
String xml = xstream.toXML(student);

Schritt 3: De-serialisieren Sie XML, um das Objekt abzurufen

Verwenden Sie die fromXML () -Methode, um das Objekt aus dem XML abzurufen.

//XML to Object Conversion		
Student student1 = (Student)xstream.fromXML(xml);

Aliasing ist eine Technik zum Anpassen des generierten XML oder zum Verwenden eines bestimmten formatierten XML mit XStream. Angenommen, das folgende XML-Format wird zum Serialisieren / De-Serialisieren des Student-Objekts verwendet.

<student name = "Suresh">
   <note>
      <title>first</title>
      <description>My first assignment.</description>
   </note>
   
   <note>
      <title>second</title>
      <description>My second assignment.</description>
   </note>
</student>

Basierend auf dem obigen XML-Format erstellen wir Modellklassen.

class Student {
   private String studentName;
   private List<Note> notes = new ArrayList<Note>();
   
   public Student(String name) {
      this.studentName = name;
   }
   
   public void addNote(Note note) {
      notes.add(note);
   }
   
   public String getName() {
      return studentName;
   }
   
   public List<Note> getNotes() {
      return notes;
   }
}

class Note {
   private String title;
   private String description;

   public Note(String title, String description) {
      this.title = title;
      this.description = description;
   }

   public String getTitle() {
      return title;
   }

   public String getDescription() {
      return description;
   }     
}

Testen wir die Serialisierung der oben genannten Objekte mit XStream.

Erstellen Sie eine Java-Klassendatei mit dem Namen XStreamTester in C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

File: XStreamTester.java

package com.tutorialspoint.xstream;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

import java.util.ArrayList;
import java.util.List;

import javax.xml.transform.OutputKeys;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.stream.StreamResult;

import org.xml.sax.InputSource;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.StaxDriver;

public class XStreamTester {
   public static void main(String args[]) {
   
      XStreamTester tester = new XStreamTester();
      XStream xstream = new XStream(new StaxDriver());
      Student student = tester.getStudentDetails();
      
      //Object to XML Conversion
      String xml = xstream.toXML(student);
      System.out.println(formatXml(xml));		
   }	

   private Student getStudentDetails() {
   
      Student student = new Student("Mahesh");
      
      student.addNote(new Note("first","My first assignment."));
      student.addNote(new Note("second","My Second assignment."));
      
      return student;
   }

   public static String formatXml(String xml) {
   
      try {
         Transformer serializer = SAXTransformerFactory.newInstance().newTransformer();
         
         serializer.setOutputProperty(OutputKeys.INDENT, "yes");
         serializer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
         
         Source xmlSource = new SAXSource(new InputSource(
            new ByteArrayInputStream(xml.getBytes())));
         StreamResult res =  new StreamResult(new ByteArrayOutputStream());            
         
         serializer.transform(xmlSource, res);
         
         return new String(((ByteArrayOutputStream)res.getOutputStream()).toByteArray());
         
      } catch(Exception e) {
         return xml;
      }
   }
}

class Student {
   private String studentName;
   private List<Note> notes = new ArrayList<Note>();
   
   public Student(String name) {
      this.studentName = name;
   }
   
   public void addNote(Note note) {
      notes.add(note);
   }
   
   public String getName() {
      return studentName;
   }
   
   public List<Note> getNotes() {
      return notes;
   }
}

class Note {
   private String title;
   private String description;
   
   public Note(String title, String description) {
      this.title = title;
      this.description = description;
   }
   
   public String getTitle() {
      return title;
   }
   
   public String getDescription() {
      return description;
   }     
}

Verify the Result

Kompilieren Sie die Klassen mit javac Compiler wie folgt -

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>javac XStreamTester.java

Führen Sie nun den XStreamTester aus, um das Ergebnis anzuzeigen -

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>java XStreamTester

Überprüfen Sie die Ausgabe wie folgt:

<?xml version = "1.0" encoding = "UTF-8"?>
<com.tutorialspoint.xstream.Student>
   <studentName>Mahesh</studentName>
   <notes>
      <com.tutorialspoint.xstream.Note>
         <title>first</title>
         <description>My first assignment.</description>
      </com.tutorialspoint.xstream.Note>
      
      <com.tutorialspoint.xstream.Note>
         <title>second</title>
         <description>My Second assignment.</description>
     </com.tutorialspoint.xstream.Note>
   </notes>
</com.tutorialspoint.xstream.Student>

Im obigen Ergebnis ist der Name des Schülerobjekts vollständig qualifiziert. Folgen Sie dem nächsten Abschnitt, um es als Student-Tag zu ersetzen.

• Klassen-Aliasing

• Feld-Aliasing

• Implizites Sammlungs-Aliasing

• Attribut-Aliasing

• Paket-Aliasing

XStream unterstützt Anmerkungen ähnlich wie die automatische Konfiguration anstelle der Codierung. Im vorherigen Kapitel haben wir die folgenden Konfigurationen im Code gesehen.

xstream.alias("student", Student.class);
xstream.alias("note", Note.class);

xstream.useAttributeFor(Student.class, "studentName");
xstream.aliasField("name", Student.class, "studentName");
xstream.addImplicitCollection(Student.class, "notes");

Das folgende Codefragment veranschaulicht die Verwendung von Anmerkungen, um dieselbe Arbeit auf viel einfachere Weise auszuführen.

@XStreamAlias("student")   //define class level alias
class Student {

   @XStreamAlias("name")   //define field level alias
   @XStreamAsAttribute     //define field as attribute
   private String studentName;
   
   @XStreamImplicit        //define list as an implicit collection
   private List<Note> notes = new ArrayList<Note>();
   
   @XStreamOmitField       //omit a field to not to be a part of XML
   private int type;
}

Lassen Sie uns die obige Anmerkung mit XStream testen.

Erstellen Sie eine Java-Klassendatei mit dem Namen XStreamTester in C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

Datei: XStreamTester.java

package com.tutorialspoint.xstream;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

import java.util.ArrayList;
import java.util.List;

import javax.xml.transform.OutputKeys;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.stream.StreamResult;

import org.xml.sax.InputSource;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.annotations.XStreamAsAttribute;
import com.thoughtworks.xstream.annotations.XStreamImplicit;
import com.thoughtworks.xstream.annotations.XStreamOmitField;
import com.thoughtworks.xstream.io.xml.StaxDriver;

public class XStreamTester {

   public static void main(String args[]) {

      XStreamTester tester = new XStreamTester();
      XStream xstream = new XStream(new StaxDriver());
      Student student = tester.getStudentDetails();
      
      xstream.processAnnotations(Student.class);		

      //Object to XML Conversion
      String xml = xstream.toXML(student);
      System.out.println(formatXml(xml));		
   }
   
   private Student getStudentDetails() {
   
      Student student = new Student("Mahesh");
      
      student.addNote(new Note("first","My first assignment."));
      student.addNote(new Note("second","My Second assignment."));
      student.setType(1);
      
      return student;
   }

   public static String formatXml(String xml) {
   
      try {
         Transformer serializer = SAXTransformerFactory.newInstance().newTransformer();
         
         serializer.setOutputProperty(OutputKeys.INDENT, "yes");
         serializer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
         
         Source xmlSource = new SAXSource(new InputSource(
            new ByteArrayInputStream(xml.getBytes())));
         StreamResult res = new StreamResult(new ByteArrayOutputStream());            
         
         serializer.transform(xmlSource, res);
         
         return new String(((ByteArrayOutputStream)res.getOutputStream()).toByteArray());
         
      } catch(Exception e) {
         return xml;
      }
   }
}

@XStreamAlias("student")
class Student {

   @XStreamAlias("name")
   @XStreamAsAttribute   
   private String studentName;

   @XStreamImplicit
   private List<Note> notes = new ArrayList<Note>();

   public Student(String name) {
      this.studentName = name;
   }

   public void addNote(Note note) {
      notes.add(note);
   }

   public String getName() {
      return studentName;
   }

   public List<Note> getNotes() {
      return notes;
   }
   
   @XStreamOmitField		
   private int type;

   public int getType() {
      return type;
   }

   public void setType(int type) {
      this.type = type;
   }
}

@XStreamAlias("note")
class Note {
   private String title;
   private String description;

   public Note(String title, String description) {
      this.title = title;
      this.description = description;
   }

   public String getTitle() {
      return title;
   }

   public String getDescription() {
      return description;
   }     
}

Überprüfen Sie das Ergebnis

Kompilieren Sie die Klassen mit javac Compiler wie folgt -

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>javac XStreamTester.java

Führen Sie nun den XStreamTester aus, um das Ergebnis anzuzeigen -

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>java XStreamTester

Überprüfen Sie die Ausgabe wie folgt:

<?xml version = "1.0" encoding = "UTF-8"?>
<student name = "Mahesh">
   <note>
      <title>first</title>
      <description>My first assignment.</description>
   </note>

   <note>
      <title>second</title>
      <description>My Second assignment.</description>
   </note>
</student>

Um das XStream-Framework anzuweisen, Anmerkungen zu verarbeiten, müssen Sie den folgenden Befehl hinzufügen, bevor Sie XML serialisieren.

xstream.processAnnotations(Student.class);

Oder

xstream.autodetectAnnotations(true);

XStream-Konverter sind die Schlüsselkomponenten der XStream-Bibliothek, die für die Konvertierung eines Objekts in XML verantwortlich sind und umgekehrt. XStream bietet zahlreiche Konverter für gängige Typen wie Grundelemente, Zeichenfolgen, Dateien, Sammlungen, Arrays und Datumsangaben.

Konverter verwenden

Verwenden wir einen SingleValueConvertor, dessen Zweck darin besteht, ein Objekt in eine einzelne Zeichenfolge zu konvertieren. Wir werden SingleValueConvertor verwenden, um ein Objekt als Attributzeichenfolge zu schreiben.

Erstellen Sie einen Konverter

class NameConverter implements SingleValueConverter {

   public Object fromString(String name) {
      String[] nameparts = name.split(",");
      return new Name(nameparts[0], nameparts[1]);
   }
   
   public String toString(Object name) {
      return ((Name)name).getFirstName() + "," + ((Name)name).getLastName();
   }
   
   public boolean canConvert(Class type) {
      return type.equals(Name.class);
   }	
}

Registrieren Sie einen Konverter

xstream.registerConverter(new NameConverter());

Beispiel ohne Konverter

Testen wir zunächst den Code ohne Konverter in XStream.

Erstellen Sie eine Java-Klassendatei mit dem Namen XStreamTester in C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

File: XStreamTester.java

package com.tutorialspoint.xstream;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

import javax.xml.transform.OutputKeys;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.stream.StreamResult;

import org.xml.sax.InputSource;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.annotations.XStreamAsAttribute;
import com.thoughtworks.xstream.io.xml.StaxDriver;

public class XStreamTester {
   public static void main(String args[]) {
   
      XStreamTester tester = new XStreamTester();
      XStream xstream = new XStream(new StaxDriver());
      Student student = tester.getStudentDetails();
      xstream.autodetectAnnotations(true);
      
      //Object to XML Conversion
      String xml = xstream.toXML(student);
      System.out.println(formatXml(xml));
   }
   
   private Student getStudentDetails() {
      Student student = new Student("Mahesh","Parashar");
      return student;
   }
   
   public static String formatXml(String xml) {
   
      try {
      
         Transformer serializer = SAXTransformerFactory.newInstance().newTransformer();
         
         serializer.setOutputProperty(OutputKeys.INDENT, "yes");
         serializer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
         
         Source xmlSource = new SAXSource(new InputSource(
            new ByteArrayInputStream(xml.getBytes())));
         StreamResult res =  new StreamResult(new ByteArrayOutputStream());
         
         serializer.transform(xmlSource, res);
         
         return new String(((ByteArrayOutputStream)res.getOutputStream()).toByteArray());
         
      } catch(Exception e) {
         return xml;
      }
   }
}

@XStreamAlias("student")
class Student {

   @XStreamAlias("name")
   @XStreamAsAttribute
   private Name studentName;

   public Student(String firstName, String lastName) {
      this.studentName = new Name(firstName, lastName);
   }

   public Name getName() {
      return studentName;
   }	
}

class Name {
   private String firstName;
   private String lastName;

   public Name(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
   }

   public String getFirstName() {
      return firstName;
   }

   public String getLastName() {
      return lastName;
   }     
}

Verify the Result

Kompilieren Sie die Klassen mit javac Compiler wie folgt -

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>javac XStreamTester.java

Führen Sie nun den XStreamTester aus, um das Ergebnis anzuzeigen -

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>java XStreamTester

Überprüfen Sie die Ausgabe wie folgt:

<?xml version = "1.0" encoding = "UTF-8"?>
<student>
   <name>
      <firstName>Mahesh</firstName>
      <lastName>Parashar</lastName>
   </name>
</student>

Beispiel mit Konverter

Testen wir nun den Code mit dem Konverter in XStream.

Erstellen Sie eine Java-Klassendatei mit dem Namen XStreamTester in C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

File: XStreamTester.java

package com.tutorialspoint.xstream;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

import javax.xml.transform.OutputKeys;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.stream.StreamResult;

import org.xml.sax.InputSource;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.annotations.XStreamAsAttribute;
import com.thoughtworks.xstream.converters.SingleValueConverter;
import com.thoughtworks.xstream.io.xml.StaxDriver;

public class XStreamTester {

   public static void main(String args[]) {
   
      XStreamTester tester = new XStreamTester();
      XStream xstream = new XStream(new StaxDriver());
      Student student = tester.getStudentDetails();		
      
      xstream.autodetectAnnotations(true);
      xstream.registerConverter(new NameConverter());
      
      //Object to XML Conversion
      String xml = xstream.toXML(student);
      System.out.println(formatXml(xml));		
   }	

   private Student getStudentDetails() {
      Student student = new Student("Mahesh","Parashar");		
      return student;
   }

   public static String formatXml(String xml) {

      try {
      
         Transformer serializer = SAXTransformerFactory.newInstance().newTransformer();
         
         serializer.setOutputProperty(OutputKeys.INDENT, "yes");         
         serializer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
         
         Source xmlSource = new SAXSource(new InputSource(
            new ByteArrayInputStream(xml.getBytes())));
         StreamResult res = new StreamResult(new ByteArrayOutputStream());            
         
         serializer.transform(xmlSource, res);
         
         return new String(((ByteArrayOutputStream)res.getOutputStream()).toByteArray());
         
      } catch(Exception e) {   
         return xml;
      }
   }
}

@XStreamAlias("student")
class Student {

   @XStreamAlias("name")
   @XStreamAsAttribute	
   private Name studentName;

   public Student(String firstName, String lastName) {
      this.studentName = new Name(firstName, lastName);
   }

   public Name getName() {
      return studentName;
   }	
}

class Name {
   private String firstName;
   private String lastName;

   public Name(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
   }

   public String getFirstName() {
      return firstName;
   }

   public String getLastName() {
      return lastName;
   }     
}

class NameConverter implements SingleValueConverter  {

   public Object fromString(String name) {
      String[] nameparts = name.split(",");
      return new Name(nameparts[0], nameparts[1]);
   }

   public String toString(Object name) {
      return ((Name)name).getFirstName() + "," + ((Name)name).getLastName();
   }

   public boolean canConvert(Class type) {
      return type.equals(Name.class);
   }
}

Verify the Result

Kompilieren Sie die Klassen mit javac Compiler wie folgt -

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>javac XStreamTester.java

Führen Sie nun den XStreamTester aus, um das Ergebnis anzuzeigen -

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>java XStreamTester

Überprüfen Sie die Ausgabe wie folgt:

<?xml version = "1.0" encoding = "UTF-8"?>
<student name = "Mahesh,Parashar"/>

Benutzerdefinierter Konverter

XStream bietet alternative Implementierungen von java.io.ObjectInputStream und java.io.ObjectOutputStream, sodass Streams von Objekten aus XML serialisiert oder deserialisiert werden können. Dies ist besonders nützlich, wenn große Mengen von Objekten verarbeitet werden sollen, wobei jeweils ein Objekt im Speicher bleibt.

Syntax: createObjectOutputStream ()

ObjectOutputStream objectOutputStream = xstream.createObjectOutputStream(
   new FileOutputStream("test.txt"));

Syntax: createObjectInputStream ()

ObjectInputStream objectInputStream = xstream.createObjectInputStream(
   new FileInputStream("test.txt"));

Testen wir nun den Code mit Objektströmen in XStream.

Erstellen Sie eine Java-Klassendatei mit dem Namen XStreamTester in C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

Datei: XStreamTester.java

package com.tutorialspoint.xstream;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.io.xml.StaxDriver;

public class XStreamTester {
   public static void main(String args[]) {
   
      XStreamTester tester = new XStreamTester();
      XStream xstream = new XStream(new StaxDriver());
      
      xstream.autodetectAnnotations(true);
      
      Student student1 = new Student("Mahesh","Parashar");
      Student student2 = new Student("Suresh","Kalra");
      Student student3 = new Student("Ramesh","Kumar");
      Student student4 = new Student("Naresh","Sharma");
      
      try {
      
         ObjectOutputStream objectOutputStream = xstream.createObjectOutputStream(
            new FileOutputStream("test.txt"));
         
         objectOutputStream.writeObject(student1);
         objectOutputStream.writeObject(student2);
         objectOutputStream.writeObject(student3);
         objectOutputStream.writeObject(student4);
         objectOutputStream.writeObject("Hello World");
         
         objectOutputStream.close();
         
         ObjectInputStream objectInputStream = xstream.createObjectInputStream(
            new FileInputStream("test.txt"));
         
         Student student5 = (Student)objectInputStream.readObject();
         Student student6 = (Student)objectInputStream.readObject();
         Student student7 = (Student)objectInputStream.readObject();
         Student student8 = (Student)objectInputStream.readObject();
         
         String text = (String)objectInputStream.readObject();
         
         System.out.println(student5);
         System.out.println(student6);
         System.out.println(student7);
         System.out.println(student8);
         System.out.println(text);
      
      } catch (IOException e) {
         e.printStackTrace();
         
      } catch (ClassNotFoundException e) {
         e.printStackTrace();
      }
   }
}

@XStreamAlias("student")
class Student {

   private String firstName;
   private String lastName;
   
   public Student(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
   }

   public String getFirstName() {
      return firstName;
   }

   public String getLastName() {
      return lastName;
   }   

   public String toString() {
      return "Student [ firstName: "+firstName+", lastName: "+ lastName+ " ]";
   }	
}

Überprüfen Sie das Ergebnis

Kompilieren Sie die Klassen mit javac Compiler wie folgt -

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>javac XStreamTester.java

Führen Sie nun den XStreamTester aus, um das Ergebnis anzuzeigen -

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>java XStreamTester

Überprüfen Sie die Ausgabe wie folgt:

Student [ firstName: Mahesh, lastName: Parashar ]
Student [ firstName: Suresh, lastName: Kalra ]
Student [ firstName: Ramesh, lastName: Kumar ]
Student [ firstName: Naresh, lastName: Sharma ]
Hello World

Sehen Sie sich den Inhalt der Datei test.txt an, die sich im Ordner C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream befindet.

<?xml version = "1.0" ?>
<object-stream>
   <student>
      <firstName>Mahesh</firstName>
      <lastName>Parashar</lastName>
   </student>
   
   <student>
      <firstName>Suresh</firstName>
      <lastName>Kalra</lastName>
   </student>
   
   <student>
      <firstName>Ramesh</firstName>
      <lastName>Kumar</lastName>
   </student>
   
   <student>
      <firstName>Naresh</firstName>
      <lastName>Sharma</lastName>
   </student>
   <string>Hello World</string>
</object-stream>

XStream unterstützt JSON, indem das XStream-Objekt mit einem geeigneten Treiber initialisiert wird. XStream unterstützt derzeit JettisonMappedXmlDriver und JsonHierarchicalStreamDriver.

Lassen Sie uns nun den Code mit JSON-Behandlung in XStream testen.

Erstellen Sie eine Java-Klassendatei mit dem Namen XStreamTester in C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

Datei: XStreamTester.java

package com.tutorialspoint.xstream;

import java.io.Writer;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
import com.thoughtworks.xstream.io.json.JsonHierarchicalStreamDriver;
import com.thoughtworks.xstream.io.json.JsonWriter;

public class XStreamTester {

   public static void main(String args[]) {

      XStreamTester tester = new XStreamTester();
      XStream xstream = new XStream(new JsonHierarchicalStreamDriver() {
      
         public HierarchicalStreamWriter createWriter(Writer writer) {
            return new JsonWriter(writer, JsonWriter.DROP_ROOT_MODE);
         }
      });

      Student student = new Student("Mahesh","Parashar");

      xstream.setMode(XStream.NO_REFERENCES);
      xstream.alias("student", Student.class);
      
      System.out.println(xstream.toXML(student));
   }
}

@XStreamAlias("student")
class Student {

   private String firstName;
   private String lastName;

   public Student(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
   }

   public String getFirstName() {
      return firstName;
   }

   public String getLastName() {
      return lastName;
   }   
	
   public String toString() {
      return "Student [ firstName: "+firstName+", lastName: "+ lastName+ " ]";
   }	
}

Überprüfen Sie das Ergebnis

Kompilieren Sie die Klassen mit javac Compiler wie folgt -

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>javac XStreamTester.java

Führen Sie nun den XStreamTester aus, um das Ergebnis anzuzeigen -

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>java XStreamTester

Überprüfen Sie die Ausgabe wie folgt:

{
   "firstName": "Mahesh",
   "lastName": "Parashar"
}