feat: optimize image

build.gradle

@@ -93,6 +93,10 @@ dependencies {
     runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.11.5'
     runtimeOnly 'io.jsonwebtoken:jjwt-jackson:0.11.5'
     implementation 'org.bouncycastle:bcpkix-jdk15on:1.70'
+
+    // Image Processing
+    implementation 'net.coobird:thumbnailator:0.4.20'
+    implementation 'org.sejda.imageio:webp-imageio:0.1.6'
 }
 
 // Kotlin 컴파일 옵션 설정

src/main/kotlin/upbrella/be/config/ImageProcessingConfig.kt

@@ -0,0 +1,24 @@
+package upbrella.be.config
+
+import org.springframework.boot.context.properties.ConfigurationProperties
+import org.springframework.boot.context.properties.ConstructorBinding
+import org.springframework.context.annotation.Configuration
+
+@Configuration
+@ConfigurationProperties(prefix = "image.processing")
+@ConstructorBinding
+data class ImageProcessingConfig(
+    val sizes: ImageSizes = ImageSizes(),
+    val quality: ImageQuality = ImageQuality()
+)
+
+data class ImageSizes(
+    val thumbnail: Int = 300,
+    val medium: Int = 800,
+    val large: Int = 1200
+)
+
+data class ImageQuality(
+    val webp: Float = 0.85f,
+    val jpeg: Float = 0.90f
+)

src/main/kotlin/upbrella/be/store/dto/response/ImageUrlsResponse.kt

@@ -0,0 +1,13 @@
+package upbrella.be.store.dto.response
+
+data class ImageUrlsResponse(
+    val id: Long?,
+    val webp: ImageSizeUrls?,
+    val jpeg: ImageSizeUrls
+)
+
+data class ImageSizeUrls(
+    val thumb: String,
+    val medium: String,
+    val large: String
+)

src/main/kotlin/upbrella/be/store/dto/response/SingleImageUrlResponse.kt

@@ -4,12 +4,17 @@ import upbrella.be.store.entity.StoreImage
 
 data class SingleImageUrlResponse(
     val id: Long?,
-    val imageUrl: String?
+    val imageUrl: String?, // 기존 호환성 유지
+    val imageUrls: ImageUrlsResponse
 ) {
     companion object {
-        fun createImageUrlResponse(imageUrl: StoreImage) = SingleImageUrlResponse(
-            id = imageUrl.id,
-            imageUrl = imageUrl.imageUrl
-        )
+        fun createImageUrlResponse(storeImage: StoreImage): SingleImageUrlResponse {
+            val imageUrlsResponse = storeImage.getImageUrlsResponse()
+            return SingleImageUrlResponse(
+                id = storeImage.id,
+                imageUrl = storeImage.imageUrl, // 기존 호환성
+                imageUrls = imageUrlsResponse
+            )
+        }
     }
 }

src/main/kotlin/upbrella/be/store/entity/StoreImage.kt

@@ -1,5 +1,9 @@
 package upbrella.be.store.entity
 
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import upbrella.be.store.dto.response.ImageSizeUrls
+import upbrella.be.store.dto.response.ImageUrlsResponse
 import javax.persistence.*
 
 @Entity
@@ -8,17 +12,56 @@ class StoreImage(
     @JoinColumn(name = "store_detail_id")
     val storeDetail: StoreDetail? = null,
     var imageUrl: String? = null,
+
+    @Column(name = "image_urls", columnDefinition = "TEXT")
+    var imageUrls: String? = null,
+
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     val id: Long? = null,
 ) {
     companion object {
+        private val objectMapper: ObjectMapper = jacksonObjectMapper()
+
         @JvmStatic
         fun createStoreImage(storeDetail: StoreDetail, imageUrl: String): StoreImage {
             return StoreImage(
                 storeDetail = storeDetail,
                 imageUrl = imageUrl,
             )
         }
+
+        @JvmStatic
+        fun createStoreImageWithUrls(
+            storeDetail: StoreDetail,
+            imageUrlsResponse: ImageUrlsResponse
+        ): StoreImage {
+            return StoreImage(
+                storeDetail = storeDetail,
+                imageUrl = imageUrlsResponse.jpeg.medium, // 기존 호환성
+                imageUrls = objectMapper.writeValueAsString(imageUrlsResponse),
+            )
+        }
+    }
+
+    /**
+     * 다중 URL 구조 반환 (JSON 파싱 또는 기존 URL fallback)
+     */
+    fun getImageUrlsResponse(): ImageUrlsResponse {
+        return if (imageUrls != null) {
+            // 새 포맷: JSON 파싱
+            objectMapper.readValue(imageUrls, ImageUrlsResponse::class.java)
+        } else {
+            // 기존 이미지: 단일 URL을 모든 크기에 사용
+            ImageUrlsResponse(
+                id = id,
+                webp = null,
+                jpeg = ImageSizeUrls(
+                    thumb = imageUrl ?: "",
+                    medium = imageUrl ?: "",
+                    large = imageUrl ?: ""
+                )
+            )
+        }
     }
 }

src/main/kotlin/upbrella/be/store/service/ImageProcessingService.kt

