Feat: [FN-4] 회원가입

build.gradle

@@ -28,9 +28,14 @@ dependencies {
 	implementation 'org.springframework.boot:spring-boot-starter-security'
 	implementation 'org.springframework.boot:spring-boot-starter-web'
 	implementation 'org.springframework.boot:spring-boot-starter-validation'
-	implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.8.9'
+	implementation 'org.springframework.boot:spring-boot-starter-data-redis'
 	implementation 'org.springframework.boot:spring-boot-starter-actuator'
+	implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
+	implementation 'org.springframework.boot:spring-boot-starter-aop'
+	implementation 'org.springframework.retry:spring-retry'
+	implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.8.9'
 	implementation 'io.jsonwebtoken:jjwt:0.12.6'
+	implementation 'com.resend:resend-java:4.1.1'
 	compileOnly 'org.projectlombok:lombok'
 	runtimeOnly 'com.mysql:mysql-connector-j'
 	annotationProcessor 'org.projectlombok:lombok'

docker-compose.local.yml

@@ -0,0 +1,17 @@
+services:
+  flipnote-mysql:
+    image: mysql:latest
+    container_name: flipnote-mysql
+    ports:
+      - "3306:3306"
+    environment:
+      MYSQL_USERNAME: root
+      MYSQL_ROOT_PASSWORD: root
+      MYSQL_DATABASE: flipnote
+      TZ: Asia/Seoul
+
+  flipnote-redis:
+    image: redis:latest
+    container_name: flipnote-redis
+    ports:
+      - "6379:6379"

src/main/java/project/flipnote/auth/constants/AuthRedisKey.java

@@ -0,0 +1,15 @@
+package project.flipnote.auth.constants;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import project.flipnote.common.constants.RedisKeys;
+
+@Getter
+@AllArgsConstructor
+public enum AuthRedisKey implements RedisKeys {
+	EMAIL_CODE("auth:email:code:%s", VerificationConstants.CODE_TTL_MINUTES * 60),
+	EMAIL_VERIFIED("auth:email:verified:%s", 600);
+
+	private final String pattern;
+	private final int ttlSeconds;
+}

src/main/java/project/flipnote/auth/constants/VerificationConstants.java

@@ -0,0 +1,10 @@
+package project.flipnote.auth.constants;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class VerificationConstants {
+	public static final int CODE_LENGTH = 6;
+	public static final int CODE_TTL_MINUTES = 5;
+}

src/main/java/project/flipnote/auth/controller/AuthController.java

@@ -9,6 +9,8 @@
 import jakarta.servlet.http.HttpServletResponse;
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
+import project.flipnote.auth.model.EmailVerificationConfirmRequest;
+import project.flipnote.auth.model.EmailVerificationRequest;
 import project.flipnote.auth.model.TokenPair;
 import project.flipnote.auth.model.UserLoginDto;
 import project.flipnote.auth.service.AuthService;
@@ -40,4 +42,20 @@ public ResponseEntity<Void> logout(HttpServletResponse servletResponse) {
 
 		return ResponseEntity.ok().build();
 	}
+
+	@PostMapping("/email")
+	public ResponseEntity<Void> sendEmailVerificationCode(@Valid @RequestBody EmailVerificationRequest req) {
+		authService.sendEmailVerificationCode(req);
+
+		return ResponseEntity.ok().build();
+	}
+
+	@PostMapping("/email/confirm")
+	public ResponseEntity<Void> confirmEmailVerificationCode(
+		@Valid @RequestBody EmailVerificationConfirmRequest req
+	) {
+		authService.confirmEmailVerificationCode(req);
+
+		return ResponseEntity.ok().build();
+	}
 }

src/main/java/project/flipnote/auth/event/EmailVerificationSendEvent.java

@@ -0,0 +1,7 @@
+package project.flipnote.auth.event;
+
+public record EmailVerificationSendEvent(
+	String to,
+	String code
+) {
+}

src/main/java/project/flipnote/auth/exception/AuthErrorCode.java

