yml, ymal 대해 이해 해보도록 하는 포스팅을 작성하려고 합니다.

yml 이란?

YAML이라는 이름은 "YAML은 마크업 언어가 아니다 (YAML Ain't Markup Language)” 라는 재귀적인 이름에서 유래되었습니다.

기존 properties보단 직관적이지만 계층구조를 사용하기 때문에 잘못된 띄어쓰기나 탭으로 오류가 나기 쉽습니다.

yml 문법 정리

기본적인 사용법은 key : value의 형태로 이루어지면 key : value가 붙지 않도록 주의해야 합니다.

# this is a comment  #주석 입니다.

name: kyh  # 일반 String 입니다.

names: k1, k2, k33   # list 입니다.
truth: yes # boolean 입니다.

another_truth: True # boolean 입니다.

more_true: true # boolean 입니다.

false: no #false 값을 출력합니다.

colon_string: "my coureses: one two three" # :를 문자에 포함하고 싶을때 사용합니다.

include_new_lines:    # 줄 바꿈 입니다.
  new line1
  new line2
  new line3

ignore_new_lines: >   # 표현은 줄을 바꿨지만 출력시 문장은 이어져 있습니다.
  string 0
  string 1
  string 2

보통 java 내에서는 호출할때 @Value 어노테이션과 함께 호출되며 사용방법은 아래와 같습니다.

코드를 입력@Configuration
public class propertiConfig {

    @Value("${name}")
    String name;

    @Value("${names}")
    private List<String> names;

    @Value("${truth}")
    Boolean truth;

    @Value("${another_truth}")
    Boolean anotherTruth;

    @Value("${more_true}")
    Boolean moreTrue;

    @Value("${false}")
    Boolean false2;

    @Value("${include_new_lines}")
    String includeNewLines;

    @Value("${ignore_new_lines}")
    String ignoreNewLines;


    @PostConstruct
    public void init(){

        System.out.println(name);
        names.forEach(System.out::println);
        System.out.println(truth);
        System.out.println(anotherTruth);

        System.out.println(moreTrue);
        System.out.println(false2);
        System.out.println(includeNewLines); 
        System.out.println(ignoreNewLines);
    }

}

아래는 실제 출력물 입니다.

감사합니다.

내결합성에 대해 이해 해보도록 하는 포스팅을 작성하려고 합니다.

• 내결합성이란? 내결함성(Fault Tolerance)은 하나 이상의 구성 요소가 고장나도 시스템이 중단 없이 계속 작동할 수 있는 능력을 의미합니다.

우리가 작성한 프로그램에 오류가 있어도 프로그램에 중단없이 계속 작동할수 있게 작업을 해야될지 아니면 프로세스를 중단시키는게 나을지를 한번쯤은 모두 고민해 봤을 겁니다.

아래 코드는 리스트의 값을 입력받아 sum을 하는 간단한 예제이다.

import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.Test;

class FaultToleranceTest {

    @Test
    void print() {
        System.out.println("fault_tolerance");
        System.out.println("-------------------");
        List<Object> intStrList = Arrays.asList("1", "2", "3");
        System.out.println("result : " + listSum(intStrList));
        System.out.println("-------------------");
        List<Object> intList = Arrays.asList(1, 2, 3);
        System.out.println("result : " + listSum(intList));
        System.out.println("-------------------");
        List<Object> strList = Arrays.asList("a", "2", "c");
        System.out.println("result : " + listSum(strList));
    }

    private static int listSum(List<Object> lists) {
        try {
            return lists.stream().mapToInt(x -> Integer.parseInt(x.toString())).sum();
        }catch (NumberFormatException e){
            return 0;
        }
    }
}

결과는 아래와 같다.

문제는 무엇인가? Integer 값은 물론이고 Integer로 변환될수 있는 값이면 정상적으로 sum해준다. 또한 잘못된 값이 들어 왔어도 0으로 처리하기 때문에 이 시스템이 멈추는일 없이 항상 운영될것이기 때문에 안정성이 증가되었다. 하지만 안정성을 증가시킨 대신 신뢰성이 높다고는 판단할수 없다. 과연 a 2 c를 입력받아 합쳐진 값이 0으로 판단할 기준이 어디에 있을까? 과연 a 2 c에 이 아닌 "11 ", "2", "2" 이란 띄어쓰기가 잘못들어 갔을 경우도 0으로 반환한다. 그리고 개발자는 잘못된 값에 대한 피드백을 받기 쉽지 않다.

차라리.....

@Test
    void print2() {
        try {
            System.out.println("fault_tolerance");
            System.out.println("-------------------");
            List<Object> intStrList = Arrays.asList("1", "2", "3");
            System.out.println("result : " + listSum2(intStrList));
            System.out.println("-------------------");
            List<Object> intList = Arrays.asList(1, 2, 3);
            System.out.println("result : " + listSum2(intList));
            System.out.println("-------------------");
            List<Object> strList = Arrays.asList("a ", "2", "c");
            System.out.println("result : " + listSum2(strList));
        } catch (NumberFormatException e) {
            System.out.println("error : " + e.getMessage());
        }
    }

    private static int listSum2(List<Object> lists) {
        return lists.stream().mapToInt(x -> Integer.parseInt(x.toString())).sum();
    }