@@ -0,0 +1,164 @@
+package upbrella.be.store.service
+
+import net.coobird.thumbnailator.Thumbnails
+import org.springframework.stereotype.Service
+import org.springframework.web.multipart.MultipartFile
+import upbrella.be.config.ImageProcessingConfig
+import java.awt.image.BufferedImage
+import java.io.ByteArrayOutputStream
+import javax.imageio.ImageIO
+
+@Service
+class ImageProcessingService(
+    private val config: ImageProcessingConfig
+) {
+
+    enum class ImageSize(val maxSize: Int) {
+        THUMBNAIL(300),
+        MEDIUM(800),
+        LARGE(1200);
+
+        companion object {
+            fun from(configValue: Int): ImageSize {
+                return when (configValue) {
+                    300 -> THUMBNAIL
+                    800 -> MEDIUM
+                    1200 -> LARGE
+                    else -> throw IllegalArgumentException("Unknown image size: $configValue")
+                }
+            }
+        }
+    }
+
+    /**
+     * 이미지를 3가지 크기 x 2가지 포맷(WebP, JPEG)으로 처리
+     */
+    fun processImage(file: MultipartFile): ProcessedImageSet {
+        val originalImage = ImageIO.read(file.inputStream)
+            ?: throw IllegalArgumentException("Invalid image file")
+
+        // 3가지 크기로 리사이징
+        val thumbnail = processSize(originalImage, config.sizes.thumbnail)
+        val medium = processSize(originalImage, config.sizes.medium)
+        val large = processSize(originalImage, config.sizes.large)
+
+        return ProcessedImageSet(thumbnail, medium, large)
+    }
+
+    /**
+     * 특정 크기로 리사이징하고 WebP와 JPEG 포맷으로 변환
+     */
+    private fun processSize(originalImage: BufferedImage, targetSize: Int): ImageVariantData {
+        // 리사이징
+        val resized = resizeImage(originalImage, targetSize)
+
+        // WebP 변환
+        val webp = convertToWebP(resized, config.quality.webp)
+
+        // JPEG 변환
+        val jpeg = convertToJpeg(resized, config.quality.jpeg)
+
+        return ImageVariantData(webp, jpeg)
+    }
+
+    /**
+     * 이미지를 지정된 크기로 리사이징 (비율 유지)
+     */
+    private fun resizeImage(image: BufferedImage, maxSize: Int): BufferedImage {
+        return Thumbnails.of(image)
+            .size(maxSize, maxSize)
+            .asBufferedImage()
+    }
+
+    /**
+     * BufferedImage를 WebP 포맷으로 변환
+     */
+    private fun convertToWebP(image: BufferedImage, quality: Float): ByteArray {
+        val outputStream = ByteArrayOutputStream()
+
+        // WebP ImageWriter 설정
+        val writer = ImageIO.getImageWritersByFormatName("webp").next()
+            ?: throw IllegalStateException("WebP ImageWriter not found. Make sure webp-imageio is on the classpath")
+
+        val writeParam = writer.defaultWriteParam
+        if (writeParam.canWriteCompressed()) {
+            writeParam.compressionMode = javax.imageio.ImageWriteParam.MODE_EXPLICIT
+            writeParam.compressionQuality = quality
+        }
+
+        val output = ImageIO.createImageOutputStream(outputStream)
+        writer.output = output
+        writer.write(null, javax.imageio.IIOImage(image, null, null), writeParam)
+        writer.dispose()
+        output.close()
+
+        return outputStream.toByteArray()
+    }
+
+    /**
+     * BufferedImage를 JPEG 포맷으로 변환
+     */
+    private fun convertToJpeg(image: BufferedImage, quality: Float): ByteArray {
+        val outputStream = ByteArrayOutputStream()
+
+        // RGB 이미지로 변환 (JPEG는 투명도 미지원)
+        val rgbImage = if (image.type == BufferedImage.TYPE_INT_ARGB ||
+                           image.type == BufferedImage.TYPE_4BYTE_ABGR) {
+            val newImage = BufferedImage(image.width, image.height, BufferedImage.TYPE_INT_RGB)
+            val g = newImage.createGraphics()
+            g.drawImage(image, 0, 0, null)
+            g.dispose()
+            newImage
+        } else {
+            image
+        }
+
+        val writer = ImageIO.getImageWritersByFormatName("jpeg").next()
+        val writeParam = writer.defaultWriteParam
+        writeParam.compressionMode = javax.imageio.ImageWriteParam.MODE_EXPLICIT
+        writeParam.compressionQuality = quality
+
+        val output = ImageIO.createImageOutputStream(outputStream)
+        writer.output = output
+        writer.write(null, javax.imageio.IIOImage(rgbImage, null, null), writeParam)
+        writer.dispose()
+        output.close()
+
+        return outputStream.toByteArray()
+    }
+}
+
+/**
+ * 3가지 크기의 이미지 데이터 세트
+ */
+data class ProcessedImageSet(
+    val thumbnail: ImageVariantData,
+    val medium: ImageVariantData,
+    val large: ImageVariantData
+)
+
+/**
+ * 각 크기별 WebP와 JPEG 데이터
+ */
+data class ImageVariantData(
+    val webp: ByteArray,
+    val jpeg: ByteArray
+) {
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as ImageVariantData
+
+        if (!webp.contentEquals(other.webp)) return false
+        if (!jpeg.contentEquals(other.jpeg)) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = webp.contentHashCode()
+        result = 31 * result + jpeg.contentHashCode()
+        return result
+    }
+}