@@ -10,7 +10,12 @@
 @RequiredArgsConstructor
 public enum AuthErrorCode implements ErrorCode {
 
-	INVALID_CREDENTIALS(HttpStatus.UNAUTHORIZED, "AUTH_001", "이메일 또는 비밀번호가 올바르지 않습니다.");
+	INVALID_CREDENTIALS(HttpStatus.UNAUTHORIZED, "AUTH_001", "이메일 또는 비밀번호가 올바르지 않습니다."),
+	ALREADY_ISSUED_VERIFICATION_CODE(HttpStatus.BAD_REQUEST, "AUTH_002", "이미 발급된 인증번호가 있습니다. 잠시 후 다시 시도해 주세요."),
+	NOT_ISSUED_VERIFICATION_CODE(HttpStatus.BAD_REQUEST, "AUTH_003", "발급된 인증번호가 없습니다. 인증번호를 먼저 요청해 주세요."),
+	INVALID_VERIFICATION_CODE(HttpStatus.FORBIDDEN, "AUTH_004", "잘못된 인증번호입니다. 입력한 인증번호를 확인해 주세요."),
+	UNVERIFIED_EMAIL(HttpStatus.FORBIDDEN, "AUTH_005", "인증되지 않은 이메일입니다. 이메일 인증을 완료해 주세요."),
+	EXISTING_EMAIL(HttpStatus.CONFLICT, "AUTH_006", "이미 가입된 이메일입니다. 다른 이메일을 사용해 주세요.");
 
 	private final HttpStatus httpStatus;
 	private final String code;

src/main/java/project/flipnote/auth/listener/EmailVerificationEventListener.java

@@ -0,0 +1,39 @@
+package project.flipnote.auth.listener;
+
+import org.springframework.context.event.EventListener;
+import org.springframework.retry.annotation.Backoff;
+import org.springframework.retry.annotation.Recover;
+import org.springframework.retry.annotation.Retryable;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Component;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import project.flipnote.auth.constants.VerificationConstants;
+import project.flipnote.auth.event.EmailVerificationSendEvent;
+import project.flipnote.common.exception.EmailSendException;
+import project.flipnote.infra.email.EmailService;
+
+@Slf4j
+@RequiredArgsConstructor
+@Component
+public class EmailVerificationEventListener {
+
+	private final EmailService emailService;
+
+	@Async
+	@Retryable(
+		maxAttempts = 3,
+		retryFor = { EmailSendException.class },
+		backoff = @Backoff(delay = 2000, multiplier = 2)
+	)
+	@EventListener
+	public void handleEmailVerificationSendEvent(EmailVerificationSendEvent event) {
+		emailService.sendEmailVerificationCode(event.to(), event.code(), VerificationConstants.CODE_TTL_MINUTES);
+	}
+
+	@Recover
+	public void recover(EmailSendException ex, EmailVerificationSendEvent event) {
+		log.error("이메일 인증번호 전송 3회 실패: to={}", event.to(), ex);
+	}
+}

src/main/java/project/flipnote/auth/model/EmailVerificationConfirmRequest.java

@@ -0,0 +1,17 @@
+package project.flipnote.auth.model;
+
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+import project.flipnote.auth.constants.VerificationConstants;
+
+public record EmailVerificationConfirmRequest(
+
+	@Email @NotBlank
+	String email,
+
+	@NotBlank
+	@Size(min = VerificationConstants.CODE_LENGTH, max = VerificationConstants.CODE_LENGTH)
+	String code
+) {
+}

src/main/java/project/flipnote/auth/model/EmailVerificationRequest.java

@@ -0,0 +1,11 @@
+package project.flipnote.auth.model;
+
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+
+public record EmailVerificationRequest(
+
+	@Email @NotBlank
+	String email
+) {
+}

src/main/java/project/flipnote/auth/model/UserLoginDto.java

@@ -1,16 +1,16 @@
 package project.flipnote.auth.model;
 
 import jakarta.validation.constraints.Email;
-import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotBlank;
 
 public class UserLoginDto {
 
 	public record Request(
 
-		@Email @NotEmpty
+		@Email @NotBlank
 		String email,
 
-		@NotEmpty
+		@NotBlank
 		String password
 	) {
 	}

src/main/java/project/flipnote/auth/repository/EmailVerificationRedisRepository.java

@@ -0,0 +1,63 @@
+package project.flipnote.auth.repository;
+
+import java.time.Duration;
+import java.util.Optional;
+
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Repository;
+
+import lombok.RequiredArgsConstructor;
+import project.flipnote.auth.constants.AuthRedisKey;
+
+@RequiredArgsConstructor
+@Repository
+public class EmailVerificationRedisRepository {
+
+	private final RedisTemplate<String, String> emailRedisTemplate;
+
+	public void saveCode(String email, String code) {
+		String key = AuthRedisKey.EMAIL_CODE.key(email);
+		Duration ttl = AuthRedisKey.EMAIL_CODE.getTtl();
+
+		emailRedisTemplate.opsForValue().set(key, code, ttl);
+	}
+
+	public boolean existCode(String email) {
+		String key = AuthRedisKey.EMAIL_CODE.key(email);
+
+		return emailRedisTemplate.hasKey(key);
+	}
+
+	public Optional<String> findCode(String email) {
+		String key = AuthRedisKey.EMAIL_CODE.key(email);
+
+		String code = emailRedisTemplate.opsForValue().get(key);
+
+		return Optional.ofNullable(code);
+	}
+
+	public void deleteCode(String email) {
+		String key = AuthRedisKey.EMAIL_CODE.key(email);
+
+		emailRedisTemplate.delete(key);
+	}
+
+	public void markAsVerified(String email) {
+		String key = AuthRedisKey.EMAIL_VERIFIED.key(email);
+		Duration ttl = AuthRedisKey.EMAIL_VERIFIED.getTtl();
+
+		emailRedisTemplate.opsForValue().set(key, "1", ttl);
+	}
+
+	public boolean isVerified(String email) {
+		String key = AuthRedisKey.EMAIL_VERIFIED.key(email);
+
+		return emailRedisTemplate.hasKey(key);
+	}
+
+	public void deleteVerified(String email) {
+		String key = AuthRedisKey.EMAIL_VERIFIED.key(email);
+
+		emailRedisTemplate.delete(key);
+	}
+}

src/main/java/project/flipnote/auth/service/AuthService.java

@@ -1,33 +1,45 @@
 package project.flipnote.auth.service;
 
-import java.util.UUID;
+import java.security.SecureRandom;
+import java.util.Objects;
 
+import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.stereotype.Service;
 
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import project.flipnote.auth.constants.VerificationConstants;
+import project.flipnote.auth.event.EmailVerificationSendEvent;
 import project.flipnote.auth.exception.AuthErrorCode;
+import project.flipnote.auth.model.EmailVerificationConfirmRequest;
+import project.flipnote.auth.model.EmailVerificationRequest;
 import project.flipnote.auth.model.TokenPair;
 import project.flipnote.auth.model.UserLoginDto;
+import project.flipnote.auth.repository.EmailVerificationRedisRepository;
 import project.flipnote.common.exception.BizException;
 import project.flipnote.common.security.jwt.JwtComponent;
 import project.flipnote.user.entity.User;
 import project.flipnote.user.repository.UserRepository;
 
+@Slf4j
 @RequiredArgsConstructor
 @Service
 public class AuthService {
 
 	private final UserRepository userRepository;
 	private final PasswordEncoder passwordEncoder;
 	private final JwtComponent jwtComponent;
+	private final EmailVerificationRedisRepository emailVerificationRedisRepository;
+	private final ApplicationEventPublisher eventPublisher;
+
+	private static final SecureRandom random = new SecureRandom();
 
 	public TokenPair login(UserLoginDto.Request req) {
 		User user = findByEmailOrThrow(req);
 
-		if (!passwordEncoder.matches(req.password(), user.getPassword())) {
-			throw new BizException(AuthErrorCode.INVALID_CREDENTIALS);
-		}
+		validatePasswordMatch(req.password(), user.getPassword());
+		log.error("{}", user.getPhone());
 
 		return jwtComponent.generateTokenPair(user.getEmail(), user.getId(), user.getRole().name());
 	}
@@ -36,4 +48,73 @@ private User findByEmailOrThrow(UserLoginDto.Request req) {
 		return userRepository.findByEmail(req.email())
 			.orElseThrow(() -> new BizException(AuthErrorCode.INVALID_CREDENTIALS));
 	}
+
+	private void validatePasswordMatch(String rawPassword, String encodedPassword) {
+		if (!passwordEncoder.matches(rawPassword, encodedPassword)) {
+			throw new BizException(AuthErrorCode.INVALID_CREDENTIALS);
+		}
+	}
+
+	public void sendEmailVerificationCode(EmailVerificationRequest req) {
+		final String email = req.email();
+
+		validateEmailIsAvailable(email);
+		validateVerificationCodeNotExists(email);
+
+		final String code = generateVerificationCode(VerificationConstants.CODE_LENGTH);
+
+		emailVerificationRedisRepository.saveCode(email, code);
+
+		eventPublisher.publishEvent(new EmailVerificationSendEvent(email, code));
+	}
+
+	private void validateEmailIsAvailable(String email) {
+		if (userRepository.existsByEmail(email)) {
+			throw new BizException(AuthErrorCode.EXISTING_EMAIL);
+		}
+	}
+
+	private void validateVerificationCodeNotExists(String email) {
+		if (emailVerificationRedisRepository.existCode(email)) {
+			throw new BizException(AuthErrorCode.ALREADY_ISSUED_VERIFICATION_CODE);
+		}
+	}
+
+	public void confirmEmailVerificationCode(EmailVerificationConfirmRequest req) {
+		String email = req.email();
+
+		String code = findVerificationCodeOrThrow(email);
+
+		validateVerificationCode(req.code(), code);
+
+		emailVerificationRedisRepository.deleteCode(email);
+		emailVerificationRedisRepository.markAsVerified(email);
+	}
+
+	private String findVerificationCodeOrThrow(String email) {
+		return emailVerificationRedisRepository.findCode(email)
+			.orElseThrow(() -> new BizException(AuthErrorCode.NOT_ISSUED_VERIFICATION_CODE));
+	}
+
+	private void validateVerificationCode(String inputCode, String savedCode) {
+		if (!Objects.equals(inputCode, savedCode)) {
+			throw new BizException(AuthErrorCode.INVALID_VERIFICATION_CODE);
+		}
+	}
+
+	public void validateEmail(String email) {
+		if (!emailVerificationRedisRepository.isVerified(email)) {
+			throw new BizException(AuthErrorCode.UNVERIFIED_EMAIL);
+		}
+	}
+
+	public void deleteVerifiedEmail(String email) {
+		emailVerificationRedisRepository.deleteVerified(email);
+	}
+
+	private String generateVerificationCode(int length) {
+		int origin = (int)Math.pow(10, length - 1);
+		int bound = (int)Math.pow(10, length);
+		return String.valueOf(random.nextInt(origin, bound));
+	}
 }