돈나뉴의 기술블로그

오늘 Spring  Boot 에 Logback 설정을 하다가 profile 에 따라 분리의 필요성을 느껴 찾아보고 적용하였습니다.

우선 logback.xml 파일은 spring extention 을 사용할 수 있게 logback-spring.xml 로 이름을 짓습니다.

그리고 2가지 경우로 나누어 설정해 보았습니다.

첫번째로 미리 appender 를 선언하고 호출하여 쓰는 경우.

<property name="LOG_PATH" value=""/>
<property name="LOG_FILE_NAME" value=""/>

<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>
%-5level %d{HH:mm:ss.SSS} [%thread %F:%L] %method - %msg%n
</pattern>
</encoder>
</appender>

<appender name="ROLLING_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
<file>${LOG_PATH}/${LOG_FILE_NAME}.log</file>
<encoder>
<pattern>%-5level %d{HH:mm:ss.SSS} [%thread %F:%L] %method - %msg%n</pattern>
</encoder>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<fileNamePattern>${LOG_PATH}/${LOG_FILE_NAME}.%d{yyyy-MM-dd}_%i.log.gz</fileNamePattern>
<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<maxFileSize>100MB</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>
<maxHistory>60</maxHistory>
</rollingPolicy>
</appender>

<springProfile name="dev | stage">
<root level="DEBUG">
<appender-ref ref="CONSOLE"/>

<appender-ref ref="ROLLING_FILE"/>

</root>
</springProfile>

이렇게 쓸경우 springProfile 에 따라 appender 가 중복되지 않고 호출만 하여 사용하면 되어 편리합니다.

하지만 로그 파일의 위치가 권한이 필요한 곳이라면 미리 appender 를 선언하고 해당 설정을 읽을때 파일에 접근, 생성하기 때문에 따로 권한을 줘야합니다. (제 경우에는 앱 실행당시 바로 access denied 가 떴었습니다.)

두번째로 springProfile 별로 선언하고 쓰는 경우.

<springProfile name="dev | stage">

<property name="LOG_PATH" value=""/>
<property name="LOG_FILE_NAME" value=""/>

<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>
%-5level %d{HH:mm:ss.SSS} [%thread %F:%L] %method - %msg%n
</pattern>
</encoder>
</appender>

<appender name="ROLLING_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
<file>${LOG_PATH}/${LOG_FILE_NAME}.log</file>
<encoder>
<pattern>%-5level %d{HH:mm:ss.SSS} [%thread %F:%L] %method - %msg%n</pattern>
</encoder>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<fileNamePattern>${LOG_PATH}/${LOG_FILE_NAME}.%d{yyyy-MM-dd}_%i.log.gz</fileNamePattern>
<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<maxFileSize>100MB</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>
<maxHistory>60</maxHistory>
</rollingPolicy>
</appender>

<root level="DEBUG">
<appender-ref ref="CONSOLE"/>
<appender-ref ref="ROLLING_FILE"/>
</root>
</springProfile>

이렇게 쓸경우 중복은 되지만 환경에 따라 세부적인 설정을 변경하기도 좋고 파일 생성이 필요없는 환경에서는 쓸데없이 파일을 만드는 appender 에 접근하지 않아 파일을 만들지 않아서 좋았습니다.

어느날 코딩을 하던 도중 List 에 add() 를 하였는데 에러가 발생하였다.

익셉션은 UnsupportedOperationException.

원인을 찾던 도중 해결에 결정적인 역활을 하는 글과 재밌는 것을 발견하였다.

우선 글은

https://stackoverflow.com/questions/5755477/java-list-add-unsupportedoperationexception

인데 내용을 번역해보자면

모든 List 는 add() 메서드를 구현, 지원하지 않으며 가장 일반적인 예로 Arrays.asList(); 같은 경우 고정된 사이즈의 Array 를 리턴한다.
그렇기에 사이즈를 수정할 수 없다.

