Parsing(파싱) - CSV, XML, JSON

  이번 글에서는 데이터의 종류, Parsing(파싱) & Parser(파서), Parsing의 실제 사용 방법을 살펴보도록 하자.

 

1. CSV, XML, JSON 🌞

(1) CSV (Comma Separated Value) 🌱

  CSV는 몇 가지 필드를 쉼표(,)로 구분한 텍스트 데이터 및 텍스트 파일이다.

name,age,visitTime
최하늘,23,2023-01-28
이구름,15,2023-01-29
김산,32,2023-01-30

(2) XML (eXtensible Markup Language) 🌳

XML은 HTML과 매우 비슷한 문자 기반의 마크업 언어(text-based markup language)이다. 태그를 통해 데이터 형식을 정의한다. XML 태그는 HTML 태그처럼 미리 정의되어 있지 않고, 사용자가 직접 정의할 수 있다.

<visitorResult>
    <visitRange>20230124~20230130</visitRange>
    <visitors>
        <visitor>
            <name>최하늘</name>
            <age>23</age>
            <visitTime>2023-01-28</visitTime>
        </visitor>
        <visitor>
            <name>이구름</name>
            <age>15</age>
            <visitTime>2023-01-29</visitTime>
        </visitor>
        <visitor>
            <name>김산</name>
            <age>32</age>
            <visitTime>2023-01-30</visitTime>
        </visitor>
    </visitors>
</visitorResult>

(3) JSON (Javascript Object Notation) 🌴

  JSON은 키(Key)와 값(Value)의 쌍으로 이루어져 있는 데이터 형식이다.

{
  "visitorResult": {
    "visitRange": "20230124~20230130",
    "visitors": [
      {
        "name": "최하늘",
        "age": 23,
        "visitTime": "2023-01-28"
      },
      {
        "name": "이구름",
        "age": 15,
        "visitTime": "2023-01-29"
      },
      {
        "name": "김산",
        "age": 32,
        "visitTime": "2023-01-30"
      }
    ]
  }
}

각각의 특징은 아래와 같다.

	CSV	XML	JSON
장점	용량이 가장 작음   CSV는 용량이 작기 때문에 변하지 않는 많은 양의 데이터를 제공할 때 주로 이용이 가능	XML은 3가지 형식 중 가장 직관적   메타 정보를 제공해서 정보 표현 이상의 효과를 가져올 수 있음	모양과 규칙 자체가 단순해서 타 언어에서도 구현하기가 쉬움
단점	데이터가 많아지면 어떤 데이터가 항목을 나타내는지 가시화가 어려움	실제 전송하는 정보보다 메타 데이터의 크기가 더 커질 수 있음	콤마가 누락되거나 중괄호가 잘 못 닫히는 등 문법 오류에 취약하다.
주요 사용처	간단한 테이블 작성 또는 읽는 속도가 중요한 부분에서 사용	단순 게임 옵션, 직접 데이터 수정이 잦은 부분에 사용	서버 통신 REST API를 사용할 때 가장 많이 사용

 

2. Parsing (파싱) & Parser(파서) ⛅

  Parsing이란 문서에서 필요한 정보를 얻기 위해 태그를 구별하고 내용을 추출하는 과정이다. 문장이 이루고 있는 구성 성분을 분해하고 분해된 성분의 위계 관계를 분석하여 내용을 얻는다.

  Parsing의 기법으로는 XML Parsing과 JSON Parsing이 있다. (CSV의 경우에는 콤마로 손쉽게 데이터를 다룰 수 있다.) 

  Parser란 Parsing을 수행하는 프로그램이다. Parser는 Compiler의 일부로 컴파일러나 인터프리터에서 원시 프로그램을 읽어 들여 그 문장이 구조를 알아내는 Parsing을 수행한다.

 

3. XML Parsing 🌂

  XML Parsing에는 SAX(Simple API for XML) Parser와 DOM(Document Object Model) Parser를 사용할 수 있다. SAX Parsers는 문서를 읽으면서 태그의 시작, 종료 등 이벤트 기반으로 처리를 하는 방식이고, DOM Parser는 문서를 다 읽고 난 후 문서 구조 전체를 자료구조에 저장하여 탐색하는 방식이다. 

	SAX Parser	DOM Parser
특징	상대적으로 빠르다. 메모리 저장 X	상대적으로 느리다. 메모리 저장 O
사용처	읽기 전용	XML 내용을 수정하기 위한 용도

  'visitor.xml'과 Visitor.java를 공통으로 사용하고 SAX Parser와 DOM Parser를 이용해서 Parsing 해보자.

