XStream-퀵 가이드

XStream은 Java 객체를 XML로 또는 그 반대로 직렬화하는 간단한 Java 기반 라이브러리입니다.

풍모

• Easy to use − XStream API는 일반적인 사용 사례를 단순화하기 위해 높은 수준의 파사드를 제공합니다.

• No need to create mapping − XStream API는 직렬화 할 대부분의 객체에 대한 기본 매핑을 제공합니다.

• Performance − XStream은 빠르고 메모리 사용량이 적어 대형 개체 그래프 또는 시스템에 적합합니다.

• Clean XML − XStream은 읽기 쉬운 깔끔하고 간결한 XML 출력을 생성합니다.

• Object modification not required− XStream은 private 및 final 필드와 같은 내부 필드를 직렬화하고 non-public 및 inner 클래스를 지원합니다. 기본 생성자는 필수 요구 사항이 아닙니다.

• Full object graph support − XStream은 객체 모델에서 발생하는 중복 참조를 유지하고 순환 참조도 지원합니다.

• Customizable conversion strategies − 사용자 지정 전략을 등록하여 특정 유형의 사용자 지정을 XML로 표시 할 수 있습니다.

• Security framework − XStream은 마샬링되지 않은 유형에 대한 공정한 제어를 제공하여 조작 된 입력으로 인한 보안 문제를 방지합니다.

• Error messages − 잘못된 XML로 인한 예외 발생시 상세한 진단을 제공하여 문제를 해결합니다.

• Alternative output format − XStream은 JSON 및 모핑과 같은 다른 출력 형식을 지원합니다.

일반적인 용도

• Transport − XML은 객체의 텍스트 표현이며 사용되는 직렬화 / 역 직렬화 기술과 관계없이 유선을 통해 객체를 전송하는 데 사용할 수 있습니다.

• Persistence − 객체는 데이터베이스에서 XML로 유지 될 수 있으며 필요할 때 마샬링 / 마샬링 해제 될 수 있습니다.

• Configuration− XML은 자명하며 구성을 정의하는 데 많이 사용됩니다. 객체를 XML 표현으로 변환 한 후 구성 목적으로 사용할 수도 있습니다.

• Unit Tests − XStream API는 JUnit과 호환되며 애플리케이션 모듈의 단위 테스트를 향상시키는 데 사용할 수 있습니다.

이 장에서는 Java에 적합한 환경을 설정하는 다양한 측면에 대해 설명합니다.

지역 환경 설정

Java 프로그래밍 언어에 대한 환경을 설정하려는 경우이 섹션에서는 시스템에서 Java를 다운로드하고 설정하는 방법에 대해 설명합니다. Java 환경을 설정하려면 아래 단계를 따르십시오.

Java SE는 링크에서 무료로 다운로드 할 수 있습니다.

Java를 다운로드하십시오 .

지침에 따라 Java를 다운로드하고 .exe컴퓨터에 Java를 설치합니다. 시스템에 Java를 설치 한 후에는 올바른 설치 디렉토리를 가리 키도록 환경 변수를 설정해야합니다.

Windows 2000 / XP 용 경로 설정

c : \ Program Files \ java \ jdk 디렉토리에 Java를 설치했다고 가정합니다 .

• '내 컴퓨터'를 마우스 오른쪽 버튼으로 클릭하고 '속성'을 선택합니다.

• '고급'탭에서 '환경 변수'버튼을 클릭합니다.

• Java 실행 파일의 경로도 포함하도록 'Path'변수를 변경하십시오. 예를 들어 현재 경로가 'C : \ WINDOWS \ SYSTEM32'로 설정되어 있으면 경로를 'C : \ WINDOWS \ SYSTEM32; c : \ Program Files \ java \ jdk \ bin'으로 변경하십시오.

Windows 95 / 98 / ME 용 경로 설정

c : \ Program Files \ java \ jdk 디렉토리에 Java를 설치했다고 가정합니다 .

• 'C : \ autoexec.bat'파일을 편집하고 끝에 다음 줄을 추가합니다.

  '경로 설정 = % PATH %; C : \ Program Files \ java \ jdk \ bin'

Linux, UNIX, Solaris, FreeBSD에 대한 경로 설정

환경 변수 PATH는 Java 바이너리가 설치된 위치를 가리 키도록 설정되어야합니다. 이 작업을 수행하는 데 문제가있는 경우 쉘 문서를 참조하십시오.

예를 들어 bash 를 셸로 사용하는 경우 '.bashrc : export PATH = / path / to / java : $ PATH'끝에 다음 줄을 추가합니다.

인기있는 Java 편집자

