[ KOSTA 23일차 교육 ] 복습 (POJO와 JSON 사이의 변환, maven) | Jackson API Deep-Dive | Jackson API와 기본생성자 | JDBC ( Java DataBase Connectivity )

API ( Application Programming Interface )

API는 어플리케이션 사이에서 정보를 주고받기 위해
요청과 응답의 양식을 미리 정해놓은 것입니다.

API의 사용자(클라이언트)는
API 제공자가 이미 잘 만들어놓은 기능을
호출하는 방법만 숙지하고, 이를 준수한다면
쉽게 서버가 제공하는 검증된 기능을 사용할 수 있습니다.

Java API

개발하기 위해 Java를 설치한다는 것은
JDK를 설치하는 것과 같은 말입니다.

JDK ( Java Development Kit ) 안에는
JRE( Java Runtime Environment )와
Java 개발에 필요한 여러 유틸리티 실행파일이 있습니다.
(javac, java, javadoc..)

JRE 안에는
JVM과 미리 컴파일된 클래스파일들, 즉 Java에서 제공하는 라이브러리들이 있습니다.
이러한 라이브러리는 jar(java ARchive) 형태로 제공되고,
rt.jar 파일에 기본적인 Java 라이브러리, 즉 Java에서 제공하는 API가 있습니다.
( 여기서 rt는 runtime의 약자입니다. )
이것을 JDK의 API, 즉 Java API라 합니다.

이렇게 Java가 미리 만들어놓은 유용한 .class 파일 모음인 jar를 찾으려면
해당 jar 파일이 들어가있는 디렉토리, 즉 classpath를 JVM에 알려주어야 합니다.
기본적으로 rt.jar는 JRE System Library에 등록되어,
JVM의 클래스 로더가 런타임 때 참조 가능합니다.

Java 외부 API와 Maven Repository

자바로 개발을 하다 보면
JDK가 제공하는 기능 이외의 API가 필요할 수 있습니다.
여러 벤더가 공유하는 3rd Party API 중 검증된 라이브러리들을 모아놓은 곳을
메이븐 저장소(Maven Repository)라 합니다.
이 곳에서는 다양한 3rd-party의 API들을 버전별로 다운로드 받아볼 수 있습니다.

이렇게 모여있는 Java 외부 API를 사용하는 방식은
크게 두가지로 볼 수 있습니다.

첫번째는 직접 jar 파일을 다운로드 받아
미리 등록해 둔 classpath에 옮겨놓는 방법.

두번째는 빌드 도구 ( 빌드 스크립트 )들 ( maven, gradle )의 스크립트에
내가 필요로 하는 의존성 라이브러리의 정보를 추가하면
maven/gradle이 CDN을 통해 이를 다운로드 받아 주는 방법입니다.

Maven 빌드 시 줄 수 있는 명령어

compile : 컴파일 수행, 컴파일된 결과는 target/classes에 생성됨.

test : 테스트 코드를 컴파일한 뒤 테스트 코드를 실행.
테스트 클래스들은 target/test-classes에 생성됨.

package : 컴파일된 결과물을 패키지 파일로 생성한다.
컴파일된 결과물을 패키지 파일로 생성.
컴파일, 테스트, 빌드를 통해 파일을 생성합ㅂ니다.
프로젝트 이름, 버전, 패키징 옵션에 맞게 파일을 수정합니다.

install : 패키징한 파일을 로컬 저장소에 배포합니다. maven install로 실행.

deploy : 패키징한 파일을 원격 저장소에 배포.

clean : 메이븐 빌드를 통해 생성된 모든 산출물들을 삭제합니다. Maven Clean으로 실행합니다.

