1004 - 1010

1005 - 동기와 비동기, 블럭과 넌블럭

동기(Synchronous)와 비동기(Asynchronous), 그리고 블럭(Blocking)과 넌블럭(Non-blocking)

Blocking / Non-blocking

행위자가 취한 행위 자체가, 또는 그 행위로 인해 다른 무엇이 막혀버린, 제한된, 대기하는 상태. 대개의 경우에는 나 이외의 대상으로 하여금 내가 Block 당하겠지만(Blocked), 어찌 되었든 문자 자체로는 나라는 ***단일 개체 스스로의 상태***를 나타낸다.

• 호출된 함수가 자신이 할 일을 모두 마칠 때까지 제어권을 계속 가지고서 호출한 함수에게 바로 돌려주지 않으면 Block
• 호출된 함수가 자신이 할 일을 채 마치지 않았더라도 바로 제어권을 건네주어(return) 호출한 함수가 다른 일을 진행할 수 있도록 해주면 Non-block

Synchronous / Asynchronous

***동시에 발생하는***것들. 동시라는 것은 즉, 시(time)라는 단일계(system)에서 같이, 함께 무언가가 이루어지는 두 개 이상의 개체 혹은 이벤트를 의미한다고 볼 수 있다.

• 호출된 함수의 수행 결과 및 종료를 호출한 함수가(호출된 함수뿐 아니라 호출한 함수도 함께) 신경 쓰면 Synchronous
• 호출된 함수의 수행 결과 및 종류를 호출된 함수 혼자 직접 신경 쓰고 처리한다면(as a callback function) Asynchronus

예제

Blocking & Synchronous

나 : 대표님, 개발자 좀 더 뽑아주세요..
대표님 : 오케이, 잠깐만 거기 계세요!
나 : …?!!
대표님 : (채용 공고 등록.. 지원자 연락.. 면접 진행.. 연봉 협상..)
나 : (과정 지켜봄.. 궁금함.. 어차피 내 일 하러는 못 가고 계속 서 있음)

Blocking & Asynchronous

나 : 대표님, 개발자 좀 더 뽑아주세요..
대표님 : 오케이, 잠깐만 거기 계세요!
나 : …?!!
대표님 : (채용 공고 등록.. 지원자 연락.. 면접 진행.. 연봉 협상..)
나 : (안 궁금함.. 지나가는 말로 여쭈었는데 붙잡혀버림.. 딴 생각.. 못 가고 계속 서 있음)

Non-blocking & Synchronous

나 : 대표님, 개발자 좀 더 뽑아주세요..
대표님 : 알겠습니다. 가서 볼 일 보세요.
나 : 넵!
대표님 : (채용 공고 등록.. 지원자 연락.. 면접 진행.. 연봉 협상..)
나 : 채용하셨나요?
대표님 : 아직요.
나 : 채용하셨나요?
대표님 : 아직요.
나 : 채용하셨나요?
대표님 : 아직요~!!!!!!

Non-blocking & Asynchronous

나 : 대표님, 개발자 좀 더 뽑아주세요..
대표님 : 알겠습니다. 가서 볼 일 보세요.
나 : 넵!
대표님 : (채용 공고 등록.. 지원자 연락.. 면접 진행.. 연봉 협상..)
나 : (열일중..)
대표님 : 한 분 모시기로 했습니다~!
나 : 😍

1006 - Spring5 WebClient

WebClient란?

Spring WebClient란? 웹으로 API를 호출하기 위해 사용되는 Non-Blocking 방식의 Http Client 모듈 중 하나이다.

Java에서 가장 많이 사용하는 Http Clent는 RestTemplate이다. 차이점은 RestTemplate는 Blocking방식이고, WebClient는 Non-Blocking방식이다.

간단한예제

Building with

• maven

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

• gradle

dependencies {
    compile 'org.springframework.boot:spring-boot-starter-webflux'
}

Instance 생성

WebClient client1 = WebClient.create();
// or
WebClient client1 = WebClient.create("http://localhost:8080");

WebClient client3 = WebClient
                    .builder()
                    .baseUrl()
                    .defaultCookie()
                    .defaultHeader()
                .build();

WebClient Java Config

@Configuration
@Slf4j
public class WebClientConfig {

