[Feature] S3 이미지 업로드 기능 구현

build.gradle

@@ -77,6 +77,7 @@ dependencies {
 	annotationProcessor 'jakarta.persistence:jakarta.persistence-api'
 
 	// aws s3
+	implementation platform('software.amazon.awssdk:bom:2.25.35')
 	implementation 'io.awspring.cloud:spring-cloud-aws-starter-s3:3.1.1'
 }
 

docker-compose.yml

@@ -19,6 +19,7 @@ services:
       - SPRING_REDIS_PORT=6379
       - AWS_S3_BUCKET_NAME=${AWS_S3_BUCKET_NAME}
       - AWS_S3_SECRET_ACCESS_KEY=${AWS_S3_SECRET_ACCESS_KEY}
+      - AWS_S3_ACCESS_KEY_ID=${AWS_S3_ACCESS_KEY_ID}
       - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY}
     depends_on:
       - redis

src/main/java/com/daramg/server/auth/application/AuthService.java

@@ -3,6 +3,7 @@
 import com.daramg.server.auth.dto.TokenResponseDto;
 import com.daramg.server.auth.exception.AuthErrorStatus;
 import com.daramg.server.auth.util.JwtUtil;
+import com.daramg.server.common.application.S3ImageService;
 import com.daramg.server.common.exception.BusinessException;
 import com.daramg.server.user.domain.User;
 import com.daramg.server.auth.domain.SignupVo;
@@ -17,6 +18,7 @@
 import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.multipart.MultipartFile;
 
 import java.util.concurrent.TimeUnit;
 