<visitorResult>
    <visitRange>20230124~20230130</visitRange>
    <visitors>
        <visitor>
            <name>최하늘</name>
            <age>23</age>
            <visitTime>2023-01-28</visitTime>
        </visitor>
        <visitor>
            <name>이구름</name>
            <age>15</age>
            <visitTime>2023-01-29</visitTime>
        </visitor>
        <visitor>
            <name>김산</name>
            <age>32</age>
            <visitTime>2023-01-30</visitTime>
        </visitor>
    </visitors>
</visitorResult>

public class Visitor {
	private String name;
	private Integer age;
	private Date visitTime;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public Date getVisitTime() {
		return visitTime;
	}
	public void setVisitTime(Date visitTime) {
		this.visitTime = visitTime;
	}
	
	public Date toDate(String date) {
		Date dateObj = null;
		
		SimpleDateFormat format = new SimpleDateFormat("YYYY-MM-dd");
		try {
			dateObj = format.parse(date);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		
		return dateObj;
	}
	
	@Override
	public String toString() {
		return "Visitor [name=" + name + ", age=" + age + ", visitTime=" + visitTime + "]";
	}
}

 

(1) SAX Parser 🌵

  SAX Parser를 사용하기 위해서는 DefaultHandler를 상속한다. 그리고 startDocument(), endDocument(), startElement(), endElement(), characters()를 오버라이딩 해주면 된다.

  또한, SAXParserFactory를 이용하여 팩토리를 먼저 생성하고, 그것을 이용해서 SAXParser를 만든다. 만들어진 parser를 이용해서 parse를 해주면 된다.

public class VisitorSaxParser extends DefaultHandler {

	private final File xml = new File("./visitor.xml");

	private List<Visitor> list = new ArrayList<>();

	private Visitor current;

	private String content;

	public List<Visitor> getVisitor() {
		try {
			SAXParserFactory factory = SAXParserFactory.newInstance();
			SAXParser parser = factory.newSAXParser();
			parser.parse(xml, this);
		} catch (IOException | ParserConfigurationException | SAXException e) {
			e.printStackTrace();
		}

		return list;
	}

	@Override
	public void startDocument() throws SAXException {
		System.out.println("Document Parsing START");
	}

	@Override
	public void endDocument() throws SAXException {
		System.out.println("Document Parsing END");
	}

	@Override
	public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
		if(qName.equals("visitor")) {
			current = new Visitor();
		}
	}

	@Override
	public void endElement(String uri, String localName, String qName) throws SAXException {
		if(qName.equals("visitor")) {
			list.add(current);
		} else if(qName.equals("name")) {
			current.setName(content);
		} else if(qName.equals("age")) {
			current.setAge(Integer.parseInt(content));
		} else if(qName.equals("visitTime")) {
			current.setVisitTime(current.toDate(content));
		}
	}

	@Override
	public void characters(char[] ch, int start, int length) throws SAXException {
		this.content = new String(ch, start, length);
	}
}

public class SaxParserTest {
	public static void main(String[] args) {
		VisitorSaxParser handler = new VisitorSaxParser();

	    List<Visitor> visitors = handler.getVisitor();
	    
	    for (Visitor visitor : visitors) {
	        System.out.println(visitor);
	    }
	}
}

// Document Parsing START
// Document Parsing END
// Visitor [name=최하늘, age=23, visitTime=Sun Jan 01 00:00:00 KST 2023]
// Visitor [name=이구름, age=15, visitTime=Sun Jan 01 00:00:00 KST 2023]
// Visitor [name=김산, age=32, visitTime=Sun Jan 01 00:00:00 KST 2023]

  동작 방식은 문서를 읽다가 발생하는 이벤트 기반으로 문서를 처리한다. startDocument(), endDocument(), startElement(), endElement(), characters()가 이벤트 핸들러이다. 아래의 표를 보면 쉽게 이해가 될 것이다.

이벤트 발생 시점 & 이벤트 핸들러

이벤트 핸들러

<visitorResult>(1)         ...         <visitor>(2)             <name>(2)최하늘(3)</name>(4)             <age>(2)23(3)</age>(4)             <visitTime>(2)2023-01-28(3)</visitTime>(4)         </visitor>(4)         <visitor>(2)             <name>(2)이구름(3)</name>(4)             <age>(2)15(3)</age>(4)             <visitTime>(2)2023-01-29(3)</visitTime>(4)         </visitor>(4)         ... </visitorResult>(5)

(1) startDocument() (2) startElement() (3) characters() (4) endElement() (5) endDocument()

 

(2) DOM Parser 🍀

  DOM Parser는 root를 기준으로 계속해서 child를 만들면서 해당하는 값들을 가져오면 된다. 이것이 가능한 이유는 DOM Tree로 인해 문서를 구현하는 모든 요소가 Node로 구성되어 있기 때문이다. 팩토리를 시작으로 진행하는 것은 SAX Parser와 비슷하다.