    @Bean
    public WebClient webClient() {
        // ExchangeStrategies HTTP 메세지 reader/writer 커스텀
        ExchangeStrategies exchangeStrategies = ExchangeStrategies.builder()
                                                                  .codecs(configurer -> configurer.defaultCodecs().maxInMemorySize(1024*1024*50))
                                                                  .build();
        exchangeStrategies
            .messageWriters().stream()
            .filter(LoggingCodecSupport.class::isInstance)
            .forEach(writer -> ((LoggingCodecSupport)writer).setEnableLoggingRequestDetails(true));

        return WebClient.builder()
                .clientConnector(
                    new ReactorClientHttpConnector(
                        HttpClient
                            .create()
                            .secure(
                                ThrowingConsumer.unchecked(
                                    sslContextSpec -> sslContextSpec.sslContext(
                                        SslContextBuilder.forClient().trustManager(InsecureTrustManagerFactory.INSTANCE).build()
                                    )
                                )
                            )
                            // timeout 설정
                            .tcpConfiguration(
                                client -> client.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 120_000)
                                                .doOnConnected(conn -> conn.addHandlerLast(new ReadTimeoutHandler(180))
                                                                           .addHandlerLast(new WriteTimeoutHandler(180))
                                                )
                            )
                    )
                )
                .exchangeStrategies(exchangeStrategies)
                // request 로그
                .filter(ExchangeFilterFunction.ofRequestProcessor(
                    clientRequest -> {
                        log.debug("Request: {} {}", clientRequest.method(), clientRequest.url());
                        clientRequest.headers().forEach((name, values) -> values.forEach(value -> log.debug("{} : {}", name, value)));
                        return Mono.just(clientRequest);
                    }
                ))
                // response 로그
                .filter(ExchangeFilterFunction.ofResponseProcessor(
                    clientResponse -> {
                        clientResponse.headers().asHttpHeaders().forEach((name, values) -> values.forEach(value -> log.debug("{} : {}", name, value)));
                        return Mono.just(clientResponse);
                    }
                ))
                .defaultHeader("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.87 Safari/537.3")
                .build();
    }
}

• MaxInMemorySize
  ExchageStrategies.builder()를 통해 in-memory buffer값을 변경 (기본256KB)

• Logging
  ExchageStrateges와 logging level설정

사용

• @Bean으로 등록된 WebClient는 다음과 같이 사용

@Service
@RequiredArgsConstructor
@Slf4j
public class SomeService implements SomeInterface {

    private final WebClient webClient;
    public Mono<SomeData> getSomething() {
  
    return webClient.mutate()
                    .build()
                    .get()
                    .uri("/resource")
                    .retrieve()
                    .bodyToMono(SomeData.class);
    }
}

retrieve(), exchange()

HTTP 호출 결과를 가져오는 두 가지 방법으로 retrieve()와 exchange()가 있다. Spring에서는 exchange를 이용하게 되면 Response 컨텐츠에 대한 모든 처리를 직접 하면서 발생할 수 있는 memory leak 가능성 떄문에 가급적 retrieve를 사용하기를 권고한다.

Mono<Person> result = webClient.get()
                               .uri("/persons/{id}", id)
                               .accept(MediaType.APPLICATION_JSON) 
                               .retrieve() 
                               .bodyToMono(Person.class);

4xx and 5xx처리

webClient.mutate()
         .baseUrl("https://some.com")
         .build()
         .get()
         .uri("/resource")
         .accept(MediaType.APPLICATION_JSON)
         .retrieve()
         .onStatus(status -> status.is4xxClientError() 
                          || status.is5xxServerError()
             , clientResponse ->
                           clientResponse.bodyToMono(String.class)
                           .map(body -> new RuntimeException(body)))
         .bodyToMono(SomeData.class)

GET 예제

public Mono<SomeData> getData(Integer id, String accessToken) {
    return
        webClient.mutate()
                 .baseUrl("https://some.com/api")
                 .build()
                 .get()
                 .uri("/resource?id={ID}", id)
                 .accept(MediaType.APPLICATION_JSON)
                 .header(HttpHeaders.AUTHORIZATION, "Bearer " + accessToken)
                 .retrieve()
                 .bodyToMono(SomeData.class)
        ;
}

POST 예제

• form 데이터 전송

webClient.mutate()
         .baseUrl("https://some.com/api")
         .build()
         .post()
         .uri("/login")
         .contentType(MediaType.APPLICATION_FORM_URLENCODED)
         .accept(MediaType.APPLICATION_JSON)
         .body(BodyInserters.fromFormData("id", idValue)
                            .with("pwd", pwdValue)
         )
         .retrieve()
         .bodyToMono(SomeData.class);