이다.

나같은 경우 Arrays.asList(); 를 통해 만들어진 ArrayList 에 add 를 하고 있었다.

그래서 궁금한 마음에 Arrays  클래스를 확인해본 결과 우리가 흔히 사용하는 ArrayList 를 반환하는게 아니라 

Arrays 클래스 내부에 inner Class 로 구현해놓은 ArrayList 를 반환하고 있었다.

당연하게도 Arrays 클래스의 inner Class 인 ArrayList 에는 사이즈 측정 및 조절을 위한 size 와 DEFAULT_CAPACITY 변수가 존재하지 않는다.

그리고 AbstractList 클래스를 상속받고 있어 상속받은 AbstractList 클래스의 add() 메서드는 존재하고 사용할 수는 있지만 

해당 AbstractList 클래스의 add() 메서드를  Override 하여 사용하지 않으면 해당 add() 메서드는  

throw new UnsupportedOperationException(); 하도록 구현되어있기 때문에 UnsupportedOperationException 에러가 나게 된다.

[React Native] this.state.list.map is not a function

개인 프로젝트로 React Native 를 개발하던 도중 this.state.list.map is not a function 이라는 에러를 만났다.

금방 고칠 수 있었는데 .map() 은 Array 를 위한 함수로 그 외에 String 이나 다른 값이 들어가게 되면 에러를 내게 된다.

map() 메서드는 배열 내의 모든 요소 각각에 대하여 주어진 함수를 호출한 결과를 모아 새로운 배열을 반환합니다.

라고 한다.

그래서 this.state.list 에 주입할 Array 를 만드는 부분을 보니 데이터를 받아오는 url 주소가 잘못 되어있었다.

[Node.js] Express에서 기본 Jade 템플릿 형식을 Html로 바꾸기

(Change the template system from Jade to HTML with Express)

 처음 express 를 통해 프로젝트 디렉토리를 만들경우 기본 템플릿 형식입니다.

Jade 를 처음 접하거나 쓰기 어려워하는 분들은 HTML 을 사용하고자 하는데 간단하게 기본 템플릿 형식을 바꾸는 방법이 있습니다.

출처 : https://ademirgabardo.wordpress.com/2016/03/04/how-to-change-the-template-system-from-jade-to-html-with-express/

This quick post is just to remember how to change the template engine on Express from Jade to HTML.

1. Install the ejs view engine with the NPM:

   npm install ejs

2. Set your template engine in app.js (or in your custom .js app file) as ejs

   app.engine('html', require('ejs').renderFile);
   app.set('view engine', 'html');

3. In the route file ./routes/index.js  assign template variables like this

   exports.index = function(req, res){
   res.render('index', { title: 'Page title' });};

4. Create the HTML files in the view folder /views.

2번 항목에서 app.js 파일을 보면 아래와 같이 기본 템플릿이 Jade 로 설정되어 있는 것을 볼 수 있습니다.

app.set('view engine', 'jade');

이를 지우거나 주석처리를 하고 2번을 진행하시면 됩니다.

profiles 를 활용하여 설정 값 변경하기.

스프링 개발을 하다보면 환경, 앱을 돌리고자 하는 목적에 따라 설정 값을 환경에 맞춰 변경해줘야 하는 경우가 생깁니다.

이럴 때 일일이 바꿀 필요 없이 편하게 설정 값을 변경하는 방법이 있습니다.

profiles 를 활용하는 방법입니다.

우선 환경에 따라 다른 설정 값을 가진 설정 파일을 여러개 만듭니다.

(저는 yml 을 사용했지만 properties를 사용하셔도 됩니다. )

그 후 위와 같이 Edit Configurations... 를 클릭합니다.

그 후 위 사진처럼 VM options 입력란에 -Dspring.profiles.active=적용하고자하는 환경 을 입력하고 앱을 run 시키면 설정한 환경의 설정 값을 가지고 있는 설정파일을 바탕으로 돌고 있는 것을 확인할 수 있습니다.