public class VisitorDomParser {
	private final File xml = new File("./visitor.xml");
	private List<Visitor> list = new ArrayList<>();
	
	public List<Visitor> getVisitor() {
		try {
			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
			DocumentBuilder builder = factory.newDocumentBuilder();
			
			Document doc = builder.parse(xml);
			Element root = doc.getDocumentElement();
			parse(root);
		} catch(IOException | ParserConfigurationException | SAXException e) {
			e.printStackTrace();
		}
		
		return list;
	}

	private void parse(Element root) {
		NodeList visitors = root.getElementsByTagName("visitor");
		for(int i = 0; i < visitors.getLength(); i++) {
			Node child = visitors.item(i);
			list.add(getVisitor(child));
		}
	}

	private Visitor getVisitor(Node node) {
		Visitor visitor = new Visitor();
		NodeList childs = node.getChildNodes();
		for(int i = 0; i < childs.getLength(); i++) {
			Node child = childs.item(i);
			if(child.getNodeName().equals("name")) {
				visitor.setName(child.getTextContent());
			} else if(child.getNodeName().equals("age")) {
				visitor.setAge(Integer.parseInt(child.getTextContent()));
			} else if(child.getNodeName().equals("visitTime")) {
				visitor.setVisitTime(visitor.toDate(child.getTextContent()));
			}
		}
		
		return visitor;
	}
}

public class DomParserTest {
	public static void main(String[] args) {
		VisitorDomParser parser = new VisitorDomParser();
		List<Visitor> visitors = parser.getVisitor();
		
		for (Visitor visitor : visitors) {
			System.out.println(visitor);
		}
	}
}

// Visitor [name=최하늘, age=23, visitTime=Sun Jan 01 00:00:00 KST 2023]
// Visitor [name=이구름, age=15, visitTime=Sun Jan 01 00:00:00 KST 2023]
// Visitor [name=김산, age=32, visitTime=Sun Jan 01 00:00:00 KST 2023]

 

4. JSON Parsing 🌈

  JSON Parsing은 상대적으로 간단하다. ObjectMapper를 이용해서 mapper를 지정해 주고 값을 읽어온다. 그리고 해당 값에서 키(Key)를 이용하여 값(Value)을 가져오는 것을 지정한 후, convertValue를 이용하면 자동으로 Visitor 클래스에 값이 저장된다.

public class JsonParser {
	private final File json = new File("./visitor.json");
	private List<Visitor> list = new ArrayList<>();
	
	@SuppressWarnings({ "unchecked", "rawtypes" })
    public List<Visitor> getVisitor() {
        ObjectMapper mapper = new ObjectMapper();

        mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd"));

        try {
			Map<String, Map<String, Object>> result = mapper.readValue(json, Map.class);
			List<Map<String, Object>> list = (List) result.get("visitorResult").get("visitors");
			for(Map<String, Object> item : list) {
				this.list.add(mapper.convertValue(item, Visitor.class));
			}
		} catch (JsonParseException e) {
			e.printStackTrace();
		} catch (JsonMappingException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
        
        return list;
    }
}

public class JsonParserTest {
	public static void main(String[] args) {
		JsonParser parser = new JsonParser();
        List<Visitor> visitors = parser.getVisitor();

        for (Visitor visitor : visitors) {
            System.out.println(visitor);
        }
    }
}

// Visitor [name=최하늘, age=23, visitTime=Sat Jan 28 00:00:00 KST 2023]
// Visitor [name=이구름, age=15, visitTime=Sun Jan 29 00:00:00 KST 2023]
// Visitor [name=김산, age=32, visitTime=Mon Jan 30 00:00:00 KST 2023]

  XML Parsing에서 사용한 Visitor Class에 2가지 변화가 있다. 첫 번째로는 JsonParser에서 dateFormat을 지정해 줄 수 있기 때문에 toDate를 할 필요가 없다. 두 번째로는 @JsonIgnoreProperties(ignoreUnknown = true)를 설정해 주었다. JSON은 모든 요소를 Parsing 하려고 한다. 하지만 Visitor 클래스에서는 선언되지 않은 요소를 Parsing 안 하고 싶은데 이럴 때 사용하는 것이 @JsonIgnoreProperties(ignoreUnknown = true)이다.

@JsonIgnoreProperties(ignoreUnknown = true)
public class Visitor {
	private String name;
	private Integer age;
	private Date visitTime;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public Date getVisitTime() {
		return visitTime;
	}
	public void setVisitTime(Date visitTime) {
		this.visitTime = visitTime;
	}
	
	@Override
	public String toString() {
		return "Visitor [name=" + name + ", age=" + age + ", visitTime=" + visitTime + "]";
	}
}

 

[참고자료]
[JAVA] Parsing이란 무엇인가?
데이터 포맷(XML, JSON, CSV)
SAX (Simple API for XML)