Java 프로그램을 작성하려면 텍스트 편집기가 필요합니다. 시장에는 훨씬 더 정교한 IDE가 있습니다. 그러나 지금은 다음 중 하나를 고려할 수 있습니다.

• Notepad − Windows에서는 메모장 (이 자습서에 권장 됨) 또는 TextPad와 같은 간단한 텍스트 편집기를 사용할 수 있습니다.

• Netbeans − 무료이며 다음에서 다운로드 할 수있는 Java IDE입니다. https://www.netbeans.org/index.html.

• Eclipse − 또한 Eclipse 오픈 소스 커뮤니티에서 개발 한 Java IDE이며 다음에서 다운로드 할 수 있습니다. https://www.eclipse.org/.

XStream 아카이브 다운로드

xstream-1.4.7.jar에서 최신 버전의 XStream jar 파일을 다운로드합니다. 이 튜토리얼을 작성하는 시점에 xstream-1.4.7.jar를 다운로드 하여 C : \> XStream 폴더에 복사했습니다.

OS	아카이브 이름
윈도우	xstream-1.4.7.jar
리눅스	xstream-1.4.7.jar
맥	xstream-1.4.7.jar

XStream 환경 설정

설정 XStream_HOMExstream jar가 시스템에 저장된 기본 디렉토리 위치를 가리키는 환경 변수. 다음 표는 XStream 폴더에서 xstream-1.4.7.jar을 추출했다고 가정하고 Windows, Linux 및 Mac에서 XStream 환경을 설정하는 방법을 보여줍니다.

Sr. 아니.	OS 및 설명
1	Windows 환경 변수 XStream_HOME을 C : \ XStream으로 설정합니다.
2	Linux 내보내기 XStream_HOME = / usr / local / XStream
삼	Mac 내보내기 XStream_HOME = / Library / XStream

CLASSPATH 변수 설정

설정 CLASSPATHXStream jar 위치를 가리키는 환경 변수. 다음 표는 XStream 폴더에 xstream-1.4.7.jar을 저장했다고 가정하고 Windows, Linux 및 Mac 시스템에서 CLASSPATH 변수를 설정하는 방법을 보여줍니다.

Sr. 아니.	OS 및 설명
1	Windows 환경 변수 CLASSPATH를 % CLASSPATH %; % XStream_HOME % \ xstream-1.4.7.jar로 설정합니다.
2	Linux export CLASSPATH = $ CLASSPATH : $ XStream_HOME / xstream-1.4.7.jar;
삼	Mac export CLASSPATH = $ CLASSPATH : $ XStream_HOME / xstream-1.4.7.jar;

XStream 라이브러리에 대해 자세히 알아보기 전에 애플리케이션이 작동하는지 살펴 보겠습니다. 이 예에서는 Student 및 Address 클래스를 만들었습니다. 학생 객체를 만든 다음 XML 문자열로 직렬화합니다. 그런 다음 동일한 XML 문자열을 역 직렬화하여 학생 객체를 다시 가져옵니다.

C : \> XStream_WORKSPACE에 XStreamTester라는 Java 클래스 파일을 만듭니다.

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

다음을 사용하여 클래스 컴파일 javac 다음과 같이 컴파일러-

C:\XStream_WORKSPACE>javac XStreamTester.java

이제 XStreamTester를 실행하여 결과를 확인하십시오.

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
   ] 
]

기억해야 할 단계

다음은 여기서 고려해야 할 중요한 단계입니다.

1 단계 : XStream 객체 생성

StaxDriver를 전달하여 XStream 개체를 만듭니다. StaxDriver는 Stax 풀 파서 (Java 6에서 사용 가능)를 사용하며 빠른 xml 파서입니다.

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

2 단계 : 개체를 XML로 직렬화

toXML () 메서드를 사용하여 객체의 XML 문자열 표현을 가져옵니다.

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

3 단계 : XML 역 직렬화를 통해 개체 가져 오기

fromXML () 메서드를 사용하여 XML에서 객체를 가져옵니다.

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

앨리어싱은 생성 된 XML을 사용자 지정하거나 XStream을 사용하여 특정 형식의 XML을 사용하는 기술입니다. 다음 XML 형식을 사용하여 Student 개체를 직렬화 / 역 직렬화한다고 가정 해 보겠습니다.

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

위의 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;
   }     
}

XStream을 사용하여 위의 객체 직렬화를 테스트 해 보겠습니다.

C : \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream에 XStreamTester라는 Java 클래스 파일을 만듭니다.

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

다음을 사용하여 클래스 컴파일 javac 다음과 같이 컴파일러-

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