또는 터미널에서 실행시키고 싶다면 shell script 혹은 직접 위와같이 직접 쳐서 환경 설정 파일을 바꾸어 실행할 수 있습니다.

BiFunction과 TriFunction

Java 8에 BiFunction 이라는 것이 추가되었습니다.

private BiFunction<Integer, String, String> createStatusErrorMessage = (code, status) -> {
    StringBuilder sb = new StringBuilder();

    //do something.

    return sb.toString();
};

기본적인 생김새는 위와 같습니다.

앞의 두개의 타입으로 파라미터를 받고 3번째 타입으로 return 하겠다는 의미입니다.

TriFunction도 있을 거라고 생각을 했는데 없어서 따로 만들어야 합니다.

@FunctionalInterface
public interface TriFunction<A, B, C, R> {

    R apply(A a, B b, C c);

    default <V> TriFunction<A, B, C, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (A a, B b, C c) -> after.apply(apply(a, b, c));
    }
}

위와 같이 FunctionalInterface annotation을 넣은 TriFunction interface를 만듭니다.

생김새는 BiFunction과 거의 같습니다.

private TriFunction<String, String, String, String> createStatusErrorMessage = (paymentStatus, pgStatus, pgType) -> {
    StringBuilder statusErrorBuilder = new StringBuilder();

    //do something.

    return statusErrorBuilder.toString();
};

BiFunction과 TriFunction의 사용방법도 같습니다.

예를 들어 Parameter를 분류하여 ErrorMessage 를 생성하는 용도로 사용한다고 하겠습니다.

private static Map<String, TriFunction<String, String, String, String>> errorBuilderMap = new HashMap<>();

public ErrorMessageBuilder() {
    errorBuilderMap.put("STATUS", createStatusErrorMessage);
}

public String build() {
    return errorBuilderMap.get(errorMessageBuilder.errorType)
            .apply(errorMessageBuilder.data1, errorMessageBuilder.data2, errorMessageBuilder.data3);
}

위와 같이 Map<String, TriFunction> 에 Key로 사용할 에러 메세지 타이틀과 에러 메세지를 만들 TriFunction을 넣습니다.

그리고 파라미터를 입력받아 TriFunction을 get하여 TriFunction.apply(parameter1, parameter2, parameter3) 하면 해당 TriFunction이 호출되어 실행되고 값을 리턴합니다. 

[직관적인 클린 코드를 위해] IF - ELSE IF 문 줄이기 2

이번 블로그 글은 저번에 이은 '[직관적인 클린 코드를 위해] IF - ELSE IF 문 줄이기 2' 입니다.

저번에는 동시에 확인해야 하는 조건이 하나일 경우에 IF, ELSE IF 문을 줄이는 방법을 봤습니다.

하지만 만약 동시에 확인해야 할 조건이 2개면 어떨까요?

public static void main(String[] args) {
    Map<String, Alphabet> typeMap = new HashMap<>();
    typeMap.put("A", new A());
    typeMap.put("B", new B());
    typeMap.put("C", new C());

    String type = "B";
    
    if(첫번째 조건) {
        typeMap.get(type).test();
    }
    else if(첫번째 조건) {
        typeMap.get(type).test();   
    }
    else if(첫번째 조건) {
        typeMap.get(type).test();
    }
}

어쩔 수 없이 IF, ELSE IF 문을 사용해야 하는 것일까요?

예를 들어 상황을 가정하겠습니다.

DB의 여러 테이블에서 데이터를 받는데 이를 테이블 명과 Insert, Update, Delete 로 동시에 구분해서 수행해야 한다고 가정하겠습니다.

공통적인 부분으로 묶어보겠습니다.

• 각각의 테이블은 Insert, Update, Delete가 일어납니다.

interface Insert {
    public void insert();
}

