[🔥TroubleShooting - TicToc🔥] Service 계층 이거.. 너무 무거운데..❓❓ 🏋🏋

📌 프로젝트 소개

팀원 : 개인 프로젝트
기간 : 2025.01 ~ 진행 중
링크 : https://github.com/M-ung/TicToc_Server
서비스 내용 : 당신의 시간에 가치를 매기다, 시간 거래 경매 플랫폼

---

🔥TroubleShooting🔥

Problems

경매 관련 비지니스 로직을 구현하면서 고민이 생겼다. 예를 들어 "경매 수정" 기능을 구현한다고 가정해 보자. 그럼 "경매 수정" 전에 사용자의 userId와 경매의 userId가 동일한 지 확인해야 하는 로직이 필요했다. 이 외에도 유효성 검사, 객체 수정과 같은 여러 기능들이 필요할 때 Service 계층에 메서드를 계속 만들어왔다.
그렇게 되면 Service 코드는 아래와 같다. (아래 코드는 멀티모듈 + 헥사고날 아키텍처 적용 전 코드이다.)

@Service
@Transactional
@RequiredArgsConstructor
public class AuctionCommandServiceImpl implements AuctionCommandService {
    private final AuctionRepository auctionRepository;
    private final AuctionHistoryRepository auctionHistoryRepository;

    @Override
    public void register(final Long userId, AuctionRequestDTO.Register requestDTO) {
        checkAuctionTimeRange(userId, requestDTO.sellStartTime(), requestDTO.sellEndTime());
        auctionRepository.save(Auction.of(userId, requestDTO));
    }

    @Override
    public void update(final Long userId, final Long auctionId, AuctionRequestDTO.Update requestDTO) {
        validateAuctionAccess(userId, auctionId);
        checkAuctionTimeRange(userId, requestDTO.sellStartTime(), requestDTO.sellEndTime());
        try {
            findAuctionById(auctionId).update(requestDTO);
        } catch (OptimisticLockingFailureException e) {
            throw new ConflictAuctionUpdateException(CONFLICT_AUCTION_UPDATE);
        }
    }

    @Override
    public void delete(final Long userId, final Long auctionId) {
        validateAuctionAccess(userId, auctionId);
        try {
            findAuctionById(auctionId).deactivate();
        } catch (OptimisticLockingFailureException e) {
            throw new ConflictAuctionDeleteException(CONFLICT_AUCTION_DELETE);
        }
    }

    private Auction findAuctionById(final Long auctionId) {
        return auctionRepository.findById(auctionId)
                .orElseThrow(() -> new AuctionNotFoundException(AUCTION_NOT_FOUND));
    }

    private void validateAuctionAccess(final Long userId, final Long auctioneerId) {
        if(!userId.equals(auctioneerId)) {
            throw new AuctionNoAccessException(AUCTION_NO_ACCESS);
        }
    }

    private void checkAuctionTimeRange(Long userId, LocalDateTime sellStartTime, LocalDateTime sellEndTime) {
        if(auctionRepository.existsAuctionInTimeRange(userId, sellStartTime, sellEndTime)) {
            throw new DuplicateAuctionDateException(DUPLICATE_AUCTION_DATE);
        }
    }
}

위 코드는 개발이 끝난 상태가 아닌, 개발 중인 상태이다. 그럼에도 불구하고 validateAuctionAccess 와 같은 메서드가 복잡성을 증가시키고 있으며 해당 메서드는 다른 Service 계층에서도 필요하기에 코드 중복성 또한 일으켰다.

문제를 정리하면 아래와 같다.

1. Service 계층의 책임 증가
2. 코드 복잡성 증가
3. 코드 중복성 증가

---

How

위 문제들을 해결하기 위해서 findAuctionById 와 같이 DB를 접근해야 하는 메서드가 아니라면 도메인에 메서드를 작성하는 "캡슐화" 방식을 택했다.

1. 도메인 캡슐화 메서드 적용
2. Service 계층을 단순화

---

Process

1. 도메인 캡슐화 메서드 적용
DB 접근이 필요하지 않은 도메인의 비지니스 로직은 도메인 계층에 캡슐화하여 메서드를 작성했다.
이전에는 Service 계층에서 직접 검증 로직과 상태 변경을 수행했지만, 객체 지향적인 설계하여 복잡성과 중복성을 줄이기 위해 도메인 객체가 스스로 비즈니스 로직을 수행하도록 변경했다.

