Spring MSA 구현하기 (WebClient적용하기)

                                    1. Server간의 Error사항은 정해진 Error Code를 사용하며, RFC7807형태로 에러를 상세히 기술한다.
2. DTO의 재사용성을 최소화하여 가능한 API당 DTO를 따로 제작한다.

                                    package com.example.frontServer.service

import com.example.frontServer.dto.like.LikeRequest
import com.example.frontServer.dto.like.LikeSaveResult
import com.example.frontServer.dto.like.LikeServerSaveResponse
import com.example.frontServer.enum.FrontServerError
import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker
import io.github.oshai.kotlinlogging.KotlinLogging
import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry
import org.springframework.http.HttpHeaders
import org.springframework.stereotype.Service
import org.springframework.web.reactive.function.client.WebClient
import org.springframework.web.util.UriBuilder

@Service
class LikeService(
    private val client : WebClient,
) {
    private val circuitBreaker = circuitBreakerRegistry.circuitBreaker("liveApiCircuitBreaker")
    private val logger = KotlinLogging.logger {}
    fun save(boardId: Long, userId: Long): LikeSaveResult {
        val response = client.post()
            .uri { uriBuilder: UriBuilder ->
                uriBuilder
                    .path("/like")
                    .build()
            }
            .bodyValue(
                LikeRequest(
                    boardId = boardId,
                    userId = userId,
                )
            )
            .headers { headers ->
                headers.remove(HttpHeaders.AUTHORIZATION)
            }
            .retrieve()
            .bodyToMono(LikeServerSaveResponse::class.java)
            .block()

        if (response == null) {
            return LikeSaveResult(
                error = FrontServerError.UNEXPECTED_ERROR
            )
            // fallback으로 처리 할 수 는 없을까?
        }

        return LikeSaveResult.of(response)
    }

}

                                    package com.example.frontServer.dto.like

import org.jetbrains.annotations.NotNull

data class LikeRequest(
    @field: NotNull
    val boardId: Long,

    @field: NotNull
    val userId: Long,

    @field: NotNull
    val likeType: Int,
)

                                    package com.example.frontServer.dto.like

import com.example.frontServer.dto.ServerErrorDetails
import com.example.frontServer.enum.ServiceServerError

data class LikeServerSaveResponse(
    val error: ServiceServerError?,
    val details: ServerErrorDetails?
)

                                    package com.example.frontServer.dto.like

import com.example.frontServer.enum.FrontServerError
import com.example.frontServer.enum.ServiceServerError

// service to controller
data class LikeSaveResult(
    val error: FrontServerError?
) {
    companion object {
        fun of(serverResult: LikeServerSaveResponse): LikeSaveResult {
            if (serverResult.error == null) {
                return LikeSaveResult(null)
            }

            return if (serverResult.error == ServiceServerError.UNKNOWN_ID) {
                LikeSaveResult(
                    error = FrontServerError.UNKNOWN_ID
                )
            } else {
                LikeSaveResult(
                    error = FrontServerError.UNEXPECTED_ERROR
                )
            }
        }
    }
}

                                    package com.example.frontServer.controller

import com.example.frontServer.dto.ResponseToClientDto
import com.example.frontServer.dto.like.LikeSaveResponse
import com.example.frontServer.security.AuthUserDetails
import com.example.frontServer.service.LikeService
import io.github.oshai.kotlinlogging.KotlinLogging
import org.springframework.http.ResponseEntity
import org.springframework.security.core.annotation.AuthenticationPrincipal
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.RequestParam
import org.springframework.web.bind.annotation.RestController

@RestController
class LikeController(
    private val likeService: LikeService
) {
    private val logger = KotlinLogging.logger {}

    @PostMapping("/like")
    fun save(
        @Valid @RequestBody boardId: Long,
        @AuthenticationPrincipal user: AuthUserDetails
    ): ResponseEntity<LikeSaveResponse> {
        return ResponseEntity.ok().body(
            LikeSaveResponse.of(
                likeService.save(boardId, user.getUserId())
            )
        )
    }
}

                                    package com.example.frontServer.dto.like

import com.example.frontServer.enum.FrontServerError

// controller to client
data class LikeSaveResponse(
    val error: FrontServerError?
) {
    companion object{
        fun of (result: LikeSaveResult): LikeSaveResponse {
            return if (result.error != null) {
                LikeSaveResponse(
                    error = result.error
                )
            } else {
                LikeSaveResponse(
                    error = null
                )
            }
        }
    }
}

                                    package com.example.liveApiServer.controller

import com.example.liveApiServer.dto.LikeRequest
import com.example.liveApiServer.dto.LikeServerSaveResponse
import com.example.liveApiServer.dto.save.LikeRequest
import com.example.liveApiServer.dto.save.LikeServerSaveResponse
import com.example.liveApiServer.service.LikeService
import jakarta.validation.Valid
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.DeleteMapping
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.RequestParam
import org.springframework.web.bind.annotation.RestController

@RestController
class LikeController(
    private val likeService: LikeService,
) {

    @PostMapping("/like")
    fun save(
        @Valid @RequestBody request: LikeRequest
    ): ResponseEntity<LikeServerSaveResponse> {
        return ResponseEntity.ok().body(
            LikeServerSaveResponse.of(
                likeService.save(request)
            )
        )
    }
}

                                    package com.example.liveApiServer.service

import com.example.liveApiServer.dto.save.LikeRequest
import com.example.liveApiServer.dto.save.LikeServerSaveResult
import com.example.liveApiServer.entity.Like
import com.example.liveApiServer.repository.LikeRepository
import org.springframework.stereotype.Service

@Service
class LikeService(
    private val likeRepository: LikeRepository,
) {
    fun save(request: LikeRequest): LikeServerSaveResult{
        return try {
            likeRepository.save(
                Like(
                    id = null, // 이렇게 명시하는게 좋아.
                    boardId = request.boardId,
                    userId = request.userId,
                    likeType = request.likeType,
                )
            )
            LikeServerSaveResult(
                details = null,
                error = null
            )
        }  catch {
            // error 별로 LikeServerSaveResult 관리
            // boardId userId가 없는 경우 어떻게 처리?
            // likeType이 없는 type인 경우도 있을 수 있다.
        }
    }

}

                                    👉 FrontServer - MSA Servers
ServiceServerError : Service Server사이에서 사용되는 공용 에러코드 ex) 10001, 10002 ...
ServerErrorDetails : RFC 표준을 변형하여 사용하는 에러 Spec

                                    👉 Client - FrontServer
FrontServerError : FrontServer에서 Client Server로 전달되는 에러코드 ex) 10001, 10002 ...
(클라이언트와 프론트 서버간에 미리 맞춰놓으면 됨)