MOSU-33 feature: 토스 페이먼츠 결제 흐름 구현

build.gradle

@@ -28,7 +28,10 @@ dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
     implementation 'org.springframework.boot:spring-boot-starter-web'
     implementation 'org.springframework.boot:spring-boot-starter-validation'
-
+    testImplementation 'org.projectlombok:lombok'
+    testImplementation 'org.projectlombok:lombok'
+    testCompileOnly 'org.projectlombok:lombok'
+    testAnnotationProcessor 'org.projectlombok:lombok'
     developmentOnly 'org.springframework.boot:spring-boot-devtools'
     compileOnly 'org.projectlombok:lombok'
     annotationProcessor 'org.projectlombok:lombok'
@@ -66,6 +69,10 @@ dependencies {
     implementation 'software.amazon.awssdk:core:2.30.20'
     implementation 'software.amazon.awssdk:ec2'
 
+    //retry
+    implementation 'org.springframework.retry:spring-retry'
+    implementation 'org.springframework.boot:spring-boot-starter-aop'
+
     //monitoring
     implementation 'org.springframework.boot:spring-boot-starter-actuator'
     implementation 'io.micrometer:micrometer-registry-prometheus'

src/main/java/life/mosu/mosuserver/application/payment/OrderIdGenerator.java

@@ -0,0 +1,12 @@
+package life.mosu.mosuserver.application.payment;
+
+import java.util.UUID;
+import org.springframework.stereotype.Component;
+
+@Component
+public class OrderIdGenerator {
+
+    public String generate() {
+        return UUID.randomUUID().toString();
+    }
+}

src/main/java/life/mosu/mosuserver/application/payment/PaymentEvent.java

@@ -0,0 +1,26 @@
+package life.mosu.mosuserver.application.payment;
+
+import life.mosu.mosuserver.domain.payment.PaymentStatus;
+
+public record PaymentEvent(String applicationId, String orderId, PaymentStatus status) {
+
+    public static PaymentEvent ofSuccess(String applicationId, String orderId) {
+        return new PaymentEvent(applicationId, orderId, PaymentStatus.DONE);
+    }
+
+    public static PaymentEvent ofCancelled(String applicationId, String orderId) {
+        return new PaymentEvent(applicationId, orderId, PaymentStatus.CANCELLED_DONE);
+    }
+
+    public static PaymentEvent ofFailed(String applicationId, String orderId) {
+        return new PaymentEvent(applicationId, orderId, PaymentStatus.ABORTED);
+    }
+
+    @Override
+    public String toString() {
+        return "PaymentEvent{" +
+                "orderId='" + orderId + '\'' +
+                ", status=" + status +
+                '}';
+    }
+}

src/main/java/life/mosu/mosuserver/application/payment/PaymentEventListener.java

@@ -0,0 +1,37 @@
+package life.mosu.mosuserver.application.payment;
+
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.event.TransactionPhase;
+import org.springframework.transaction.event.TransactionalEventListener;
+
+@Component
+public class PaymentEventListener {
+
+    // 1. 트랜잭션 커밋 직전에 호출됨 (롤백 가능 상태)
+    @TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)
+    public void beforeCommitHandler(PaymentEvent event) {
+        System.out.println("[BEFORE_COMMIT] 커밋 직전 처리: " + event.orderId());
+        // 예) 캐시 업데이트, 커밋 직전 검증 등
+    }
+
+    // 2. 트랜잭션 성공적으로 커밋된 후 호출 (기본값)
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+    public void afterCommitHandler(PaymentEvent event) {
+        System.out.println("[AFTER_COMMIT] 커밋 성공 후 처리: " + event.orderId());
+        // 예) 외부 API 호출, 메시지 큐 발행, 알림 전송
+    }
+
+    // 3. 트랜잭션이 롤백된 후 호출됨
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_ROLLBACK)
+    public void afterRollbackHandler(PaymentEvent event) {
+        System.out.println("[AFTER_ROLLBACK] 롤백 후 처리: " + event.orderId());
+        // 예) 보상 트랜잭션, 로그 기록, 장애 알림
+    }
+
+    // 4. 트랜잭션 커밋 성공 또는 롤백 후 무조건 호출됨
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMPLETION)
+    public void afterCompletionHandler(PaymentEvent event) {
+        System.out.println("[AFTER_COMPLETION] 커밋/롤백 후 무조건 처리: " + event.orderId());
+        // 예) 리소스 정리, 상태 초기화 등
+    }
+}

src/main/java/life/mosu/mosuserver/application/payment/PaymentService.java

