Facade

📚

Facade Pattern (퍼사드 패턴)

---

Facade Pattern이란?

퍼사드 패턴(Facade Pattern)은 구조 패턴(Structural Pattern)의 한 종류로, 복잡한 서브 시스템의 기능들을 간단한 상위 수준의 인터페이스로 제공하여 클라이언트와 서브 시스템 간의 의존성을 줄이는 역할을 합니다.
이를 통해 클라이언트는 내부의 복잡한 로직에 신경 쓰지 않고도, 단순화된 접근 방식으로 필요한 작업을 수행할 수 있습니다.

---

Facade Pattern의 특징

1. 낮은 결합도
   클라이언트는 퍼사드 객체만 알면 되므로 서브 시스템의 내부 구현에 의존하지 않습니다.

2. 가독성 증가
   클라이언트에서 여러 서브 시스템을 호출하는 대신, 단일 퍼사드 객체로 작업을 처리하여 코드의 가독성과 유지보수성을 높입니다.

3. 서브 시스템 직접 접근 가능
   필요에 따라 서브 시스템 객체를 직접 사용할 수도 있습니다. 선택지가 유연해집니다.

---

참고: 제미니의 개발실무

기존 방식의 문제점

기존 방식에서는 클라이언트가 "나의 회원 정보 조회"와 "다른 회원 정보 조회"를 요청할 때, 서비스 레이어에서 별도로 DTO를 구성하여 반환했습니다.
이는 비슷한 데이터를 처리하지만, 서비스 로직이 중복되고 확장성이 떨어지는 문제가 있었습니다.

내가 변경한 구조 쉬운 이해도

기존 구조

1. 컨트롤러의 요청 처리 방식

// UserController의 기존 방식
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/v1/users")
public class UserController {

    private final UserService userService;

    // 나의 회원정보 조회
    @GetMapping
    public ResponseEntity<?> getUserInfo(Authentication authentication) {
        return ResponseEntity.status(OK)
            .body(ResponseMessage.success(userService.getUserInfo(getCurrentUser(authentication))));
    }

    // 다른 회원 정보 조회
    @GetMapping("/{userId}")
    public ResponseEntity<?> getOtherUserInfo(@PathVariable Long userId) {
        return ResponseEntity.status(OK)
            .body(ResponseMessage.success(userService.getOtherUserInfo(userId)));
    }

    private UserEntity getCurrentUser(Authentication authentication) {
        if (authentication == null || !authentication.isAuthenticated()) {
            throw new BizException(UNAUTHORIZED_ERROR);
        }
        return userRepository.findByEmail(((CustomUserDetails) authentication.getPrincipal()).getUsername())
            .orElseThrow(() -> new BizException(USER_NOT_FOUND_ERROR));
    }
}

2. UserService의 처리 방식

@Service
@RequiredArgsConstructor
public class UserService {

    private final UserRepository userRepository;

    // 나의 회원정보 조회 로직
    public UserInfoResponseDTO getUserInfo(UserEntity currentUser) {
        return UserInfoResponseDTO.builder()
            .id(currentUser.getId())
            .username(currentUser.getUsername())
            .nickname(currentUser.getNickname())
            .phone(currentUser.getPhone())
            .email(currentUser.getEmail())
            .status(currentUser.getStatus())
            .build();
    }

    // 다른 회원 정보 조회 로직
    public OtherUserInfoResponseDTO getOtherUserInfo(Long userId) {
        UserEntity userEntity = userRepository.findById(userId)
        .orElseThrow(()->new BizException(USER_NOT_FOUND_ERROR));
      
        return OtherUserInfoResponseDTO.builder()
            .username(userEntity.getUsername())
            .nickname(userEntity.getNickname())
            .email(userEntity.getEmail())
            .status(userEntity.getStatus())
            .build();
    }
}

문제점

1. 중복된 로직

   • UserService에서 "나의 회원 정보 조회"와 "다른 회원 정보 조회" 로직이 거의 동일하지만, 별도의 DTO를 사용하여 두 번 작성됨.
   • 재사용성이 낮음.

2. 확장성 문제

   • 클라이언트 요구에 따라 추가적인 데이터를 반환해야 할 경우, 각 서비스 로직에 새로운 코드가 필요.

3. 컨트롤러의 복잡성

   • 컨트롤러에서 서비스를 호출할 때, 세부 로직이 노출되어 관리가 어려워질 수 있음.

---

Facade Pattern 적용 후 개선된 구조

개선된 구조

공통 데이터는 서비스 레이어에서 처리하고,
Facade 레이어에서 필요한 데이터를 조합하여 클라이언트 요청에 맞게 반환합니다.

이를 통해 서비스 로직의 중복 제거와 확장성 향상을 동시에 달성할 수 있습니다.

