Simple이란?

Simple은 XML의 직렬화 및 역직렬화 프로세스를 단순화하는 데 사용되는 Java 프레임워크이다. 이름에서 알 수 있듯이 Simple을 사용하는 개발자는 POJO(plain old Java object)를 XML 문서로 변환하는 직렬화 프로세스를 단순화할 수 있다. Simple은 그 반대의 기능도 제공한다. 즉, XML 문서를 POJO로 변환할 수 있으며 이 프로세스를 역직렬화라고 한다.

Simple은 그 이름에 걸맞게 어노테이션을 사용하여 직렬화 또는 역직렬화 프로세스를 수행한다. POJO는 해당 XML 문서의 표시 방법에 따라 어노테이트된다. 일부 필드는 속성으로 어노테이트되고 다른 필드는 요소로 어노테이트된다. 클래스는 일반적으로 루트 요소로 어노테이트된다. 직렬화 프로세스 동안 어노테이션을 해석하고 해당 XML 문서를 생성하는 지루한 프로세스는 프레임워크에 의해 자동으로 처리된다. 또한 어노테이션은 XML 문서가 POJO로 변환되는 역직렬화 프로세스 동안에도 해석된다.

Simple을 사용하면 여러 가지 장점을 얻을 수 있다. 첫 번째 장점은 애플리케이션을 빠르게 개발할 수 있다는 것이다. Simple은 매우 단순하므로 과도한 학습 곡선 또는 개발 오버헤드 없이도 XML 직렬화 및 역직렬화를 사용하는 강력한 애플리케이션을 빠르게 구현할 수 있다.

Simple의 다음 장점은 구성이 필요하지 않다는 것이다. 앞에서 언급한 대로 Simple은 어노테이션을 사용한다. 이러한 어노테이션은 일반적으로 이러한 특성을 가진 프레임워크에 사용되는 XML 기반 구성 파일 대신 사용된다.

마지막으로 Simple을 사용하는 애플리케이션의 풋프린트에 최소한의 공간만 추가된다는 장점이 있다. 즉, 239KB에 불과한 JAR(Java Archive) 파일만 추가된다. 또한 Simple은 다른 프레임워크와 마찬가지로 다른 JAR 파일을 사용하지 않는다.

Simple 다운로드하기

Simple을 사용하려면 먼저 참고자료에 나열되어 있는 Simple 웹 사이트로 이동하여 아카이브를 다운로드해야 한다. 하지만 이 프로세스와 관련하여 좋은 소식과 나쁜 소식이 있다. 좋은 소식은 아카이브라 무료라는 것이고 나쁜 소식은 아카이브가 .tar.gz 형식이라는 것이다. 따라서 Microsoft® Windows® 기본 아카이브 추출기로는 이 아카이브를 열 수가 없기 때문에 WinZip 또는 유사한 아카이브 유틸리티가 필요하다.

파일을 추출한 후 jar 디렉토리를 보면 하나의 JAR 파일(simple-xml-2.1.4.jar)이 있다. 이 파일은 컴파일 시간 및 런타임에 클래스 경로에 있어야 하는 JAR 파일이다.

직렬화하기

오브젝트를 XML 문서로 직렬화하는 작업은 매우 간단하다. 다음 두 단계만 수행하면 된다.

1. 적절한 어노테이션을 사용하여 POJO를 작성한다.
2. 직렬화 프로세스를 실제로 수행하는 몇 줄의 코드를 작성한다.

이 기사에서는 필자의 기사에서 자주 사용되는 테마인 루어를 다시 한번 테마로 사용할 것이며 Listing 1이 바로 루어에 대한 정보를 나타내는 POJO이다.

@Root
public class Lure {

     @Attribute
     private String type;
	
     @Element
     private String company;
	
     @Element
     private int quantityInStock;
	
     @Element
     private String model;

     public String getType() {
		return type;
     }

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

     public String getCompany() {
          return company;
     }

     public void setCompany(String company) {
          this.company = company;
     }

     public int getQuantityInStock() {
          return quantityInStock;
     }

     public void setQuantityInStock(int quantityInStock) {
          this.quantityInStock = quantityInStock;
     }

     public String getModel() {
          return model;
     }

     public void setModel(String model) {
          this.model = model;
     }
}

이 POJO에는 복잡한 내용이 하나도 없다. 처음 봤을 때 어노테이션 부분이 익숙하지 않을 수도 있겠지만 이 또한 의도적인 것이다. Simple 프레임워크가 그 이름에 걸맞다고 한 필자의 말을 떠올려 보라.

@Root 어노테이션은 XML 문서의 루트 요소를 설명한다. 모든 XML 문서에는 루트 요소가 필요하므로 이 어노테이션을 반드시 포함시켜야 한다.

type 필드 위의 @Attribute 어노테이션은 해당 필드를 속성으로 식별한다. 이 속성은 루트 요소에 속성으로 추가된다.

마지막으로 남아 있는 @Element 어노테이션은 company, quantityInStock 및 model이라는 세 필드의 바로 위에 사용된다. 이러한 필드는 XML 문서 내의 요소를 나타낸다.

POJO의 나머지 부분은 JavaBean 표준에 따라 접근자와 변경자로 구성되어 있다.

이제 POJO가 완료되었으므로 직렬화 코드를 작성할 차례이다. Listing 2에서 이 직렬화 코드를 볼 수 있다.

public static void main(String[] args) {
     try {
          Serializer serializer = new Persister();
          Lure lure = new Lure();
          lure.setCompany("Donzai");
          lure.setModel("Marlin Buster");
          lure.setQuantityInStock(23);
          lure.setType("Trolling");
		
          File result = new File("lure.xml");
          serializer.write(lure, result);
     } catch (Exception e) {
          e.printStackTrace();
     }
}

이 코드에서는 가장 먼저 Persister 오브젝트를 인스턴스화한다. 이 클래스는 Simple 프레임워크의 일부이고 Serializer 인터페이스를 구현한다.

그런 다음 Lure 오브젝트를 인스턴스화하고 필드를 적절히 설정한다. 여기에서는 루어를 제조하는 회사의 이름이 Donzai이고 모델 이름이 Marlin Buster이다. 재고량은 23개이다. 마지막으로 루어의 유형은 Trolling이다.

그런 다음 XML 문서가 될 파일의 이름을 사용하여 File 오브젝트를 인스턴스화한다. 이 경우에는 파일 이름이 lure.xml이다.

마지막으로 직렬 변환기를 호출하여 파일을 작성한다. write() 메소드에 두 개의 매개변수가 제공된다. 첫 번째 매개변수는 POJO이고 두 번째 매개변수는 File 오브젝트이다.

이제 이 코드를 실행할 수 있다. Listing 2는 Java 애플리케이션이므로 자주 사용하는 IDE(Integrated Development Environment)를 사용하여 코드를 실행할 수 있다. simple-xml-2.1.4.jar이 클래스 경로에 있는지 확인한다. Eclipse를 사용하는 경우에는 파일을 마우스 오른쪽 단추로 클릭하고 Run As를 선택한 다음 표시되는 메뉴에서 Java Application을 선택하면 된다.

애플리케이션이 정상적으로 작동했다면 Listing 3과 같은 결과 XML 문서가 생성되어야 한다. (당연히 정상적으로 작동되어야 하며 정말 간단한 작업이다.)

<lure type="Trolling">
   <company>Donzai</company>
   <quantityInStock>23</quantityInStock>
   <model>Marlin Buster</model>
</lure>

Listing 3에서는 두 가지 사항에 주목해야 한다. 첫 번째는 루어 유형이 루트 요소의 속성이라는 것이다. 이는 @Element가 아닌 @Attribute를 사용하여 POJO의 type 필드를 어노테이트했기 때문에 완벽하게 작동한다.