@@ -0,0 +1,94 @@
+package life.mosu.mosuserver.application.payment;
+
+import life.mosu.mosuserver.domain.discount.DiscountPolicy;
+import life.mosu.mosuserver.domain.payment.PaymentJpaEntity;
+import life.mosu.mosuserver.domain.payment.PaymentRepository;
+import life.mosu.mosuserver.infra.payment.TossPaymentClient;
+import life.mosu.mosuserver.infra.payment.dto.ConfirmTossPaymentResponse;
+import life.mosu.mosuserver.persistence.application.ApplicationSchoolJpaRepository;
+import life.mosu.mosuserver.presentation.payment.dto.CancelPaymentRequest;
+import life.mosu.mosuserver.presentation.payment.dto.PaymentPrepareResponse;
+import life.mosu.mosuserver.presentation.payment.dto.PaymentRequest;
+import life.mosu.mosuserver.presentation.payment.dto.PreparePaymentRequest;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.retry.annotation.Recover;
+import org.springframework.retry.annotation.Retryable;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.client.HttpStatusCodeException;
+
+/**
+ * 영속화 처리 이미 들어올 때 할인 정책을 포함해야함
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class PaymentService {
+
+    private final TossPaymentClient tossPayment;
+    private final OrderIdGenerator orderIdGenerator;
+    private final PaymentRepository paymentRepository;
+    private final ApplicationSchoolJpaRepository applicationSchoolJpaRepository;
+
+    public PaymentPrepareResponse prepare(PreparePaymentRequest request) {
+        // 인원 수 체크
+        /**
+         * 인원 수 redis에 동기화 -> 인원수가 넘어가면, application 까지 rollback
+         */
+        String uuid = orderIdGenerator.generate();
+        int applicationCount = request
+                .items()
+                .size();
+        int totalAmount = DiscountPolicy
+                .QUANTITY_PERCENTAGE
+                .calculateDiscount(applicationCount);
+
+        return PaymentPrepareResponse.of(uuid, totalAmount);
+    }
+
+    @Transactional
+    @Retryable(retryFor = {HttpStatusCodeException.class})
+    public void confirm(PaymentRequest request) {
+        // 1. 신청 조회 (가정: applicationService 또는 repository 호출)
+        int applicationCount = 3; // 나중에 실제 DB에서 조회
+        // TODO: 신청 상태 검증 (결제 가능 상태인지)
+
+        //2. 금액 재계산 및 비교
+        int totalAmount = DiscountPolicy.QUANTITY_PERCENTAGE.calculateDiscount(applicationCount);
+        if (request.amount() != totalAmount) {
+            throw new IllegalArgumentException("결제 금액이 올바르지 않습니다.");
+        }
+
+        // 3. 중복 결제 여부 확인 (예: paymentRepository.existsByApplicationIdAndStatusPaid)
+        // TODO: 중복 결제 로직 추가
+        if (paymentRepository.existsByOrderId(request.orderId())) {
+            throw new IllegalArgumentException("이미 존재하는 결제 건 입니다.");
+        }
+        // 4. Toss 결제 승인 요청 및 응답 검증
+        ConfirmTossPaymentResponse response = tossPayment.confirmPayment(request.toPayload());
+        PaymentJpaEntity paymentEntity = response.toPaymentJpaEntity(request.applicationId(),
+                applicationCount);
+
+        if (!paymentEntity.getPaymentStatus().isPaySuccess()) {
+            throw new IllegalArgumentException("결제가 실패하였습니다.");
+        }
+
+        // 5. 결제 정보 저장
+        paymentRepository.save(paymentEntity);
+    }
+
+    @Recover
+    public void recoverConfirm() {
+
+    }
+
+    @Transactional
+    public void cancel(String paymentId, CancelPaymentRequest request) {
+        //환불이 가능한가?
+        tossPayment.cancelPayment(paymentId, request);
+        // 환불 정책
+        // 영속화 해지할 필요 X
+        // 영속화 된 거에서 환불 상태로 변경
+    }
+}

src/main/java/life/mosu/mosuserver/application/profile/ProfileService.java

@@ -1,9 +1,9 @@
 package life.mosu.mosuserver.application.profile;
 
 import life.mosu.mosuserver.domain.profile.ProfileJpaEntity;
+import life.mosu.mosuserver.domain.profile.ProfileJpaRepository;
 import life.mosu.mosuserver.global.exception.CustomRuntimeException;
 import life.mosu.mosuserver.global.exception.ErrorCode;
-import life.mosu.mosuserver.persistence.profile.ProfileJpaRepository;
 import life.mosu.mosuserver.presentation.profile.dto.EditProfileRequest;
 import life.mosu.mosuserver.presentation.profile.dto.ProfileDetailResponse;
 import life.mosu.mosuserver.presentation.profile.dto.ProfileRequest;

src/main/java/life/mosu/mosuserver/domain/discount/DiscountCalculator.java

@@ -0,0 +1,6 @@
+package life.mosu.mosuserver.domain.discount;
+
+public interface DiscountCalculator {
+
+    int calculateDiscount(int quantity);
+}

src/main/java/life/mosu/mosuserver/domain/discount/DiscountPolicy.java

@@ -0,0 +1,15 @@
+package life.mosu.mosuserver.domain.discount;
+
+public enum DiscountPolicy {
+    QUANTITY_PERCENTAGE(new QuantityPercentageDiscountCalculator()),
+    FIXED_QUANTITY(new FixedQuantityDiscountCalculator());
+    private final DiscountCalculator calculator;
+
+    DiscountPolicy(DiscountCalculator calculator) {
+        this.calculator = calculator;
+    }
+
+    public int calculateDiscount(int quantity) {
+        return calculator.calculateDiscount(quantity);
+    }
+}

