요즘 이펙티브 자바 Third 에디션 책을 동네 도서관에서 대여해서 읽고있습니다.

스트림 병렬화에 대한 글을 읽다가 소수구하는 로직을 스트림으로 작성한 부분을 보게되었습니다.

소수구하기 로직은 이직준비 할 때나 다시 들여다볼만한거라 오래전에 for-loop 로 구현해본 기억만 있다보니 신선하게 느껴졌네요.

아직도 많은 블로그들에서 for-loop를 이용한 방법들만 많이 소개하고 있기도 하고해서 포스팅 주제로 삼아봤습니다. 

개인적인 기록도 할겸...

책을 읽고 새로 알게된 부분은 스트림에 대한 부분도 있지만 이미 BigInteger 클래스에 isProbablePrime 이란 메서드가 있었다는 겁니다..

아래는 특정 숫자 n 까지 소수가 몇 개인지를 출력하고, 그 목록도 출력하는 것을 테스트한 코드입니다.

public static void main(String[] args) {
    int n = (int) Math.pow(10, 8);
    // n 까지의 수 중에 소수의 개수 출력하기
    long cnt = LongStream.rangeClosed(2, n)
    	    .parallel()
            .mapToObj(BigInteger::valueOf)
            .filter(i -> i.isProbablePrime(50))
            .count();
    System.out.println(cnt);

    // n 까지의 수 중에 소수 목록 출력하기
    System.out.println(LongStream.rangeClosed(2, n)
            .mapToObj(BigInteger::valueOf)
            .filter(i -> i.isProbablePrime(50))
            .collect(Collectors.toList()));
}

LongStream을 이용하여 숫자의 범위를 정하고 mapToObj 를 이용하여 BigInteger로 변형한뒤 BigInteger.isProbablePrime(int certainty) 메서드를 필터로 전달하여 소수를 구하고 있습니다.

BigInteger.isProbablePrime(int certainty) 메서드는 소수를 구하기위해 내부적으로 밀러-라빈(Miller-Rabin) 테스트와 루카스-레머(Lucas-Lehmer) 테스트를 사용하고 있고요. 여기서 사용된 밀러라빈 테스트는 DSA(Digital Signiture Algorithm) 스펙 (NIST FIPS 186-2)을 기반으로 했다고 합니다. 이 스펙은 파일로 첨부하니 관심있으신 분들은 다운받아 보셔도 될 것 같네요. 

참고로 .parallel() 은 스트림에서 사용할 때 매우 주의를 요하는 기능입니다. 책에서는 이렇게 얘기합니다. Stream.iterate 를 데이터 소스로 이용하거나 중간 연산으로 limit 을 사용하는 스트림 파이프라인에서는 parallel을 이용한 성능개선을 기대할 수 없으며 오히려 안좋아질 수도 있다고 말이죠. 실제로 운영환경에서 저것 때문에 이슈가 발생한 적도 있었습니다. 그냥 무한루프에 빠진것처럼 쓰레드 하나가 먹통이 되어버리더군요. 스트림에서 병렬연산에 적합한 적은 reduce, min, max, count, sum 등의 연산이며, collect처럼 가변축소를 수행하는 메서드는 병렬연산에 적합하지 않다고 합니다. 참고하시기 바랍니다.

지난 포스팅에서 요청과 응답에 대한 로그를 남기는 법에 대해서 알아보았었는데요

이어서 이번에는 출력되는 로그메시지의 내용을 바꿔보려고 합니다.

혹시라도 검색으로 이 포스팅을 먼저 보게되시는 분은 아래 포스팅을 먼저 읽어보시길 추천드립니다.

[5분코딩] Filter를 이용한 요청,응답 로깅 (How to log request, response info inlcuding payload using filter) - (1/2)

로그 메시지 내맘대로 꾸미기

우선 지난 시간에 마지막으로 확인한 로그 출력 내용을 다시 확인해보면 아래와 같습니다.

2022-09-16 07:32:49.190  INFO 31518 --- [nio-8080-exec-5] c.k.demo.filter.RequestLoggingFilter     : Before request [POST /test/request-body-log, client=0:0:0:0:0:0:0:1]
2022-09-16 07:32:49.226  INFO 31518 --- [nio-8080-exec-5] c.k.demo.filter.RequestLoggingFilter     : After request [POST /test/request-body-log, client=0:0:0:0:0:0:0:1, payload={
    "id":1000,
    "name":"케이치",
    "age":20
}]

그럼 저 메시지를 어떻게 바꿀 수 있을지 한번 알아볼게요.

요청/응답 로깅을 위해서 우리는 AbstractRequestLoggingFilter 를 상속하여 필터를 하나 만들었었습니다.

로그 메시지를 바꾸려면 저 클래스에서 어떤 메서드들을 제공하고 있는지 들여다봐야 합니다. 

AbstractRequestLoggingFilter를 까보면 아래 메서드를 오버라이드해서 재정의하고 있는 것을 볼 수 있습니다.

protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)

doFilterInternal 메서드에서 하는 일은 요청에 대한 비즈니스 로직이 실행되기 전후로 로그를 남기는 것입니다.

코드를 잠시 살펴볼게요

@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
      throws ServletException, IOException {

   boolean isFirstRequest = !isAsyncDispatch(request);
   HttpServletRequest requestToUse = request;

   if (isIncludePayload() && isFirstRequest && !(request instanceof ContentCachingRequestWrapper)) {
      requestToUse = new ContentCachingRequestWrapper(request, getMaxPayloadLength());
   }

   boolean shouldLog = shouldLog(requestToUse);
   if (shouldLog && isFirstRequest) {
      beforeRequest(requestToUse, getBeforeMessage(requestToUse));
   }
   try {
      filterChain.doFilter(requestToUse, response);
   }
   finally {
      if (shouldLog && !isAsyncStarted(requestToUse)) {
         afterRequest(requestToUse, getAfterMessage(requestToUse));
      }
   }
}

beforeRequest(requestToUse, getBeforeMessage(requestToUse)) 에서 Before request ... 로그를 남기고 있고

afterRequest(requestToUse, getAfterMessage(requestToUse)) 에서 After request ... 로그를 남기고 있습니다.

따라서 우리가 원하는대로 메시지의 내용을 바꾸려면 저 두 군데를 수정해주면 됩니다.

우선 로그 메시지에 대한 수정 요구사항이 아래와 같다고 가정해보겠습니다.

1. 호출받은 API 정보와 클라이언트IP 정보를 중복 출력 하지 않는다
2. 호출받은 API uri 와 클라이언트IP, payload 정보는  before request 에서 남긴다.  🌟
3. after request 에는 응답소요시간과 http status 코드값을 남긴다.
4. 최종적으로 출력되는 모습은 다음과 같다.

2022-09-16 08:28:08.053  INFO 41196 --- [nio-8080-exec-2] c.k.demo.filter.RequestLoggingFilter     : REQ: POST uri=/test/request-body-log;client=0:0:0:0:0:0:0:1;payload={
    "id":1000,
    "name":"케이치",
    "age":20
}
2022-09-16 08:28:08.076  INFO 41196 --- [nio-8080-exec-2] c.k.demo.filter.RequestLoggingFilter     : RES: 22ms, 400

자, 이제 위 요구사항에 맞게 우리의 필터클래스를 수정해보겠습니다. 

RequestLoggingFilter 클래스에 아래 코드를 추가해주세요.

@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
        throws ServletException, IOException {

    boolean isFirstRequest = !isAsyncDispatch(request);
    HttpServletRequest requestToUse = request;

    if (isIncludePayload() && isFirstRequest && !(request instanceof ContentCachingRequestWrapper)) {
        requestToUse = new ContentCachingRequestWrapper(request);
    }

    long start = System.currentTimeMillis();

    if (isFirstRequest) {
        beforeRequest(requestToUse, getBeforeMessage(requestToUse));
    }

    try {
        filterChain.doFilter(requestToUse, response);
    } finally {
        if (!isAsyncStarted(requestToUse)) {
            afterRequest(requestToUse, getAfterMessage(System.currentTimeMillis() - start, response.getStatus()));
        }
    }
}

private String getBeforeMessage(HttpServletRequest request) {
    return createMessage(request, "REQ: ", "");
}

private String getAfterMessage(long elapsed, int status) {
    return "RES: " + elapsed + "ms, " + status;
}

AbstractRequestLoggingFilter 에 구현되어있는 doFilterInternal 메서드 내용을 그대로 가지고와서 beforeRequest와 afterRequest 메서드의 두 번째 파라미터로 전달하는 message 를 조립하는 메서드를 직접 구현합니다. getBeforeMessage의 createMessage는 super클래스, 즉, AbstractRequestLoggingFilter 에서 제공하는 것을 그대로 사용합니다. createMessage 에서는 prefix와 suffix 그리고 request 정보를 가지고 메시지를 알아서 만들어 줍니다. payload도 역시 여기 포함되어있죠.

자, 그럼 앱을 재기동하고 로깅이 어떻게 되는지 보겠습니다.

2022-09-16 08:39:20.270  INFO 43287 --- [nio-8080-exec-1] c.k.demo.filter.RequestLoggingFilter     : REQ: POST /test/request-body-log, client=0:0:0:0:0:0:0:1
2022-09-16 08:39:20.306  INFO 43287 --- [nio-8080-exec-1] c.k.demo.filter.RequestLoggingFilter     : RES: 35ms, 200

요구사항 대부분이 반영된 것을 확인할 수 있습니다. 어라? 근데 payload 가 request 로그에서 빠져있습니다.

분명 after message 로그가 출력될 때는 잘 출력이 됐었는데 말이죠. 똑같은 createMessage 메서드를 이용했는데 before request 에서는 payload가 출력이 안됩니다 ㅜㅜ

확인해보니 AbstractRequestLoggingFilter.getMessagePayload 에서 아래 wrapper 가 null 로 반환이 되고있었습니다.

ContentCachingRequestWrapper wrapper =
      WebUtils.getNativeRequest(request, ContentCachingRequestWrapper.class);

res로그에서는 잘 나오던게 req로그에서 출력하려니 null이 반환이 됩니다.

이걸 해결하려면 추가적인 작업이 필요한데 우선 아래 두 개의 클래스를 추가해줍니다.

package com.keichee.demo.filter;

import org.springframework.stereotype.Component;
import org.springframework.web.filter.GenericFilterBean;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@Component
public class RequestBodyCacheFilter extends GenericFilterBean {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain)
            throws IOException, ServletException {
        chain.doFilter(new RequestBodyCacheWrapper((HttpServletRequest) servletRequest), servletResponse);
    }
}

package com.keichee.demo.filter;

import lombok.extern.slf4j.Slf4j;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.*;
import java.nio.charset.StandardCharsets;

@Slf4j
public class RequestBodyCacheWrapper extends HttpServletRequestWrapper {

    private final ByteArrayInputStream byteArrayInputStream;

    public RequestBodyCacheWrapper(HttpServletRequest request) throws IOException {
        super(request);
        InputStream is = super.getInputStream();
        byteArrayInputStream = new ByteArrayInputStream(is.readAllBytes());
    }

    @Override
    public ServletInputStream getInputStream() {
        byteArrayInputStream.reset();
        return new MyServletInputStream(byteArrayInputStream);
    }

    @Override
    public BufferedReader getReader() {
        byteArrayInputStream.reset();
        return new BufferedReader(new InputStreamReader(byteArrayInputStream, StandardCharsets.UTF_8));
    }


    private static class MyServletInputStream extends ServletInputStream {

        private final InputStream is;

        public MyServletInputStream(InputStream bis) {
            is = bis;
        }

        @Override
        public int read() throws IOException {
            return is.read();
        }

        @Override
        public int read(byte[] b) throws IOException {
            return is.read(b);
        }

        @Override
        public boolean isFinished() {
            return false;
        }

        @Override
        public boolean isReady() {
            return false;
        }

        @Override
        public void setReadListener(ReadListener readListener) {
        }
    }
}

이제 다시 RequestLoggingFilter 클래스로 돌아와서 AbstractRequestLoggingFilter.createMessage 메서드를 그대로 복사해서 가지고 옵니다. 그리고 getMessagePayload 부분을 아래와 같이 수정해주세요. 다른 부분은 그대로 놔둡니다.