결과 XML과 관련하여 또 하나 중요한 점은 요소 이름이 JavaBean 표준을 따른다는 것이다. 예를 들어, 루트 요소는 lure이고 클래스 이름은 Lure이다. 세 개의 하위 요소 이름도 해당 필드 이름과 완벽하게 일치한다. 다시 한번 말해서, 이 방법을 사용하면 루트 요소 이름과 하위 요소 이름이 서로 다른 패턴을 따르지 않아도 되기 때문에 이는 매우 실용적인 방법이다.

역직렬화하기

오브젝트를 직렬화하는 작업이 매우 쉬웠던 것처럼 역직렬화하는 방법도 매우 쉽다.

역직렬화는 XML 문서를 POJO로 변환하는 프로세스이다. 한 가지 좋은 점은 조금 전에 작성한 XML 문서를 역직렬화 작업에 사용할 수 있다는 것이다.

Listing 4에서는 역직렬화 코드를 보여 준다.

public static void main(String[] args) {
     try {
          Serializer serializer = new Persister();
          File source = new File("lure.xml");
          Lure lure = serializer.read(Lure.class, source);

          System.out.println(lure.getCompany());
          System.out.println(lure.getModel());
          System.out.println(lure.getQuantityInStock());
          System.out.println(lure.getType());
     } catch (Exception e) {
          e.printStackTrace();
     }
}

먼저 Serializer 인터페이스를 구현하는 Persister 오브젝트를 인스턴스화한다.

File 오브젝트를 인스턴스화하는 행도 익숙해 보이겠지만 이 경우에는 명확한 차이가 있다. Listing 3에서는 존재하지 않는 파일에 대한 File 오브젝트를 인스턴스화했지만 여기에서는 파일이 존재하고 있는 것으로 가정하고 있다. (실제로도 파일이 있어야 한다.)

그런 다음 Serializer 오브젝트의 read 메소드를 호출하여 POJO를 인스턴스화한다. read 메소드는 두 개의 매개변수를 사용한다. 하는 POJO 클래스이고 다른 하나는 데이터가 포함된 XML 파일을 나타내는 File 오브젝트이다.

마지막으로 모든 정보가 올바르게 읽혔는지 확인하기 위해 POJO의 모든 정보를 출력한다.

이 코드를 실행하면 Listing 5와 같은 출력이 표시되어야 한다.

Donzai
Marlin Buster
23
Trolling

전체 트리 직렬화

지금까지 직렬화 및 역직렬화했던 XML 문서는 상당히 단순했다.

하지만 대부분의 XML 문서는 훨씬 더 복잡하다. 일반적으로 이러한 문서에는 중첩 요소뿐만 아니라 여러 개의 하위 요소를 가지고 있는 일대다 반복 요소가 여러 계층으로 포함되어 있다.

다행스럽게도 Simple은 그 이름에 걸맞게 복잡한 문서도 쉽게 처리할 수 있다. POJO 내에서 POJO를 중첩하는 것처럼 간단하게 처리할 수 있다. Listing 6을 살펴보자.

@Attribute
private String type;

@Element
private String company;
	
@Element
private int quantityInStock;
	
@Element
private String model;
	
@Element
private ConfigurationScheme configurationScheme;

Listing 6의 AdvancedLure 클래스는 Listing 1의 Lure 클래스와 매우 유사하다. 한 가지 차이점은 configurationScheme라는 또 하나의 필드가 포함되어 있다는 것이다. 구성 스키마는 Listing 7에서 설명하는 또 다른 POJO에 의해 표시된다.

@Root
public class ConfigurationScheme {
	
@Element
private String color;
	
@Element
private int size;

여기에서는 간단하게 설명하기 위해 접근자와 변경자를 생략했다.

Listing 7에서는 익숙한 어노테이션을 볼 수 있다. 이러한 어노테이션은 Listing 1에서 사용했던 것과 같은 어노테이션이다.

이제 Listing 8과 같은 결과를 얻을 수 있다.

public static void main(String[] args) {
     try {
          Serializer serializer = new Persister();
          AdvancedLure lure = new AdvancedLure();
          lure.setCompany("Donzai");
          lure.setModel("Marlin Buster");
          lure.setQuantityInStock(23);
          lure.setType("Trolling");
			
          ConfigurationScheme configurationScheme = new ConfigurationScheme();
          configurationScheme.setColor("Blue");
          configurationScheme.setSize(3);
          lure.setConfigurationScheme(configurationScheme);
			
          File result = new File("advancedlure.xml");
          serializer.write(lure, result);
     } catch (Exception e) {
          e.printStackTrace();
     }
}

Listing 2와 비교했을 때 Listing 8의 큰 차이점은 ConfigurationScheme 오브젝트를 인스턴스화한 다음 AdvancedLure 오브젝트의 해당 필드를 설정한다는 것이다.

이 코드를 실행하면 Listing 9와 같은 출력이 표시되어야 한다.

<advancedLure type="Trolling">
   <company>Donzai</company>
   <quantityInStock>23</quantityInStock>
   <model>Marlin Buster</model>
   <configurationScheme>
      <color>Blue</color>
      <size>3</size>
   </configurationScheme>
</advancedLure>

이 출력을 보면 중첩 요소가 예상대로 정확히 직렬화되었다는 것을 알 수 있다.

열거

XML 문서에는 특정 요소의 열거가 자주 사용된다. 즉, 동일한 요소 이름이 하위 또는 속성 데이터만 변경된 채로 반복해서 자주 사용된다. 다행히도 Simple은 이 상황을 잘 처리할 수 있다.

이 기능을 확인하기 위해 먼저 Inventory라는 새 클래스를 작성한다. 이 클래스에는 재고품이 보관되어 있는 창고의 이름과 해당 재고 창고에서 찾을 수 있는 루어의 목록이 있다(Listing 10 참조).

@Root
public class Inventory {
	
     @ElementList
     private List<AdvancedLure> lures;
	
