구매자 페이먼트 충전

src/main/java/camp/woowak/lab/payaccount/domain/PayAccount.java

@@ -1,13 +1,55 @@
 package camp.woowak.lab.payaccount.domain;
 
+import org.hibernate.annotations.ColumnDefault;
+
+import camp.woowak.lab.payaccount.exception.InsufficientBalanceException;
+import camp.woowak.lab.payaccount.exception.InvalidTransactionAmountException;
+import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.GeneratedValue;
 import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
 
 @Entity
 public class PayAccount {
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	private Long id;
+
+	@Column(name = "balance", nullable = false)
+	@ColumnDefault("0")
+	private long balance;
+
+	public PayAccount() {
+		this.balance = 0;
+	}
+
+	public Long getId() {
+		return id;
+	}
+
+	public long getBalance() {
+		return this.balance;
+	}
+
+	public void withdraw(long amount) {
+		validateTransactionAmount(amount);
+		validateInsufficientBalance(amount);
+		this.balance -= amount;
+	}
+
+	public void deposit(long amount) {
+		validateTransactionAmount(amount);
+		this.balance += amount;
+	}
+
+	private void validateTransactionAmount(long amount) {
+		if (amount <= 0)
+			throw new InvalidTransactionAmountException("Transaction amount must be greater than zero.");
+	}
+
+	private void validateInsufficientBalance(long amount) {
+		if (this.balance - amount < 0)
+			throw new InsufficientBalanceException("Insufficient balance for this transaction.");
+	}
 }

src/main/java/camp/woowak/lab/payaccount/exception/InsufficientBalanceException.java

@@ -0,0 +1,7 @@
+package camp.woowak.lab.payaccount.exception;
+
+public class InsufficientBalanceException extends RuntimeException {
+	public InsufficientBalanceException(String message) {
+		super(message);
+	}
+}

src/main/java/camp/woowak/lab/payaccount/exception/InvalidTransactionAmountException.java

@@ -0,0 +1,7 @@
+package camp.woowak.lab.payaccount.exception;
+
+public class InvalidTransactionAmountException extends RuntimeException {
+	public InvalidTransactionAmountException(String message) {
+		super(message);
+	}
+}

src/main/java/camp/woowak/lab/payaccount/exception/NotFoundAccountException.java

@@ -0,0 +1,7 @@
+package camp.woowak.lab.payaccount.exception;
+
+public class NotFoundAccountException extends RuntimeException {
+	public NotFoundAccountException(String message) {
+		super(message);
+	}
+}

src/main/java/camp/woowak/lab/payaccount/repository/PayAccountRepository.java

@@ -0,0 +1,17 @@
+package camp.woowak.lab.payaccount.repository;
+
+import java.util.Optional;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Lock;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import camp.woowak.lab.payaccount.domain.PayAccount;
+import jakarta.persistence.LockModeType;
+
+public interface PayAccountRepository extends JpaRepository<PayAccount, Long> {
+	@Lock(LockModeType.PESSIMISTIC_WRITE)
+	@Query("SELECT pa FROM PayAccount pa where pa.id = :id")
+	Optional<PayAccount> findByIdForUpdate(@Param("id") Long id);
+}

src/main/java/camp/woowak/lab/payaccount/service/PayAccountDepositService.java

@@ -0,0 +1,31 @@
+package camp.woowak.lab.payaccount.service;
+
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import camp.woowak.lab.payaccount.domain.PayAccount;
+import camp.woowak.lab.payaccount.exception.NotFoundAccountException;
+import camp.woowak.lab.payaccount.repository.PayAccountRepository;
+import camp.woowak.lab.payaccount.service.command.AccountTransactionCommand;
+import lombok.extern.slf4j.Slf4j;
+
+@Service
+@Slf4j
+public class PayAccountDepositService {
+	private final PayAccountRepository payAccountRepository;
+
+	public PayAccountDepositService(PayAccountRepository payAccountRepository) {
+		this.payAccountRepository = payAccountRepository;
+	}
+
+	@Transactional
+	public long depositAccount(AccountTransactionCommand command) {
+		PayAccount payAccount = payAccountRepository.findByIdForUpdate(command.payAccountId())
+			.orElseThrow(() -> new NotFoundAccountException("Invalid account id with " + command.payAccountId()));
+
+		payAccount.deposit(command.amount());
+		log.info("A deposit of {} has been completed into Account ID {}.", command.amount(), command.payAccountId());
+
+		return payAccount.getBalance();
+	}
+}