class A implements Insert{
    @Override
    public void insert() {

    }
}

class B implements Insert{
    @Override
    public void insert() {

    }
}

class C implements Insert{
    @Override
    public void insert() {

    }
}

Insert 패키지를 만들고 insert 추상매서드를 가진 인터페이스를 생성했습니다.

그리고 이 인터페이스를 implements 하는 3개의 클래스를 각각 만들었습니다.

Update와 Delete도 똑같이 했습니다.

하지만 이렇게 해도 1번 글과 같이 Map에 넣어 한번에 알아서 분류되고 원하는 value가 나오게 하려면 Insert, Update, Delete 인터페이스 타입을 value로 가진 각각의 Map이 필요합니다.

다시 공통적인 요소를 생각해보면 Insert, Update, Delete는 DB의 Crud 중 하나입니다.

interface Crud {
    public void execute();
}

interface Insert extends Crud{
    public void insert();
}

class A implements Insert{
    @Override
    public void execute() {
        insert();
    }

    @Override
    public void insert() {

    }
}

Crud 인터페이스를 만들어 이를 Insert, Update 인터페이스에 상속 시키고 A 클래스에서는 이를 구현합니다.

그리고 두가지 조건을 처리하기 위해 Enum 클래스를 만들어 사용했습니다.

enum CommandEnum {
    INSERT_A("A", "insert"),
    UPDATE_A("A", "update"),
    INSERT_B("B", "insert"),
    UPDATE_B("B", "update"),
    INSERT_C("C", "insert"),
    UPDATE_C("C", "update");

    private String tableName;
    private String queryType;

    CommandEnum(String tableName, String queryType) {
        this.tableName = tableName;
        this.queryType = queryType;
    }

    public String getTableName() {
        return this.tableName;
    }

    public String getQueryType() {
        return this.queryType;
    }
}

그리고 이런 Enum을 사용하기 위해 따로 Mapper 클래스를 만들었습니다.

Mapper 클래스에서는 EnumMap을 생성하고 이를 for - each 문으로 값을 두가지 조건에 합당하는 Crud 객체를 리턴합니다.

class QueryTypeMapper {
    private EnumMap<CommandEnum, Crud> commandEnumMap = new EnumMap<CommandEnum, Crud>(CommandEnum.class);

    QueryTypeMapper() {
        commandEnumMap.put(CommandEnum.INSERT_A, new InsertA());
        commandEnumMap.put(CommandEnum.UPDATE_A, new UpdateA());
        commandEnumMap.put(CommandEnum.INSERT_B, new InsertB());
        commandEnumMap.put(CommandEnum.UPDATE_B, new UpdateB());
        commandEnumMap.put(CommandEnum.INSERT_C, new InsertC());
        commandEnumMap.put(CommandEnum.UPDATE_C, new UpdateC());
    }

    public Crud getCommand(String tableName, String type) {
        for(CommandEnum commandEnum : commandEnumMap.keySet()) {
            if(commandEnum.getTableName().equals(tableName) && commandEnum.getQueryType().equals(type)) {
                return commandEnumMap.get(commandEnum);
            }
        }
        throw new IllegalStateException("Classify command not found. ");
    }
}

이렇게 만들어진 QueryTypeMapper 클래스와 CommandEnum enum클래스를 이용해 IF - ELSE IF 문으로 어지러워 질뻔한 코드가 단 두줄로 변하게 됩니다.

아래에 전체 코드가 있습니다. InsertA 클래스만 있지만 나머지 클래스들도 같은 방식이라 넣지 않았습니다.

간략하게 짜고 바쁘게 하다보니 클래스와 매서드, 변수의 네이밍에 신경 못쓴점은 양해 부탁드립니다.

public class CleanCode {

    public static void main(String[] args) {
        String tableName = "B";
        String type = "insert";

        QueryTypeMapper queryTypeMapper = new QueryTypeMapper();
        queryTypeMapper.getCommand(tableName, type).execute();
    }
}

