Jar에서 내부 Yaml을 처리하는 방법.

소개

얼마전 이전 포스트에서 '프로그래밍 방식으로 Java에서 YAML로 구성 파일을 관리하는 방법'을 소개한 적이 있습니다.
당신이 그것을 알고 싶다면 링크를 따르십시오:

Java Bean 객체를 생성하기 위해 Yaml 파일 내용을 전달하는 것이었습니다. 그것은 구성 또는 직렬화된 Valued-Object(VO)의 정보를 포함하고 있었습니다. 간단히 말해서 Yaml 파일과 Java 객체 사이의 로드 또는 덤프 정보였습니다.

한편, 예리한 생각을 가진 사람이 내부 리소스에서 Yaml 파일에 액세스하는 방법을 물었습니다.
그래서 필요성을 깨달았고,
여기서는 Jar에서 Yaml 파일을 로드하고 덤프하는 방법을 보여줍니다.

환경 설정.

이전 게시물과 마찬가지로 Yaml 파일을 처리하려면 SnakeYAML 라이브러리가 필요합니다.

우리 작품은 어떤 IDE 도구든 사용할 수 있지만 요즘은 VSCODE(Visual Studio Code)를 열렬히 사용할 것입니다.

그리고 SnakeYAML MAVEN 종속성을 POM.xml로 설정해야 합니다. 이전 게시물에서는 Gradle을 사용했지만 지금은 다양성을 위해 MAVEN을 사용합니다 :)

위와 같은 준비가 되었다면 코딩을 시작할 준비가 된 것입니다.

자바 클래스 설계.

구현된 코드를 보기 전에 작업의 전체 디자인을 보여드리겠습니다.

Jar에서 Yaml 파일을 처리하기 위해 "YamlInternalHandler"라는 Java 클래스를 정의합니다.

"loadInternalJar"및 "dumpInternalJar"라는 두 가지 방법을 정의합니다. 첫 번째는 Yaml의 내용을 jar 항목 경로와 내용을 로드할 클래스 개체로 Java 개체에 로드하는 것입니다. 두 번째는 jar 항목 경로와 값을 포함하는 Java 개체의 인스턴스를 사용하여 Jar의 Yaml 파일에 개체 값을 덤프하는 것입니다.

jar에 있는 Yaml 파일을 사용하여 지정된 개체 매핑을 로드하고 덤프할 수 있습니다. 물론 Jar에 Yaml 파일의 구문을 확인하는 것이 좋습니다.

코드에 대해 알아보겠습니다.

Jar에 있는 Yaml 파일의 내용은 아래에 있습니다.

firstName: Kooin
lastName: Shin
age: 48
profile:
  - character: bright
    hobby: claiming
    address: Seoul
    postalCode: 123
  - character: delight
    hobby: ski
    address: Seoul
    postalCode: 123

컨텐츠를 로드할 Java Bean은 Yaml의 값을 나타내는 'Customer'와 'Profile'입니다.

package org.chaostocosmos.doc.yml;

import java.util.List;

public class Customer {

    private String firstName;
    private String lastName;
    private int age;
    private List<Profile> profile;

    public Customer() {}

    public String getFirstName() {
        return this.firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return this.lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public int getAge() {
        return this.age;
    }

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

    public List<Profile> getProfile() {
        return this.profile;
    }

    public void setProfile(List<Profile> profile) {
        this.profile = profile;
    }

    @Override
    public String toString() {
        return "{" +
            " firstName='" + firstName + "'" +
            ", lastName='" + lastName + "'" +
            ", age='" + age + "'" +
            ", profile='" + profile + "'" +
            "}";
    }
}

package org.chaostocosmos.doc.yml;

public class Profile {

    String character;
    String hobby;
    String address;
    int postalCode;    

    public Profile() {}

    public String getCharacter() {
        return this.character;
    }

    public void setCharacter(String character) {
        this.character = character;
    }

    public String getHobby() {
        return this.hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }

    public String getAddress() {
        return this.address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public int getPostalCode() {
        return this.postalCode;
    }

    public void setPostalCode(int postalCode) {
        this.postalCode = postalCode;
    }

    @Override
    public String toString() {
        return "{" +
            " character='" + character + "'" +
            ", hobby='" + hobby + "'" +
            ", address='" + address + "'" +
            ", postalCode='" + postalCode + "'" +
            "}";
    }    
}

이제 'YamlInternalHandler' 클래스의 핵심 코드를 보여드리겠습니다.

package org.chaostocosmos.doc.yml;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.JarOutputStream;
import java.util.zip.ZipEntry;

import org.yaml.snakeyaml.DumperOptions;
import org.yaml.snakeyaml.Yaml;
import org.yaml.snakeyaml.DumperOptions.FlowStyle;
import org.yaml.snakeyaml.constructor.Constructor;

/**
 * Yaml Internal Handler 
 * 
 * @author Kooin-Shin
 * @since 2021.01.04
 */
public class YamlInternalHandler {

    /**
     * Jar file having yaml file
     */
    File file;

    /**
     * Constructor
     * @param file
     * @throws IOException
     */
    public YamlInternalHandler(File file) throws IOException {
        this.file = file;
    }

    /**
     * Load object from internal yaml file in jar
     * @param jarEntry
     * @param clazz
     * @return
     * @throws IOException
     */
    public Object loadInternalJar(String jarEntry, Class<? extends Object> clazz) throws IOException {
        if (!jarEntry.endsWith(".yml")) {
            throw new IllegalArgumentException("This component only support a yaml file in jar!!!");
        }
        JarFile jarFile = new JarFile(this.file);   //Create JarFile object
        JarEntry entry = jarFile.getJarEntry(jarEntry);  //Get JarEntry specified by first parameter
        InputStream is = jarFile.getInputStream(entry);  //Get InputStream from JarFile  by JarEntry
        Constructor constructor = new Constructor(clazz); //Create Constructor object specified by second parameter
        Yaml yaml = new Yaml(constructor);  //Create Yaml object with Constructor object
        Object obj = yaml.load(is);   //Load contents to object instance
        is.close();  //Close InputStream
        jarFile.close();  //Close JarFile
        return obj;
    }

    /**
     * Dump object to yaml file in jar
     * @param jarEntry
     * @param obj
     * @throws FileNotFoundException
     * @throws IOException
     */
    public void dumpInternalJar(String jarEntry, Object obj) throws FileNotFoundException, IOException {
        JarOutputStream jos = new JarOutputStream(new FileOutputStream(this.file));  //Create JarOutputStream object 
        jos.putNextEntry(new ZipEntry(jarEntry));  //Put jar entry by first parameter
        DumperOptions options = new DumperOptions();  //Set dump options
        options.setDefaultFlowStyle(FlowStyle.BLOCK); 
        options.setPrettyFlow(true);
        Yaml yaml = new Yaml(options);  //Create Yaml object with DumperOptions object
        yaml.dump(obj, new OutputStreamWriter(jos));  //Dump contents of second parameter
        jos.close(); // Close JarOutputStream
    }

    public static void main(String[] args) throws IOException {
        File file = new File("D:\\Projects\\chaos-commons\\yaml.jar");
        YamlInternalHandler ymlHandler = new YamlInternalHandler(file);
        Customer customer = (Customer) ymlHandler.loadInternalJar("tmp/yaml/Customer.yml", Customer.class);
        System.out.println(customer.toString());
        customer.setFirstName("Jim ");
        customer.getProfile().get(0).setAddress("Busan");
        ymlHandler.dumpInternalJar("tmp/yaml/Customer.yml", customer);
    }
}

결론

위의 코드는 Jar에서 Yaml에 액세스하는 매우 간단한 경우를 가정합니다. 상황에 따라 변형, 수정 및 개선될 수 있습니다.
언제나 탄력적인 사고는 당신의 것!!!
행운을 빕니다!!!