@Getter
@Entity
@Builder
@AllArgsConstructor
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Table(name = "auction")
public class Auction extends BaseTimeEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private Long auctioneerId;
    private String title;
    @Column(nullable = false, columnDefinition = "TEXT")
    private String content;
    private Integer startPrice;
    private Integer currentPrice;
    private Integer finalPrice;
    @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss")
    private LocalDateTime sellStartTime; // 판매하고 싶은 시간(시작)
    @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss")
    private LocalDateTime sellEndTime; // 판매하고 싶은 시간(종료)
    @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss")
    private LocalDateTime auctionOpenTime; // 경매 시작 시간
    @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss")
    private LocalDateTime auctionCloseTime; // 경매 종료 시간
    @Enumerated(EnumType.STRING)
    private AuctionProgress progress;
    @Enumerated(EnumType.STRING)
    private AuctionType type;
    @Enumerated(EnumType.STRING)
    private TicTocStatus status;

    public static Auction of(final Long userId, AuctionUseCaseReqDTO.Register requestDTO) {
        return Auction.builder()
                .auctioneerId(userId)
                .title(requestDTO.title())
                .content(requestDTO.content())
                .startPrice(requestDTO.startPrice())
                .currentPrice(requestDTO.startPrice())
                .finalPrice(requestDTO.startPrice())
                .sellStartTime(requestDTO.sellStartTime())
                .sellEndTime(requestDTO.sellEndTime())
                .auctionOpenTime(LocalDateTime.now())
                .auctionCloseTime(requestDTO.auctionCloseTime())
                .progress(NOT_STARTED)
                .type(requestDTO.type())
                .status(TicTocStatus.ACTIVE)
                .build();
    }

    public void update(AuctionUseCaseReqDTO.Update requestDTO) {
        validateAuctionAlreadyStarted();
        this.title = requestDTO.title();
        this.content = requestDTO.content();
        this.startPrice = requestDTO.startPrice();
        this.currentPrice = requestDTO.startPrice();
        this.finalPrice = requestDTO.startPrice();
        this.sellStartTime = requestDTO.sellStartTime();
        this.sellEndTime = requestDTO.sellEndTime();
        this.auctionCloseTime = requestDTO.auctionCloseTime();
        this.type = requestDTO.type();
    }

    public void deactivate(final Long userId) {
        validateAuctionAccess(userId);
        validateAuctionAlreadyStarted();
        this.status = TicTocStatus.DISACTIVE;
    }

    public void validateAuctionAccess(final Long userId) {
        if(!userId.equals(this.auctioneerId)) {
            throw new BidNoAccessException(BID_NO_ACCESS);
        }
    }

    private void validateAuctionAlreadyStarted() {
        if(!this.getProgress().equals(NOT_STARTED)) {
            throw new AuctionAlreadyStartedException(AUCTION_ALREADY_STARTED);
        }
    }
}

2. Service 계층을 단순화
Service 계층에서는 DB를 접근하는 로직만 처리하고, 비즈니스 로직은 도메인 객체에서 수행하도록 변경하여 도메인 객체를 가져와 메서드를 호출하는 역할만 담당하도록 구현했다.

@Service
@Transactional
@RequiredArgsConstructor
public class AuctionCommandService implements AuctionCommandUseCase {
    private final LocationCommandUseCase locationCommandUseCase;
    private final AuctionRepositoryPort auctionRepositoryPort;
    private final CloseAuctionUseCase closeAuctionUseCase;

    @Override
    public void register(final Long userId, AuctionUseCaseReqDTO.Register requestDTO) {
        auctionRepositoryPort.validateAuctionTimeRangeForSave(userId, requestDTO.sellStartTime(), requestDTO.sellEndTime());
        var auction = auctionRepositoryPort.saveAuction(Auction.of(userId, requestDTO));
        var auctionId = auction.getId();
        if (!requestDTO.type().equals(AuctionType.ONLINE)) {
            locationCommandUseCase.saveAuctionLocations(auctionId, requestDTO.locations());
        }
        closeAuctionUseCase.save(auctionId, auction.getAuctionCloseTime());
    }

    @Override
    public void update(final Long userId, final Long auctionId, AuctionUseCaseReqDTO.Update requestDTO) {
        var findAuction = auctionRepositoryPort.findAuctionByIdForUpdate(auctionId);
        findAuction.validateAuctionAccess(userId);
        auctionRepositoryPort.validateAuctionTimeRangeForUpdate(userId, auctionId, findAuction.getSellStartTime(), findAuction.getSellEndTime());
        try {
            findAuction.update(requestDTO);
            if(!findAuction.getType().equals(AuctionType.ONLINE)) {
                locationCommandUseCase.deleteAuctionLocations(auctionId);
            }
            if (!requestDTO.type().equals(AuctionType.ONLINE)) {
                locationCommandUseCase.saveAuctionLocations(auctionId, requestDTO.locations());
            }
            closeAuctionUseCase.delete(auctionId);
            closeAuctionUseCase.save(auctionId, findAuction.getAuctionCloseTime());
        } catch (OptimisticLockingFailureException e) {
            throw new ConflictAuctionUpdateException(CONFLICT_AUCTION_UPDATE);
        }
    }

    @Override
    public void delete(final Long userId, final Long auctionId) {
        var findAuction = auctionRepositoryPort.findAuctionByIdForUpdate(auctionId);
        try {
            findAuction.deactivate(userId);
            closeAuctionUseCase.delete(auctionId);
        } catch (OptimisticLockingFailureException e) {
            throw new ConflictAuctionDeleteException(CONFLICT_AUCTION_DELETE);
        }
    }
}

---

Result

이 결과 Auction의 유효성 검사를 AuctionCommandService 뿐만 아니라 UserCommandService, BidCommandService 에서 필요할 때 validateAuctionAccess 메서드를 중복적으로 구현할 필요 없이 도메인에서 메서드를 호출하여 처리가 가능해졌다.

---

Thoughts

항상 프로젝트를 경험할 때마다 갖게 되는 큰 고민이 코드의 중복성을 어떻게 하면 줄일 수 있을까였다. 하지만 이번 기회에 도메인에 캡슐화해서 메서드를 관리하는 방식을 적용하여 코드의 중복성과 복잡성을 줄일 수 있었다.

하지만 위 방법으로 Service 계층의 부담은 줄었지만, 도메인의 부담이 반대로 커지게 되었다. 이 방법에 대해서는 꾸준히 프로젝트 하면서 고민하며 개선해 나가야 할 부분이다.

---