이제 XStreamTester를 실행하여 결과를 확인하십시오.

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

다음과 같이 출력을 확인하십시오-

<?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>

위의 결과에서 Student 개체 이름은 정규화되었습니다. 학생 태그로 바꾸려면 다음 섹션을 따르십시오.

• 클래스 별칭

• 필드 앨리어싱

• 암시 적 컬렉션 별칭

• 속성 별칭

• 패키지 별칭

XStream은 코딩 대신 자동 구성과 유사하게 주석을 지원합니다. 이전 장에서 우리는 코드에서 다음 구성을 보았습니다.

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

다음 코드 스 니펫은 주석을 사용하여 훨씬 더 쉽게 동일한 작업을 수행하는 방법을 보여줍니다.

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

XStream을 사용하여 위의 주석을 테스트 해 보겠습니다.

C : \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream에 XStreamTester라는 Java 클래스 파일을 만듭니다.

파일 : 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;
   }     
}

결과 확인

다음을 사용하여 클래스 컴파일 javac 다음과 같이 컴파일러-

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

이제 XStreamTester를 실행하여 결과를 확인하십시오.

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

다음과 같이 출력을 확인하십시오-

<?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>

XStream 프레임 워크에 주석을 처리하도록 지시하려면 xml을 직렬화하기 전에 다음 명령을 추가해야합니다.

xstream.processAnnotations(Student.class);

또는

xstream.autodetectAnnotations(true);

XStream 변환기는 객체를 XML로 또는 그 반대로 변환하는 역할을하는 XStream 라이브러리의 핵심 구성 요소입니다. XStream은 기본 형식, 문자열, 파일, 컬렉션, 배열 및 날짜와 같은 일반적인 유형에 대한 다양한 변환기를 제공합니다.

변환기 사용

객체를 단일 문자열로 변환하는 용도의 SingleValueConvertor를 사용하겠습니다. SingleValueConvertor를 사용하여 객체를 속성 문자열로 작성합니다.

변환기 만들기

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

변환기 등록

xstream.registerConverter(new NameConverter());

변환기가없는 예

먼저 XStream에서 변환기없이 코드를 테스트 해 보겠습니다.

C : \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream에 XStreamTester라는 Java 클래스 파일을 만듭니다.

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

다음을 사용하여 클래스 컴파일 javac 다음과 같이 컴파일러-

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

이제 XStreamTester를 실행하여 결과를 확인하십시오.

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

다음과 같이 출력을 확인하십시오-

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

변환기를 사용한 예

이제 XStream에서 변환기로 코드를 테스트 해 보겠습니다.

C : \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream에 XStreamTester라는 Java 클래스 파일을 만듭니다.

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

다음을 사용하여 클래스 컴파일 javac 다음과 같이 컴파일러-

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

이제 XStreamTester를 실행하여 결과를 확인하십시오.

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

다음과 같이 출력을 확인하십시오-

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

맞춤형 변환기

XStream은 객체 스트림을 XML에서 직렬화하거나 역 직렬화 할 수 있도록 java.io.ObjectInputStream 및 java.io.ObjectOutputStream의 대체 구현을 제공합니다. 이것은 한 번에 하나의 객체를 메모리에 유지하면서 대량의 객체 세트를 처리 할 때 특히 유용합니다.

구문 : createObjectOutputStream ()

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

구문 : createObjectInputStream ()

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

이제 XStream에서 객체 스트림으로 코드를 테스트 해 보겠습니다.

C : \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream에 XStreamTester라는 Java 클래스 파일을 만듭니다.

파일 : 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+ " ]";
   }	
}

결과 확인

다음을 사용하여 클래스 컴파일 javac 다음과 같이 컴파일러-

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

이제 XStreamTester를 실행하여 결과를 확인하십시오.

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

다음과 같이 출력을 확인하십시오-

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

C : \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream 폴더에있는 test.txt의 내용을보십시오.

<?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은 적절한 드라이버로 XStream 객체를 초기화하여 JSON을 지원합니다. XStream은 현재 JettisonMappedXmlDriver 및 JsonHierarchicalStreamDriver를 지원합니다.

이제 XStream에서 json 처리로 코드를 테스트 해 보겠습니다.

C : \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream에 XStreamTester라는 Java 클래스 파일을 만듭니다.

파일 : 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+ " ]";
   }	
}

결과 확인

다음을 사용하여 클래스 컴파일 javac 다음과 같이 컴파일러-

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

이제 XStreamTester를 실행하여 결과를 확인하십시오.

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

다음과 같이 출력을 확인하십시오-

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