Kakao API를 호출했다 치고, 이를 가공하는 과정 실습 ( Jackson API 활용 )

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonParseTest {

	public static void main(String[] args) {
    	/** Kakao API로 가져온 데이터 원본이라 가정. ( API Key 발급 )
		 * 
		 * {
			  "elements":[
			    {"profile_nickname":"사랑하는 아내♥️",
			    "profile_thumbnail_image":"",
			    "id":149..xxx...378,
			    "uuid":"Q3JAcU..xxxxxx.Up6T3sd",
			    "favorite":true}
			  	],
			
			  "total_count":1,
			  "after_url":null,
			  "result_id":"zbnYtN-...xxxxx...pdPgCA",
			  "favorite_count":1
			}
		 * 
		 */
         
         String jsonStr = "{\r\n"
				+ "\"elements\":[\r\n"
				+ "	{	\n		\"profile_nickname\":\"사랑하는 아내♥️\",\r\n"
				+ "		\"profile_thumbnail_image\":\"\",\r\n"
				+ "		\"id\":\"149..xxx...378\",\r\n"
				+ "		\"uuid\":\"Q3JAcU..xxxxxx.Up6T3sd\",\r\n"
				+ "		\"favorite\":true\n	}\r\n"
				+ "],"
				+ "\r\n"
				+ "	\"total_count\":1,\r\n"
				+ "	\"after_url\":null,\r\n"
				+ "	\"result_id\":\"zbnYtN-...xxxxx...pdPgCA\",\r\n"
				+ "	\"favorite_count\":1\r\n"
				+ "}";
          
         
         ObjectMapper om = new ObjectMapper();
         HashMap<String, Object> jsonObj = new HashMap<>();
         try {
         	jsonObj = om.readValue(jsonStr, new TypeReference<HashMap<String,Object>>(){});
         } catch(JsonProcessingException e) {
         	System.out.println("JsonProcessingException 에러");
         }
         
         System.out.println("==원본 JSON==");
         System.out.println(jsonStr);
         
         HashMap<String,String> userInfo = ((ArrayList<HashMap<String,String>>) jsonObj.get("elements").get(0);
         
         	// profile_nickname 뽑아내기
		System.out.println("1. profile_nickname 뽑아내기");
		System.out.println("profile_nickname = " + userInfo.get("profile_nickname"));
		
		// 아이디 뽑아내기
		System.out.println("2. id 뽑아내기");
		System.out.println("id = " + userInfo.get("id"));
		
		// uuid 뽑아내기
		System.out.println("3. uuid 뽑아내기");
		System.out.println("uuid = " + userInfo.get("uuid"));
		
		// total_count 뽑아내기
		System.out.println("4. total_count 뽑아내기");
		System.out.println("total_count = " + jsonObj.get("total_count"));
	}
}

결과

==원본 JSON==
{
"elements":[
	{	
		"profile_nickname":"사랑하는 아내♥️",
		"profile_thumbnail_image":"",
		"id":"149..xxx...378",
		"uuid":"Q3JAcU..xxxxxx.Up6T3sd",
		"favorite":true
	}
],
	"total_count":1,
	"after_url":null,
	"result_id":"zbnYtN-...xxxxx...pdPgCA",
	"favorite_count":1
}
1. profile_nickname 뽑아내기
profile_nickname = 사랑하는 아내♥️
2. id 뽑아내기
id = 149..xxx...378
3. uuid 뽑아내기
uuid = Q3JAcU..xxxxxx.Up6T3sd
4. total_count 뽑아내기
total_count = 1

Google의 Simple-JSON API, Jackson API 활용 코드 모음

• 첫번째 케이스는 Google의 Simple-JSON API의 JSONObject, JSONArray를 활용한 코드입니다.
• 두번째 케이스는 Jackson API의 ObjectMapper를 통해 JSON 데이터를 Java Collection Framework의 데이터로 매핑하는 코드입니다.
• 세번째 케이스는 Jackson API의 ObjectMapper를 통해 JSON 데이터를 POJO 형식으로 모델링한 VO로 매핑하는 코드입니다.
• 제 3의 서비스를 우리 서비스로 가져다 쓰기 위해 REST API 호출 시,
  해당 제 3서버에서 제공하는 JSON 형식을 보고,
  그에 맞는 형식의 VO로 모델링한 뒤 JSON 역직렬화 라이브러리를 사용하여
  우리의 Java Application에서 활용할 수 있습니다.
  - POJO ( Plain Old Java Object )는 다른 의존성 없이, Java 본연의 기술에만 의존한 자바 객체를 의미합니다.

package com.kosta.sample.json;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;

import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonParseTest {

	public static void main(String[] args) {
		String jsonStr = "{\"elements\":[{\"profile_nickname\":\"사랑하는 아내♥\",\"profile_thumbnail_image\":\"\",\"id\":\"149..xxx...378\",\"uuid\":\"Q3JAcU..xxxxxx.Up6T3sd\",\"favorite\":true}],\"total_count\":1,\"after_url\":null,\"result_id\":\"zbnYtN-...xxxxx...pdPgCA\",\"favorite_count\":1}";
		
		// Using Simple-JSON
		JSONObject obj = new JSONObject();
		JSONParser p = new JSONParser(); 
		try {
		  HashMap<String,String> map2 = new HashMap<String,String>();
		  obj = (JSONObject)p.parse(jsonStr);
		  JSONArray elementsArray = (JSONArray) obj.get("elements");
	      JSONObject elementObject = (JSONObject) elementsArray.get(0);
	      String nick = (String) elementObject.get("profile_nickname");
	      String id = (String) elementObject.get("id");
	      String uuid = (String) elementObject.get("uuid");
	      Long total  = (Long)obj.get("total_count");
	      System.out.println(nick + "\t" + id + "\t" + uuid + "\t" + total);   
		} catch (ParseException e) {
				System.err.println("str --> map convert 에러");
				e.printStackTrace();
		}
		
		// Using Jackson API ( Collection Framework )
		ObjectMapper mapper = new ObjectMapper(); 
		try {
			HashMap map = mapper.readValue(jsonStr, HashMap.class);
			ArrayList<HashMap<String, Object>> elementsList = (ArrayList<HashMap<String, Object>>) map.get("elements");
			String nick = (String)elementsList.get(0).get("profile_nickname");
			String id = (String)elementsList.get(0).get("id");
			String uuid = (String)elementsList.get(0).get("uuid");
			Integer total = (Integer)map.get("total_count");
			System.out.println(nick + "\t" + id + "\t" + uuid + "\t" + total);
		} catch (JsonMappingException e) {
				e.printStackTrace();
		} catch (JsonProcessingException e) {
				e.printStackTrace();
		}
		
		
		// Using Jackson API ( Using Java POJO, VO )
		mapper = new ObjectMapper(); 
		try {
			DataVO dvo = mapper.readValue(jsonStr, DataVO.class);
			Element[] elements = dvo.getElements();
			for(Element e : elements) {
				String nick = e.getProfile_nickname();
				String uuid = e.getUuid();
				String id   = e.getId();
				int total   = dvo.getTotal_count();
				System.out.println(nick + "\t" + id + "\t" + uuid + "\t" + total);
			}
		} catch (JsonMappingException e) {
			e.printStackTrace();
		} catch (JsonProcessingException e) {
			e.printStackTrace();
		}
	}
}

// --------------------------------------------------------------
class DataVO {
    private Element[] elements;
    private int total_count;
    private String after_url;
    private String result_id;
    private int favorite_count;

    public Element[] getElements() {
        return elements;
    }

    public void setElements(Element[] elements) {
        this.elements = elements;
    }

    public int getTotal_count() {
        return total_count;
    }

    public void setTotal_count(int total_count) {
        this.total_count = total_count;
    }

    public String getAfter_url() {
        return after_url;
    }

    public void setAfter_url(String after_url) {
        this.after_url = after_url;
    }

    public String getResult_id() {
        return result_id;
    }

    public void setResult_id(String result_id) {
        this.result_id = result_id;
    }

    public int getFavorite_count() {
        return favorite_count;
    }

    public void setFavorite_count(int favorite_count) {
        this.favorite_count = favorite_count;
    }

}
//--------------------------------------------------------------
class Element {
    private String profile_nickname;
    private String profile_thumbnail_image;
    private String id;
    private String uuid;
    private boolean favorite;

    public String getProfile_nickname() {
        return profile_nickname;
    }

    public void setProfile_nickname(String profile_nickname) {
        this.profile_nickname = profile_nickname;
    }

    public String getProfile_thumbnail_image() {
        return profile_thumbnail_image;
    }

    public void setProfile_thumbnail_image(String profile_thumbnail_image) {
        this.profile_thumbnail_image = profile_thumbnail_image;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getUuid() {
        return uuid;
    }

    public void setUuid(String uuid) {
        this.uuid = uuid;
    }

    public boolean isFavorite() {
        return favorite;
    }

    public void setFavorite(boolean favorite) {
        this.favorite = favorite;
    }
}

Jackson API와 TypeFactory & JavaType

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;

public class JacksonTest {
		// ...
		public static void main(String[] args) {
        // ...
		// Jackson API ( TypeFactory )
		TypeFactory fact = mapper.getTypeFactory();
		JavaType javaType = fact.constructType(EmpVO.class); 
		// JavaType = JSONFactory에서 가장 높은 단계.. (다형성)
		try {
			EmpVO empVO = mapper.readValue(jsonStr, javaType);
		// EmpVO.class 가 생성됨.
		// Jackson에서 Object Type으로 이를 읽어낸다.
		// Type Reference - Converting.. 값을 넣고 뺄 수 있는 준비를 한다.
			System.out.println(empVO.getEname());
		} catch(JsonProcessingException e) {
			e.printStackTrace();
		}