@@ -32,8 +34,9 @@ public class AuthService {
     private final JwtUtil jwtTokenProvider;
     private final PasswordEncoder passwordEncoder;
     private final RedisTemplate<String, String> redisTemplate;
+    private final S3ImageService s3ImageService;
 
-    public void signup(SignupRequestDto dto){
+    public void signup(SignupRequestDto dto, MultipartFile image){
         if (userRepository.existsByEmail(dto.getEmail())) {
             throw new BusinessException("중복된 이메일입니다.");
         }
@@ -42,12 +45,19 @@ public void signup(SignupRequestDto dto){
         }
         // TODO: bio, 닉네임에 금칙어 검사
         String encodedPassword = passwordEncoder.encode(dto.getPassword());
+
+        // 이미지가 있으면 S3에 업로드하고 URL을 받아옴, 없으면 null (기본 이미지 사용)
+        String profileImageUrl = null;
+        if (image != null && !image.isEmpty()) {
+            profileImageUrl = s3ImageService.uploadImage(image);
+        }
+
         SignupVo vo = new SignupVo(
                 dto.getName(),
                 dto.getBirthdate(),
                 dto.getEmail(),
                 encodedPassword,
-                dto.getProfileImage(),
+                profileImageUrl,
                 dto.getNickname(),
                 dto.getBio()
         );

src/main/java/com/daramg/server/auth/dto/SignupRequestDto.kt

@@ -20,13 +20,6 @@ class SignupRequestDto(
     )
     val password: String,
 
-    @get:Pattern(
-        regexp = "^(https?://).+\\.(jpg|jpeg|png|gif|svg)$",
-        flags = [Pattern.Flag.CASE_INSENSITIVE],
-        message = "올바른 이미지 URL 형식이 아닙니다"
-    )
-    val profileImage: String?,
-
     @get:NotBlank(message = "닉네임은 필수입니다")
     @get:Pattern(
         regexp = "^[a-zA-Z0-9가-힣._]{2,8}$",

src/main/java/com/daramg/server/auth/presentation/AuthController.java

@@ -15,8 +15,10 @@
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
 import org.springframework.http.ResponseCookie;
 import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
 
 @RestController
 @RequestMapping("/auth")
@@ -50,10 +52,13 @@ public void verify(@RequestBody @Valid CodeVerificationRequestDto request) {
         mailVerificationService.verifyEmailWithCode(request);
     }
 
-    @PostMapping("/signup")
+    @PostMapping(value = "/signup", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
     @ResponseStatus(HttpStatus.CREATED)
-    public void signup(@Valid @RequestBody SignupRequestDto request) {
-        authService.signup(request);
+    public void signup(
+            @RequestPart("signupRequest") @Valid SignupRequestDto request,
+            @RequestPart(value = "image", required = false) MultipartFile image
+    ) {
+        authService.signup(request, image);
     }
 
     @PostMapping("/login")

src/main/java/com/daramg/server/common/application/S3ImageService.java

@@ -0,0 +1,98 @@
+package com.daramg.server.common.application;
+
+import com.daramg.server.common.exception.BusinessException;
+import com.daramg.server.common.exception.ImageErrorStatus;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+import software.amazon.awssdk.core.sync.RequestBody;
+import software.amazon.awssdk.services.s3.S3Client;
+import software.amazon.awssdk.services.s3.model.PutObjectRequest;
+import software.amazon.awssdk.services.s3.model.S3Exception;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.UUID;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class S3ImageService {
+
+    private static final java.util.Set<String> ALLOWED_CONTENT_TYPES = java.util.Set.of(
+            "image/jpeg", "image/jpg", "image/png", "image/gif"
+    );
+    private static final long MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
+    private static final String S3_URL_FORMAT = "https://%s.s3.%s.amazonaws.com/%s";
+
+    private final S3Client s3Client;
+
+    @Value("${aws.s3.bucket}")
+    private String bucketName;
+
+    @Value("${aws.region.static:ap-northeast-2}")
+    private String region;
+
+    public List<String> uploadImages(List<MultipartFile> images) {
+        return images.stream()
+                .map(this::uploadImage)
+                .toList();
+    }
+
+    public String uploadImage(MultipartFile file) {
+        validateFile(file);
+
+        try {
+            String fileName = generateFileName(file.getOriginalFilename());
+            String key = "images/" + fileName;
+
+            PutObjectRequest putObjectRequest = PutObjectRequest.builder()
+                    .bucket(bucketName)
+                    .key(key)
+                    .contentType(file.getContentType())
+                    .contentLength(file.getSize())
+                    .build();
+
+            try (InputStream inputStream = file.getInputStream()) {
+                s3Client.putObject(putObjectRequest, RequestBody.fromInputStream(inputStream, file.getSize()));
+            }
+
+            String imageUrl = String.format(S3_URL_FORMAT, bucketName, region, key);
+            log.info("Image uploaded successfully: {}", imageUrl);
+            return imageUrl;
+
+        } catch (S3Exception e) {
+            log.error("Failed to upload image to S3", e);
+            throw new BusinessException(ImageErrorStatus.FILE_UPLOAD_FAILED);
+        } catch (IOException e) {
+            log.error("Failed to read file input stream", e);
+            throw new BusinessException(ImageErrorStatus.FILE_UPLOAD_FAILED);
+        }
+    }
+
+    private void validateFile(MultipartFile file) {
+        if (file == null || file.isEmpty()) {
+            throw new BusinessException(ImageErrorStatus.EMPTY_FILE);
+        }
+
+        if (file.getSize() > MAX_FILE_SIZE) {
+            throw new BusinessException(ImageErrorStatus.FILE_TOO_LARGE);
+        }
+
+        String contentType = file.getContentType();
+        if (contentType == null || !ALLOWED_CONTENT_TYPES.contains(contentType.toLowerCase())) {
+            throw new BusinessException(ImageErrorStatus.INVALID_FILE_TYPE);
+        }
+    }
+
+    private String generateFileName(String originalFilename) {
+        String extension = "";
+        if (originalFilename != null && originalFilename.contains(".")) {
+            extension = originalFilename.substring(originalFilename.lastIndexOf("."));
+        }
+        return UUID.randomUUID() + extension;
+    }
+}

src/main/java/com/daramg/server/common/config/AppConfig.java

@@ -2,12 +2,17 @@
 
 import com.daramg.server.auth.resolver.AuthUserResolver;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.web.method.support.HandlerMethodArgumentResolver;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
+import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
+import software.amazon.awssdk.regions.Region;
+import software.amazon.awssdk.services.s3.S3Client;
 
 import java.util.List;
 
@@ -17,11 +22,29 @@ public class AppConfig implements WebMvcConfigurer {
 
     private final AuthUserResolver authUserResolver;
 
+    @Value("${aws.credentials.access-key}")
+    private String accessKey;
+
+    @Value("${aws.credentials.secret-key}")
+    private String secretKey;
+
+    @Value("${aws.region.static:ap-northeast-2}")
+    private String region;
+
     @Bean
     public PasswordEncoder passwordEncoder() {
         return new BCryptPasswordEncoder();
     }
 
+    @Bean
+    public S3Client s3Client() {
+        AwsBasicCredentials awsCredentials = AwsBasicCredentials.create(accessKey, secretKey);
+        return S3Client.builder()
+                .region(Region.of(region))
+                .credentialsProvider(StaticCredentialsProvider.create(awsCredentials))
+                .build();
+    }
+
     @Override
     public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
         resolvers.add(authUserResolver);

src/main/java/com/daramg/server/common/dto/ImageUploadResponseDto.kt

@@ -0,0 +1,6 @@
+package com.daramg.server.common.dto
+
+data class ImageUploadResponseDto(
+    val imageUrls: List<String>
+)
+

src/main/java/com/daramg/server/common/exception/ErrorCategory.java

@@ -5,7 +5,8 @@ public enum ErrorCategory {
     COMMON("COMMON_"),
     AUTH("AUTH_"),
     USER("USER_"),
-    POST("POST_");
+    POST("POST_"),
+    IMAGE("IMAGE_");
 
     private final String prefix;
 

src/main/java/com/daramg/server/common/exception/GlobalExceptionHandler.java

@@ -7,9 +7,9 @@
 import org.springframework.http.HttpStatus;
 import org.springframework.http.HttpStatusCode;
 import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.AuthenticationException;
 import org.springframework.web.bind.MethodArgumentNotValidException;
 import org.springframework.web.bind.annotation.ExceptionHandler;
-import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
 import org.springframework.web.context.request.WebRequest;
 import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;
@@ -19,7 +19,7 @@
 
 @Slf4j
 @RequiredArgsConstructor
-@RestControllerAdvice(annotations = {RestController.class})
+@RestControllerAdvice
 public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
 
     private final ErrorCodeRegistry errorCodeRegistry;
@@ -34,6 +34,59 @@ public ResponseEntity<ErrorResponse> handleGeneralException(BusinessException e)
                 .body(ErrorResponse.of(errorCode));
     }
 
+    @ExceptionHandler(AuthenticationException.class)
+    public ResponseEntity<ErrorResponse> handleAuthenticationException(AuthenticationException e) {
+        // AuthenticationException의 원인 예외에서 BusinessException 확인
+        Throwable cause = e.getCause();
+        while (cause != null) {
+            if (cause instanceof BusinessException businessException) {
+                BaseErrorCode errorCode = businessException.getErrorCode();
+                log.warn("BusinessException (from AuthenticationException): {}", errorCode.getMessage());
+                return ResponseEntity
+                        .status(errorCode.getHttpStatus())
+                        .body(ErrorResponse.of(errorCode));
+            }
+            cause = cause.getCause();
+        }
+
+        // 기본 인증 실패 응답
+        log.warn("AuthenticationException: {}", e.getMessage());
+        return ResponseEntity
+                .status(HttpStatus.UNAUTHORIZED)
+                .body(ErrorResponse.of(CommonErrorStatus.UNAUTHORIZED));
+    }
+
+
+    @Override
+    protected ResponseEntity<Object> handleExceptionInternal(Exception ex, Object body, HttpHeaders headers, HttpStatusCode statusCode, WebRequest request) {
+        // 예외 자체가 BusinessException인지 확인
+        if (ex instanceof BusinessException businessException) {
+            BaseErrorCode errorCode = businessException.getErrorCode();
+            log.warn("BusinessException (from handleExceptionInternal, direct): {}", errorCode.getMessage());
+            return ResponseEntity
+                    .status(errorCode.getHttpStatus())
+                    .body(ErrorResponse.of(errorCode));
+        }
+
+        // HandlerMethodArgumentResolver에서 발생한 BusinessException을 확인
+        Throwable current = ex;
+        int depth = 0;
+        while (current != null && depth < 10) {
+            if (current instanceof BusinessException businessException) {
+                BaseErrorCode errorCode = businessException.getErrorCode();
+                log.warn("BusinessException (from handleExceptionInternal, depth={}): {}", depth, errorCode.getMessage());
+                return ResponseEntity
+                        .status(errorCode.getHttpStatus())
+                        .body(ErrorResponse.of(errorCode));
+            }
+            current = current.getCause();
+            depth++;
+        }
+
+        log.warn("handleExceptionInternal: {} - {}", ex.getClass().getName(), ex.getMessage());
+        return super.handleExceptionInternal(ex, body, headers, statusCode, request);
+    }
+
     @Override
     protected ResponseEntity<Object> handleMethodArgumentNotValid(MethodArgumentNotValidException e, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
         log.warn("MethodArgumentNotValidException: {}", e.getMessage());
@@ -60,7 +113,31 @@ protected ResponseEntity<Object> handleMethodArgumentNotValid(MethodArgumentNotV
 
     @ExceptionHandler(Exception.class)
     public ResponseEntity<ErrorResponse> handleUnexpectedException(Exception e) {
-        log.error("Unexpected Exception: ", e);
+        // 예외 자체가 BusinessException인지 확인
+        if (e instanceof BusinessException businessException) {
+            BaseErrorCode errorCode = businessException.getErrorCode();
+            log.warn("BusinessException (direct): {}", errorCode.getMessage());
+            return ResponseEntity
+                    .status(errorCode.getHttpStatus())
+                    .body(ErrorResponse.of(errorCode));
+        }
+
+        // HandlerMethodArgumentResolver에서 발생한 BusinessException을 확인
+        Throwable current = e;
+        int depth = 0;
+        while (current != null && depth < 10) {
+            if (current instanceof BusinessException businessException) {
+                BaseErrorCode errorCode = businessException.getErrorCode();
+                log.warn("BusinessException (in chain, depth={}): {}", depth, errorCode.getMessage());
+                return ResponseEntity
+                        .status(errorCode.getHttpStatus())
+                        .body(ErrorResponse.of(errorCode));
+            }
+            current = current.getCause();
+            depth++;
+        }
+
+        log.error("Unexpected Exception: {} - {}", e.getClass().getName(), e.getMessage(), e);
         return ResponseEntity
                 .status(HttpStatus.INTERNAL_SERVER_ERROR)
                 .body(ErrorResponse.of(CommonErrorStatus.INTERNAL_SERVER_ERROR));