src/main/java/camp/woowak/lab/payaccount/service/PayAccountWithdrawService.java

@@ -0,0 +1,31 @@
+package camp.woowak.lab.payaccount.service;
+
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import camp.woowak.lab.payaccount.domain.PayAccount;
+import camp.woowak.lab.payaccount.exception.NotFoundAccountException;
+import camp.woowak.lab.payaccount.repository.PayAccountRepository;
+import camp.woowak.lab.payaccount.service.command.AccountTransactionCommand;
+import lombok.extern.slf4j.Slf4j;
+
+@Service
+@Slf4j
+public class PayAccountWithdrawService {
+	private final PayAccountRepository payAccountRepository;
+
+	public PayAccountWithdrawService(PayAccountRepository payAccountRepository) {
+		this.payAccountRepository = payAccountRepository;
+	}
+
+	@Transactional
+	public long withdrawAccount(AccountTransactionCommand command) {
+		PayAccount payAccount = payAccountRepository.findByIdForUpdate(command.payAccountId())
+			.orElseThrow(() -> new NotFoundAccountException("Invalid account id with " + command.payAccountId()));
+
+		payAccount.withdraw(command.amount());
+		log.info("A withdrawal of {} has been completed from Account ID {}", command.amount(), command.payAccountId());
+
+		return payAccount.getBalance();
+	}
+}

src/main/java/camp/woowak/lab/payaccount/service/command/AccountTransactionCommand.java

@@ -0,0 +1,6 @@
+package camp.woowak.lab.payaccount.service.command;
+
+public record AccountTransactionCommand(
+	Long payAccountId,
+	long amount) {
+}

src/test/java/camp/woowak/lab/payaccount/domain/PayAccountTest.java

@@ -0,0 +1,133 @@
+package camp.woowak.lab.payaccount.domain;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import camp.woowak.lab.payaccount.exception.InsufficientBalanceException;
+import camp.woowak.lab.payaccount.exception.InvalidTransactionAmountException;
+
+@DisplayName("PayAccount 클래스")
+class PayAccountTest {
+	private PayAccount payAccount;
+
+	@BeforeEach
+	void setUp() {
+		payAccount = new PayAccount();
+	}
+
+	@Nested
+	@DisplayName("기본 생성자는")
+	class DefaultConstructorTest {
+		@Test
+		@DisplayName("기본 생성자로 호출하면 balance는 0이된다.")
+		void initializeBalanceToZero() {
+			// then
+			assertThat(payAccount.getBalance()).isZero();
+		}
+	}
+
+	@Nested
+	@DisplayName("Deposit 메서드는")
+	class DepositTest {
+		@Test
+		@DisplayName("입금한 만큼 잔고가 증가한다.")
+		void increaseBalanceByDepositedAmount() {
+			// given
+			long amount = 1000;
+
+			// when
+			payAccount.deposit(amount);
+
+			// then
+			assertThat(payAccount.getBalance()).isEqualTo(amount);
+		}
+
+		@Test
+		@DisplayName("음수를 입금하려하면 exception을 던진다. 잔고는 유지된다.")
+		void throwExceptionForNegativeAmount() {
+			// given
+			long amount = -1000;
+
+			// when & then
+			assertThatThrownBy(() -> payAccount.deposit(amount))
+				.isExactlyInstanceOf(InvalidTransactionAmountException.class);
+			assertThat(payAccount.getBalance()).isZero();
+		}
+
+		@Test
+		@DisplayName("0원을 입금하려면 exception을 던진다. 잔고는 유지된다.")
+		void throwExceptionForZeroAmount() {
+			// given
+			long amount = 0;
+
+			// when & then
+			assertThatThrownBy(() -> payAccount.deposit(amount))
+				.isExactlyInstanceOf(InvalidTransactionAmountException.class);
+			assertThat(payAccount.getBalance()).isZero();
+		}
+	}
+
+	@Nested
+	@DisplayName("Withdraw 메서드는")
+	class WithdrawTest {
+		private long originBalance = 1000;
+
+		@BeforeEach
+		void setUpBalance() {
+			payAccount.deposit(originBalance);
+		}
+
+		@Test
+		@DisplayName("출금한 만큼 잔고에서 차감된다.")
+		void decreaseBalanceByWithdrawnAmount() {
+			// given
+			long withdrawAmount = 100;
+
+			// when
+			payAccount.withdraw(withdrawAmount);
+
+			// then
+			assertThat(payAccount.getBalance()).isEqualTo(originBalance - withdrawAmount);
+		}
+
+		@Test
+		@DisplayName("음수를 출금하려면 exception을 던진다. 잔고는 유지된다.")
+		void throwExceptionForNegativeAmount() {
+			// given
+			long amount = -100;
+
+			// when & then
+			assertThatThrownBy(() -> payAccount.withdraw(amount))
+				.isExactlyInstanceOf(InvalidTransactionAmountException.class);
+			assertThat(payAccount.getBalance()).isEqualTo(originBalance);
+		}
+
+		@Test
+		@DisplayName("0원을 출금하려면 exception을 던진다. 잔고는 유지된다.")
+		void throwExceptionForZeroAmount() {
+			// given
+			long amount = 0;
+
+			// when & then
+			assertThatThrownBy(() -> payAccount.withdraw(amount))
+				.isExactlyInstanceOf(InvalidTransactionAmountException.class);
+			assertThat(payAccount.getBalance()).isEqualTo(originBalance);
+		}
+
+		@Test
+		@DisplayName("남은 잔고보다 더 많은 돈을 출금하려면 exception을 던진다. 잔고는 유지된다.")
+		void throwExceptionForInsufficientBalance() {
+			// given
+			long amount = originBalance + 1;
+
+			// when & then
+			assertThatThrownBy(() -> payAccount.withdraw(amount))
+				.isExactlyInstanceOf(InsufficientBalanceException.class);
+			assertThat(payAccount.getBalance()).isEqualTo(originBalance);
+		}
+	}
+}