Facade 구현 코드

@Service
@Slf4j
@RequiredArgsConstructor
public class UserInfoFacade {

    private final UserParticipationService userParticipationService;
    private final UserService userService;
    private final RedisTemplate<String, Object> redisTemplate;

    public UserInfoFacadeDto getUserInfo(Long userId) {
        String cacheKey = "userInfo:" + userId;

        // Redis에서 캐시된 데이터 조회
        Object cachedData = redisTemplate.opsForValue().get(cacheKey);
        if (cachedData != null) {
            log.info("Cache hit for user ID: {}", userId);
            return (UserInfoFacadeDto) cachedData;
        }
        UserServiceDto userInfo = userService.getUserInfo(userId);

        Integer completedTripsCount = userParticipationService.getCompletedTripsCount(
            String.valueOf(userId));

        UserInfoFacadeDto build = UserInfoFacadeDto.builder()
            .id(userInfo.getId())
            .count(completedTripsCount)
            .username(userInfo.getUsername())
            .phone(userInfo.getPhone())
            .email(userInfo.getEmail())
            .mbti(userInfo.getMbti())
            .ratingAvg(userInfo.getRatingAvg())
            .birth(userInfo.getBirth())
            .introduction(userInfo.getIntroduction())
            .nickname(userInfo.getNickname())
            .status(userInfo.getStatus())
            .smoking(userInfo.getSmoking())
            .gender(userInfo.getGender())
            .build();

        // Redis에 캐시 저장 (만료 시간 1시간 설정)
        redisTemplate.opsForValue().set(cacheKey, build, 1, TimeUnit.HOURS);
        log.info("Cache miss for user ID: {}. Data cached.", userId);

        return build;
    }
}

UserService의 getUserInfo

 public UserServiceDto getUserInfo(long userId) {
        UserEntity userEntity = userRepository.findById(userId).orElseThrow(()->new BizException(USER_NOT_FOUND_ERROR));
        ProfileEntity profileEntity = profileRepository.findByUserId(userEntity.getId())
            .orElseThrow(() -> new BizException(PROFILE_NOT_FOUND_ERROR));

        // 데이터베이스에서 조회
        UserServiceDto userInfo = UserServiceDto.builder()
            .id(userEntity.getId())
            .username(userEntity.getUsername())
            .nickname(userEntity.getNickname())
            .phone(userEntity.getPhone())
            .email(userEntity.getEmail())
            .status(userEntity.getStatus())
            .introduction(profileEntity.getIntroduction())
            .mbti(profileEntity.getMbti())
            .gender(profileEntity.getGender())
            .smoking(profileEntity.getSmoking())
            .birth(profileEntity.getBirth())
            .ratingAvg(profileEntity.getRatingAvg())
            .build();

        return userInfo;
    }

컨트롤러에서 Facade 호출

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/v1/users")
public class UserController {

    private final UserInfoFacade userInfoFacade;

    // 나의 회원정보 조회
    @GetMapping
    public ResponseEntity<ResponseMessage<UserInfoResponseDTO>> getUserInfo(
        Authentication authentication) {
        UserInfoFacadeDto otherUserInfo = userInfoFacade.getUserInfo(getCurrentUser(authentication).getId());
        return ResponseEntity.status(OK)
            .body(ResponseMessage.success(UserInfoResponseDTO.fromDto(otherUserInfo)));
    }

    // 다른 회원 정보 조회
    @GetMapping("/{userId}")
    public ResponseEntity<ResponseMessage<OtherUserInfoResponseDTO>> getOtherUserInfo(
        @PathVariable Long userId) {

        UserInfoFacadeDto otherUserInfo = userInfoFacade.getUserInfo(userId);
        return ResponseEntity.status(OK)
            .body(ResponseMessage.success(OtherUserInfoResponseDTO.fromDto(otherUserInfo)));
    }

UserInfoResponseDTO

@Data
@Builder
@Getter
@AllArgsConstructor
@JsonDeserialize(builder = UserInfoResponseDTO.UserInfoResponseDTOBuilder.class)
public class UserInfoResponseDTO {

    private Long id;
    private String username;
    private String nickname;
    private String phone;
    private String email;
    private String status;
    private MBTI mbti;
    private String smoking;
    private String introduction;
    private String gender;

    @JsonSerialize(using = LocalDateSerializer.class)
    @JsonDeserialize(using = LocalDateDeserializer.class)
    private LocalDate birth;
    private Double ratingAvg;