class QueryTypeMapper {
    private EnumMap<CommandEnum, Crud> commandEnumMap = new EnumMap<CommandEnum, Crud>(CommandEnum.class);

    QueryTypeMapper() {
        commandEnumMap.put(CommandEnum.INSERT_A, new InsertA());
        commandEnumMap.put(CommandEnum.UPDATE_A, new UpdateA());
        commandEnumMap.put(CommandEnum.INSERT_B, new InsertB());
        commandEnumMap.put(CommandEnum.UPDATE_B, new UpdateB());
        commandEnumMap.put(CommandEnum.INSERT_C, new InsertC());
        commandEnumMap.put(CommandEnum.UPDATE_C, new UpdateC());
    }

    public Crud getCommand(String tableName, String type) {
        for(CommandEnum commandEnum : commandEnumMap.keySet()) {
            if(commandEnum.getTableName().equals(tableName) && commandEnum.getQueryType().equals(type)) {
                return commandEnumMap.get(commandEnum);
            }
        }
        throw new IllegalStateException("Classify command not found. ");
    }
}

enum CommandEnum {
    INSERT_A("A", "insert"),
    UPDATE_A("A", "update"),
    INSERT_B("B", "insert"),
    UPDATE_B("B", "update"),
    INSERT_C("C", "insert"),
    UPDATE_C("C", "update");

    private String tableName;
    private String queryType;

    CommandEnum(String tableName, String queryType) {
        this.tableName = tableName;
        this.queryType = queryType;
    }

    public String getTableName() {
        return this.tableName;
    }

    public String getQueryType() {
        return this.queryType;
    }
}

interface Crud {
    public void execute();
}

interface Insert extends Crud{
    public void insert();
}

class InsertA implements Insert{
    @Override
    public void execute() {
        insert();
    }

    @Override
    public void insert() {
        System.out.println("Class A insert method!");
    }
}

제가 준비한 내용은 여기까지 입니다.

부족함이 많은 글임에도 끝까지 읽어주셔서 감사합니다.

다음에도 이와 같이 기본적인 내용이지만 괜찮다고 생각드는 것이 있으면 잘 정리해서 공유드리겠습니다.

감사합니다.

[직관적인 클린 코드를 위해] IF - ELSE IF 문 줄이기

이번 블로그 글은 '[직관적인 클린 코드를 위해] IF - ELSE IF 문 줄이기' 입니다.

직장에서 코딩을 하고 집에 와서는 친구와 함께하는 개인적인 프로젝트를 진행하며 직관적이고 깔끔한 코드를 위해 많은 고민을 했었습니다.

정답은 아니지만 그 경험을 공유하고자 하는 글이니 편하게 봐주셨으면 좋겠습니다.

코딩을 하다 보면 깔끔하고 보기 좋게 짜겠다는 처음 생각과 다르게 지저분해지는 경우가 많습니다.

그 주요 요인 중 하나로 수많은 IF 문과 그에 이어지는 ELSE IF 문 을 많이 꼽으실 겁니다. (Switch - case 도..)

처음 생각과 다르게 여러가지 조건이 생기고 그 조건을 검사해서 분류해야 하는 경우 가장 쉽게 할 수 있는 방법이기에 더욱 그런 것 같습니다.

하지만 그 간편함과 다르게 점점 IF 문이 자라날수록 코드는 분간하기 어렵고 직관적인 코드와는 거리를 두게 됩니다.

public static void main(String[] args) {
    String type = "?";

    if("A".equals(type)) {

    }
    else if("B".equals(type)) {

    }
    else if("C".equals(type)) {

    }
}

위 예시같은 경우 String 변수 type에 들어있는 값을 분류하고 그에 따라 다르게 실행하기 위해 IF문과 ELSE IF 문이 걸려있습니다.

지금은 검사할 조건이 3가지라서 보기 어렵지 않을 수 있지만 조건이 증가함에 따라 보기 어려워지게 됩니다.