     @Attribute
     private String warehouse;

이 Listing에서는 @ElementList라는 새 어노테이션을 사용하고 있다. 이 어노테이션은 해당 List 오브젝트가 XML 요소의 열거를 나타낸다는 의미를 지닌다.

이 POJO의 직렬화를 보여 주기 위해 사용된 코드는 더 간단한 POJO(예: Listing 2에서 직렬화했던 POJO)를 직렬화하는 데 사용했던 코드와 마찬가지로 쉽게 이해할 수 있다. Listing 11을 살펴보자.

Serializer serializer = new Persister();

AdvancedLure lure = new AdvancedLure();
lure.setCompany("Donzai");
lure.setModel("Marlin Buster");
lure.setQuantityInStock(23);
lure.setType("Trolling");
			
ConfigurationScheme configurationScheme = new ConfigurationScheme();
configurationScheme.setColor("Blue");
configurationScheme.setSize(3);
lure.setConfigurationScheme(configurationScheme);
			
			
AdvancedLure lure2 = new AdvancedLure();
lure2.setCompany("Ziggi");
lure2.setModel("Tuna Finder");
lure2.setQuantityInStock(44);
lure2.setType("Trolling");
		
ConfigurationScheme configurationScheme2 = new ConfigurationScheme();
configurationScheme2.setColor("Red");
configurationScheme2.setSize(5);
lure2.setConfigurationScheme(configurationScheme2);
			
List<AdvancedLure> lures = new ArrayList<AdvancedLure>();
lures.add(lure);
lures.add(lure2);
			
Inventory inventory = new Inventory();
inventory.setLures(lures);
inventory.setWarehouse("Midwest");
			
File result = new File("inventory.xml");

serializer.write(inventory, result);

이 코드를 실행하면 inventory.xml이라는 XML 파일이 작성된다. 이 파일의 내용은 Listing 12와 같다.

<inventory warehouse="Midwest">
   <lures>
      <advancedLure type="Trolling">
         <company>Donzai</company>
         <quantityInStock>23</quantityInStock>
         <model>Marlin Buster</model>
         <configurationScheme>
            <color>Blue</color>
            <size>3</size>
         </configurationScheme>
      </advancedLure>
      <advancedLure type="Trolling">
         <company>Ziggi</company>
         <quantityInStock>44</quantityInStock>
         <model>Tuna Finder</model>
         <configurationScheme>
            <color>Red</color>
            <size>5</size>
         </configurationScheme>
      </advancedLure>
   </lures>
</inventory>

이 Listing을 보면 Listing 11에서 인스턴스화하고 작성했던 POJO와 출력이 완전히 같다는 것을 알 수 있다. 두 개의 advancedLure 요소가 있고 각 요소에는 해당 POJO를 채우는 데 사용했던 데이터가 있다. 여기에서도 중첩이 적절히 사용되고 있다.

생성자

코드에서 변경되지 않는 POJO를 사용할 수 있다. 이 경우 setter 메소드를 사용하여 필드 속성을 수정하는 대신 생성자를 사용하여 이러한 값을 설정할 수 있다. Simple은 이 상황을 잘 처리할 수 있다.

이 경우에는 필드 이름 위가 아닌 생성자 매개변수 내에서 어노테이션을 지정한다. 해당 접근자 메소드 위에도 어노테이션이 필요하다. Listing 13을 살펴보자.

public Inventory2(@ElementList(name="lures") List<AdvancedLure> lures,
 @Attribute(name="warehouse") String warehouse) {
     this.lures = lures;
     this.warehouse = warehouse;
}

@ElementList(name="lures")
public List<AdvancedLure> getLures() {
     return lures;
}

@Attribute(name="warehouse")
public String getWarehouse() {
     return warehouse;
}

어노테이션을 생성자 매개변수의 일부로 지정할 경우에는 매개변수에 해당하는 필드 이름도 지정해야 한다. 첫 번째 매개변수에 대한 필드 이름은 lures이고 두 번째 매개변수에 대한 필드 이름은 warehouse이다.

그런 다음 접근자 메소드 위에 일치하는 어노테이션 및 필드 이름을 제공한다. lures에 대한 getter 바로 위에서 생성자에 사용된 어노테이션과 완전히 일치하는 해당 어노테이션을 볼 수 있다. 이와 마찬가지로 warehouse에 대한 getter 위의 어노테이션도 해당 어노테이션과 완전히 일치한다.

이 코드를 실행하기 위해 먼저 Listing 11을 약간 수정하여 Listing 14의 코드를 포함시킨다.

Inventory2 inventory = new Inventory2(lures,"MidWest");

여기에서는 Listing 11에서 사용했던 setter 메소드 대신 Listing 14의 코드를 사용하며 나머지 부분은 모두 동일하다.

템플리트 필터

XML 문서를 역직렬화할 때 템플리트 필터 또는 기본값을 사용할 수 있다는 점은 Simple의 또 다른 주요 기능이다.

이제 원래의 lure.xml로 돌아가서 Listing 15처럼 약간만 수정해 보자.

<lure type="Trolling">
   <company>${lure.company}</company>
   <quantityInStock>23</quantityInStock>
   <model>Marlin Buster</model>
</lure>

이 문서의 company 요소에는 실제 회사의 이름 대신 Apache Ant 유형의 변수 선언이 포함되어 있으며 변수의 이름은 lure.company이다.

템플리트 필터를 사용하면 런타임에 변수 선언을 실제 값으로 대체하여 설정할 수 있다. 이를 수행하는 쉬운 방법으로는 변수 이름과 해당 값을 연결하는 Map 오브젝트를 사용하는 것이다. 그런 다음 Map 오브젝트를 사용하여 Simple 프레임워크에서 Filter 오브젝트를 생성한다. 그런 다음 Filter 오브젝트를 사용하여 Persister 오브젝트를 생성한다. Listing 16을 살펴보자.

Map<String,String> map = new HashMap<String,String>();
map.put("lure.company", "Monmouth");
Filter filter = new MapFilter(map);
			
Serializer serializer = new Persister(filter);
File source = new File("lure2.xml");

Lure lure = serializer.read(Lure.class, source);

System.out.println(lure.getCompany());
System.out.println(lure.getModel());
System.out.println(lure.getQuantityInStock());
System.out.println(lure.getType());

Listing 16은 Listing 2와 크게 다르지 않다. 주요 차이점은 String 값을 String 키에 연결하는 HashMap이 인스턴스화된다는 것이다. 이 경우 String 키는 예상대로 Listing 15에서 사용했던 변수 이름인 lure.company이다. 여기에서는 앞에서 보았던 XML 문서에 있던 값인 Donzai대신 Monmouth라는 값을 이 키에 지정한다.

이 코드를 실행하면 Listing 17과 같은 출력이 표시되어야 한다.

Monmouth
Marlin Buster
23
Trolling

이 출력을 보면 템플리트 필터가 변수 이름 lure.company를 Map 오브젝트에 있는 해당 키 이름에 연결된 실제 값으로 대체했다는 것을 알 수 있다. 이 출력은 예상과 정확히 일치한다.

결론

지금까지 살펴보았듯이 Simple은 강력한 XML 직렬화 및 역직렬화 프레임워크이며 사용하기도 쉽고, 구성도 필요하지 않기 때문에 빠른 개발이 가능하다.

Simple에는 여러 가지 강력한 기능이 있지만 여기에서는 지면의 제약으로 인해 일부 기능만을 살펴보았다. 소프트웨어 개발 작업 중에 XML 직렬화 및 역직렬화가 필요한 개발자라면 Simple을 사용해 보기를 적극 권장한다.

위로

다운로드 하십시오

다운로드 방식에 대한 정보

package com.mimul.xstream;

public interface IXmlRule
{
public String toXML();

}

package com.mimul.xstream;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.annotations.Annotations;

import java.io.Serializable;
import java.lang.reflect.Field;


public class BaseRule implements Serializable {

/**
* XML 문자열로 변환
*/
protected String toXML() {
XStream xstream = new XStream();
Annotations.configureAliases(xstream, getClass());
Field[] fields = getClass().getDeclaredFields();
for (Field f : fields) {
Annotations.configureAliases(xstream, f.getType());
}
String xmlString = xstream.toXML(this);
xstream = null;
return xmlString;
}

/**
* XML 데이터로부터 Rule Build
*/
public static IXmlRule fromXML(String xmlString, Class clazz) {
XStream xstream = new XStream();
Annotations.configureAliases(xstream, clazz);
Field[] fields = clazz.getDeclaredFields();
for (Field f : fields) {
Annotations.configureAliases(xstream, f.getType());
}
IXmlRule rule = (IXmlRule) xstream.fromXML(xmlString);
xstream = null;
return rule;
}
}

package com.mimul.xstream;

import com.thoughtworks.xstream.annotations.XStreamAlias;

@XStreamAlias("xstream.Member")
public class Member {

private String accountNo;
private String password;


public String getAccountNo() {
return accountNo;
}

public void setAccountNo(String accountNo) {
this.accountNo = accountNo;
}

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password;
}
}

package com.mimul.xstream;

import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.annotations.XStreamImplicit;

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


@XStreamAlias("Person")
public class PersonRule extends BaseRule implements IXmlRule
{
private static final long serialVersionUID = 1L;

public String toXML() {
return super.toXML();
}

private String name;
private int age;
private String occupation;

@XStreamImplicit(itemFieldName = "members")
private List<Member> members;


public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getOccupation() {
return occupation;
}

public void setOccupation(String occupation) {
this.occupation = occupation;
}

public List<Member> getMembers() {
return members;
}

public void setMembers(List<Member> members) {
this.members = members;
}

public static void main(String args[])
{
PersonRule person = null;
List<Member> members = null;
Member member = null;

try {
person = new PersonRule();
person.setName("미물");
person.setAge(32);
person.setOccupation("Consultant");

members = new ArrayList<Member>(3);
member = new Member();
member.setAccountNo("mimul");
member.setPassword("mimuladmim");
members.add(member);

member = new Member();
member.setAccountNo("pepsi");
member.setPassword("pepsiadmin");
members.add(member);

member = new Member();
member.setAccountNo("scott");
member.setPassword("tigerda");
members.add(member);

person.setMembers(members);

// Object에서 XML 생성
String xmlString = person.toXML();
System.out.println("XML : " + xmlString);

// XML파일 Object 매핑
PersonRule personRule = (PersonRule) BaseRule.fromXML(xmlString, PersonRule.class);

System.out.println(personRule.getName());
System.out.println(personRule.getAge());
System.out.println(personRule.getOccupation());

for (Member mem : personRule.getMembers()) {
System.out.println(mem.getAccountNo());
System.out.println(mem.getPassword());
}
} catch (Exception e) {
System.out.println(e);
person = null;
members = null;
}
}
}

Serializing an object to XML

Let's create an instance of Person and populate its fields:

Person joe = new Person("Joe", "Walnes");
joe.setPhone(new PhoneNumber(123, "1234-456"));
joe.setFax(new PhoneNumber(123, "9999-999"));

Now, to convert it to XML, all you have to do is make a simple call to XStream:

String xml = xstream.toXML(joe);

The resulting XML looks like this:

<person>
  <firstname>Joe</firstname>
  <lastname>Walnes</lastname>
  <phone>
    <code>123</code>
    <number>1234-456</number>
  </phone>
  <fax>
    <code>123</code>
    <number>9999-999</number>
  </fax>
</person>

It's that simple. Look at how clean the XML is.

JAXB를 활용한 Java 객체의 XML 자동 변환

Using JAXB for XML data binding

package client;


import javax.xml.bind.annotation.XmlRootElement;


@XmlRootElement(name = "person")

public class Person

{