    public static UserInfoResponseDTO fromDto(UserInfoFacadeDto userInfoFacadeDto) {
        return UserInfoResponseDTO.builder()
            .id(userInfoFacadeDto.getId())
            .username(userInfoFacadeDto.getUsername())
            .nickname(userInfoFacadeDto.getNickname())
            .phone(userInfoFacadeDto.getPhone())
            .email(userInfoFacadeDto.getEmail())
            .mbti(userInfoFacadeDto.getMbti())
            .introduction(userInfoFacadeDto.getIntroduction())
            .birth(userInfoFacadeDto.getBirth())
            .ratingAvg(userInfoFacadeDto.getRatingAvg())
            .smoking(userInfoFacadeDto.getSmoking().getSmoke())
            .gender(userInfoFacadeDto.getGender().getGender())
            .status(userInfoFacadeDto.getStatus().getStatus())
            .build();
    }

    @JsonPOJOBuilder(withPrefix = "")
    public static class UserInfoResponseDTOBuilder {

    }
}

OtherUserInfoResponseDTO

@Builder
@Getter
@AllArgsConstructor
@JsonDeserialize(builder = OtherUserInfoResponseDTO.OtherUserInfoResponseDTOBuilder.class)
public class OtherUserInfoResponseDTO {

    private String username;
    private String nickname;
    private String email;
    private Integer count; // 여행 횟수
    private Double ratingAvg;
    private String gender;
    private String status;

    public static OtherUserInfoResponseDTO fromDto(UserInfoFacadeDto userInfoFacadeDto) {
        return OtherUserInfoResponseDTO.builder()
            .username(userInfoFacadeDto.getUsername())
            .nickname(userInfoFacadeDto.getNickname())
            .email(userInfoFacadeDto.getEmail())
            .count(userInfoFacadeDto.getCount())
            .ratingAvg(userInfoFacadeDto.getRatingAvg())
            .gender(userInfoFacadeDto.getGender().getGender())
            .status(userInfoFacadeDto.getStatus().getUserStatus())
            .build();
    }

    @JsonPOJOBuilder(withPrefix = "")
    public static class OtherUserInfoResponseDTOBuilder {

    }
}

FeignClient 활용

@Service
@RequiredArgsConstructor
public class UserParticipationService {

    private final TravelClient travelClient;

    public Integer getCompletedTripsCount(String userId) {
        ResponseEntity<Integer> response = travelClient.getParticipationsCompletedByUserId(userId);
        if (response.getStatusCode().is2xxSuccessful()) {
            return response.getBody();
        } else {
            throw new BizException(INTERNAL_SERVER_ERROR);
        }
    }
}

---

적용 후 장점

1. 재사용성 증가

   • Facade 레이어에서 데이터를 조합하므로, 공통 로직은 서비스에서 처리하고 추가 로직만 Facade에서 관리 가능.

2. 중복 코드 제거

   • 기존의 "나의 회원 정보 조회"와 "다른 회원 정보 조회" 로직에서 발생하던 중복 제거.

3. 확장성 및 유지보수성 향상

   • 추가 데이터 요구 사항은 Facade에서 처리 가능하므로 서비스 로직 수정이 최소화됨.

---

결론

퍼사드 패턴을 적용하여, 기존의 중복된 로직을 제거하고 유연한 데이터 반환 구조를 설계했습니다.
클라이언트는 내부 로직에 신경 쓰지 않고 Facade 객체를 통해 필요한 데이터를 쉽게 호출할 수 있으며, 이는 가독성과 확장성 모두를 높이는 결과를 가져왔습니다.

ChatGPT의 개선할 수 있는 측면분석

Facade의 역할 명확화:
현재 UserInfoFacade가 단순히 데이터를 조합하고 캐시를 관리하는 역할을 하고 있습니다. Facade 패턴의 목적은 클라이언트에게 서브 시스템의 복잡성을 숨기는 것이므로, 추가적인 서브 시스템이나 복잡한 로직이 더 있다면 Facade가 이를 더 잘 감싸도록 할 수 있습니다.
예를 들어, 인증, 권한 검사, 로깅 등 다른 서브 시스템과의 연계가 있다면 Facade에서 이를 통합 관리할 수 있습니다.

DTO 변환 로직의 위치:

현재 DTO 변환 로직이 Facade와 컨트롤러 양쪽에 분산되어 있습니다. 변환 로직을 일관되게 관리하기 위해 Facade 내에서 모든 DTO 변환을 처리하고, 컨트롤러는 Facade에서 반환된 DTO를 그대로 사용하는 방식으로 통일할 수 있습니다.

캐시 관리의 추상화:

캐시 로직이 Facade에 직접 포함되어 있는데, 이를 별도의 캐시 관리 서비스로 분리하면 Facade의 책임을 더욱 명확히 할 수 있습니다. 예를 들어, UserInfoCacheService를 만들어 캐시 관련 로직을 전담하게 할 수 있습니다.