public static void main(String[] args) {
    String type = "?";

    if("A".equals(type)) {
        for(int i = 0; i < 10;i++) {
            if() {

            }
        }
    }
    else if("B".equals(type)) {
        for(int i = 0; i < 10;i++) {
            if() {

            }
        }
    }
    else if("C".equals(type)) {
        for(int i = 0; i < 10;i++) {
            if() {

            }
        }
    }
}

위 예시처럼 보기 어려운 코드가 될 수 있습니다.

이를 해결하기 위해선 여러가지 방법이 있을 겁니다.

그 중 저는 Map과 해당 부분을 다른 클래스로 분리를 하는 방법을 섞어썼습니다.

String 변수 type에 특정한 값이 들어오고 그 값을 분류하여 그에 따라 실행해야 하는 로직이 각각 있다고 가정하겠습니다.

public static void main(String[] args) {
    Map<String, Object> typeMap = new HashMap<>();
    
    typeMap.put("A", new A());
    typeMap.put("B", new B());
    typeMap.put("C", new C());

    String type = "?";

    typeMap.get(type).test();
}

• 이 예시에서는 HashMap을 이용하였고 메인문 안에서 생성했지만 편의상 그렇게 한 것이니 본인의 상황과 코드에 맞춰 구현하면 됩니다.

"A" 조건을 분류하는 IF 문의 내부 로직은 클래스 A의 test 메서드에, 

"B" 조건을 분류하는 ELSE IF 문의 내부 로직은 클래스 B의 test 메서드에, 

"C" 조건을 분류하는 ELSE IF 문의 내부 로직은 클래스 C의 test 매서드에 넣었습니다.

그럼 testMap.get() 에 type을 넣음으로써 원하는 분류되어있는 로직을 가지고 있는 객체가 리턴될 것 입니다.

하지만 여러 객체를 담을 수 있도록 Map의 Value 부분을 Object로 선언하여 원하는 매서드를 호출하지 못하게 되었습니다.

마우스를 가져다 대면 'Cannot resolve method test()' 라는 메세지가 뜰 것 입니다.

이유는 Object 에는 test() 라는 매서드가 없는데 호출을 하려고하니 에러가 나는 것 입니다.

이를 해결하기 위해선 간단하게 interface를 추가하면 됩니다.

interface Alphabet {
    public void test();
}

위와 같은 Alphabet 인터페이스를 추가하고 해당 인터페이스 내부에는 test() 라는 추상매서드를 추가하고 Map 의 value 자리에는 Object 대신 인터페이스 Alphabet 을 써줍니다.

그리고 해당 인터페이스를 각각 분류한 클래스에 implements 해주고 test() 메서드를 Overriding 해주면 끝입니다.

class A implements Alphabet{

    @Override
    public void test() {
        System.out.println("Alphabet A!!");
    }
}

class B implements Alphabet{

    @Override
    public void test() {
        System.out.println("Alphabet B!!");
    }
}

class C implements Alphabet{

    @Override
    public void test() {
        System.out.println("Alphabet C!!");
    }
}

이제 main 문의 typeMap.get(type).test(); 에 있던 빨간색은 사라졌을 겁니다.

그리고 돌려보면 type의 값에 따라서 출력을 하는 것을 볼 수 있습니다.

public static void main(String[] args) {
    Map<String, Alphabet> typeMap = new HashMap<>();

    typeMap.put("A", new A());
    typeMap.put("B", new B());
    typeMap.put("C", new C());

    String type = "B";

    typeMap.get(type).test();
}

제가 준비한 내용은 여기까지 입니다.

부족함이 많은 글임에도 끝까지 읽어주셔서 감사합니다.

다음에도 이와 같이 기본적인 내용이지만 괜찮다고 생각드는 것이 있으면 잘 정리해서 공유드리겠습니다.

감사합니다.