	private String firstName;

	private String lastName;

	private Family family;


	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 Family getFamily() {

		return family;

	}


	public void setFamily(Family family) {

		this.family = family;

	}

}

package client;

import java.util.ArrayList;

import java.util.List;


import javax.xml.bind.annotation.XmlElement;

import javax.xml.bind.annotation.XmlElementWrapper;


public class Family 

{

	private String description;

	@XmlElementWrapper(name = "persons")  

	@XmlElement 

	private List<Person> members = new ArrayList<Person>();




	public String getDescription() {

		return description;

	}


	public void setDescription(String description) {

		this.description = description;

	}

	

	public List<Person> getMembers() {

		return members;

	}

}

package client;


import java.util.ArrayList;

import java.util.List;


import javax.xml.bind.JAXBContext;

import javax.xml.bind.JAXBException;

import javax.xml.bind.Marshaller;


public class JAXBClient 

{

	public static void main(String[] args) {

		JAXBContext context = null;

		List<Person> list = null;

		Person person1 = null;

		Person person2 = null;

		Family family = null;

		Marshaller marshaller = null;

		

		try {

			context = JAXBContext.newInstance(Person.class);

			list = new ArrayList<Person>();

			

			person1 = new Person();

			family = new Family();

			

			family.setDescription("Family Mimul");

			person1.setFirstName("IlDong");

			person1.setLastName("Hong");

			person1.setFamily(family);

			list.add(person1);


			person2 = new Person();

			person2.setFirstName("LeeDong");

			person2.setLastName("Hong");

			person2.setFamily(family);

			list.add(person2);


			// Marshal 객체를 XML로 변환

			// Unmarshal the objects from XML


			marshaller = context.createMarshaller();

			marshaller.setProperty(Marshaller.JAXB_ENCODING, "utf-8");  

			marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, 

			   Boolean.TRUE); 

			

			marshaller.marshal(person2, System.out);

		

		} catch (JAXBException e) {

			e.printStackTrace();

		}

	}

}

<?xml version="1.0" encoding="utf-8" standalone="yes"?>

<person>

    <family>

        <persons/>

        <description>Family Mimul</description>

    </family>

    <firstName>LeeDong</firstName>

    <lastName>Hong</lastName>

</person>

앞에서 배운 지식을 바탕으로 간단한 RSS Reader를 제작해 보도록 하겠습니다. 먼저 아래의 데모를 한번씩들 실행하여 보시기 바랍니다. 그리고 구독하고 있는 채널이 있다면 다른 RSS URL로 테스트도 해 보시구요. 아마도 해당 강좌를 보신 후에는 이 보다 멋진 RSS Reader(Aggregator)를 작성하실 수 있을 것입니다.

1. 데모보기

Simple RSS Reader - http://www.ihelpers.co.kr/lib/jmrss/simplereader.php?URL=http://rss.joins.com/joins_news_list.xml

2. URL 통신

그럼 URL로 RSS 구문을 어떻게 가지고 올까요?

저의 경우는 대부분의 경우는 HTTP 모듈을 사용하나, PHP에서는 fopen 함수를 사용하여 복잡한 과정 없이 웹상의 정보를 로컬디렉토리의 파일정보 처리하는 것 처럼 너무도 쉽게 구현 할수  있습니다.

HTTP의 헤더정보를 같이 좀더 세부적인 처리를 원하는 분은 소스코드에 포함된 "httpclass.php" 클래스를 분석해 보시기 바랍니다. 해당 강좌의 모든 코드는 HTTP 모듈을 사용하였습니다.

//$fd = fopen("http://www.ihelpers.co.kr", "r");

$fd = fopen("http://xmlmanager.egloos.com", "r");
while (!feof($fd)) {

 $buffer .= fgets($fd, 4086);

}
fclose($fd);
echo $buffer;
?>

3. RSSReader Class

RSSReader 변수(Property)

• url - RSS URL정보
• isCache - Cache 사용여부 ( true,false )
• CacheDir - Cache 디렉토리
• cacheInterval - Cache 갱신 주기
• ErrNum - 에러번호
• ErrMsg - 에러메세지

• RSSReader - 생성자로써 URL정보,Cache사용여부,Cache 갱신주기, Cache 디렉토리를 변수로써 입력 받는다.
• setCache - Cache 사용여부 설정
• setCacheDir - Cache 디렉토리 설정
• setCacheInterval - Cache 갱신 주기 설정
• Read

  RSS Reader 클래스에서 가장 주요 업무인 HTTP 통신과 RSS 구문 분석을 수행하는 함수이니 RSSReader 클래스에서 가장 중요한 함수라고 할 수 있을 것입니다. Read 함수는 내부적으로 _getResponse를 호출하여 HTTP 통신을 수행하고, 부모 클래스의 parse 함수를 통하여 RSS 구문을 분석하여 줍니다.