src/test/java/camp/woowak/lab/payaccount/service/PayAccountDepositServiceConcurrencyTest.java

@@ -0,0 +1,79 @@
+package camp.woowak.lab.payaccount.service;
+
+import static org.assertj.core.api.Assertions.*;
+
+import java.util.Optional;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.stream.IntStream;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import camp.woowak.lab.payaccount.domain.PayAccount;
+import camp.woowak.lab.payaccount.repository.PayAccountRepository;
+import camp.woowak.lab.payaccount.service.command.AccountTransactionCommand;
+
+@SpringBootTest
+@DisplayName("PayAccountWithdrawService 클래스")
+class PayAccountDepositServiceConcurrencyTest {
+	@Autowired
+	private PayAccountRepository payAccountRepository;
+
+	@Autowired
+	private PayAccountDepositService payAccountDepositService;
+
+	private PayAccount payAccount;
+	private final long originBalance = 1000L;
+
+	@BeforeEach
+	void setUp() throws Exception {
+		payAccount = new PayAccount();
+		payAccount.deposit(originBalance);
+		payAccountRepository.save(payAccount);
+		payAccountRepository.flush();
+	}
+
+	@Nested
+	@DisplayName("withdrawAccount 메서드는")
+	class WithdrawAccount {
+		@Test
+		@DisplayName("동시에 여러 오청이 들어오면 요청에 맞게 출금이 모두 완료되어야한다.")
+		void withdrawAccountWithdrawMultipleRequest() throws InterruptedException {
+			//given
+			int multipleRequestCount = 100;
+			long eachAmount = 1L;
+			AccountTransactionCommand command = new AccountTransactionCommand(payAccount.getId(), eachAmount);
+
+			ExecutorService executorService = Executors.newFixedThreadPool(multipleRequestCount);
+			CountDownLatch latch = new CountDownLatch(multipleRequestCount);
+
+			//when
+			IntStream.range(0, multipleRequestCount)
+				.forEach(i -> {
+					executorService.submit(() -> {
+						payAccountDepositService.depositAccount(command);
+						latch.countDown();
+					});
+				});
+
+			latch.await();
+
+			//then
+			validateAfterBalanceInPersistenceLayer(payAccount.getId(),
+				originBalance + (multipleRequestCount * eachAmount));
+		}
+
+		private void validateAfterBalanceInPersistenceLayer(Long accountId, long afterBalance) {
+			Optional<PayAccount> byId = payAccountRepository.findById(accountId);
+			assertThat(byId).isNotEmpty();
+			PayAccount targetAccount = byId.get();
+			assertThat(targetAccount.getBalance()).isEqualTo(afterBalance);
+		}
+	}
+}