src/main/java/life/mosu/mosuserver/domain/discount/FixedQuantityDiscountCalculator.java

@@ -0,0 +1,21 @@
+package life.mosu.mosuserver.domain.discount;
+
+import java.util.Map;
+
+public class FixedQuantityDiscountCalculator implements DiscountCalculator {
+
+    // 회차별 고정 할인 가격 (총 결제 금액 기준)
+    private static final Map<Integer, Integer> FIXED_TOTAL_PRICE = Map.of(
+            1, 49_000,
+            2, 89_000,
+            3, 129_000
+    );
+
+    @Override
+    public int calculateDiscount(int quantity) {
+        if (!FIXED_TOTAL_PRICE.containsKey(quantity)) {
+            throw new IllegalArgumentException("지원되지 않는 회차 수입니다. (1~3회만 가능)");
+        }
+        return FIXED_TOTAL_PRICE.get(quantity);
+    }
+}

src/main/java/life/mosu/mosuserver/domain/discount/QuantityPercentageDiscountCalculator.java

@@ -0,0 +1,48 @@
+package life.mosu.mosuserver.domain.discount;
+
+public class QuantityPercentageDiscountCalculator implements DiscountCalculator {
+
+    private static final int PERCENT_DIVISOR = 100;
+    private static final int ROUNDING_OFFSET = PERCENT_DIVISOR / 2;
+
+    private static final int DISCOUNT_RATE_ONE = 10;
+    private static final int DISCOUNT_RATE_TWO = 20;
+    private static final int DISCOUNT_RATE_THREE_OR_MORE = 30;
+    private static final int UNIT_PRICE = 1_000;
+
+    @Override
+    public int calculateDiscount(int quantity) {
+        validateInputs(quantity);
+
+        int discountRate = determineDiscountRate(quantity);
+        int totalPrice = calculateTotalPrice(quantity, UNIT_PRICE);
+
+        return calculateDiscountAmount(totalPrice, discountRate);
+    }
+
+    private void validateInputs(int quantity) {
+        if (quantity < 0) {
+            throw new IllegalArgumentException("수량(quantity)은 음수일 수 없습니다: " + quantity);
+        }
+        if (QuantityPercentageDiscountCalculator.UNIT_PRICE < 0) {
+            throw new IllegalArgumentException("단가(unitPrice)는 음수일 수 없습니다: "
+                    + QuantityPercentageDiscountCalculator.UNIT_PRICE);
+        }
+    }
+
+    private int determineDiscountRate(int quantity) {
+        return switch (quantity) {
+            case 1 -> DISCOUNT_RATE_ONE;
+            case 2 -> DISCOUNT_RATE_TWO;
+            default -> DISCOUNT_RATE_THREE_OR_MORE;
+        };
+    }
+
+    private int calculateTotalPrice(int quantity, int unitPrice) {
+        return quantity * unitPrice;
+    }
+
+    private int calculateDiscountAmount(int totalPrice, int discountRate) {
+        return (totalPrice * discountRate + ROUNDING_OFFSET) / PERCENT_DIVISOR;
+    }
+}

src/main/java/life/mosu/mosuserver/domain/payment/PaymentAmountVO.java

@@ -0,0 +1,59 @@
+package life.mosu.mosuserver.domain.payment;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Embeddable;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Embeddable
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class PaymentAmountVO {
+    @Column(name = "total_amount", nullable = false)
+    private Integer totalAmount;
+
+    @Column(name = "supplied_amount", nullable = false)
+    private Integer suppliedAmount;
+
+    @Column(name = "vat_amount", nullable = false)
+    private Integer vatAmount;
+
+    @Column(name = "balance_amount")
+    private Integer balanceAmount;
+
+    @Column(name = "tax_free_amount")
+    private Integer taxFreeAmount;
+
+    @Builder
+    public PaymentAmountVO(
+            Integer totalAmount,
+            Integer suppliedAmount,
+            Integer vatAmount,
+            Integer balanceAmount,
+            Integer taxFreeAmount
+    ) {
+        this.totalAmount = totalAmount;
+        this.suppliedAmount = suppliedAmount;
+        this.vatAmount = vatAmount;
+        this.balanceAmount = balanceAmount;
+        this.taxFreeAmount = taxFreeAmount;
+    }
+
+    public static PaymentAmountVO of(
+            Integer totalAmount,
+            Integer suppliedAmount,
+            Integer vatAmount,
+            Integer balanceAmount,
+            Integer taxFreeAmount
+    ) {
+        return PaymentAmountVO.builder()
+                .totalAmount(totalAmount)
+                .suppliedAmount(suppliedAmount)
+                .vatAmount(vatAmount)
+                .balanceAmount(balanceAmount)
+                .taxFreeAmount(taxFreeAmount)
+                .build();
+    }
+}