• _getResponse

  Cache 사용여부를 판단하고 Cache를 사용할 경우는 Cache된 파일의 최종수정시간과 설정된 갱신 주기를 비교하여 Cache의 갱신 및 조회여부를 판단하여 URL정보를 읽어오게 됩니다. Cache를 사용하지 않을 경우는 당연히 직접 자료를 조회하게 됩니다.

  if($status == 0){ // 캐쉬정보가 이전것일때
  
   $response = $cache->get($this->url);
  
   $http->AddHeader("If-Modified-Since",$response['last-modified']);
  
   $http->AddHeader("ETag",$response['etag']);
  
  }
  
  $http->Get($path);
  
  
  
  
  
  if($http->Response['code'] == 304){
  
  } elseif($http->Response['code'] == 200 || $http->Response['code'] == 304){
  
   $response = $http->Response;
  
   $cache->set($this->url,$response);
  
  } else {
  
   $this->Error(0,"Response Not Success");
  
   return false;
  
  }
  
  return $response;
  
  

• 위의 코드는 조금 재미있게 볼 수 있을 것 같습니다. Cache 정보가 이전 것이라면 URL통신을 하여 새로운 정보를 가지고 와야 할 것입니다. 그 때 etag 와 last-modified를 포함하여 웹서버와 통신하여 URL 정보가 Cache된 정보와 비교하여 갱신이 되지 않았다면,웹서버는 상태코드로 304 를 리턴해 줍니다. 웹서버에 정보가 갱신이 되지 않았다면 RSS Reader쪽은 Cache정보를 갱신할 필요가 없고 웹서버에서는 URL에 해당하는 문서의 갱신상태만 파악하면 되기 때문에 좀 더 빠르게 통신을 할 수 있게 됩니다.

4. URLCache에 대하여

브라우저가 Cache를 사용하지 않아 매번 접속시마다 변경이 잘 되지 않는 이미지를 다운로드 받아야 한다면 이처럼 웹이 발전되지 않았을 것입니다.

아마도 제작한 RSS Reader에서 Cache를 사용하지 않는다면, 채널을 구독하고 있는 사용자들의 주기적인 접속은 웹서버에 대한 공격으로 변신하여 웹서버 관리자의 얼굴을 하얗게 변하게 할 것입니다. 10,000명의 구독자에 의하여 프로그램이 1분 단위로 채널에 접속하여 정보의 갱신여부만 확인한다고 생각하면 이 만큼의 시스템 자원 낭비가 어디 있겠습니까?

RSS Reader의 경우는 시간이 많이 소요되는 Network 통신을 해야 하기에, 이 문제를 최소화 할 수 있는 Cache의 사용은 RSS Reader 프로그램 개발시에 상당히 중요한 부분이라고 생각합니다. Cache 사용은 "URL Cache를 사용하여 웹을 더욱 빠르게"  강좌와 소스코드에 포함되어 있는 URLCache 클래스를 참고하여 주십시요.

5. Simple RSS Reader

강좌 시작에서 본 간단한 RSS Reader 코드입니다.

include "RSSReader.php";

$url = $_GET["URL"];

$rss = new RSSReader($url,false);

echo "
echo "< style>\n?;