String payload = null;
try {
    payload = new String(request.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
} catch (IOException e) {
    log.error("failed to read payload", e);
}

수정이 완료된 createMessage 메서드는 아래와 같습니다.

@Override
protected String createMessage(HttpServletRequest request, String prefix, String suffix) {
    StringBuilder msg = new StringBuilder();
    msg.append(prefix);
    msg.append(request.getMethod()).append(' ');
    msg.append(request.getRequestURI());

    if (isIncludeQueryString()) {
        String queryString = request.getQueryString();
        if (queryString != null) {
            msg.append('?').append(queryString);
        }
    }

    if (isIncludeClientInfo()) {
        String client = request.getRemoteAddr();
        if (StringUtils.hasLength(client)) {
            msg.append(", client=").append(client);
        }
        HttpSession session = request.getSession(false);
        if (session != null) {
            msg.append(", session=").append(session.getId());
        }
        String user = request.getRemoteUser();
        if (user != null) {
            msg.append(", user=").append(user);
        }
    }

    if (isIncludeHeaders()) {
        HttpHeaders headers = new ServletServerHttpRequest(request).getHeaders();
        if (getHeaderPredicate() != null) {
            Enumeration<String> names = request.getHeaderNames();
            while (names.hasMoreElements()) {
                String header = names.nextElement();
                if (!getHeaderPredicate().test(header)) {
                    headers.set(header, "masked");
                }
            }
        }
        msg.append(", headers=").append(headers);
    }

    if (isIncludePayload()) {
        String payload = null;
        try {
            payload = new String(request.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
        } catch (IOException e) {
            log.error("failed to read payload", e);
        }
        if (payload != null) {
            msg.append(", payload=").append(payload);
        }
    }

    msg.append(suffix);
    return msg.toString();
}

마지막으로 doFilterInternal 메서드 로직 중 filterChain.doFilter에서 사용하는 request 객체를 ContentCachingRequestWrapper 가 아닌 메서드 파라미터로 전달받은 request를 그대로 사용하도록 수정합니다. (reuqestToUse -> request)

최종적으로 RequestLoggingFilter 클래스의 소스코드는 다음과 같습니다.

package com.keichee.demo.filter;

import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpHeaders;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.AbstractRequestLoggingFilter;
import org.springframework.web.util.ContentCachingRequestWrapper;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Enumeration;

@Slf4j
public class RequestLoggingFilter extends AbstractRequestLoggingFilter {

    @Override
    protected void beforeRequest(HttpServletRequest request, String message) {
        logger.info(message);
    }

    @Override
    protected void afterRequest(HttpServletRequest request, String message) {
        logger.info(message);
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {

        boolean isFirstRequest = !isAsyncDispatch(request);
        HttpServletRequest requestToUse = request;

        if (isIncludePayload() && isFirstRequest && !(request instanceof ContentCachingRequestWrapper)) {
            requestToUse = new ContentCachingRequestWrapper(request);
        }

        long start = System.currentTimeMillis();

        if (isFirstRequest) {
            beforeRequest(requestToUse, getBeforeMessage(requestToUse));
        }

        try {
            filterChain.doFilter(request, response);
        } finally {
            if (!isAsyncStarted(requestToUse)) {
                afterRequest(requestToUse, getAfterMessage(System.currentTimeMillis() - start, response.getStatus()));
            }
        }
    }

    private String getBeforeMessage(HttpServletRequest request) {
        return createMessage(request, "REQ: ", "");
    }

    private String getAfterMessage(long elapsed, int status) {
        return "RES: " + elapsed + "ms, " + status;
    }

    @Override
    protected String createMessage(HttpServletRequest request, String prefix, String suffix) {
        StringBuilder msg = new StringBuilder();
        msg.append(prefix);
        msg.append(request.getMethod()).append(' ');
        msg.append(request.getRequestURI());

        if (isIncludeQueryString()) {
            String queryString = request.getQueryString();
            if (queryString != null) {
                msg.append('?').append(queryString);
            }
        }

        if (isIncludeClientInfo()) {
            String client = request.getRemoteAddr();
            if (StringUtils.hasLength(client)) {
                msg.append(", client=").append(client);
            }
            HttpSession session = request.getSession(false);
            if (session != null) {
                msg.append(", session=").append(session.getId());
            }
            String user = request.getRemoteUser();
            if (user != null) {
                msg.append(", user=").append(user);
            }
        }

        if (isIncludeHeaders()) {
            HttpHeaders headers = new ServletServerHttpRequest(request).getHeaders();
            if (getHeaderPredicate() != null) {
                Enumeration<String> names = request.getHeaderNames();
                while (names.hasMoreElements()) {
                    String header = names.nextElement();
                    if (!getHeaderPredicate().test(header)) {
                        headers.set(header, "masked");
                    }
                }
            }
            msg.append(", headers=").append(headers);
        }

        if (isIncludePayload()) {
            String payload = null;
            try {
                payload = new String(request.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
            } catch (IOException e) {
                log.error("failed to read payload", e);
            }
            if (payload != null) {
                msg.append(", payload=").append(payload);
            }
        }

        msg.append(suffix);
        return msg.toString();
    }

}

자, 이제 앱을 재기동하고 다시 API를 호출해보겠습니다.

2022-09-16 10:04:36.918 DEBUG 57590 --- [           main] com.keichee.demo.DemoLoggingApplication  : Running with Spring Boot v2.7.3, Spring v5.3.22
2022-09-16 10:04:36.918  INFO 57590 --- [           main] com.keichee.demo.DemoLoggingApplication  : The following 1 profile is active: "local"
2022-09-16 10:04:37.301 DEBUG 57590 --- [           main] c.k.demo.filter.RequestBodyCacheFilter   : Filter 'requestBodyCacheFilter' configured for use
2022-09-16 10:04:37.301 DEBUG 57590 --- [           main] c.k.demo.filter.RequestLoggingFilter     : Filter 'loggingFilter' configured for use
2022-09-16 10:04:37.416  INFO 57590 --- [           main] com.keichee.demo.DemoLoggingApplication  : Started DemoLoggingApplication in 0.642 seconds (JVM running for 0.873)
2022-09-16 10:04:39.588  INFO 57590 --- [nio-8080-exec-2] c.k.demo.filter.RequestLoggingFilter     : REQ: POST /test/request-body-log, client=0:0:0:0:0:0:0:1, payload={
    "id":1000,
    "name":"케이치",
    "age":20
}
2022-09-16 10:04:39.627  INFO 57590 --- [nio-8080-exec-2] c.k.demo.filter.RequestLoggingFilter     : RES: 40ms, 200

request payload가 정상적으로 출력되는 것을 확인할 수 있습니다. 응답 status도 200이 나온것을 확인했습니다.

자, 잘 따라 오셨나요? 

이 부분은 tricky한 부분이라 비즈니스 로직이 실행되기 전에 request body를 출력하는 부분에서 애를 먹는 분들이 많습니다. stackoverflow에서 해결책을 찾기도 힘들더군요. 의도한건지는 모르겠으나 springboot에 내장된 tomcat에 request body를 한번만 읽어서 쓸 수 있도록 제한(?)되어있기 때문에 잘못 설정하면 로그에는 payload가 잘 출력되지만 비즈니스로직 실행시 request body를 못 읽어와서 400 bad request가 발생하기도 합니다.

이상으로 request, response 로그를 내맘대로 바꿔보는 방법에 대해서 알아보았습니다.

읽어주셔서 감사합니다~ 🙇

좋아요 꾹 눌러주고 가세요~ 

개발자로서 운영이슈를 해결하기 위해서는 로그메시지가 디버깅을 위해서 꼭 필요하다는건 누구나 알고계실겁니다.

하지만 로깅을 잘 하기 위해서는 많은 고민이 필요합니다.

로그레벨은 어떻게 할지 로그의 내용은 어떤 정보들로 채워넣을지 등등 말이죠.

로그는 많이 남긴다고 좋은게 아니죠.

어떤 분들은 아무런 의미도 없는 정보를 로깅하기도 합니다.

비용적인 측면이 문제되지 않는다면 대량의 로그를 마음껏 남겨도 되겠지만 현실은 그렇지 않죠.

따라서 중요도에 따라서 적당~~히 최소한의 내용만 로깅하는게 좋습니다.

로그 중에서 가장 중요한 로그는 요청과 응답에 대한 것입니다.

API 요청시 어떤 정보를 전달받았는지에 대한 request log과

그 데이터를 기준으로 비즈니스 로직을 태운 뒤에 어떤 응답을 내주었는지

response log 만 있어도 디버깅은 충분히 가능하죠.

물론 요청과 응답 중간에 로직이 복잡하다면 중간중간 추가적인 로그를 심어주는게 많은 도움이 될 수 있습니다.

그래서 이번 포스팅에서는 요청과 응답을 어떻게 로깅하는지에 대해 공유드리고자 합니다.

1. 프로젝트 생성

기본적인 개발환경은 아래와 같습니다.

• IntelliJ IDEA 2021.3.3 (Ultimate Edition)
• SpringBoot 2.7.3
• Java 18 (OpenJDK)

자, 우선 깡통 프로젝트를 만들겠습니다.

자, 깡통 프로젝트가 완성되었습니다. 

2. 라이브러리 추가

이제 개발편의를 위해 lombok과 로깅을 위한 logback 라이브러리를 추가하고, API 개발을 위해 spring-boot-starter-web 라이브러리를 추가하겠습니다.

implementation 'org.springframework.boot:spring-boot-starter-web'
implementation 'org.projectlombok:lombok:1.18.24'
annotationProcessor 'org.projectlombok:lombok:1.18.24'
implementation 'ch.qos.logback:logback-classic:1.2.11'

3. API 작성

그리고 아래와 같이 테스트용 컨트롤러를 하나 작성해줍니다.

package com.keichee.demo.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

@Slf4j
@RestController
@RequestMapping("/test")
public class TestController {

    @GetMapping("/log")
    public int requestResponseLog(@RequestParam int code) {
        log.info("requestResponseLog method called with code {}", code);
        return code;
    }
}

여기까지하고 앱을 기동한 뒤 API를 호출하여 로그가 잘 남는지 확인해볼게요.

2022-09-15 17:04:50.580  INFO 92637 --- [           main] com.keichee.demo.DemoLoggingApplication  : No active profile set, falling back to 1 default profile: "default"
2022-09-15 17:04:51.034  INFO 92637 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
2022-09-15 17:04:51.038  INFO 92637 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2022-09-15 17:04:51.038  INFO 92637 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.65]
2022-09-15 17:04:51.105  INFO 92637 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2022-09-15 17:04:51.107  INFO 92637 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 495 ms
2022-09-15 17:04:51.306  INFO 92637 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2022-09-15 17:04:51.312  INFO 92637 --- [           main] com.keichee.demo.DemoLoggingApplication  : Started DemoLoggingApplication in 0.879 seconds (JVM running for 1.294)
2022-09-15 17:05:56.173  INFO 92637 --- [nio-8080-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2022-09-15 17:05:56.173  INFO 92637 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2022-09-15 17:05:56.174  INFO 92637 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 1 ms
2022-09-15 17:05:56.186  INFO 92637 --- [nio-8080-exec-1] c.k.demo.controller.TestController       : requestResponseLog method called with code 2

제일 마지막줄에 보면 TestController에서 출력한 로그가 보이네요.

비즈니스 로직의 로그는 잘 출력되고 있으니 이제 기본적인 준비가 끝났습니다.

4. Filter 구현

요청과 응답에 대한 로그출력을 위해서 우리는 Filter를 이용할 겁니다. 

spring-web에서는 아래와 같이 여러 종류의 filter를 제공하고 있습니다.

AbstractRequestLoggingFilter
CharacterEncodingFilter
CommonsRequestLoggingFilter
CompositeFilter
CorsFilter
DelegatingFilterProxy
FormContentFilter
ForwardedHeaderFilter
GenericFilterBean
HiddenHttpMethodFilter
HttpPutFormContentFilter
OncePerRequestFilter
RelativeRedirectFilter
RelativeRedirectResponseWrapper
RequestContextFilter
ServletContextRequestLoggingFilter
ServletRequestPathFilter
ShallowEtagHeaderFilter

여기서 request logging과 관련된 filter는 AbstractRequestLoggingFilter, CommonsRequestLoggingFilter, 그리고 ServletContextRequestLoggingFilter 가 있습니다.

우리는 AbstractRequestLoggingFilter를 상속해서 우리만의 필터를 만들어 볼거에요.

com.keichee.demo 패키지 아래에 filter 패키지를 만들고 이 안에 RequestLoggingFilter 라는 클래스를 아래와 같이 만들어주세요

package com.keichee.demo.filter;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.filter.AbstractRequestLoggingFilter;
import org.springframework.web.util.ContentCachingRequestWrapper;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Slf4j
public class RequestLoggingFilter extends AbstractRequestLoggingFilter {

    @Override
    protected void beforeRequest(HttpServletRequest request, String message) {
        logger.info(message);
    }

    @Override
    protected void afterRequest(HttpServletRequest request, String message) {
        logger.info(message);
    }
}

이제 이 필터를 빈으로 등록해줘야 합니다.

com.keichee.demo 패키지 아래에 config 패키지를 만들고 이 안에 RequestLoggingConfig 클래스를 만들겠습니다.

package com.keichee.demo.config;

import com.keichee.demo.filter.RequestLoggingFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RequestLoggingConfig {

    public static int MAX_PAYLOAD_LENGTH = 1000;

    @Bean
    public RequestLoggingFilter loggingFilter() {
        RequestLoggingFilter filter = new RequestLoggingFilter();
        filter.setIncludeClientInfo(true);
        filter.setIncludeHeaders(false);
        filter.setIncludePayload(true);
        filter.setIncludeQueryString(true);
        filter.setMaxPayloadLength(MAX_PAYLOAD_LENGTH);
        return filter;
    }
}

헤더정보 로깅이 필요할 경우 setIncludeHeaders(true)로 설정해주시면 됩니다.

payload의 max length는 로깅량과 로그를 저장하는 시스템의 용량 등에 따라 적당히 설정해주시면됩니다. 

이제 마지막 한스텝이 남았습니다.

logback-spring.xml 파일을 resources 디렉토리에 추가해줍니다.

<?xml version="1.0" encoding="UTF-8"?>

<configuration>

    <include resource="org/springframework/boot/logging/logback/defaults.xml"/>
    <include resource="org/springframework/boot/logging/logback/console-appender.xml"/>

    <springProfile name="local">
        <logger name="com.keichee.demo" level="debug" additivity="false">
            <appender-ref ref="CONSOLE"/>
        </logger>

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

</configuration>

지금까지 작성한 파일들을 포함하여 최종적으로 패키지 트리를 보면 아래와 같습니다.

이제 active profile 값에 local 을 주고 앱을 재기동한뒤 필터가 정상적으로 적용되었는지 확인해보겠습니다.

2022-09-16 07:28:54.399 DEBUG 31518 --- [           main] com.keichee.demo.DemoLoggingApplication  : Running with Spring Boot v2.7.3, Spring v5.3.22
2022-09-16 07:28:54.399  INFO 31518 --- [           main] com.keichee.demo.DemoLoggingApplication  : The following 1 profile is active: "local"
2022-09-16 07:28:54.751 DEBUG 31518 --- [           main] c.k.demo.filter.RequestLoggingFilter     : Filter 'loggingFilter' configured for use
2022-09-16 07:28:54.866  INFO 31518 --- [           main] com.keichee.demo.DemoLoggingApplication  : Started DemoLoggingApplication in 0.607 seconds (JVM running for 0.819)

출력되는 로그 중에 Filter 'loggingFilter' configured for use 가 출력된걸로 보아 정상적으로 적용이 된 것으로 확인됩니다.

이제 기존에 만들어 두었던 API를 다시 호출해보겠습니다.

2022-09-16 07:29:18.541  INFO 31518 --- [nio-8080-exec-2] c.k.demo.filter.RequestLoggingFilter     : Before request [GET /test/log?code=2, client=0:0:0:0:0:0:0:1]
2022-09-16 07:29:18.550  INFO 31518 --- [nio-8080-exec-2] c.k.demo.controller.TestController       : requestResponseLog method called with code 2
2022-09-16 07:29:18.560  INFO 31518 --- [nio-8080-exec-2] c.k.demo.filter.RequestLoggingFilter     : After request [GET /test/log?code=2, client=0:0:0:0:0:0:0:1]

요청에 대한 정보 uri와 query parameter 그리고 client에 X-Forwarded-For 값이 출력된 것을 볼 수 있고, 비즈니스 로직 실행이 끝난 뒤 소요시간이 얼마인지 http status 값이 뭔지 출력되는 것을 확인할 수 있습니다.

지금까지 요청에 대한 uri, query parameter와 API를 요청한 클라이언트의 IP 를 출력하고,

응답을 주기까지의 소요시간과 응답 상태값을 로깅하도록 설정을 해보았습니다. 여기까지 잘 따라 오셨나요? 😋

이제 request body 를 입력받아 payload가 잘 출력되는지 보겠습니다.

TestController 에 request body를 받는 API를 하나 추가하겠습니다.

@PostMapping("/request-body-log")
public long requestBodyLog(@RequestBody Employee employee) {
    return employee.getId();
}

Employee 정보를 받아서 id를 그대로 리턴해주는 간단한 API입니다. (어차피 request body 로깅을 위한거니 심플하게 

그리고 domain 패키지 하위에 Employee 클래스를 아래와 같이 생성해주겠습니다.

@Getter
@Setter
@FieldDefaults(level = AccessLevel.PRIVATE)
public class Employee {
    long id;
    String name;
    int age;
}

이제  앱을 기동해서 postman으로 테스트를 해보겠습니다.

로그는 아래와 같이 출력되었습니다.

2022-09-16 07:32:49.190  INFO 31518 --- [nio-8080-exec-5] c.k.demo.filter.RequestLoggingFilter     : Before request [POST /test/request-body-log, client=0:0:0:0:0:0:0:1]
2022-09-16 07:32:49.226  INFO 31518 --- [nio-8080-exec-5] c.k.demo.filter.RequestLoggingFilter     : After request [POST /test/request-body-log, client=0:0:0:0:0:0:0:1, payload={
    "id":1000,
    "name":"케이치",
    "age":20
}]

그런데 로그를 보니 uri 정보와 client 정보가 중복되서 출력이 되고 있고, request body로 넘겨준 데이터가 비즈니스 로직이 모두 실행되고 난 뒤에 출력되는 After request ... 부분에 출력이 되고 있습니다. 뭔가 출력되는 내용이 마음에 들지 않네요. 

다음 포스팅에서는 로그메시지를 바꿔보도록 하겠습니다.

읽어주셔서 감사합니다~ 🙇

도움이 되셨다면 좋아요 꾹 눌러주고 가세요~

[ 다음 포스팅 바로 읽기 ]

안녕하세요~ 오랜만에 포스팅을 하게되네요.

오늘은 스프링부트 기반의 프로젝트에서 스프링캐시를 사용하는 방법에 대해서 공유드리려고 합니다.

스프링캐시는 레디스, 카페인, ehcache 등과 연계하여 사용하게 되는데요,

이번  포스팅에서는 ehcache와 연동하여 사용할 예정입니다.

우선 기본적인 개발환경은 아래와 같습니다.

• IntelliJ IDEA 2021.3.3 (Ultimate Edition)
• SpringBoot 2.7.3
• Java 18 (OpenJDK)

1. 프로젝트 생성

우선 빈 깡통 프로젝트를 만들어 볼게요.

이미 사용할 프로젝트가 있다면 건너뛰셔도 좋습니다 :)

자, 빈깡통 프로젝트 생성이 완료되었습니다.

2. 라이브러리 추가 

이제 구현 및 테스트에 필요한 라이브러리들을 추가해볼게요.

우선 현재 build.gradle 파일은 아래와 같이 되어있을거에요

plugins {
    id 'org.springframework.boot' version '2.7.3'
    id 'io.spring.dependency-management' version '1.0.13.RELEASE'
    id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '18'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

tasks.named('test') {
    useJUnitPlatform()
}

저기에 아래 5개 라이브러리들을 추가해줍니다.

implementation 'org.ehcache:ehcache:3.10.1'
implementation 'org.springframework:spring-context-support:5.3.22'

implementation 'org.projectlombok:lombok:1.18.24'
annotationProcessor 'org.projectlombok:lombok:1.18.24'

implementation 'ch.qos.logback:logback-classic:1.2.11'

왜 저 라이브러리들이 필요한지 하나씩 볼게요.

이렇게 라이브러리를 추가한 뒤 캐시설정을 좀 해주도록 할게요

3. 캐시 설정

com.example.demo.config 패키지를 만든 뒤 아래와 같이 CacheConfig 클래스를 작성해줍니다.

package com.example.demo.config;

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.jcache.JCacheCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.cache.Cache;
import javax.cache.Caching;
import javax.cache.configuration.MutableConfiguration;
import javax.cache.expiry.CreatedExpiryPolicy;
import javax.cache.expiry.Duration;
import javax.cache.spi.CachingProvider;
import java.util.concurrent.TimeUnit;

@EnableCaching
@Configuration
public class CacheConfig {

    private final CachingProvider cachingProvider = Caching.getCachingProvider();
    private final javax.cache.CacheManager cacheManager = cachingProvider.getCacheManager();

    @Bean
    public CacheManager cacheManager() {
        return new JCacheCacheManager(cacheManager);
    }

    @Bean
    public Cache<Integer, Integer> commonCache() {
        MutableConfiguration<Integer, Integer> configuration =
                new MutableConfiguration<Integer, Integer>()
                        .setTypes(Integer.class, Integer.class)
                        .setStoreByValue(false)
                        .setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new Duration(TimeUnit.SECONDS, 5)));
        return cacheManager.createCache("commonCache", configuration);
    }
}

위 내용을 간략히 살펴보면 cacheManager 빈을 하나 등록해주고 그 캐시매니저에 commonCache라는 이름의 캐시 빈을 하나 등록해주는 겁니다. 이 commonCache가 key, value 페어를 저장하는 하나의 서랍이라고 생각하시면되고요. 여기서는 키와 값의 타입이 모두 Integer 이고 만료정책은 생성시간을 기준으로 5초로 설정해주었습니다.

4. API 구현 및 테스트

이제 commonCache에 값을 저장하고 만료되기 전까지 캐시의 데이터를 사용하도록 서비스 클래스를 하나 만들어주겠습니다.

package com.example.demo.service;

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class CacheService {

    @Cacheable(cacheNames = "commonCache", cacheManager = "cacheManager", key = "#code")
    public Integer getCachedValue(int code) {
        System.out.println("계산중....");
        // DB 조회 등의 로직...
        return (int) (Math.random() * 10);
    }
}

com.example.demo.service 패키지를 만들고 CacheService 클래스를 작성했습니다.

getCachedValue 메서드에 @Cacheable 어노테이션을 붙여주고 commonCache를 사용하고 cacheManager는 CacheConfig에 등록했던 cacheManager 이름을 적어주었습니다. 그리고 key로 파라미터로 전달받는 code 값을 사용하겠다고 선언해주었습니다. 만약 key로 어떤 객체의 멤버변수를 사용해야한다면 key = "#obj.employeeId" 와 같이 사용가능합니다. (공식문서 참고)

CacheService.getCachedValue 가 호출되면 code 값을 key로하여 return된 Integer 값을 commonCache에 저장하게되고 만료시간인 5초 이내에 동일한 key값(여기서는 code 파라미터 값)으로 메서드 호출이 발생할 경우 메서드 내부의 비즈니스 로직을 타지않고 바로 캐시에 저장되어있는 값을 반환합니다. 이를 확인하기위해 계산중.... 메시지를 출력하도록 했습니다.

마지막으로 위 서비스를 호출하는 테스트 API 를 만들어 줄게요.

com.example.demo.controller 패키지를 신규추가하고 TestController를 생성하겠습니다.

package com.example.demo.controller;

import com.example.demo.service.CacheService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
@RequestMapping("/test")
@RequiredArgsConstructor
public class TestController {

    private final CacheService cacheService;

    @GetMapping("/cache")
    public Integer getCachedValue(int code) {
        log.info("Request accepted for code {}", code);
        return cacheService.getCachedValue(code);
    }
}

API 호출이 들어올때마다 Request accepted for code X 로그가 출력되도록 하고, 캐시서비스의 메서드를 호출하도록 했습니다.

이제 DemoApplication을 실행하고 API를 호출해볼게요.

2022-09-14 12:32:59.783  INFO 47720 --- [           main] com.example.demo.DemoApplication         : Started DemoApplication in 0.778 seconds (JVM running for 0.997)
2022-09-14 12:33:06.871  INFO 47720 --- [nio-8080-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2022-09-14 12:33:06.871  INFO 47720 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2022-09-14 12:33:06.872  INFO 47720 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 1 ms
2022-09-14 12:33:06.882  INFO 47720 --- [nio-8080-exec-1] c.e.demo.controller.TestController       : Request accepted for code 1
계산중....
2022-09-14 12:33:08.270  INFO 47720 --- [nio-8080-exec-2] c.e.demo.controller.TestController       : Request accepted for code 1
2022-09-14 12:33:09.186  INFO 47720 --- [nio-8080-exec-3] c.e.demo.controller.TestController       : Request accepted for code 1
2022-09-14 12:33:10.017  INFO 47720 --- [nio-8080-exec-4] c.e.demo.controller.TestController       : Request accepted for code 1
2022-09-14 12:33:10.880  INFO 47720 --- [nio-8080-exec-5] c.e.demo.controller.TestController       : Request accepted for code 1
2022-09-14 12:33:11.764  INFO 47720 --- [nio-8080-exec-6] c.e.demo.controller.TestController       : Request accepted for code 1
2022-09-14 12:33:12.631  INFO 47720 --- [nio-8080-exec-7] c.e.demo.controller.TestController       : Request accepted for code 1
계산중....
2022-09-14 12:33:13.538  INFO 47720 --- [nio-8080-exec-8] c.e.demo.controller.TestController       : Request accepted for code 1
2022-09-14 12:33:14.408  INFO 47720 --- [nio-8080-exec-9] c.e.demo.controller.TestController       : Request accepted for code 1

호출은 모두 code값 1을 넣어서 하였고, 최초 호출을 12:33:06.882 에 하면서 서비스 내부로직을 실행하여 값을 반환하였습니다. (계산중.... 출력으로 확인)

이후 12:33:11.764 까지는 계산중.... 이 출력되지 않은 것으로 보아 캐싱되어있는 값을 그대로 응답한걸로 볼 수 있습니다.

5초가 지난 12:33:12.631 에 들어온 호출건은 계산중.... 이 출력된걸로 보아 응답값에 변동이 발생했을 것으로 추측됩니다. (랜덤값으로 응답하는 서비스니 응답값에 변동이 없을 수도 있죠)

여기서 중요한 것은 응답값에 변동이 있느냐가 아니라 캐시되어있는 데이터가 만료되기 전까지 메서드 내부로직을 실행하지 않고 캐시에서 조회된 데이터를 리턴해준다는 점입니다.

이상으로 5분만에 스프링캐시와 ehcache를 이용하여 캐시를 구현하는 방법에 대해 알아보았습니다.

읽어주셔서 감사합니다~  🙇

자바에서 비동기 호출하기 (AsyncRestTemplate, ListenableFuture)

안녕하세요, 최근에 관리자용 앱을 개선하다가 비동기 처리에 대해서 공유하고 싶은 것이 있어 포스팅을 작성합니다.

제가 관리중인 관리자용 앱은 Spring Framework 4, Java 8, Bootstrap 3 기반으로 작성되어있습니다.

오래된 라이브러리들을 업그레이드 하고 싶지만 메인 업무가 아니다보니 짬날때 조금씩 업그레이드 해주고 있는데 부트스트랩이나 스프링 버전을 올리기엔 작업량이 많아보여서 안건드리고 있네요.

아무튼 자바에서 비동기로 호출을 하는 방법은 크게 두 가지가 있는 것 같습니다.

첫 번째는 callee 메서드 쪽에서 @Async 를 붙여서 비동기로 동작하게 하는 방법이 있고요

이 방법은 callee가 외부 팀이거나 외부 회사일 경우 불가능하거나 일이 빨리 진행하기 어려울 수 있습니다.

굳이 특별한 이유가 있지 않은이상 callee쪽에 요청을 할 필요는 전혀 없습니다.

하지만 callee가 내부에 있다면 아키텍처 구조상 이 방법을 선택할 수도 있습니다.

두 번째는 caller가 호출방식을 직접 비동기로 호출하는 방법입니다.

callee가 어떻게 처리하던지 caller는 신경쓸 필요가 없죠. 

단지 응답만 잘 받아서 처리해주면 됩니다.

오늘 소개해 드릴 내용은 두 번째 방식인 caller 입장에서 비동기로 호출하는 방법입니다.

스프링을 사용하신다면 API 호출하실 때 RestTemplate을 사용하실 겁니다.

근데 스프링에서는 비동기 호출을 위해서 이미 AsyncRestTemplate 을 제공하고 있습니다.

AsyncRestTemplate 을 이용해서 API를 호출하는 방법은 RestTemplate과 다를게 없죠.

그리고 당연히도 응답을 기다리지 않고 다음 프로세스를 처리하게 됩니다.

그리고 그 응답은 ListenableFuture<ResponseEntity<T>> 타입으로 받습니다.

간단한 예제를 한번 보겠습니다.

    // Autowired로 주입된 상태라 가정합니다.
    private final AsyncRestTemplate asyncRestTemplate;
	
    public void test() {
        URI uri = UriComponentsBuilder.fromUriString("http://localhost")
                .path("/test")
                .build()
                .toUri();

        HttpHeaders headers = new HttpHeaders();
        headers.add(HttpHeaders.CONTENT_TYPE, "application/json;charset=UTF-8");

        HttpEntity<String> requestEntity = new HttpEntity<>(headers);
        HttpMethod httpMethod = HttpMethod.POST;

        ListenableFuture<ResponseEntity<Void>> res = 
        	asyncRestTemplate.exchange(uri, httpMethod, requestEntity, Void.class);
        log.info("호출 성공!!");
    }

위 코드는 http://localhost/test 를 POST 방식으로 호출하고 있습니다. 헤더에 application/json;charset=UTF-8 정보도 넣어주고 있고요 응답메시지에 대해서는 Void로 처리하고 있습니다. 어떤 메시지를 응답으로 주던지 신경안쓴다는 거겠죠.

그리고 호출에 대한 결과를 ListenableFuture<ResponseEntity<Void>> res 에 받게 됩니다.

하지만 응답을 받기 전에 호출하자마자 호출 성공!! 로그를 출력하게 됩니다.

그러면 그렇게 받은 응답의 결과에 따라 정상과 실패를 구분해서 예외처리를 해줘야 할텐데 그건 어떻게 할까요?

res 에 callback 함수를 넣어주면 됩니다.

콜백을 추가한 예제를 보겠습니다.

    // Autowired로 주입된 상태라 가정합니다.
    private final AsyncRestTemplate asyncRestTemplate;

    public void test() {
        URI uri = UriComponentsBuilder.fromUriString("http://localhost")
                .path("/test")
                .build()
                .toUri();

        HttpHeaders headers = new HttpHeaders();
        headers.add(HttpHeaders.CONTENT_TYPE, "application/json;charset=UTF-8");

        HttpEntity<String> requestEntity = new HttpEntity<>(headers);
        HttpMethod httpMethod = HttpMethod.POST;

        ListenableFuture<ResponseEntity<Void>> res = asyncRestTemplate.exchange(uri, httpMethod, requestEntity, Void.class);
        res.addCallback(new ListenableFutureCallback<ResponseEntity<Void>>() {
            @Override
            public void onFailure(Throwable th) {
                log.error("실패");
            }

            @Override
            public void onSuccess(ResponseEntity<Void> voidResponseEntity) {
                if (HttpUtil.isNot2xxSuccessful(voidResponseEntity)) {
                    log.error("실패, 응답코드:{}", voidResponseEntity.getStatusCodeValue();
                } else {
                    log.info("성공");
                    // TODO: 추가 작업
                }
            }
        });

    }

여기서는 annonymous ListenableFutureCallback 클래스를 만들어서 addCallback 메서드에 넘겨주었습니다.

onFailure 와 onSuccess 메서드를 구현해주면 되는데요 이때 주의할 점이 하나 있습니다.

onSuccess 메서드가 호출되는 케이스가 2xx 성공인 케이스만이 아니라는 점입니다.

4xx 케이스도 onSuccess 메서드를 호출하게 됩니다.

onFailure는 SocketTimeout과 같은 예외가 발생하면 호출됩니다.

따라서 실질적으로 우리가 원하는 성공 은 response entity에서 응답코드로 확인해줘야 합니다.

참고로 위 코드에서 HttpUtil.isNot2xxSuccessful(voidResponseEntity) 메서드는 아래처럼 코딩되어 있습니다.

public class HttpUtil {

    public static boolean is2xxSuccessful(ResponseEntity responseEntity) {
        return HttpStatus.Series.valueOf(responseEntity.getStatusCodeValue())
        	.equals(HttpStatus.Series.SUCCESSFUL);
    }

    public static boolean isNot2xxSuccessful(ResponseEntity responseEntity) {
        return !is2xxSuccessful(responseEntity);
    }
}

ListenableFuture<ResponseEntity<T>> 에서 제공하는 addCallback 메서드 시그니처는 아래 두 가지가 있습니다.

void addCallback(ListenableFutureCallback<? super T> var1);
void addCallback(SuccessCallback<? super T> var1, FailureCallback var2);

위 예제에서는 첫 번째 addCallback 메서드를 사용했습니다만, 만약 SuccessCallback와 FailureCallback을 나눠서 구현하여 사용하고 싶다면 각각 구현해서 addCallback 메서드에 파라미터로 전달해주셔도 됩니다.

추가로 AsyncRestTemplate 을 스프링에서 제공해주는 기본 클래스를 사용해도 되지만 타임아웃 등 설정을 바꿔서 사용해야한다면 아래 코드를 참고하시면 도움이 되실겁니다.

    @Bean
    public AsyncRestTemplate asyncRestTemplate2() {
        SimpleAsyncTaskExecutor simpleAsyncTaskExecutor = new SimpleAsyncTaskExecutor();
        simpleAsyncTaskExecutor.setTaskDecorator(new MdcTaskDecorator());

        SimpleClientHttpRequestFactory simpleClientHttpRequestFactory = new SimpleClientHttpRequestFactory();
        simpleClientHttpRequestFactory.setConnectTimeout(30_000);    // 밀리초 단위
        simpleClientHttpRequestFactory.setReadTimeout(30_000);       // 밀리초 단위
        simpleClientHttpRequestFactory.setTaskExecutor(simpleAsyncTaskExecutor);

        AsyncRestTemplate asyncRestTemplate = new AsyncRestTemplate(simpleClientHttpRequestFactory);

        return asyncRestTemplate;
    }

    static class MdcTaskDecorator implements TaskDecorator {

        @Override
        public Runnable decorate(Runnable runnable) {
            // Web thread context
            Map<String, String> contextMap = MDC.getCopyOfContextMap();
            return () -> {
                try {
                    // @Async thread context
                    MDC.setContextMap(contextMap);
                    runnable.run();
                } finally {
                    MDC.clear();
                }
            };
        }
    }

이상으로 AsyncRestTemplate을 이용하여 자바에서 비동기 호출하기에 대해서 알아봤습니다.

하지만 AsyncRestTemplate은 Spring 5로 넘어가면서 deprecated 되었고, WebClient를 사용하도록 권장하고 있습니다.

Deprecated as of Spring 5.0, in favor of org.springframework.web.reactive.function.client.WebClient

WebClient에 대해서는 다음 포스팅에서 다루도록 하겠습니다.

오늘도 즐프행프하세요~

이번 포스팅에서는 SpringBoot에서 ThreadPoolTaskExecutor를 어떻게 간단하게 설정하여 사용할 수 있는지 알려드립니다.

SpringBoot 프로젝트는 이미 구성되어 있다는 전제하에 Java11, SpringBoot 2.4.2 기준으로 작성했습니다.

참고로 ThreadPoolTaskExecutor의 설정 및 구체적인 사용법에 대해서는 이전에 포스팅한 문서를 참고하시기 바랍니다.

ThreadPoolTaskExecutor의 사용법

ThreadPoolTaskExecutor Bean 등록하기

우선 ThreadPoolTaskExecutor를 빈으로 등록하도록 하겠습니다. 

TaskExecutorConfig 클래스를 만들고 @Configuration 어노테이션을 추가하여 설정을 위한 클래스를 하나 만들었습니다.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@Configuration
public class TaskExecutorConfig {

	@Bean(name = "executor")
	public ThreadPoolTaskExecutor executor() {
		ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
		executor.setThreadNamePrefix("my-");
		return executor;
	}
}

그리고 executor() 메서드를 하나 만들어서 ThreadPoolTaskExecutor를 생성하여 반환해주도록 하고 @Bean으로 등록하면서 name 속성을 지정해주었습니다. 참고로 name 속성의 값은 메서드명과 달라고 무관합니다. 또한, 해당 executor를 이용하여 쓰레드를 실행시켰을 때 내가 만든 ThreadPoolTaskExecutor가 사용되는 것인지 확인할 수 있도록 쓰레드명prefix를 "my-"로 세팅해주었습니다. 

이전 포스팅을 읽어보셨거나 또는 ThreadPoolTaskExecutor를 직업 new 키워드로 생성해서 사용해보신 분은 눈치채셨을 수도 있을텐데요, 여기서 initialize()를 하지 않았습니다. 공식문서에는 initialize 메서드를 호출하는 것으로 나와있지만 굳이 하지 않아도 빈으로 등록될 때 initialize를 하더군요.

@Autowired 로 ThreadPoolTaskExecutor 사용하기

아래는 빈으로 등록한 executor를 서비스 레이어에서 autowired하여 사용하는 예제입니다.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class TestService {

  @Autowired
  @Qualifier("executor")
  private ThreadPoolTaskExecutor executor;

  public void executeThreads() {
      log.info("executing threads....");
      Runnable r = () -> {
          try {
              log.info(Thread.currentThread().getName() + ", Now sleeping 10 seconds...");
              Thread.sleep(10000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      };

      for (int i = 0; i < 10; i++) {
          executor.execute(r);
      }
  }
}

TestService라는 서비스 클래스에서 멤버변수 executor에 위에서 빈으로 등록한 객체를 쓰도록 @Qualifier로 executor 이름을 명시해주었습니다.

위 코드를 실행해보면 쓰레드 명이 my-1 로 출력되는 것을 확인하실 수 있습니다. corePoolSize를 default 값인 1 로 사용하여 싱글 쓰레드로 실행되기 때문에 my-2, my-3은 보이지 않습니다. corePoolSize 를 2 이상으로 세팅해주면 my-2, my-3 등의 쓰레드도 확인가능합니다.

2021-01-26 18:16:23.147  INFO 16390 --- [           my-1] com.keichee.test.service.TestService     : my-1, Now sleeping 10 seconds...
2021-01-26 18:16:33.150  INFO 16390 --- [           my-1] com.keichee.test.service.TestService     : my-1, Now sleeping 10 seconds...
2021-01-26 18:16:43.152  INFO 16390 --- [           my-1] com.keichee.test.service.TestService     : my-1, Now sleeping 10 seconds...
2021-01-26 18:16:53.157  INFO 16390 --- [           my-1] com.keichee.test.service.TestService     : my-1, Now sleeping 10 seconds...

@Async로 ThreadPoolTaskExecutor 사용하기

@Async 어노테이션을 이용하여 위에서 빈으로 등록한 ThreadPoolTaskExecutor를 사용하려면 @EnableAsync 도 추가해주어야 합니다.

따라서 TaskExecutorConfig 클래스에 @EnableAsync 어노테이션을 추가해줍니다.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@EnableAsync
@Configuration
public class TaskExecutorConfig {

	@Bean(name = "executor")
	public ThreadPoolTaskExecutor executor() {
		ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
		executor.setThreadNamePrefix("my-");
		return executor;
	}
}

그리고 서비스 레이어의 메서드를 하나 추가하겠습니다.

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class TestService {

    @Async("executor")
    public void task() {
        try {
            log.info(Thread.currentThread().getName() + ", Now sleeping 10 seconds...");
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

이제 controller 쪽에서 task() 메서드를 loop 돌면서 호출해보면 @Autowired 를 이용한 방법과 동일하게 로그가 출력되는 것을 확인하실 수 있을 겁니다.

이상으로 SpringBoot에서 ThreadPoolTaskExecutor 설정하여 사용하는 방법에 대해서 알아보았습니다.

간략하게 다시 정리해보자면

1. @Configuration 으로 등록한 클래스에 executor @Bean 추가 (@Async 를 이용할 경우 @EnableAsync 도 추가)

2. @Autowired @Qualifier 로 주입하여 사용하거나 또는 메서드 레벨에 @Async 를 붙여 사용

이렇게 정리할 수 있겠네요.

그럼 오늘도 행복한 코딩하세요~

프로그래밍을 하다보면 DB 조회 시에 정렬해서 조회해오는 방법도 있고, 애플리케이션 레벨에서 정렬해야 할 때도 있습니다.

오늘은 애플리케이션에서 배열, 리스트, 맵, 셋에 대하여 각각 오름차순, 내림차순 정렬하는 방법에 대해서 알아보도록 하겠습니다.

1. 배열 정렬하기

우선 아래와 같이 int 배열이 있다고 가정해보겠습니다.

int[] arr = new int[] { 5, 1, 89, 255, 7, 88, 200, 123, 66 };

배열의 정렬은 java.util.Arrays 클래스에 있는 sort() 메서드를 이용하여 정렬할 수 있습니다.

이 메서드를 이용하면 모든 primitive 타입에 대한 정렬이 가능합니다. 물론 원시타입이 아닌 Object[] 도 정렬이 가능합니다.

int[] arr = new int[] { 5, 1, 89, 255, 7, 88, 200, 123, 66 };
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));

Arrays.sort(배열) 호출을 하면 인자로 넘겨준 배열을 정렬해줍니다. 

그리고 출력을 해보면 아래와 같이 잘 정렬이 된 것을 확인할 수 있습니다.

[1, 5, 7, 66, 88, 89, 123, 200, 255]

그럼 이 메서드가 내부적으로 사용하는 정렬 알고리즘은 어떤 것일까요?

Java8 문서에는 듀얼 피봇 퀵소트(Dual-Pivot Quick Sort) 알고리즘을 사용한다고 나와있습니다.

듀얼 피봇 퀵소트는 모든 데이터 셋에 대해서 O(n log(n)) 의 퍼포먼스를 보이고 일반적으로 기존의 One-Pivot 퀵소트 정렬보다 빠르다고 합니다.

Java7 문서, Java14 문서에도 동일한 알고리즘을 사용하는 것으로 나와있습니다.

1.1 부분정렬

위 예제는 배열의 전체 요소를 정렬하는 반면 배열의 일부분만 정렬을 할 수도 있습니다.

일부분만 정렬할 때는 Arrays.sort(int[] a, int fromIndex, int toIndex) 메서드를 이용하시면 됩니다.

int[] arr = new int[] { 5, 1, 89, 255, 7, 88, 200, 123, 66 };
Arrays.sort(arr, 0, 4);
System.out.println(Arrays.toString(arr));

출력을 해보면 아래와 같이 0번 인덱스부터 3번 인덱스까지(4는 exclude입니다) 정렬이 된 것을 확인할 수 있습니다.

[1, 5, 89, 255, 7, 88, 200, 123, 66]

1.2 병렬 정렬 (ParallelSort)

Arrays.sort()가 싱글쓰레드로 돌아간다면 Arrays.parallelSort()는 멀티쓰레드로 동작을 합니다. parallelSort는 배열을 sub-array로 나눈 뒤 각각을 별도의 쓰레드에서 처리를 하고 각 쓰레드에서는 Arrays.sort()를 실행하여 정렬을 하게 됩니다.

Arrays.parallelSort 의 결과는 당연히 Arrays.sort의 결과와 동일합니다. 멀티쓰레딩을 이용했느냐의 차이만 존재할 뿐입니다.

참고로 Arrays.parallelSort 도 부분정렬이 가능합니다. Arrays.parallelSort (int [] a, int fromIndex, int toIndex);

2. List 정렬하기

리스트를 정렬할 때는 java.util.Collections.sort(List<T> list) 메서드를 이용하는 방법이 있습니다.

int[] arr = new int[] { 5, 1, 89, 255, 7, 88, 200, 123, 66 };
List<Integer> toSortList = Ints.asList(arr);    // int[]을 Integer[]로 변환 (구글 guava 라이브러리 이용) 
Collections.sort(toSortList);

출력 결과는 Arrays.sort()를 사용한 것과 동일합니다.

기본적으로 오름차순으로 정렬을 합니다. 만약 내림차순으로 정렬하고 싶다면 comparator를 인자로 전달받는 sort​(List list, Comparator c) 메서드를 이용할 수 있습니다.

그리고 너무나도 기본적인 얘기지만 정렬을 하려면 두 요소(element)를 비교할 수 있어야 하기 때문에 리스트 내의 모든 요소들이 Comparable 인터페이스를 구현하고 있어야 합니다.

Collections.sort(List<T> list) 는 merge sort 알고리즘을 이용하여 정렬을 합니다. List.sort(Comparator c)에서 제공하는 기본 알고리즘과는 조금 다르다고 합니다만, 더 안좋게 변형된 알고리즘을 사용하는 건 아니겠죠. 그리고 기본적으로 List.sort()에서 사용하는 merge sort는 어느정도 부분 정렬이 되어있는 데이터에 대해서는 n log(n) 보다 훨씬 적은 횟수만 비교하며(거의 정렬이 되어있는 상태라면 거의 n번의 비교만으로도 정렬 가능), 랜덤하게 섞여있는 데이터 셋에 대해서는 전통적인 merge sort의 퍼포먼스를 낸다고 합니다. Java14 Collections.sort() 참고하시면 좋을 것 같습니다.

만약 역순(내림차순)으로 정렬을 하고 싶으면 Collections.sort(List list, Comparator c) 메서드를 이용하면 됩니다.

// 내림 차순 정렬
Collections.sort(list, Comparator.reverseOrder());

자바에서는 내림차순 정렬을 위해 Comparator.reverseOrder() 메서드를 통해 기본 comparator를 제공해주고 있습니다. 

3. Set 정렬하기

Set은 기본적으로 순서를 보장하지 않습니다. 하지만 LinkedHashSet은 순서를 보장하죠. 따라서 Set을 정렬한다는 것은 이 LinkedHashSet 처럼 순서를 보장하는 set 구현체에 대한 얘기입니다.

Set을 정렬할 때도 Collections.sort()를 이용합니다. 하지만 해당 메서드는 List만을 인자로 전달받고 있기 때문에 Set을 정렬하려면 List로 변경하는 작업이 필요합니다.

Set<Integer> set = new LinkedHashSet<>(Ints.asList(arr));
System.out.println(set);    // 정렬하기 전 출력

List<Integer> list = new ArrayList<>(set);
Collections.sort(list);
set = new LinkedHashSet<>(list);

System.out.println(set);    // 정렬 후 출력

위에서 보듯이 list로 변환 후 다시 set으로 변환하여 정렬을 할 수 있습니다.

4. Map 정렬하기

Map은 아시다시피 key와 value 쌍으로 이루어진 자료구조입니다. 따라서 Map을 정렬할 때는 key를 기준으로 정렬하는 방법과 value를 기준으로 정렬하는 방법, 두 가지 방법이 있습니다. 또한, Map도 Set과 마찬가지로 HashMap 같은 경우는 순서와는 무관한 자료구조이기 때문에 정렬을 위해서는 LinkedHashMap을 이용해야 합니다.

우선 key를 기준으로 정렬하는 방법에 대해서 알아보겠습니다. Map을 정렬할 때도 List, Set과 마찬가지로 Collections.sort(List list) 메서드를 이용할 수 있습니다. 따라서 list로 변환을 해주어야 하죠. 그리고 정렬 후에는 순서의 보장을 위해 list를 LinkedHashMap으로 변환해주어야 합니다. 또한 List.sort(Comparator c)를 이용할 수도 있습니다. 예제에서 두 가지 방법에 대해 모두 확인해보도록 하겠습니다.

// 기본 데이터 셋
HashMap<Integer, String> map = new HashMap<>();
map.put(5, "Orange");
map.put(8, "Apple");
map.put(2, "WaterMelon");
map.put(13, "Pear");
map.put(9, "Grape");
map.put(4, "Banana");


// key, value 를 모두 가져오기 위해서 entrySet()을 리스트로 변환
List<Map.Entry<Integer, String>> entries = new ArrayList<>(map.entrySet());

// 1. List.sort 를 이용하는 방법
entries.sort(Comparator.comparing(Map.Entry::getKey));

// 2. Collections.sort 를 이용하는 방법
Collections.sort(entries, Comparator.comparing(Map.Entry::getKey));

// 정렬된 데이터를 LinkedHashMap에 저장
Map<Integer, String> sortedByKey = new LinkedHashMap<>();
for (Map.Entry<Integer, String> entry : entries) {
	sortedByKey.put(entry.getKey(), entry.getValue());
}

// 정렬된 내용 출력
System.out.println(sortedByKey);

정렬할 때 List.sort(Comparator c) 와 Collections.sort(List list)를 이용하는 방법을 모두 소개해드렸습니다.

여기서 사용한 Comparator.comparing() 메서드는 comparator를 반환하는 메서드입니다. Comparator.comparing(Map.Entry::getKey) 는 Map의 key 값을 비교하는 comparator를 만들어주죠.

위 코드에서 출력되는 내용은 아래왁 같습니다.

{2=WaterMelon, 4=Banana, 5=Orange, 8=Apple, 9=Grape, 13=Pear}

key 값 순서대로 정렬이 된 것을 확인할 수 있습니다.

그럼 이번에는 위 코드를 조금 수정하여 value를 기준으로 정렬을 해보도록 하겠습니다.

// 1. List.sort 를 이용하는 방법
entries.sort(Comparator.comparing(Map.Entry::getValue));

// 2. Collections.sort 를 이용하는 방법
Collections.sort(entries, Comparator.comparing(Map.Entry::getValue));

Comparator.comparing() 메서드의 인자로 key가 아닌 value 값을 넘겨주기만 하면 됩니다.

수정된 코드 실행 결과는 다음과 같습니다.

{8=Apple, 4=Banana, 9=Grape, 5=Orange, 13=Pear, 2=WaterMelon}

value값으로 넣어주었던 과일명 순으로 정렬이 되어 출력된 것을 확인할 수 있습니다.

5. 커스텀 객체 정렬하기

이번에는 커스텀 객체를 정렬하는 방법에 대해 알아보겠습니다. 사실 커스텀 객체를 정렬하는 방법이라고 따로 있는건 아닙니다. 이미 위에서 설명드린 내용중에 comparator를 이용하는 방법을 이용해야 합니다.

일단 쇼핑몰에 판매중인 상품에 대한 객체 정의를 해보겠습니다.

@Getter
@Setter
@AllArgsConstructor
class Product {
    String name;        // 상품 명
    int price;          // 상품 가격
    float sellerRating; // 판매자 평점
    
    @Override
    public String toString() {
    	return "{" + this.name + ", " + price + ", " + sellerRating + "}";
    }
}

이제 이 객체를 리스트로 만들어 가격, 판매자 평점을 기준으로 각각 오름차순, 내림차순으로 정렬을 해보도록 하겠습니다.

// 기본 데이터 셋
List<Product> data = new ArrayList<>(Arrays.asList(
    new Product("Apple", 100, 4.3f),
    new Product("Apple", 200, 3.3f),
    new Product("Apple", 150, 4.8f)));

// 1. List.sort 를 이용하여 가격 오름차순 정렬
data.sort(Comparator.comparing(Product::getPrice));
System.out.println("\n1. List.sort 를 이용하여 가격 오름차순 정렬");
System.out.println(data);

// 2. List.sort 를 이용하여 가격 내림차순 정렬
data.sort(Comparator.comparing(Product::getPrice, Comparator.reverseOrder()));
System.out.println("\n2. List.sort 를 이용하여 가격 내림차순 정렬");
System.out.println(data);

// 3. Collections.sort 를 이용하여 판매자 편점 오름차순 정렬
Collections.sort(data, Comparator.comparing(Product::getSellerRating));
System.out.println("\n3. Collections.sort 를 이용하여 판매자 편점 오름차순 정렬");
System.out.println(data);

// 4. Collections.sort 를 이용하여 판매자 편점 내림차순 정렬
Collections.sort(data, Comparator.comparing(Product::getSellerRating, Comparator.reverseOrder()));
System.out.println("\n4. Collections.sort 를 이용하여 판매자 편점 내림차순 정렬");
System.out.println(data);

Product 리스트를 특정 필드를 기준으로 오름차순 내림차순으로 정렬하는 코드는 List.sort를 사용해도, Collections.sort를 사용해도 한 줄이면 됩니다. 매우 간단합니다. 내림차순으로 정렬을 하고 있을 때는 Comparator.comparing() 메서드에 Comparator.reverseOrder() 인자를 추가해주면 됩니다. 즉, Comparator.comparing(정렬기준, 정렬순서) 이렇게 사용하시면 되는거죠.

자, 이제 출력 결과를 확인해보면 다음과 같습니다.

1. List.sort 를 이용하여 가격 오름차순 정렬
[{Apple, 100, 4.3}, {Apple, 150, 4.8}, {Apple, 200, 3.3}]

2. List.sort 를 이용하여 가격 내림차순 정렬
[{Apple, 200, 3.3}, {Apple, 150, 4.8}, {Apple, 100, 4.3}]

3. Collections.sort 를 이용하여 판매자 편점 오름차순 정렬
[{Apple, 200, 3.3}, {Apple, 100, 4.3}, {Apple, 150, 4.8}]

4. Collections.sort 를 이용하여 판매자 편점 내림차순 정렬
[{Apple, 150, 4.8}, {Apple, 100, 4.3}, {Apple, 200, 3.3}]

Summary

여기까지 자바에서 정렬하는 방법에 대해서 알아보았습니다.

간략히 요약을 하면 다음과 같습니다.

배열의 정렬 -> Arrays.sort() 이용

List 정렬 -> Collections.sort(), List.sort() 이용

Set, Map 정렬 -> List로 변환 후 Collections.sort(), List.sort() 이용

기본적으로 오름차순 정렬

내림차순 정렬은 Comparator.reverseOrder() 이용

예외 처리/에러 핸들링 잘하기

안녕하세요, 오늘은 예외 처리(에러 핸들링)에 대해서 얘기를 해볼까 합니다.

책에 나오는 또는 인터넷 상에서 간략하게 설명하는 try-catch 예외처리에 대한 내용은 아니고 직접 개발을 진행하면서 경험한 내용을 토대로 이렇게 하면 좋겠다 싶은 내용들을 공유하는 차원에서 작성하는 글입니다. 혹여나 더 좋은 방법이나 공유해주시고 싶은 내용이 있다면 댓글도 환영합니다.

우선 자바 서적이나 구글링을 해서 찾는 에러 핸들링에 대한 내용들은 대부분 try-catch 문을 사용하면 된다에서 끝납니다.

하지만 단순히 그렇게 작업하면 에러 핸들링을 잘한다고 할 수 없습니다.

복잡한 비즈니스 로직을 구현하다보면 여러 클래스들을 넘나들면서 여러 메서드들을 거치게 됩니다.

위 메서드 콜 체인은 하나의 프로세스(기능)이 처리될 때의 과정의 일부입니다. 예를들면 controller -> service -> dao 뭐 이런 건데요, 아무리 복잡한 서비스라 하더라도 결국 요청에서부터 응답을 주기까지의 과정은 결국 위 그림처럼 한 줄로 연결이 가능하죠.

따라서 어느 시점에 try-catch 로 예외를 잡아야 할지 그리고 예외를 잡았다면 어떤 처리를 해야할지에 대해 많은 고민이 필요합니다. 하지만 실상 그런 고민을 별로 하지 않고 대충 에러로그 찍어놓는 개발자들이 많은 것이 사실이죠. 심지어 catch로 잡아서 로그만 남기고 다시 throw를 하기도 합니다. 무슨 폭탄돌리기 하는 것도 아니고 말이죠 -_-;; 최악입니다. 그렇게 개발된 서비스는 하나의 에러에 대해서 중복적으로 여러개의 로그를 남기는 것을 확인할 수 있고 디버깅도 비효율적으로 만들어 버립니다. 그럼 어떻게 하는 것이 좋은 것일까요?

첫 번째는 요청을 받아서 응답을 주기까지 하나의 체인에서 특정 예외에 대한 처리는 한 곳에서만 하도록 하는 것이 좋습니다. 즉, 위 체인 그림에서 메서드 1, 2, 3, 4 중 하나의 메서드에서만 A라는 예외에 대한 처리를 한다는거죠. 컨트롤러 부분에서 ExceptionHandler를 이용해서 처리할 수도 있고 서비스 레이어에서 try-catch 문을 이용해서 처리해도 됩니다. 메서드3에서 예외처리를 해놓았는데 불필요하게 메서드2에서 또 하고 있다거나 한다면 둘 중 하나를 제거하는게 유지보수하는데 큰 도움이 됩니다.

두 번째는 catch를 했으면 적절한 처리를 해줘야 한다는 겁니다. 여기서 "적절한" 이라는 말이 애매할 수 있는데요, 단순히 로그만 찍고 catch한 예외를 다시 throw 하고있다면 해당 try-catch문은 쓸모없는 것일 가능성이 99.9%입니다. 그런 경우라면 callee에서만 catch해서 로그를 남기고 적절한 처리를 하는게 더 깔끔합니다. 굳이 두 군데서 나누어 catch할 필요가 없다는 거죠. 또, 어떤 예외는 잡아서 로그만 남기고 무시할 수도 있고 (옵셔널 값이 없다거나 하는 경우), 어떤 예외는 디버깅용 로그를 남기고 비즈니스 로직을 롤백하는 처리를 해야할 수도 있습니다. 해당 프로세스를 진행함에 있어서 어떻게 처리해야 할 지는 API스펙 또는 정책에 따라 달라질 겁니다.

마지막으로, 예외가 발생했을 경우 디버깅용 로그를 남기기로 했다면 정말 필요한 정보만 가독성 있게 로그를 남기는 것입니다. 한 줄의 로그만 잘 남겨도 디버깅하기 쉽도록 작성하면 유지보수 효율성 뿐만 아니라 로깅 시스템에 부하도 줄일 수 있게 됩니다.

제 경험을 토대로 신입 또는 주니어 개발자 분들께서 이렇게 해보시면 좋겠다는 생각으로 끄적여 보았습니다.

혹시 이 글을 읽으시다가 멋진 노하우가 있으신 분들은 댓글로 공유 부탁드려요 ^-^

1차원 배열 생성에 대한 내용을 아직 안보셨다면 보고 오세요~ >> 1차원 배열 생성(선언 및 초기화)

1차원 배열이 1열로 된 저장공간이었다면 2차원 배열은 matrix(행렬)을 생각하시면 됩니다.

2차원 배열 선언

자바에서 2차원 배열은 아래와 같이 선언할 수 있습니다.

    public static void main(String[] args) {
        int[][] array;  // O
        int [][]array;  // X
        int array[][];  // X
    }

지난 1차원 배열 생성 시와는 다르게 제일 위의 방법으로만 문법적 오류 없이 정상적으로 2차원 배열을 선언할 수 있습니다.

2차원 배열의 초기화

2차원 배열을 초기화 할 때는 아래와 같이 합니다.

    public static void main(String[] args) {

        int[][] array;  // 2차원 배열의 선언

        array = new int[1][5];	// 2차원 배열의 초기화
    }

2차원 배열의 선언과 초기화를 동시에 하는 방법

2차원 배열도 1차원 배열처럼 선언과 초기화를 동시에 할 수 있습니다.

    public static void main(String[] args) {
        
        int[][] array = new int[1][5];  // 2차원 배열의 선언과 초기화를 한 번에

    }

이렇게 하면 배열 내에는 0으로 기본값이 들어가게 됩니다.

1차원 배열과 마찬가지로 아래처럼 초기화도 가능합니다.

    public static void main(String[] args) {

        int[][] array = {{1,2,3}, {4,5,6}};

    }

이렇게 초기화를 한다는 것은 기본값을 하드코딩하여 정해주겠다는 것이겠죠.

자, 배열을 선언하고 공간을 만들어 주는 작업을 완료했습니다.

이제 배열에 저장된 내용을 출력하는 것을 한 번 보겠습니다.

2차원 배열 출력하기

1차원 배열을 출력할 때는 Arrays.toString() 메서드를 사용했었습니다.

하지만 2차원 배열을 출력할 때는 그 메서드를 사용할 수가 없습니다.

왜냐면 2차원 배열은 배열 안에 배열이 있는 형태이기 때문입니다.

그리고 배열은 기본적으로 Object 이고 Object의 toString이 호출되어 원하는 결과를 출력해주지 않습니다.

따라서 별도로 출력문을 구현해야합니다.

쉽게하려면 아래처럼 loop를 한번 돌리면서 출력을 할 수 있습니다.

    public static void main(String[] args) {

        int[][] array = new int[8][9];  // 구구단 결과값 저장을 위한 2차원 배열의 선언 및 초기화

        for (int i = 0; i < array.length; i++) {
            System.out.println(Arrays.toString(array[i]));
        }
    }

그럼 연습삼아 2차원 배열안에 구구단의 결과를 저장해보도록 해볼게요.

    public static void main(String[] args) {

        int[][] array = new int[8][9];  // 구구단 결과값 저장을 위한 2차원 배열의 선언 및 초기화

	// 배열에 구구단의 결과값을 저장
        for (int i = 2; i < 10; i++) {
            for (int j = 1; j < 10; j++) {
                array[i-2][j-1] = i * j;
            }
        }

	// 배열에 저장된 내용을 출력
        for (int i = 0; i < array.length; i++) {
            System.out.print((i + 2) + "단: ");
            System.out.print(Arrays.toString(array[i]));
            System.out.println();
        }
    }
    
    
    // 출력 결과
    2단: [2, 4, 6, 8, 10, 12, 14, 16, 18]
    3단: [3, 6, 9, 12, 15, 18, 21, 24, 27]
    4단: [4, 8, 12, 16, 20, 24, 28, 32, 36]
    5단: [5, 10, 15, 20, 25, 30, 35, 40, 45]
    6단: [6, 12, 18, 24, 30, 36, 42, 48, 54]
    7단: [7, 14, 21, 28, 35, 42, 49, 56, 63]
    8단: [8, 16, 24, 32, 40, 48, 56, 64, 72]
    9단: [9, 18, 27, 36, 45, 54, 63, 72, 81]

로직을 한번 보면 크게 구구단을 저장할 때와 저장된 내용을 출력하는 부분으로 구분했습니다. 그리고 for-loop문의 조건걸에 하드코딩한 숫자를 사용하기도 하고 array.length 를 사용하기도 했습니다. 가급적 array.length 의 사용을 권장하며 2차원 배열에서 array.length는 행이 몇 개가 존재하는지를 반환하고, array[x].length는 열의 개수를 반환합니다. 구구단은 보통 2단부터 9단까지이기 때문에 배열을 초기화할 때 사이즈를 8행, 9열로 정의를 하였고, array.length 는 8, array[x].length 는 9 가 됩니다.

이상으로 자바에서 2차원 배열을 생성하고 초기화하고 실제로 데이터를 저장한 뒤 출력하는 것 까지 살펴보았습니다.

질문있으시면 댓글 달아주세요~

도움이 되셨다면 공감~ 꾸~~~욱 눌러주세요 ^-^

감사합니다~

자바 스트림을 이용한 유용한 변환 방법

해당 게시글은 java의 stream을 이용하여 데이터를 쉽게 가공할 수 있는 방법을 정리 해놓은 문서로

유용한 케이스를 발견할 때마다 계속 업데이트할 예정입니다.

1. String배열을 int배열로 변환하기

int[] intArray = Stream.of(stringArray).mapToInt(Integer::parseInt).toArray();

2. Integer배열을 String배열로 변환하기

String[] stringArray = Stream.of(arr).map(String::valueOf).toArray(String[]::new);

3. String배열을 String리스트로 변환하기

String[] stringArray = new String[]{"!", "@", "#"};
List<String> stringList = Stream.of(stringArray).collect(Collectors.toList());

4. String리스트를 String배열로 변환하기

List<String> stringList = new ArrayList<>(Arrays.asList("!","@","#"));
String[] stringArray = stringList.toArray(new String[0]);

5. stream().map()을 이용한 객체(object) 변환하기

// 변환 전 클래스
@Getter
class Soldier {
  String name;
  int age;

  public Soldier(String name, int age) {
    this.name = name;
    this.age = age;
  }
}

// 변환 대상 클래스
@Getter
class King {
  String name;
  int age;
  public King(String name, int age) {
    this.name = name;
    this.age = age;
  }
}

// 샘플 Soldier stream 생성
Stream<Soldier> s = Stream.of(new Soldier("A", 18), new Soldier("B", 22), new Soldier("C", 19));

// map()을 이용하여 변환하기
List<King> k = s.map(soldier -> new King(soldier.getName(), soldier.getAge()))
		.collect(Collectors.toList());

6. filter()를 이용하여 필터링하기

// 변환 전 클래스
@Getter
class Soldier {
  String name;
  int age;

  public Soldier(String name, int age) {
    this.name = name;
    this.age = age;
  }
}

// 변환 대상 클래스
@Getter
class King {
  String name;
  int age;
  public King(String name, int age) {
    this.name = name;
    this.age = age;
  }
}

// 샘플 Soldier stream 생성
Stream<Soldier> s = Stream.of(new Soldier("Arthur", 18), new Soldier("Belisarius", 22), new Soldier("Caesar", 19));

// filter()를 이용하여 Arthur만 골라서 map()을 이용하여 King으로 변환하기
List<King> k = s.filter(soldier -> "Arthur".equals(soldier.getName()))
    .map(soldier -> new King(soldier.getName(), soldier.getAge()))
    .collect(Collectors.toList());

7. min() / max() 를 이용하여 comparator 기준 최소 / 최대 값을 갖는 객체 추출하기

    @Getter
    @Setter
    class Datapoint {
        private Double maximum;
    }
    
    public void sortStream() {
        List<Datapoint> datapoints = new ArrayList<>();
        int max = 10;
        datapoints.add(new Datapoint().withMaximum(Math.random() * max));
        datapoints.add(new Datapoint().withMaximum(Math.random() * max));
        datapoints.add(new Datapoint().withMaximum(Math.random() * max));
        log.debug("data points: {}", datapoints);

        // 객체 목록 중 특정 필드(maximum)값을 기준으로 최대값을 갖고 있는 객체 추출 (stream.max() 이용)
        Datapoint datapointMax = datapoints.stream()
                .max(Comparator.comparing(Datapoint::getMaximum))
                .orElse(new Datapoint().withMaximum(0D));
        log.debug("data point MAX: {}", datapointMax);

        // 객체 목록 중 특정 필드(maximum)값을 기준으로 최소값을 갖고 있는 객체 추출 (stream.min() 이용)
        Datapoint datapointMin = datapoints.stream()
                .min(Comparator.comparing(Datapoint::getMaximum))
                .orElse(new Datapoint().withMaximum(0D));
        log.debug("data point MIN: {}", datapointMin);
    }
    
    
    
    // 실행 로그
    data points: [{Maximum: 5.471390124016474,}, {Maximum: 2.7559360370945916,}, {Maximum: 0.5778257233234019,}]
    data point MAX: {Maximum: 5.471390124016474,}
    data point MIN: {Maximum: 0.5778257233234019,}

Converting timestamp to date time string format and vice versa

실제 업무에서 java로 프로그래밍 할 때 날짜/시간을 다뤄야 할 때가 참 많습니다.

데이터 업데이트 시간을 기록하거나 로깅을 하거나 등등 말이죠.

그래서 오늘은 시간 변환에 대해서 짧게 한가지만 알려드립니다.

자바 프로그래밍을 시작한지 얼마 안되었을 때 System.currentTimemillis()를 이용해서 내가 작성한 알고리즘이 얼마나 빨리 돌아가는지 확인을 했었는데요, 저 함수의 결과는 long형입니다. 

1970년 1월 1일 UTC 자정 이후로 몇 밀리초가 지났는지를 반환해주죠.

반환값에 대한 정확한 정의는 아래와 같습니다.

   * @return  the difference, measured in milliseconds, between
   *          the current time and midnight, January 1, 1970 UTC.

그런데 이 long형 숫자는 길이도 길고 이게 도대체 그래서 몇 일 몇 시 라는 건지를 알아보기가 힘들죠

그래서 이 long형 숫자를 가독성있게 우리가 일반적으로 사용하는 시간 포맷에 맞게 String 타입으로 변환하려면 어떻게 해야 할까요? 그리고 그렇게 얻은 String 타입 시간값을 다시 long형으로 변환하려면 또 어떻게 해야 할까요?

우선 long타입 시간을 원하는 일시 포맷으로 변경하는 것은 Date와 SimpleDateFormat을 이용하면 쉽게 변환할 수 있습니다. 아래와 같이 말이죠.

 public static void main(String[] args) {
     Date d = new Date(vv);
     DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
     String bb = format.format(d);
     System.out.println(bb);
 }

반대로 String으로 된 일시를 long으로 변환할 때는 아래와 같이 java.sql.Timestamp를 이용하면 쉽게 변환이 가능합니다.

public static void main(String[] args) {
    String prdt = "2020-01-10 10:38:09.419";
    long vv = Timestamp.valueOf(prdt).getTime();
    System.out.println(vv);
}

하지만 Timestamp.valueOf(String) 메서드는 "yyyy-mm-dd hh:mm:ss[.fffffffff]" 형태의 string만 입력 가능합니다.

일자만 있거나 시간값만 있으면 사용이 불가능 하다는 것 명심하세요.

만약 일시 포맷을 잘못 입력하면 아래와 같은 오류가 발생합니다.

Exception in thread "main" java.lang.IllegalArgumentException: 
		Timestamp format must be yyyy-mm-dd hh:mm:ss[.fffffffff]

java.sql.Timestamp 대신에 LocalDateTime을 이용할 수도 있습니다.

public static void main(String[] args) {

    String prdt2 = "2020-01-11 00:00:00";
    System.out.println(Timestamp.valueOf(prdt2).getTime());
    System.out.println(LocalDateTime.parse("2020-01-11T00:00:00")
        .atZone(ZoneId.of("Asia/Seoul"))
        .toInstant()
        .toEpochMilli());
}

---출력결과---
1578668400000
1578668400000

하지만 LocalDateTime의 경우 parse할 때 들어가는 string형태의 일시값에 'T'구분자를 포함해줘야 합니다.

그렇지 않을 경우 아래와 같이 파싱오류가 발생합니다.

Exception in thread "main" java.time.format.DateTimeParseException: 
		Text '2020-01-11 00:00:00' could not be parsed at index 10

Summary

이번 포스팅에서는 자바에서 long타입의 timestampe를 String 타입의 가독성 좋은 형태로 변환하는 작업과 그렇게 변환된 String을 다시 long으로 변경하는 부분에 대해서 알아보았습니다.

long -> String -> long 변경을 했을 때 동일한 값이 나오는지도 아래 테스트를 통해서 확인할 수 있었습니다.

public static void main(String[] args) {

    // String to long conversion 1
    String prdt = "2020-01-11 10:24:09.419";
    long l1 = Timestamp.valueOf(prdt).getTime();
    System.out.println(l1);

    // String to long conversion 2
    String prdt2 = "2020-01-11T10:24:09.419";
    long l2 = LocalDateTime.parse(prdt2)
        .atZone(ZoneId.of("Asia/Seoul"))
        .toInstant()
        .toEpochMilli();
    System.out.println(l2);

    // long to String conversion
    DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    System.out.println(format.format(new Date(l1)));
}

---출력결과---
1578705849419
1578705849419 <-- Timestamp를 이용해서 얻은 결과와 동일함을 확인 
2020-01-11 10:24:09.419 <-- long으로 변환했던 String 형태의 시간과 동일하게 출력되는지 확인

이상으로 Java에서 datetime을 long에서 String으로 다시 String에서 long으로 변환하는 방법에 대해서 알아보았습니다.

유용했다면 공감 꾹 부탁해요~

이번에는 자바로 1차원 배열을 만들어 보도록 하겠습니다.
자바로 배열을 만드는 방법은 여러 가지가 있습니다.
우선 용어부터 정리하고 가겠습니다.
제가 만든다라고 얘기한 것은 일반적으로 얘기하려고 한 것인데 이는 두 가지 의미를 포함하고 있습니다.
바로 "선언"과 "초기화"입니다.
여기서 "선언"이라는 것은 변수의 이름을 지어주는 것을 얘기하며,
"초기화"라는 것은 그 변수에 값을 할당하는 것을 의미합니다.
이 용어들을 머릿속에 넣고 출발하도록 하겠습니다.

배열을 선언하는 방법

자바에서 배열을 선언하는 방법은 아래와 같이 3가지가 있습니다.

public static void main(String[] args) {

        // 배열을 선언하는 방법
        int[] intArr1;
        int []intArr2;
        int intArr3[];
}

위에서는 int 타입의 배열을 3가지 방법으로 선언해 보았습니다.
int타입 대신 long, double, Integer, Long, Double, String 등 다른 타입을 사용할 수도 있습니다.
이렇게 선언을 해 놓아도 공간(메모리)을 차지하지는 않습니다.
배열은 초기화를 하면서 사이즈를 정해줘야 공간(메모리)을 차지하게 됩니다.
그럼 배열 초기화는 어떻게 할까요?

배열을 초기화하는 방법

배열을 초기화할 때는 아래와 같이 합니다.

public static void main(String[] args) {

        // 배열을 선언하는 방법
        int[] intArr1;

        // 배열을 초기화하는 방법
        intArr1 = new int[3];
}

위 예제에서는 intArr1이라는 이름을 가진 배열을 사이즈가 3인 배열로 초기화를 하였습니다.
이렇게 초기화를 하면 int 타입의 경우 기본값 0으로 세팅이 됩니다.

배열의 선언과 초기화를 동시에 하는 방법

자바에서는 아래와 같이 배열의 선언과 초기화를 동시에 할 수도 있습니다.

public static void main(String[] args) {

        int[] intArr1 = new int[10];    // size 10, index range from 0 to 9
        int []intArr2 = new int[20];    // size 20, index range from 0 to 19
        int intArr3[] = new int[20];    // size 20, index range from 0 to 19
}

위에서 설명드린 선언문과 초기화문을 한 줄에 붙여 쓰면 동시에 선언과 초기화가 가능합니다.

자, 그런데 이렇게 하면 int 타입의 배열에는 모두 0으로 값이 세팅이 됩니다.

전, 제가 원하는 값으로 세팅을 하고 싶은데 그렇게도 할 수 있나요?

물론이죠~ 그렇게도 할 수 있습니다.
아래와 같이 하시면 됩니다.

public static void main(String[] args) {

        int[] intArr4 = {1, 2, 3, 4};   // size 4, index range from 0 to 3
        int[] intArr5 = {0, 0, 0, 0, 0, 0, 0};  // size 7, index range from 0 to 6
}

intArr4에는 [1, 2, 3, 4]가 저장됩니다.
intArr5에는 new int[7] 로 초기화한 것과 같이 0으로 값이 들어갑니다.

배열 출력하기

그럼 이렇게 배열에 들어간 값을 출력해보고 싶을 땐 어떻게 할까요?
자바에서 콘솔창에 출력을 할 때에는 System.out.println() 메서드를 사용하는 것은 다들 알고 계시죠?
Hello World를 해보셨다면 다들 알고 계실겁니다.
그럼 이 메서드를 이용해서 변수이름을 넣어주면 될까요?
아닙니다. 배열이 담긴 변수명만 넣어주면 쓰레기값이 출력이 됩니다.
이런 경우에는 Arrays.toString() 메서드를 이용하면 됩니다.

public static void main(String[] args) {

        int[] intArr1 = new int[10];    // size 10, index range from 0 to 9
        int []intArr2 = new int[20];    // size 20, index range from 0 to 19
        int intArr3[] = new int[20];    // size 20, index range from 0 to 19
        int[] intArr4 = {1, 2, 3, 4};   // size 4, index range from 0 to 3
        int[] intArr5 = {0, 0, 0, 0, 0, 0, 0};  // size 7, index range from 0 to 6

        System.out.println(Arrays.toString(intArr1));
        System.out.println(Arrays.toString(intArr2));
        System.out.println(Arrays.toString(intArr3));
        System.out.println(Arrays.toString(intArr4));
        System.out.println(Arrays.toString(intArr5));
}

출력 결과

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[1, 2, 3, 4]
[0, 0, 0, 0, 0, 0, 0]

이상으로 배열의 선언과 초기화에 대한 포스팅을 마치겠습니다.
궁금한 점이 있으시면 댓글 달아주시면 답변드리겠습니다.

2차원 배열에 대한 내용은 [Java] 자바 2차원 배열 생성(선언 및 초기화)에서 더 다루고 있으니 참고하시구요~

도움이 되셨다면 공감 꾸~~~~욱 눌러주고 가세요 ^-^

감사합니다.

지난 시간에는 프로그래밍이란 무엇인지에 대해 간략하게 설명을 해보았습니다.

너무 지루한 이론적인 이야기 보다는 개발자로 개발을 하면서 느낌점을 바탕으로 정의를 내렸었는데

이해하는데 도움이 되었으리라 생각합니다. 

이번 시간에는 무작정 따라하기 시간을 가져보겠습니다.

우선 여러분들 컴퓨터에 아래와 같은 것들을 준비해야 합니다.

1. JDK (Java Development Kit)

2. 이클립스 IDE (Integrated Development Environment)

설치하기 전에 이친구들이 뭔지부터 알고 설치를 해야겠죠? 해킹프로그램이면 큰 일 날 테니까요.

우선, JDK라는 친구는 "자바 개발 툴" 줄여서 "자개툴"이라는 녀석이죠. 자바 언어 사전이라고 생각하시면 됩니다.

이 녀석이 있어야 여러분들이 작성한 자바소스코드를 컴퓨터가 이해하는 언어로 변경이 가능하고,

자바 프로그램을 실행시킬 수가 있습니다. 태생부터 현재까지 무료입니다. (Java 8의 특정 버전 부터는 유료라이센스로 전환되었습니다)

다음으로 이클립스라는 친구는 여러분들이 개발을 좀 더 쉽게 할 수 있도록 하기위해

오픈소스로 공개된 무료로 사용가능한 "통합 개발 환경"을 제공하는 도구입니다.

개발자가 소설작가라면 이클립스 IDE는 워드프로세서와 같은 것입니다.

자, 그럼 설치를 하러 가볼까요??

1. JDK 8 (Java SE Development Kit 8) 설치 -> 다운로드 링크

-> 혹시 다운로드 링크 들어갔는데 cookie 관련 아래와 같은 창이 뜬다면 그냥 I agree 하지마시고 아래처럼 따라해주세요.

2. 이클립스(개발툴, IDE) 설치 -> 다운로드 링크

3. 이제 다운로드 받은 JDK 설치 파일을 "더블클릭"해서 설치해주세요.

-> 설치 시 세팅(설치 경로 변경 등)은 하지말고 기본값 그대로 Next, Next 하시면 됩니다.

설치가 완료되면 윈도우에서는 cmd창, Mac에서는 터미널창에서 아래와 같이 자바의 버전을 확인하는 명령어를 입력해보세요.

java -version

결과는 아래처럼 나와야 합니다. 물론 버전을 나타내는 숫자는 다를 수 있습니다.

여기서 확인할 것은 세 번 째 줄에 HotSpot이라고 뜨는지가 중요합니다.

(자바는 실행환경만 제공하는 JRE와 개발환경까지 제공하는 JDK가 있습니다.

저희는 JDK를 설치한 것이고 JDK의 버전에는 저렇게 HotSpot Server VM이라는 게 출력됩니다.)

여기까지 잘 따라오셨다면 이제 이클립스를 설치해주세요.

우리는 이클립스 인스톨러에서 위에서 두 번째 꺼를 선택해서 설치할겁니다. 

설치 위치는 기본적으로 세팅이 되어있습니다. 그냥 INSTALL 버튼을 꾹 눌러주시면 됩니다.

만약 Java 경로가 나오지 않는다면 Java 설치가 제대로 안되었다는 의미이므로 확인을 해보셔야 합니다.

설치가 진행되고 있습니다. 

이런 저런 파일들을 인터넷에서 다운로드 받아가면서 설치를 합니다.

중간에 이런 라이센스 동의 팝업창이 뜨면 "Remember accepted licenses"에 체크해주고 "Accept"버튼을 눌러줍니다.

여기도 마찬가지입니다. "Remember choice"에 체크해주시고, "Accept" 고고싱~

이 화면은 윈도우 운영체제에서는 안나올 수 있으니, "이런 화면은 왜 안나오지?"하실 필요가 없습니다.

윈도우에서는 그냥 next, next 하시면 될겁니다.

여기서도 체크해주고 "Accept selected" 고고싱~

설치가 완료되면 Launch 버튼이 활성화됩니다.

이제 Launch 버튼을 눌러 실행을 시켜보도록 하겠습니다.

실행하면 위와 같은 창이 뜨는데 무시하고 그냥 "Launch" 버튼을 클릭합니다. (경로는 다를 수 있습니다.)

welcome 창이 떠있습니다. 이런저런 메뉴가 보이고 바로 프로젝트를 만들어 볼 수 있는 메뉴도 보입니다.

이제 간단한 프로젝트를 하나 만들어 보겠습니다.

바로 "안녕 프로젝트"입니다.

welcome 창의 우측에서 "Tutorials"를 선택합니다.

"Create a Hello World application"을 선택합니다.

뭔가 바둑판처럼 생긴 복잡해보이는 화면이 나왔는데 신경끄고 오른쪽에 보이는 "웰컴창"만 보시면 됩니다.

따라하기처럼 되어있는데 버튼만 누르면 알아서 이것저것 해줍니다.

여기서 중요한 것은 순서입니다.

Hello World 애플리케이션을 만들기 위한 작업 순서를 한번 연습하고

다음에 다른 애플리케이션을 만들 때 동일한 순서로 작업을 진행하면 됩니다.

가운데 파란색으로 "Click to Begin"을 클릭해봅시다.

바로 아래쪽에 있는 "Open the Java perspective" 메뉴가 열리면서 이런저런 설명이 또 나옵니다.

설명은 어렵지 않으니 한번 읽어보고, "Click to perform"을 클릭합니다.

뭔가 실행하는 듯 하더니 이클립스 창 우상단에 선택된 아이콘이 변경되었습니다.

원래 커피콩 모양이 있는 아이콘이 선택되어있었는데, 이제 J라는 글자가 있는 아이콘이 선택되어져 있네요.

그리고 웰컴창에서는 다음 단계인 "Create a Java project" 메뉴가 열렸습니다.

설명을 한번 읽어보고 또 "Click to perform" 을 클릭합니다.

자바 프로젝트 생성창이 떴는데 여기서 "Project name"만 입력해주고 "Finish"버튼을 클릭합니다.

좌측의 "Project Explorer" 뷰에 입력만 프로젝트명이 보이는지 확인합니다.

이제 다음 단계인 "Create your HelloWorld class" 를 진행합니다.

설명에 있는대로 따라하거나 "Click to perform"을 클릭합니다.

클래스 생성창이 뜨는데 여기서는 "Name"에 "HelloWorld" 입력 후 아래쪽에 "public static void main(String[] args)" 옆의 체크박스를 체크하고 "Finish" 합니다.

HelloWorld 클래스가 생성되어 좌측의 Package Explorer 에도 파일이 생성된 것을 확인할 수 있고,

가운데 텅텅 비어있던 창에도 뭔가가 나타났습니다. 

이것이 바로 자바 문법에 기초한 소스코드입니다.

자, 이제 처음으로 소스코드를 작성해볼 차례입니다.

웰컴창의 설명대로 아래처럼 출력문을 하나 작성해 주세요.

위 처럼 한줄을 추가하고 저장합니다.

이제 마지막으로 우리가 작성한 코드를 실행해보겠습니다.

웰컴창 마지막 단계의 설명을 따라서 실행해봅니다.

HelloWorld에 작성한 출력문에 따라 그대로 출력되는 것을 확인할 수 있습니다.

여기까지가 HelloWorld 튜토리얼의 끝입니다.

우리는 하나만 더 해보죠.

System.out.println("Hello world!");

여기서 "Hello world!" 를 "안녕 프로젝트 성공" 으로 바꿔서 출력할겁니다.

아래처럼 변경해주시면 됩니다.

System.out.println("안녕 프로젝트 성공");

이제 다시 실행해보세요. 

아래처럼 결과가 잘 나오면 됩니다. 

여기까지 잘 따라 오셨습니다.

여러분은 이제 개발자가 되었습니다. 

이번 시간에는 JDK 설치와 이클립스 IDE 설치 그리고 헬로월드 애플리케이션 만들기 까지

무작정 따라해보는 시간을 가졌습니다.

이제 개발을 위한 기본적인 준비는 모두 끝났습니다.

다음 시간부터는 자바언어를 이용하여 간단한 애플리케이션을 직접 만들어보는 시간을 가지도록 하겠습니다.

서문

나는 이 글을 쓰는 지금 7년차 자바 백엔드 개발자이다.

나는 자바를 제대로 공부하지도 않고 개발자가 되었고, 개발자가 된지 5년이 지나서야 책을 읽어봤다.

수많은 책들이 있었고 그 중 제일 유명한 남궁성님의 책과 윤성우님의  책을 사서 훑어보았다.

책은 너무 두꺼웠고 다시금 까먹고 있던 기초지식을 확인하는 기회가 되었다.

그러다가 한 학생을 가르치게 되었는데 비전공자라 책의 내용을 이해하는데 힘들어했다.

언젠간 나도 책을 내봐야지라는 생각을 가지고 있던터라 이참에 책의 기초가 될만한 강의를 여기서 해볼까 한다.

일반인들, 개발자가 되려는 비전공자들, 그리고 어린 학생들이 읽어도 쉽게 이해할 수 있는 내용으로 강의를 하려 한다.

내 아이가 나중에 커서도 자바가 많이 사용된다면 읽어보도록 추천할 수 있을 정도의 퀄리티를 갖는 내용으로 말이다.

그래서 어떻게 쉽게 전달할 수 있을지 많은 고민을 해야할 것이기에 강의가 빨리 진행되기는 어려울 수 있으나 조금씩 꾸준히 해보려고 한다.

오늘은 그 1일차로 프로그래밍이란 무엇인지에 대해 얘기를 해보겠습니다.

자바란?

세상에는 많은 언어들이 있습니다. 한국어, 중국어, 영어, 일본어, 스페인어, 불어, 독어 등등 말이죠.

한국사람들은 한국어를 사용하고, 일본사람들은 일어를 사용합니다.

어떤 사람들은 3개국어 4개국어를 하기도 합니다.

일본어는 한국어와 문법이 유사해서 쉽고, 영어는 문법이 달라 배우기 어렵다고들 합니다.

언어마다 특정 표현을 할 때 좀더 공감이 가는 문장이 있습니다.

한국어로 직역 또는 의역해도 영어의 특정 문장의 느낌을 그대로 전달하기는 힘들 때가 있는 것처럼 말이죠.

프로그래밍 언어에도 그러한 내용이 딱 들어맞습니다.

자바는 수많은 프로그래밍 언어(세계 각국의 언어)들 중 하나입니다. 

자바 개발자(한국인)들은 자바(한국어)로 개발을 합니다.

모국어는 한국어이지만 3개국어, 4개국어를 할 줄 아는 사람들이 있듯이,

자바 개발자들도 자바만 하는것이 아니라 파이썬, 자바스크립트, C# 등의 언어를 제2외국어처럼 하기도 합니다.

자바와 문법이 유사한 언어는 자바개발자들에게는 learning curve가 낮지만, 너무 다른 언어는 적응하기가 힘들죠.

마치 한국어와 일본어, 한국어와 영어의 차이처럼 말이죠.

자바로는 구현하기 쉬운 기능이 다른 언어에서는 구현하기 힘들 수도 있습니다.

사람들은 언어를 이용하여 다른 사람들과 소통을 합니다.

어휘력이 좋은 사람이 있고 안좋은 사람도 있죠.

대화의 논리가 확실히 잡혀있는 사람도 있고 논리는 없고 앞뒤없는 대화를 하기도 합니다.

개발자들은 소스코드를 이용하여 소통을 합니다.

자바 언어에서 제공하는 문법을 많이 알고있는 개발자도 있고 기초적인 것만 알고있는 개발자도 있죠.

동일한 문제를 풀때에도 알고리즘이 간결하고 명확한 개발자도 있고, 그렇지 않은 개발자도 있습니다.

즉, 자바라는 언어는 개발자들이 프로그래밍을 할 때 사용하는 제2외국어와 같은 존재입니다.

소스코드와 소설

제 와이프는 제가 IDE(개발툴)화면에 코딩을 하는 모습을 보고, "이게 뭐야? 도대체 뭐라고 쓰는건지 하나도 모르겠네. 이런게 이해가 되?" 라고 질문을 합니다. 당연히 그런 반응이 나올 수 밖에 없습니다. 와이프 입장에서는 제가 오지의 인디언이 사용하는 언어로 글을 쓰고있는 것처럼 느껴질 테니까요. 

개발자들은 자신이 사용하는 프로그래밍 언어(제2외국어)를 이용하여 자신들만의 글을 써내려 갑니다. 같은 내용에 대해서 개발을 한다해도 개발자들 성향에 따라 1. 효율성은 조금 떨어지지만 가독성이 좋은 코드를 작성할 수도 있고, 2. 효율성은 극대화했지만 다른 개발자가 이해하기 힘든 코드를 작성할 수도 있습니다. 물론 저는 전자를 지향하고 후배들에게도 전자를 지향하도록 조언합니다.

시인, 소설작가, 수필가 등 글을 쓰는 분들이 단어 하나하나에 고심을 하듯 저도 코딩을 할 때 고민을 많이 합니다. 동일한 기능을 하더라도 좀 더 간결하고 명확하게 효율적인 코딩을 하려고 말이죠. 좋은 글을 작성하기위해 첨삭을 받는 것처럼, 개발자들도 코드리뷰 시간을 통해 고급개발자들의 조언을 듣습니다. 그래서 저는 프로그래밍을 이렇게 정의합니다. "프로그래밍이란 개발자들이 써내려가는 글이다"라고 말이죠. 내가 작성한 코드가 짧지만 이해하기 어려운 시가 될 수도 있고, 좀 길어도 술술 읽어내려갈 수 있는 판타지 소설이 될 수도 있습니다. 어떤 글을 작성하느냐는 순전히 개발자들의 몫이죠. 

Wrap Up

프로그래밍 언어란 개발을 위한 언어로 일어, 중국어, 영어와 같은 제2외국어의 하나다.

프로그래밍 언어에는 여러 언어들이 존재하는데 그 중 하나가 자바(java)다.

고급내용 보충

자바는 다른 언어들과는 다르게 JVM(Java Virtual Machine)이라는 가상머신 위에서 실행이 됩니다. 이 때문에 플랫폼(OS, 운영체제)에 의존적이지 않죠. Linux계열에서도 실행이 가능하고, Windows에서도 실행이 가능합니다. 심지어 안드로이드 애플리케이션도 자바로 개발합니다(요즘은 Kotlin이라는 언어도 많이 사용하시더군요). 또한, JVM이 직접 메모리 관리를 해주기 때문에 별도로 개발자가 메모리 관리를 하지 않아도 됩니다. C언어는 개발자가 직접 메모리에 접근을 하여 사용할 수 있기 때문에 관리도 직접 해야하죠.

자바는 웹개발에 많이 사용됩니다. Python(파이썬)은 빅데이터 영역에서 많이 사용되고, C, C++은 임베디드 영역에서 많이 사용되며, C#은 게임개발에서 많이 사용됩니다.