feat: AI 이미지 생성권 구매 시스템 구현

src/main/java/hanium/modic/backend/common/entity/BaseEntity.java

@@ -19,9 +19,10 @@
 public abstract class BaseEntity {
 
 	@CreatedDate
-	@Column(updatable = false)
+	@Column(name = "create_at", updatable = false)
 	private LocalDateTime createAt;
 
 	@LastModifiedDate
+	@Column(name = "update_at")
 	private LocalDateTime updateAt;
 }

src/main/java/hanium/modic/backend/common/error/ErrorCode.java

@@ -75,9 +75,12 @@ public enum ErrorCode {
 	AI_REQUEST_NOT_FOUND(HttpStatus.NOT_FOUND, "A-001", "해당 AI 요청을 찾을 수 없습니다."),
 	CREATED_AI_IMAGE_NOT_FOUND(HttpStatus.NOT_FOUND, "A-002", "생성된 AI 이미지를 찾을 수 없습니다."),
 	AI_IMAGE_DATA_INCONSISTENCY(HttpStatus.INTERNAL_SERVER_ERROR, "A-003", "AI 이미지 데이터 일관성 오류가 발생했습니다."),
-	AI_IMAGE_PERMISSION_NOT_FOUND(HttpStatus.FORBIDDEN, "A-004", "AI 이미지 생성 권한이 없습니다."),
-	AI_REQUEST_TICKET_PROCESSING_FAIL_EXCEPTION(HttpStatus.INTERNAL_SERVER_ERROR, "A-005", "티켓 처리에 실패했습니다."),
+	AI_IMAGE_PERMISSION_NOT_FOUND(HttpStatus.NOT_FOUND, "AI-004", "AI 이미지 생성권을 구매한 이력이 없습니다."),
+	AI_REQUEST_TICKET_PROCESSING_FAIL_EXCEPTION(HttpStatus.INTERNAL_SERVER_ERROR, "AI-005", "티켓 처리에 실패했습니다."),
 	AI_REQUEST_TICKET_NOT_ENOUGH_EXCEPTION(HttpStatus.BAD_REQUEST, "AI-006", "티켓이 부족합니다."),
+	REMAINING_GENERATIONS_NOT_ENOUGH_EXCEPTION(HttpStatus.BAD_REQUEST, "AI-007", "AI 이미지 생성권이 부족합니다."),
+	AI_IMAGE_PERMISSION_FAIL_EXCEPTION(HttpStatus.INTERNAL_SERVER_ERROR, "AI-008", "이미지 생성권 처리에 실패하였습니다."),
+	AI_IMAGE_PERMISSION_ALREADY_EXISTS_EXCEPTION(HttpStatus.CONFLICT, "AI-009", "이미 AI 이미지 생성권을 구매했습니다."),
 	;
 
 	private final HttpStatus status;

src/main/java/hanium/modic/backend/common/redis/distributedLock/DistributionLockExecutor.java

@@ -0,0 +1,74 @@
+package hanium.modic.backend.common.redis.distributedLock;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import org.redisson.RedissonMultiLock;
+import org.redisson.api.RLock;
+import org.redisson.api.RedissonClient;
+import org.springframework.stereotype.Component;
+
+import hanium.modic.backend.common.error.exception.LockException;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class DistributionLockExecutor {
+
+	private final RedissonClient redissonClient;
+	private final AopForTransaction aopForTransaction;
+
+
+	private final LockOptions DEFAULT_OPTS =
+		LockOptions.builder().waitTime(3).leaseTime(10).timeUnit(TimeUnit.SECONDS).build();
+
+	/** 단일 키 락 */
+	public void withLock(String key, Runnable block) throws LockException {
+		withLock(key, DEFAULT_OPTS, block);
+	}
+
+	public void withLock(String key, LockOptions opts, Runnable block) throws LockException {
+		RLock lock = redissonClient.getLock(key);
+		executeWith(lock, key, opts, block);
+	}
+
+	/** 다중 키 락(데드락 방지 위해 키 정렬 권장) */
+	public void withMultiLock(Collection<String> keys, Runnable block) throws LockException {
+		withMultiLock(keys, DEFAULT_OPTS, block);
+	}
+
+	public void withMultiLock(Collection<String> keys, LockOptions opts, Runnable block) throws LockException {
+		List<String> sorted = keys.stream().sorted().toList();
+		RLock[] locks = sorted.stream().map(redissonClient::getLock).toArray(RLock[]::new);
+		RedissonMultiLock multiLock = new RedissonMultiLock(locks);
+		executeWith(multiLock, sorted.toString(), opts, block);
+	}
+
+	/** 공통 실행부: tryLock → 트랜잭션 내 block.run() → 안전 unlock */
+	private void executeWith(RLock lock, String logKey, LockOptions opts, Runnable block) throws LockException {
+		boolean acquired = false;
+		try {
+			acquired = lock.tryLock(opts.getWaitTime(), opts.getLeaseTime(), opts.getTimeUnit());
+			if (!acquired) {
+				throw new LockException(new InterruptedException("락 획득 실패: " + logKey));
+			}
+			aopForTransaction.proceed(block);
+		} catch (InterruptedException e) {
+			Thread.currentThread().interrupt();
+			throw new LockException(e);
+		} finally {
+			try {
+				if (acquired && lock.isHeldByCurrentThread()) {
+					lock.unlock();
+				}
+			} catch (IllegalMonitorStateException ignored) {
+				log.info("락이 이미 해제됨: {}", logKey);
+			}
+		}
+	}
+}

src/main/java/hanium/modic/backend/common/redis/distributedLock/LockManager.java

@@ -1,148 +1,56 @@
 package hanium.modic.backend.common.redis.distributedLock;
 
-import static org.springframework.transaction.annotation.Propagation.*;
-
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 
-import org.redisson.RedissonMultiLock;
-import org.redisson.api.RLock;
-import org.redisson.api.RedissonClient;
 import org.springframework.stereotype.Component;
-import org.springframework.transaction.annotation.Transactional;
 
 import hanium.modic.backend.common.error.exception.LockException;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 
+/**
+ * Service 계층에서 Lock 제어를 위한 객체
+ * 내부적으로 DistributionLockExecutor로 락을 제어하고 있음.
+ * 새로운 도메인에 대한 락이 필요하면 이 객체를 수정하여 도입
+ */
 @Slf4j
 @Component
 @RequiredArgsConstructor
 public class LockManager {
 
-	private final AopForTransaction aopForTransaction;
-	private final RedissonClient redissonClient;
-
-	private static final TimeUnit timeUnit = TimeUnit.SECONDS; // 락 시간 단위
-	private static final long waitTime = 5L; // 락 획득 대기 시간(5초)
-	private static final long leaseTime = 3L; // 락 유지 시간(3초)
-	private static final long postLikeWaitTime = 2L; // 좋아요 락 대기 시간(2초)
-	private static final long postLikeLeaseTime = 1L; // 좋아요 락 유지 시간(1초)
-	private static final String REDISSON_USER_LOCK_PREFIX = "USER_LOCK:";
-	private static final String REDISSON_POST_LIKE_LOCK_PREFIX = "POST_LIKE:";
-	private static final String REDISSON_USER_TICKET_LOCK_PREFIX = "USER_TICKET_LOCK:";
+	private final DistributionLockExecutor exec;
 
-	// 유저 단일 락
-	public void userLock(
-		final long userId,
-		Runnable block
-	) throws LockException {
-		String key = REDISSON_USER_LOCK_PREFIX + userId;
-		RLock rLock = redissonClient.getLock(key);
+	private final LockOptions POST_LIKE_OPTS =
+		LockOptions.builder().waitTime(1).leaseTime(3).timeUnit(TimeUnit.SECONDS).build();
 
-		try {
-			boolean available = rLock.tryLock(waitTime, leaseTime, timeUnit);
-			if (!available) {
-				throw new LockException(new InterruptedException("단일 락 획득 실패"));
-			}
+	private final String USER_PREFIX = "lock:user:";
+	private final String USER_TICKET_PREFIX = "lock:user:ticket:";
+	private final String POST_LIKE_PREFIX = "lock:postlike:";
+	private final String AI_PERMISSION_PREFIX = "lock:ai:perm:";
 
-			aopForTransaction.proceed(block); // lock 범위 안에서 트랜잭션 적용 후 로직 처리
-		} catch (InterruptedException e) {
-			throw new LockException(e); // 락 획득 실패시 Exception 발생
-		} finally {
-			try {
-				rLock.unlock();
-			} catch (IllegalMonitorStateException e) {
-				log.info("분산 락이 이미 해제되었습니다. :key({})", key);
-			}
-		}
+	public void userLock(long userId, Runnable block) throws LockException {
+		exec.withLock(USER_PREFIX + userId, block);
 	}
 
-	// 여러 유저 동시 락
-	@Transactional(propagation = REQUIRES_NEW)
-	public void multipleUserLock(
-		final List<Long> userIds,
-		Runnable block
-	) throws LockException {
-		List<String> sortedKeys = userIds.stream()
-			.sorted() // 데드락 방지용 정렬
-			.map(id -> REDISSON_USER_LOCK_PREFIX + id)
-			.toList();
-
-		List<RLock> locks = sortedKeys.stream()
-			.map(redissonClient::getLock)
+	public void multipleUserLock(List<Long> userIds, Runnable block) throws LockException {
+		List<String> keys = userIds.stream()
+			.map(id -> USER_PREFIX + id)
 			.toList();
-
-		RedissonMultiLock multiLock = new RedissonMultiLock(locks.toArray(new RLock[0]));
-
-		try {
-			boolean available = multiLock.tryLock(waitTime, leaseTime, timeUnit);
-			if (!available) {
-				throw new LockException(new InterruptedException("멀티 락 획득 실패"));
-			}
-
-			aopForTransaction.proceed(block); // lock 범위 안에서 트랜잭션 적용 후 로직 처리
-		} catch (InterruptedException e) {
-			throw new LockException(e); // 락 획득 실패시 Exception 발생
-		} finally {
-			try {
-				multiLock.unlock();
-			} catch (IllegalMonitorStateException e) {
-				log.info("멀티 분산 락이 이미 해제되었습니다. : keys={}", sortedKeys);
-			}
-		}
+		exec.withMultiLock(keys, block);
 	}
 
-	// 게시글 좋아요 락
-	public void postLikeLock(
-		final Long userId,
-		final Long postId,
-		Runnable block
-	) throws LockException {
-		String key = REDISSON_POST_LIKE_LOCK_PREFIX + userId + ":" + postId;
-		RLock rLock = redissonClient.getLock(key);
-
-		try {
-			boolean available = rLock.tryLock(postLikeWaitTime, postLikeLeaseTime, timeUnit);
-			if (!available) {
-				throw new LockException(new InterruptedException("좋아요 락 획득 실패"));
-			}
-
-			aopForTransaction.proceed(block); // lock 범위 안에서 트랜잭션 적용 후 로직 처리
-		} catch (InterruptedException e) {
-			throw new LockException(e); // 락 획득 실패시 Exception 발생
-		} finally {
-			try {
-				rLock.unlock();
-			} catch (IllegalMonitorStateException e) {
-				log.info("좋아요 분산 락이 이미 해제되었습니다. :key({})", key);
-			}
-		}
+	public void postLikeLock(long userId, long postId, Runnable block) throws LockException {
+		exec.withLock(POST_LIKE_PREFIX + userId + ":" + postId,
+			POST_LIKE_OPTS,
+			block);
 	}
 
-	// AI 요청 티켓 락
-	public void aiRequestTicketLock(
-		final Long userId,
-		Runnable block
-	) throws LockException {
-		String key = REDISSON_USER_TICKET_LOCK_PREFIX + userId;
-		RLock rLock = redissonClient.getLock(key);
-
-		try {
-			boolean available = rLock.tryLock(waitTime, leaseTime, timeUnit);
-			if (!available) {
-				throw new LockException(new InterruptedException("유저 티켓 락 획득 실패"));
-			}
+	public void aiRequestTicketLock(long userId, Runnable block) throws LockException {
+		exec.withLock(USER_TICKET_PREFIX + userId, block);
+	}
 
-			aopForTransaction.proceed(block); // lock 범위 안에서 트랜잭션 적용 후 로직 처리
-		} catch (InterruptedException e) {
-			throw new LockException(e); // 락 획득 실패시 Exception 발생
-		} finally {
-			try {
-				rLock.unlock();
-			} catch (IllegalMonitorStateException e) {
-				log.info("유저 티켓 분산 락이 이미 해제되었습니다. :key({})", key);
-			}
-		}
+	public void aiImagePermissionLock(long userId, long postId, Runnable block) throws LockException {
+		exec.withLock(AI_PERMISSION_PREFIX + userId + ":" + postId, block);
 	}
 }

src/main/java/hanium/modic/backend/common/redis/distributedLock/LockOptions.java

@@ -0,0 +1,16 @@
+package hanium.modic.backend.common.redis.distributedLock;
+
+import java.util.concurrent.TimeUnit;
+
+import lombok.Builder;
+import lombok.Getter;
+
+/** Lock에 대한 세부 설정을 도와주는 객체 */
+@Getter
+@Builder
+public class LockOptions {
+	private final long waitTime;
+	private final long leaseTime;
+	private final TimeUnit timeUnit;
+	private final boolean requiresNewTx; // 필요 시 트랜잭션 분리 제어(선택)
+}

src/main/java/hanium/modic/backend/domain/ai/domain/AiImagePermissionEntity.java

@@ -1,18 +1,29 @@
-package hanium.modic.backend.domain.ai.entity;
+package hanium.modic.backend.domain.ai.domain;
+
+import static hanium.modic.backend.common.error.ErrorCode.*;
 
 import hanium.modic.backend.common.entity.BaseEntity;
+import hanium.modic.backend.common.error.exception.AppException;
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.GeneratedValue;
 import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
 import jakarta.persistence.Table;
+import jakarta.persistence.UniqueConstraint;
 import lombok.AccessLevel;
 import lombok.Builder;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 
-@Table(name = "ai_image_permissions")
+@Table(
+	name = "ai_image_permissions",
+	uniqueConstraints = {
+		@UniqueConstraint(
+			name = "uk_ai_image_permission_user_post", // 제약조건 이름
+			columnNames = {"user_id", "post_id"}       // 유니크 컬럼 지정
+		)
+	})
 @Entity
 @Getter
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
@@ -31,36 +42,22 @@ public class AiImagePermissionEntity extends BaseEntity {
 	@Column(name = "remaining_generations", nullable = false)
 	private Integer remainingGenerations;
 
-	@Column(name = "is_active", nullable = false)
-	private Boolean isActive = true;
-
 	@Builder
-	private AiImagePermissionEntity(Long userId, Long postId, Integer remainingGenerations, Boolean isActive) {
+	private AiImagePermissionEntity(Long userId, Long postId, Integer remainingGenerations) {
 		this.userId = userId;
 		this.postId = postId;
 		this.remainingGenerations = remainingGenerations;
-		this.isActive = isActive != null ? isActive : true;
 	}
 
-	public void decreaseRemainingGenerations() {
-		if (this.remainingGenerations > 0) {
+	public void decreaseRemainingGenerations() throws AppException {
+		if (hasRemainingGenerations()) {
 			this.remainingGenerations--;
+		} else {
+			throw new AppException(REMAINING_GENERATIONS_NOT_ENOUGH_EXCEPTION);
 		}
 	}
 
-	public void deactivate() {
-		this.isActive = false;
-	}
-
-	public void activate() {
-		this.isActive = true;
-	}
-
 	public boolean hasRemainingGenerations() {
 		return this.remainingGenerations > 0;
 	}
-
-	public boolean isPermissionValid() {
-		return this.isActive && hasRemainingGenerations();
-	}
 }