echo "
echo "
echo "
if(!empty($url)){

 $response = $rss->Read();

 if($response){

  $channel = $rss->getChannel();

  while (list($key, $value) = each ($channel)) {

   echo "\n?;

  }
  echo "
  $count = 0;

  foreach($rss->getItems() as $items){



   if($count == 0){

    $titles = $items;

    echo "
    while (list($key, $value) = each ($titles)) {

     printf("

   echo "
   while (list($key, $value) = each ($items)) {

    printf("

6. 소스코드

• 원본파일 : RSSReader.zip

XML Article

XML Beans : XMLBeans는 스키마 기반으로 XML 인포셋 전체에 커서 기반으로 접근할 수 있도록 하는 XML-Java binding tool이다. BEA Systems에 의해 개발 되었으며 2003년에 아파치 프로젝트에 기증 되었다. 기존의 SAX와 Dom등의 방식으로 XML 코딩을 하다 보니 코드 자체가 길어져 개발 및 유지보수하는데 어려움이 많았다. 이 같은 단점은 보완하기 위한 새로운 방법을 제시하고 있다.

XML 라이브러리

• Xstream : 눈여겨 볼만한 놈.

XML 실전 프로그래밍

• 1장 관계형 데이터를 XML로 만들기 1
• 1장 관계형 데이터를 XML로 만들기 2
• 1장 관계형 데이터를 XML로 만들기 3
• 2장 XSLT 적용 1
• 2장 XSLT 적용 2
• 2장 XSLT 적용 3
• 2장 XSLT 적용 4
• 3장 XSLT 확장을 이용한 게시판 완성
• 4장 관계형 데이터를 XML화하는 다른 방법 1
• 4장 관계형 데이터를 XML화하는 다른 방법 2
• 5장 XSLT 작성시의 문제 해결 방법과 실행 속도 향상 방법
• 6장 XSLT 변환기
• 7장 강좌용 게시판 만들기 1
• 7장 강좌용 게시판 만들기 2
• 8장 강좌를 PDF와 플래시로 만들기
• 9장 쿼리 관리기 생성을 통한 XML 문서 파싱 1
• 9장 쿼리 관리기 생성을 통한 XML 문서 파싱 2
• 10장 웹에서 XML로 쿼리와 메뉴 관리하기 1
• 10장 웹에서 XML로 쿼리와 메뉴 관리하기 2
• 11장 XML을 이용한 쇼핑몰 만들기 1
• 11장 XML을 이용한 쇼핑몰 만들기 2
• 11장 XML을 이용한 쇼핑몰 만들기 3

이 글에서는 Java 2 Java 2, Enterprise Edition, v 1.4 를 사용합니다. 다운로드

SUN JAVA STREAMING XML PARSER 소개

XML을 사용하는 대부분의 Java 개발자는 SAX (Simple API for XML) 라이브러리와 DOM(Document Object Model) 라이브러리에 익숙할 것이다. SAX는 이벤트 기반의 API이며, 이는 일반적으로 프로그래머가 파서와 몇 개의 리스너를 등록하고, 특정 XML 문법 생성자(예를 들어 요소나 속성)가 도착되면 리스너 메소드가 호출된다는 의미이다. 그 반대로 DOM은 트리 기반의 아케텍처를 가지며, 전체 문서를 스캔하여 마주치는 각각의 문법 생성자의 오브젝트 트리를 구축한다. 프로그래머는 스캔이 완료된 후 오브젝트 트리에 접근하여 수정할 수 있다

이 두 방법 모두 각각의 결점을 가지고 있다: 리스너를 이용하는 이벤트 기반의 API는 일반적으로 다루기 힘들다. 리스너들이 파서에 의해 조종되기 때문이다. 트리 기반의 API는 스캔되는 문서의 양에 비해 과도한 양의 메모리를 소모할 수 있다. 이제 Java 개발자들이 XML 을 스캔하는데 이용할 수 있는 세 번째 API가 등장하였다. StAX (Streaming API for XML parse)가 그것이다.

SJSXP란?

SJSXP(Sun Java Streaming XML Parser)는 StAX를 빠른 속도로 구현한다. 썬마이크로시스템즈와 협력하고 있는 BEA Systems, XML-guru James Clark, Stefan Haustein, Aleksandr Slominski (XmlPull 개발자들), 그리고 JCP의 다른 멤버들은 JSR 173를 구현하는 것으로써 StAX를 개발하였다. StAX은 공유 인터페이스들에 기반하는, 파서(parser) 독립적인 Java API이다.

SJSXP는 Java Web Services Developer Pack v1.5에 포함되어있다. SJSXP에 대해 처음으로 알아차릴만한 것은 이것이 스트림 API에 기반한다는 것이다. 즉, 개발자가 어느 한 노드에 접근하기 위해 전체 문서를 읽을 필요가 없다. 또한, 파서를 시작하여 파서가 데이터를 이벤트 리스너 메소드에 "push"하도록 허용하는 법칙을 따르지 않는다. 대신에 SJSXP는 "pull" 메소드를 구현하며, 이 메소드는 정렬 포인터를 문서에서 현재 스캔되고 있는 지점에 유지한다. 이는 종종 커서(cursor)라고 불린다. 사용자는 단순히 커서가 현재 가리키고 있는 노드에 대한 파서를 요청하면 된다.

XML 문서 파싱에 SJSXP 이용하기

SJSXP를 이용하여 XML 문서를 읽는 것은 아주 쉽다. 대부분의 작업은 javax.xml.stream.XMLStreamReader 인터페이스를 구현하는 오브젝트를 통해 이뤄진다. 이 인터페이스는 XML 문서의 첫 부분에서 마지막까지 이동되는 커서를 나타낸다. 몇 가지 명심해야할 것이 있다. 커서는 항상 하나의 아이템(시작 태그 요소, 진행 명령, DTD 선언 등)만을 가리켜야 한다. 또한 커서는 항상 앞으로 움직여야 하며 (뒤로 움직일 수 없다), 다음에 무엇이 나타나는지 미리 보기를 실행할 수 없다. 다음의 코드 발췌에서 파일로부터 XML을 읽는 XMLStreamReader를 얻을 수 있다.

   URL url = Class.forName("MyClassName").getResource(
           "sample.xml");            
   InputStream in = url.openStream();
   XMLInputFactory factory = XMLInputFactory.newInstance();
   XMLStreamReader parser = factory.createXMLStreamReader(in);

그 후 다음 코드를 이용하여 XML 파일을 반복할 수 있다.

   while(parser.hasNext()) {
             
         eventType = parser.next();
         switch (eventType) {

              case START_ELEMENT:
              //  Do something
              break;
              case END_ELEMENT:
              //  Do something
              break;
              //  And so on ...
         }
     }

XMLStreamReader의 hasNext() 메소드는 XML 파일에서 또다른 유효한 아이템이 있는지 확인한다. 만약 있다면, 커서가 다음 아이템으로 넘어가게하기 위해 next() 메소드를 사용할 수 있다. next() 메소드는 만나게되는 문법상 생성자(아이템)의 타입을 가리키는 인티거 코드를 리턴한다.

XMLInputStreamReader에는 몇 개의 get 메소드가 있어서 커서가 가리키는 XML 아이템의 내용을 얻는 데 사용할 수 있다. 첫번째 메소드는 getEventType()이다:

   public int getEventType()

메소드는 커서가 있는 곳에서 파서가 찾은 아이템의 타입을 식별하는 integer 코드를 리턴한다. next() 메소드에 의해 리턴되는 것과 같은 코드이다. 아이템은 XMLInputStream 상수 중 하나에 의해 식별된다.

  XMLStreamConstants.START_DOCUMENT 
  XMLStreamConstants.END_DOCUMENT 
  XMLStreamConstants.START_ELEMENT 
  XMLStreamConstants.END_ELEMENT 
  XMLStreamConstants.ATTRIBUTE 
  XMLStreamConstants.CHARACTERS 
  XMLStreamConstants.CDATA 
  XMLStreamConstants.SPACE 
  XMLStreamConstants.COMMENT 
  XMLStreamConstants.DTD 
  XMLStreamConstants.START_ENTITY 
  XMLStreamConstants.END_ENTITY 
  XMLStreamConstants.ENTITY_DECLARATION 
  XMLStreamConstants.ENTITY_REFERENCE 
  XMLStreamConstants.NAMESPACE 
  XMLStreamConstants.NOTATION_DECLARATION 
  XMLStreamConstants.PROCESSING_INSTRUCTION 

만약 아이템에 이름이 있는 경우, getName()과 getLocalName() 메소드를 사용하여 이름을 얻을 수 있다. 후자는 어떤 다른 정보(예; 확인된 네임스페이스가 없는 요소의 이름) 없이 이름 자체를 산출한다.

   public Qname getName()
   public String getLocalName()

만약 당신이 현재 아이템의 네임스페이스를 식별하고 싶다면 getNamespaceURI() 메소드를 사용 할 수 있다.

   public String getNamespaceURI()

만약 DTD 선언 내의 텍스트나 요소 안의 텍스트 등과 같은 동반되는 텍스트가 있을 때에는 다음 메소드들을 사용하여 얻을 수 있다.(후자는 요소를 위해 단독으로 사용 될 수 있다)

   public String getText()
   public String getElementText()

만약 요소가 그것과 관계 되는 속성을 가진다면 getAttributeCount() 메소드를 사용하여 현재 요소가 가진 속성들의 갯수를 얻을 수 있다. 그 후 getAttributeName() 와 getAttributeValue() 메소드를 사용하여 각각의 정보를 검색 할 수 있다.

   public int getAttributeCount()
   public Qname getAttributeName(int index)
   public String getAttributeValue(int index)

만약 속성의 로컬 이름과 요소의 네임스페이스 URI를 안다면, 또한 다음의 메소드를 이용하여 속성값을 얻을 수 있다.

   public String getAttributeValue(
     String elementNamespaceURI, String localAttributeName) 

추측했겠지만, 모든 접근자 메소드가 특정 상태에 적용가능한 것이 아니다. 예를 들어, 현재 DTD를 프로세싱 중이라면 getElementText()을 호출할 수 없다. 만약 이를 호출한다면, 파서가 충돌하는 이벤트 타입을 식별했다는 XMLStreamException을 얻게 되거나 메소드가 스스로 널(null) 값을 리턴하게 될 것이다.

XMLInputFactory 클래스의 setProperty() 메소드를 사용하여 몇 가지 파서 속성을 시작할 수 있다. 예를 들어, 다음은 파서와 마주치는 엔티티 레퍼런스는 교체될 것이라고 지정한다.

   factory.setProperty(
     XMLInputFactory.IS_REPLACING_ENTITY_REFERENCES, 
       Boolean.TRUE);

파서가 외부 엔티티를 지원하는 것을 막기 위해 다음과 같이 설정한다.

   factory.setProperty(
     XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, 
       Boolean.FALSE);

파서가 네임스페이스를 알아차리게하기 위해 다음과 같이 설정한다.

   factory.setProperty(
     XMLInputFactory.IS_NAMESPACE_AWARE, Boolean.TRUE);

SJSXP의 현재 버전에서는 다음의 명령은 허용되지만 파서는 확인되지 않는다는 것을 유의하기 바란다.

   factory.setProperty(XMLInputFactory.IS_VALIDATING, 
     Boolean.TRUE);

만약 이 XMLInputFactory 특성들 중 어느 하나라도 가능하게 된다면 setXMLReporter() 메소드를 사용하여 파서가 만나게되는 오류를 제어할 수 있다. 파서가 만나는 오류의 타입을 가장 빨리 정확하게 결정할 수 있는 방법은 setXMLReporter() 메소드와 상호 작용하는 익명의 이너 클래스를 사용하는 것이다. 이는 다음과 같다.

   factory.setXMLReporter(new XMLReporter() {
     public void report(String message, String errorType,
       Object relatedInformation, Location location) {
         System.err.println("Error in " 
          + location.getLocationURI());
         System.err.println("at line " 
          + location.getLineNumber()
          + ", column " + location.getColumnNumber());
         System.err.println(message);
     }
   });

XML 문서 작성에 SJSXP 사용하기

XML 결과를 작성하는 것은 SJSXP를 이용하면 쉽다. 이 경우, XMLStreamReader 인터페이스 대신에 XMLStreamWriter 인터페이스를 사용할 수 있다. XMLStreamWriter 인터페이스는 작성하는 요소, 속성, 코멘트, 텍스트를 비롯해 XML 문서의 모든 부분을 작성하기 위한 직접적인 메소드를 제공한다. 다음의 예제에서는 어떻게 이 인터페이스를 얻어서 XML 문서를 작성하는데 사용하는지 보여준다.

   XMLOutputFactory xof =  XMLOutputFactory.newInstance();
   XMLStreamWriter xtw = 
     xof.createXMLStreamWriter(new FileWriter("myFile"));

   xtw.writeComment(
     "all elements here are in the HTML namespace");
   xtw.writeStartDocument("utf-8","1.0");
   xtw.setPrefix("html", "http://www.w3.org/TR/REC-html40");
   xtw.writeStartElement(
     "http://www.w3.org/TR/REC-html40","html");
   xtw.writeNamespace(
     "html", "http://www.w3.org/TR/REC-html40");
   xtw.writeStartElement(
     "http://www.w3.org/TR/REC-html40","head");
   xtw.writeStartElement(
     "http://www.w3.org/TR/REC-html40","title");
   xtw.writeCharacters("Java Information");
   xtw.writeEndElement();
   xtw.writeEndElement();

   xtw.writeStartElement(
     "http://www.w3.org/TR/REC-html40","body");
   xtw.writeStartElement("http://www.w3.org/TR/REC-html40","p");
   xtw.writeCharacters("Java homepage is ");
   xtw.writeStartElement("http://www.w3.org/TR/REC-html40","a");
   xtw.writeAttribute("href","http://java.sun.com");
   xtw.writeCharacters("here");
   xtw.writeEndElement();
   xtw.writeEndElement();
   xtw.writeEndElement();
   xtw.writeEndElement();
   xtw.writeEndDocument();

   xtw.flush();
   xtw.close();

각 요소를 작성하는 것이 끝나면 사용자는 라이터(writer)를 날려보내고 닫아야한다.

이전의 코드는 다음의 XML로 결과가 나타난다.(여기서는 쉽게 읽을 수 있게 라인 별로 나타내었다.)

   <!--all elements here are explicitly in the HTML namespace-->
   <?xml version="1.0" encoding="utf-8"?>
   <html:html xmlns:html="http://www.w3.org/TR/REC-html40">
   <html:head>
   <html:title>Java Information</html:title>
   </html:head>
   <html:body>
   <html:p>
   Java information is 
   <html:a href="http://frob.com">here</html:a>
   </html:p>
   </html:body>
   </html:html>

XML 문서 필터링

만약 각각의 아이템 타입을 스캔하고 싶지 않다면 들어오는 XML 문서에 대한 필터를 생성할 수 있다. 이를 위해서는 javax.xml.stream.StreamFilter 인터페이스를 구현하는 클래스를 생성한다. 이 인터페이스는 단지 accept() 메소드만으로 구성된다. 이 메소드는 XMLStreamReader 오브젝트를 허용하고 원시 Boolean을 리턴한다. StreamFilter의 일반적인 구현은 다음과 같다.

   public class MyStreamFilter implements StreamFilter {

       public boolean accept(XMLStreamReader reader) {
           if(!reader.isStartElement() && !reader.isEndElement())
               return false;
           else
               return true;
       }
   }

그 다음으로 XMLInputFactory의 createFilteredReader() 메소드를 호출하여 필터링된 리더(reader)를 생성하고 이를 원래 XML 스트림 리더와 StreamFilter 구현에 모두 전달한다. 다음과 같다.

   factory.createFilteredReader(
     factory.createXMLStreamReader(in), new MyStreamFilter());

SJSXP의 더 자세한 정보는 Sun Java Streaming XML Parser release notes를 참고하기 바란다.

Sun Java Streaming XML Parser 예제 코드 구동하기

1. 이번 테크팁에 대한 샘플 아카이브(ttfeb2005sjsxp.jar)를 다운로드한다.
   
   
2. Java Web Services Developer Pack Downloads page에서 Java WSDP 1.5를 다운로드, 설치한다.
   
   
3. 예제 압축파일을 다운로드 받은 디렉토리를 변경하고, 다음과 같이 샘플 아카이브에 대한 JAR 파일의 압축을 푼다.
   

        jar xvf ttfeb2005sjsxp.jar
   

4. 사용자의 classpath가 ttfeb2005sjsxp.jar와 jsr173_api.jar를 포함하도록 설정한다. 이들은 Java WSDP 1.5 installation의 sjsxp/lib 디렉토리에 위치하고 있다.
   
   
5. SJSXPInput를 컴파일하고 구동한다.
   
   다음의 각각의 XML 아이템과 유사한 엔트리가 나타날 것이다.

      Event Type (Code=11): DTD
      Without a Name
      With Text: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 
      Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-
      transitional.dtd">
     -----------------------------
   

6. SJSXPOutput를 컴파일하고 구동한다. 결과는 XMLOutputFile라는 이름의 파일에 보내지며, 위의 결과 예제에 보여지는 요소들을 포함할 것이다.

//인터넷 XML 날씨 정보를 파싱 (DomParser.java)

import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class DomParser {

        private static Document xmlDoc = null;
        private static String XML_URL = "http://weather.unisys.com/forexml.cgi?seoul";
        private static String XML_NODE = "observation";
        private static String XML_CITY = "city";
        private static String XML_TIME = "time";
        private static String XML_SKIES = "skies";
        private static String XML_TEMP = "temp.C";

        public static void main(String[] args) {
                printXmlFromUrl(XML_URL);
        }

        private static void printXmlFromUrl(String urlString) {
                try {
                        URL url = new URL(urlString);

                        try {
                                URLConnection urlConnection = url.openConnection();
                                HttpURLConnection httpConnection = (HttpURLConnection)urlConnection;

                                int responseCode = httpConnection.getResponseCode();
                                if (responseCode == HttpURLConnection.HTTP_OK) {
                                        InputStream inputStream = httpConnection.getInputStream();

                                        // Parsing XML Document
                                        createDomParser(inputStream);
                                        String[] xmlData = getByTagName(XML_NODE);
                                        for (int i = 0; i < xmlData.length; i++) {
                                                System.out.println(xmlData[i]);
                                        }

                                        inputStream.close();
                                } else {
                                        System.out.println("HTTP Response is not \"HTTP Status-Code 200: OK.\"");
                                }
                        } catch (IOException e) {
                                e.printStackTrace();
                        }
                } catch (MalformedURLException e) { 
                        e.printStackTrace();
                }
        }

        private static void createDomParser(InputStream inputStream) {

                // Use factory to create a DOM document
                DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
                factory.setIgnoringElementContentWhitespace(true);
                DocumentBuilder builder = null;

                try { // Get a DOM parser from the Factory
                        builder = factory.newDocumentBuilder();
                } catch (ParserConfigurationException e) {
                        e.printStackTrace();
                        return;
                }

                try { // Request the DOM parser to parse the file
                        xmlDoc = builder.parse(inputStream);
                } catch (SAXException e) {
                        e.printStackTrace();
                        return;
                } catch (IOException e) {
                        e.printStackTrace();
                        return;
                }
        }

        private static String[] getByTagName(String tagName) {

                if (!(xmlDoc == null)) {
                        NodeList nodes = xmlDoc.getElementsByTagName(tagName);
                        NamedNodeMap nodeMap = nodes.item(0).getAttributes();

                        String[] values = new String[4];
                        values[0] = nodeMap.getNamedItem(XML_CITY).getNodeValue();
                        values[1] = nodeMap.getNamedItem(XML_TIME).getNodeValue();
                        values[2] = nodeMap.getNamedItem(XML_SKIES).getNodeValue();
                        values[3] = nodeMap.getNamedItem(XML_TEMP).getNodeValue();
                        return values;
                }
                return null;
        }
}

XML Parser 함수들

[ xml_parser_create() ]

XML 파서 컨텍스트를 만든다.

int xml_parser_create(string [encoding_parameter]);

encoding_parameter : 파서가 사용할 문자 소스 암호화. 일단 설정된 소스 암호화는 나중에 변경할 수 없다. 가능한 값으로는 ISO-8859-1(default) , US-ASCII, UTF-8

[ xml_set_element_handler()]

"start()"와 “end()"ㅅ구성 요소 핸들러 함수들을 XML 파서에 등록한다.

int xml_set_element_handler( int parser, string startElementHandler , string endElementHandler);

parser : XML 파서의 핸들러. 시작과 끝 구성 요소 핸들러들이 등록되어있다.

startElementHandler : 시작 구성 요소 핸들러 함수의 이름. 만약 null이 지정되면 시작 구성 요소 핸들러가 등록되지 않은 것이다.

endElementHandler : 끝 구성 요소 핸들러 함수의 이름. 만약 null이 지정되면 끝 구성 요소 핸들러가 등록되지 않는다.

< satartElementHandler(int parser, string name, string attribs[]); >

parser : 이함수를 호출하고 있는 XML 파서에 대한 참조

name : 구성 요소의 이름

attribs() : 구성 요소의 속성들을 포함하고 있는 조합배열

< endElementHandler(int parser, string name); >

parser : 이 함수를 호출하고 있는 XML 파서로의 참조

name 구성요소 이름

[ xml_set_character_data_handler() ]

XML 파서에 문자 데이터 핸들러를 등록한다.

int xml_set_character_data_handler( int parser, string characterDataHandler);

parser : 문자 데이터 핸들러가 등록된 XML 파서를 위한 핸들

characterDataHandler : 문자 데이터 핸들러 함수의 이름. 만약 null이 지정되면 문자 데이터 핸들러가 등록되지 않는다.

< characterDataHandler( int parser, string data); >

parser : 이 함수를 호출 중인 XML 파서로의 참조

data : XML 문서에 제공되는 문자 데이터. 파서는 문자 데이터를 이TSms 그대로 리턴하며, 어떠한 공백 문자도 제거하지 않는다.

[ xml_parse() ]

XML 문서의 컨텐츠를 파서로 전달한다. 이 함수는 문서의 실제 분석을 수행한다(XML 문서에서 노드들을 만나면 등록된 적당한 핸들러들을 호출한다.).

이 함수는 XML 문서에 있는 다양한 노드 타입들에 대한 핸들러 함수들이 모두 파서에 등록된 후에 호출된다.

int xml_parse( int parser, string data, int [isFinal]);

parser : 제공된 데이터를 분석할 XML 파서의 핸들

data : XML 문서의 컨텐츠. XML 파일의 전체 컨텐츠는 한 번의 호출로 전달될 필요는 없다.

isFinal : 입력 데이터의 끝을 지정한다.

전달된 데이터의 분석이 가능하면 true를 리턴하고, 그렇지 않으면 false를 리턴한다. 실패이 경우 , 오류정보는 xml_get_error_code()와 xml_get_error_string()함수를 이용하여 발견 할 수 있다.

[ xml_get_error_code ]

XML 파서로부터 오류 코드를 리턴한다.

int xml_get_error_code( int parser);

parser : XML 파서으 핸들

분석에 실패하거나 유호한 XML파서가 아닐 경우 flase를 리턴한다.

[ xml_error_string ]

오류 코드에 따라 오류 메시지를 리턴한다.

string xml_get_error_code( int errorCode);

ErrorCode : xml_get_error_code() 함수가 리턴한 오류 코드

[ 예제 ]

<?
class RSSParser {
 var $feed_info = array();
 var $feed_articles = array();
 var $inchannel = FALSE;
 var $initem = FALSE;
 var $inimage = FALSE;
 var $current_item = array();
 var $current_el = FALSE;

 // 여는 태그 처리
 function startElement($parser, $name, $attrs)
 {
  $el = strtoupper($name);

  if ($el == 'RSS') {
   return;
  } else if ($el == 'CHANNEL') {
   $this->inchannel = TRUE;
  } else if ($el == 'ITEM') {
   $this->initem = TRUE;
  } else if ($el == 'IMAGE') {
   $this->inimage = TRUE;
  } else {
   $this->current_el = $el;
  }
 }

 // 닫는 태그 처리
 function endElement($parser, $name)
 {
  $el = strtoupper($name);

  if ($el == 'RSS') {
   return;
  } else if ($el == 'CHANNEL') {
   $this->inchannel = FALSE;
  } else if ($el == 'ITEM') {
   $this->feed_articles[] = $this->current_item;
   $this->current_item = array();
   $this->initem = FALSE;
  } else if ($el == 'IMAGE') {
   $this->inimage = FALSE;
  } else {
   $this->current_el = FALSE;
  }
 }

 // 태그 사이의 데이터 처리
 function characterData($parser, $data)
 {
  if ($this->initem) {
   if ($this->current_el) {
    $this->current_item[$this->current_el] .= $data;
   }
  } else if ($this->inimage) {
  } else if ($this->inchannel) {
   if ($this->current_el) {
    $this->feed_info[$this->current_el] .= $data;
   }
  }
 }
}

function parse_save_rss($document)
{
 // RSS 피드의 인코딩을 UTF-8에 맞춤
 if (preg_match('/<?xml.*encoding=[\'"](.*?)[\'"].*?>/m', $document, $m)) {
  $in_enc = strtoupper($m[1]);
  if ($in_enc != 'UTF-8') {
   $document = preg_replace('/(<?xml.*encoding=[\'"])(.*?)([\'"].*?>)/m', '$1UTF-8$3', $document);
   $document = iconv($in_enc, 'UTF-8', $document);
  }
 }

 // XML 및 RSS 분석기 생성
 $xml_parser = xml_parser_create('UTF-8');
 $rss_parser = new RSSParser();

 xml_set_object($xml_parser, $rss_parser);
 xml_set_element_handler($xml_parser, "startElement", "endElement");
 xml_set_character_data_handler($xml_parser, "characterData");

 if (!xml_parse($xml_parser, $document, true)) {
  printf("XML error: %s at line %d\n",
    xml_error_string(xml_get_error_code($xml_parser)),
    xml_get_current_line_number($xml_parser));
 } else {
  // 분석결과를 DB에 저장
  $link = mysql_connect('mysql_host', 'mysql_user', 'mysql_password') or die('Could not connect: '.mysql_error());
  mysql_select_db('my_database') or die('Could not select database');

  foreach ($rss_parser->feed_articles as $article) {
   $published = date('Y-m-d H:i:s', strtotime($article['PUBDATE']));

   $query = sprintf("INSERT INTO feed_articles (source, title, link, description, published) VALUES ('%s', '%s', '%s', '%s', '%s')",
       mysql_real_escape_string($rss_parser->feed_info['TITLE']),
       mysql_real_escape_string($article['TITLE']),
       mysql_real_escape_string($article['LINK']),
       mysql_real_escape_string($article['DESCRIPTION']),
       $published);
   if (mysql_query($query, $link)) echo $query."\n";
  }
 }

 xml_parser_free($xml_parser);
}

// 읽어올 피드 목록
$feed_urls = array(
  'http://blog.rss.naver.com/kickthebaby.xml',
  'http://srlog.egloos.com/index.xml',
  'http://feeds.feedburner.com/tapestrydilbert'
  );

foreach ($feed_urls as $url) {
 $handle = fopen($url, 'r');
 if ($handle) {
  $document = '';
  while (!feof($handle)) {
   $document .= fgets($handle, 4096);
  }
  echo $url."\n";
  // 읽어온 피드를 분석하여 DB에 저장
  parse_save_rss($document);
  fclose($handle);
 }
}
?>