위와 같이 코드를 만들면 "a ", "2", "c"가 들어왔을 경우 바로 에러가 나오고 시스템은 멈출것이다. 시스템은 멈춰지만 신뢰성을 높아지고 오류에 대한 피드백이 빨라 개발자는 해당 오류를 찾아 고칠려고 할것이다. 또 중요한점은 NumberFormatException의 처리가 메인 함수에 있다는 것 또한 명심해야 한다. Exception이 메인 함수로 갈수록 코드를 읽기 쉬워진다. Exception의 처리 로직이 메인에 있을수록 코드에 가시성이 높아지며 처리하기도 쉽다.

• 결론에 앞서 ... 항상 운영중인 시스템에는 회사마다 또는 서비스 마다의 rule이 존재한다. 결국 그 rule에 따라 결정이 달라지며 그 rule에 의해 대책에 마련되어 있기 마련이다.

결론

우린 내부의 오류를 숨기지 말고 최대한 빨리 알려주고 전파를 막아야 한다. 특히 오류를 숨기고 동작하게 만드는 내결합성이 높은 프로그램은 나중에 더 큰문제를 야기할뿐더러 데이터를 항상 깨트릴 수 있다는걸 명심해야 한다.

내결합성에 대해 이해 해보도록 하는 포스팅을 작성하려고 합니다.

• 내결합성이란? 내결함성(Fault Tolerance)은 하나 이상의 구성 요소가 고장나도 시스템이 중단 없이 계속 작동할 수 있는 능력을 의미합니다.

우리가 작성한 프로그램에 오류가 있어도 프로그램에 중단없이 계속 작동할수 있게 작업을 해야될지 아니면 프로세스를 중단시키는게 나을지를 한번쯤은 모두 고민해 봤을 겁니다.

아래 코드는 리스트의 값을 입력받아 sum을 하는 간단한 예제이다.

import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.Test;

class FaultToleranceTest {

    @Test
    void print() {
        System.out.println("fault_tolerance");
        System.out.println("-------------------");
        List<Object> intStrList = Arrays.asList("1", "2", "3");
        System.out.println("result : " + listSum(intStrList));
        System.out.println("-------------------");
        List<Object> intList = Arrays.asList(1, 2, 3);
        System.out.println("result : " + listSum(intList));
        System.out.println("-------------------");
        List<Object> strList = Arrays.asList("a", "2", "c");
        System.out.println("result : " + listSum(strList));
    }

    private static int listSum(List<Object> lists) {
        try {
            return lists.stream().mapToInt(x -> Integer.parseInt(x.toString())).sum();
        }catch (NumberFormatException e){
            return 0;
        }
    }
}

결과는 아래와 같다.

문제는 무엇인가? Integer 값은 물론이고 Integer로 변환될수 있는 값이면 정상적으로 sum해준다. 또한 잘못된 값이 들어 왔어도 0으로 처리하기 때문에 이 시스템이 멈추는일 없이 항상 운영될것이기 때문에 안정성이 증가되었다. 하지만 안정성을 증가시킨 대신 신뢰성이 높다고는 판단할수 없다. 과연 a 2 c를 입력받아 합쳐진 값이 0으로 판단할 기준이 어디에 있을까? 과연 a 2 c에 이 아닌 "11 ", "2", "2" 이란 띄어쓰기가 잘못들어 갔을 경우도 0으로 반환한다. 그리고 개발자는 잘못된 값에 대한 피드백을 받기 쉽지 않다.

차라리.....

@Test
    void print2() {
        try {
            System.out.println("fault_tolerance");
            System.out.println("-------------------");
            List<Object> intStrList = Arrays.asList("1", "2", "3");
            System.out.println("result : " + listSum2(intStrList));
            System.out.println("-------------------");
            List<Object> intList = Arrays.asList(1, 2, 3);
            System.out.println("result : " + listSum2(intList));
            System.out.println("-------------------");
            List<Object> strList = Arrays.asList("a ", "2", "c");
            System.out.println("result : " + listSum2(strList));
        } catch (NumberFormatException e) {
            System.out.println("error : " + e.getMessage());
        }
    }

    private static int listSum2(List<Object> lists) {
        return lists.stream().mapToInt(x -> Integer.parseInt(x.toString())).sum();
    }

위와 같이 코드를 만들면 "a ", "2", "c"가 들어왔을 경우 바로 에러가 나오고 시스템은 멈출것이다. 시스템은 멈춰지만 신뢰성을 높아지고 오류에 대한 피드백이 빨라 개발자는 해당 오류를 찾아 고칠려고 할것이다. 또 중요한점은 NumberFormatException의 처리가 메인 함수에 있다는 것 또한 명심해야 한다. Exception이 메인 함수로 갈수록 코드를 읽기 쉬워진다. Exception의 처리 로직이 메인에 있을수록 코드에 가시성이 높아지며 처리하기도 쉽다.

• 결론에 앞서 ... 항상 운영중인 시스템에는 회사마다 또는 서비스 마다의 rule이 존재한다. 결국 그 rule에 따라 결정이 달라지며 그 rule에 의해 대책에 마련되어 있기 마련이다.

결론

우린 내부의 오류를 숨기지 말고 최대한 빨리 알려주고 전파를 막아야 한다. 특히 오류를 숨기고 동작하게 만드는 내결합성이 높은 프로그램은 나중에 더 큰문제를 야기할뿐더러 데이터를 항상 깨트릴 수 있다는걸 명심해야 한다.