• JSON body 데이터 전송

webClient.mutate()
         .baseUrl("https://some.com/api")
         .build()
         .post()
         .uri("/login")
         .contentType(MediaType.APPLICATION_JSON)
         .accept(MediaType.APPLICATION_JSON)
         .bodyValue(loginInfo)
         .retrieve()
         .bodyToMono(SomeData.class);

DELETE

webClient.mutate()
         .baseUrl("https://some.com/api")
         .build()
         .delete()
         .uri("/resource/{ID}", id)
         .retrieve()
         // Void 반환
         .bodyToMono(Void.class);

1010 - Inner class에 Static을 붙이는 이유

Nested Class

- Nested classes
    - Inner classes
        - Inner classes
        - Method local Inner classes
        - Anonymous Inner classes (익명클래스)
    - Static Nested classes

자바는 일반적인 클래스를 제외하고 일반적으로 클래스의 중첩을 이렇게 나눈다.

Nested Class

• 패키지가 되는 클래스가 아닌 나머지 클래스
• 하나의 패키지에 대해 여러 클래스를 사용할 수 있고, 서로간 결합만이 존재하는 클래스의 경우 가독성이 좋고 관리하기 편하다.

클래스가 다른 클레스에만 유용 할 경우 해당 클래스에 클래스를 포함시키고 두 클래스를 핢께 유지하는 것이 논리적이다. 이러한 "헬퍼 클래스"를 중첩하면 패키지가 더욱 간소화된다.

• 중첩 클래스들은 패키지 클래스 내부에 숨겨져있으므로 캡슐화에 도움이 된다.

A와 B라는 두 가지 최상위 클래스를 고려한다. 여기서 B는 선언 될 A의 멤버에 액세스해야한다. 클래스 A 내에 클래스 B를 숨기면 A의 구성원을 비공개로 선언하고 B가 액세스 할 수 있다. 또한 B 자체는 외부 세계에서 숨길 수 있다.

non-static nested class

• Inner class라고 하며 외부 인스턴스에 대한 참조가 유지된다.
• 외부 인스턴스는 내부 클래스를 new를 통한 인스턴스 할당으로 멤버변수러첢 사용할 수 있다.
• 외부에 대한 참조가 유지되므로 내부 클래스도 외부 클래스의 자원을 사용할 수 있다.

public class Outer {
	class Inner {
    }
  }
  
Outer outer = new Outer();
Outer.Inner inner = new Outer.Inner(); 

static nested class

• static이 붙는 중첩 클래스
• 동일한 static 멤버들을 사용 가능
• static의 특징에 따라 외부 인스턴스 멤버의 직접참조가 불가능

public class Outer {
	static class staticNasted {
    }
  }
  
Outer.Inner staticNasted = new Outer.Inner();

차이

• 외부 참조의 여부
• 외부 참조가 유지된다는 것은 메모리에 대한 참조가 유지되고 있다는 뜻으로 GC가 메모리를 회수할 수없다. 당연히 이는 메모리 누수를 부르는 치명적인 단점.
• 항상 외부 인스턴스의 참조를 통해야 하므로 성능 상 비효율적.
• 결국 외부 인스턴스에 대한 참조가 필요하지 않다면 static nested class가 낫다.
• 여기서의 staitc의 의미는 외부 인스턴스 없이 내부 클래스르의 인스턴스를 바로 생성할 수 있다는 뜻으로 사용 된다.

Spring Boot에서 DTO관리를 위한 static nested class

• DTO 예제

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.Setter;

public class User {

    @Getter
    @AllArgsConstructor
    @Builder
    public static class Info {
        private int id;
        private String name;
        private int age;
    }

    @Getter
    @Setter
    public static class Request {
        private String name;
        private int age;
    }

    @Getter
    @AllArgsConstructor
    public static class Response {
        private Info info;
        private int returnCode;
        private String returnMessage;
    }
}

• Controller

import com.parksh.demo.dto.DefaultResponse;
import com.parksh.demo.dto.user.User;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping(“user”)
public class UserController {

    @GetMapping(“/{user_id}”)
    public User.Response getUser(@PathVariable(“user_id”) String userId) {

        return new User.Response(new User.Info(), 200, “success”);
    }

    @PostMapping
    public DefaultResponse addUser(@RequestBody User.Info info) {

        return new DefaultResponse();
    }
}