Google Drive 이미지 프록시 성능 개선 — Virtual Thread와 경량 캐시 적용

[브라우저] → /photo/lifelog/nature/cherry.jpg
               ↓
          [Spring Boot 서버]
               ↓
          [Google Drive API]  ← 폴더 탐색 → 파일 검색 → 메타데이터 조회 → 파일 다운로드
               ↓
          [이미지 바이트 응답]

fun getImageByPath(path: String): ImageResource? {
    val drive = googleDriveHelper.drive
    val segments = path.split("/").filter { it.isNotEmpty() }

    // 1) 폴더 경로 순차 탐색 — depth마다 API 1회
    var parentId = "root"
    for (i in 0 until segments.size - 1) {
        parentId = googleDriveHelper.findFileId(drive, parentId, segments[i], true)
            ?: throw RuntimeException("폴더를 찾을 수 없습니다")
    }

    // 2) 파일 ID 검색 — API 1회
    val fileId = googleDriveHelper.findFileId(drive, parentId, segments.last(), false)
        ?: throw RuntimeException("파일을 찾을 수 없습니다")

    // 3) 메타데이터 조회 — API 1회
    val fileMeta = drive.files().get(fileId)
        .setFields("id, name, mimeType, size")
        .execute()

    // 4) 파일 다운로드 — API 1회
    val buffer = ByteArrayOutputStream()
    drive.files().get(fileId).executeMediaAndDownloadTo(buffer)
    val bytes = buffer.toByteArray()

    return ImageResource(ByteArrayInputStream(bytes), fileMeta.mimeType, fileMeta.name, bytes.size.toLong())
}

/** 경로 → 폴더 ID 캐시 */
private val folderIdCache = ConcurrentHashMap<String, String>()

/** 파일 경로 → 파일 ID 캐시 */
private val fileIdCache = ConcurrentHashMap<String, String>()

// Virtual Thread로 메타데이터 조회와 파일 다운로드를 병렬 실행
val metaFuture = asyncSupply(virtualThreadExecutor) {
    drive.files().get(fileId)
        .setFields("id, name, mimeType, size")
        .execute()
}
val downloadFuture = asyncSupply(virtualThreadExecutor) {
    val buffer = ByteArrayOutputStream()
    drive.files().get(fileId).executeMediaAndDownloadTo(buffer)
    buffer.toByteArray()
}

val fileMeta = metaFuture.get()   // 먼저 끝나는 쪽은 즉시 반환
val bytes = downloadFuture.get()  // 나중에 끝나는 쪽을 대기

@Configuration
public class VirtualThreadConfig {
    @Bean
    public TaskExecutor virtualThreadExecutor() {
        return new TaskExecutorAdapter(Executors.newVirtualThreadPerTaskExecutor());
    }
}

public final class AsyncSupporter {
    public static <T> CompletableFuture<T> asyncSupply(TaskExecutor executor, Supplier<T> supplier) {
        return CompletableFuture.supplyAsync(supplier, executor);
    }
}

@Service
class GoogleDriveService(
    private val virtualThreadExecutor: TaskExecutor,
    private val googleDriveHelper: GoogleDriveHelper,
) {
    private val folderIdCache = ConcurrentHashMap<String, String>()
    private val fileIdCache = ConcurrentHashMap<String, String>()

    fun getImageByPath(path: String): ImageResource? {
        val segments = path.split("/").filter { it.isNotEmpty() }
        if (segments.isEmpty()) throw RuntimeException("경로가 비어 있습니다: $path")

        val drive = googleDriveHelper.drive

        // ① 폴더 ID 캐시 활용 — 캐시 히트 시 API 호출 0회
        val parentId = resolveFolderPath(segments.dropLast(1))

        // ② 파일 ID 캐시 활용 — 캐시 히트 시 API 호출 0회
        val fileName = segments.last()
        val fileId = fileIdCache.getOrPut(path) {
            googleDriveHelper.findFileId(drive, parentId, fileName, false)
                ?: throw RuntimeException("파일을 찾을 수 없습니다: $fileName")
        }

        // ③ Virtual Thread로 메타데이터 + 다운로드 병렬 실행
        val metaFuture = asyncSupply(virtualThreadExecutor) {
            drive.files().get(fileId).setFields("id, name, mimeType, size").execute()
        }
        val downloadFuture = asyncSupply(virtualThreadExecutor) {
            val buffer = ByteArrayOutputStream()
            drive.files().get(fileId).executeMediaAndDownloadTo(buffer)
            buffer.toByteArray()
        }

        val fileMeta = metaFuture.get()
        val bytes = downloadFuture.get()

        return ImageResource(
            ByteArrayInputStream(bytes), fileMeta.mimeType,
            fileMeta.name, bytes.size.toLong()
        )
    }

    private fun resolveFolderPath(folders: List<String>): String {
        if (folders.isEmpty()) return "root"
        val drive = googleDriveHelper.drive
        var parentId = "root"
        val pathBuilder = StringBuilder()

        for (folder in folders) {
            if (pathBuilder.isNotEmpty()) pathBuilder.append("/")
            pathBuilder.append(folder)
            parentId = folderIdCache.getOrPut(pathBuilder.toString()) {
                googleDriveHelper.findFileId(drive, parentId, folder, true)
                    ?: throw RuntimeException("폴더를 찾을 수 없습니다: $folder")
            }
        }
        return parentId
    }
}

fun uploadImage(folderPath: String, file: MultipartFile): Pair<File, File> {
    // ... 업로드 로직 ...

    // 업로드 후 해당 폴더 경로의 파일 ID 캐시 무효화
    fileIdCache.keys.removeIf { it.startsWith(folderPath) }

    return Pair(mainJobFuture.get(), subJobFuture.get())
}

// build.gradle.kts (shared 모듈)
dependencies {
    api("org.springframework.boot:spring-boot-starter-data-redis")
}

# 로컬/테스트 — Embedded Redis 자동 구동
spring:
  data:
    redis:
      host: localhost
      port: 6379

# live 환경 — Valkey SaaS 접속
spring:
  data:
    redis:
      ssl:
        enabled: true
      url: ENC(암호화된_접속_URL)

@Configuration
@EnableCaching
public class RedisCacheConfig {
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        final RedisCacheConfiguration defaultConfig = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofHours(24))
                .serializeKeysWith(SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(SerializationPair.fromSerializer(new StringRedisSerializer()))
                .disableCachingNullValues();

        return RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(defaultConfig)
                .build();
    }
}

@Service
class GoogleDriveCacheSaver(
    private val googleDriveHelper: GoogleDriveHelper,
) {
    @Cacheable(value = ["driveFolderId"], key = "#cacheKey")
    fun getFolderId(cacheKey: String, drive: Drive, parentId: String, folderName: String): String {
        return googleDriveHelper.findFileId(drive, parentId, folderName, true)
            ?: throw RuntimeException("path cannot be found: $folderName")
    }

    @Cacheable(value = ["driveFileId"], key = "#cacheKey")
    fun getFileId(cacheKey: String, drive: Drive, parentId: String, fileName: String): String {
        return googleDriveHelper.findFileId(drive, parentId, fileName, false)
            ?: throw RuntimeException("file cannot be found: $fileName")
    }

    @CacheEvict(value = ["driveFileId"], allEntries = true)
    fun evictAllFileIdCache() {
        log.info("All file ID cache evicted.")
    }
}

@Service
class GoogleDriveService(
    private val virtualThreadExecutor: TaskExecutor,
    private val googleDriveHelper: GoogleDriveHelper,
    private val googleDriveCacheSaver: GoogleDriveCacheSaver,  // 캐시 전용 Bean
) {
    fun getImageByPath(path: String): ImageResource? {
        // ...
        val parentId = resolveFolderPath(segments.dropLast(1))
        val fileId = googleDriveCacheSaver.getFileId(path, drive, parentId, fileName)
        // ... Virtual Thread 병렬 실행 (기존과 동일)
    }

    fun uploadImage(folderPath: String, file: MultipartFile): Pair<File, File> {
        // ... 업로드 로직 ...
        googleDriveCacheSaver.evictAllFileIdCache()  // 캐시 무효화
        return Pair(mainJobFuture.get(), subJobFuture.get())
    }

    private fun resolveFolderPath(folders: List<String>): String {
        // ...
        for (folder in folders) {
            parentId = googleDriveCacheSaver.getFolderId(pathBuilder.toString(), drive, parentId, folder)
        }
        return parentId
    }
}

[Before — redisTemplate 직접 호출]

val fileIdCacheKey = "$FILE_ID_PREFIX$path"
val fileId = redisTemplate.opsForValue().get(fileIdCacheKey)
    ?: run {
        val id = googleDriveHelper.findFileId(drive, parentId, fileName, false)
            ?: throw RuntimeException("파일을 찾을 수 없습니다")
        redisTemplate.opsForValue().set(fileIdCacheKey, id, CACHE_TTL)
        id
    }

[After — @Cacheable]

val fileId = googleDriveCacheSaver.getFileId(path, drive, parentId, fileName)

[1차 개선 — 인메모리]

ConcurrentHashMap (JVM 내부)
  └─ 서버 재시작 시 소멸
  └─ 인스턴스 간 비공유
  └─ TTL 없음

[2차 개선 — Valkey/Redis]

Valkey/Redis (외부 저장소)
  └─ 서버 재시작 후에도 캐시 유지
  └─ 다중 인스턴스 간 캐시 공유
  └─ TTL 24시간 자동 만료
  └─ @Cacheable로 비즈니스 로직에서 캐시 관심사 분리

@Configuration
@Profile("!live")
class EmbeddedRedisConfig {
    private var redisServer: RedisServer? = null

    @PostConstruct
    fun startRedis() {
        redisServer = RedisServer.newRedisServer().build()
        redisServer?.start()
    }

    @PreDestroy
    fun stopRedis() {
        redisServer?.stop()
    }
}

[최초]                    [1차 개선]                  [2차 개선]
순차 API 5회              인메모리 캐시               Valkey/Redis 캐시
~950ms                   + Virtual Thread            + Spring Cache
                          ~300ms (재요청)             + @Cacheable/@CacheEvict

  ↓ 문제점                   ↓ 문제점                    ✓ 해결
API 호출 과다              서버 재시작 시 소멸           서버 재시작 후 캐시 유지
순차 실행 병목              인스턴스 간 비공유            다중 인스턴스 캐시 공유
                          TTL 없음                    TTL 24시간 자동 만료
                          보일러플레이트                선언적 캐시 처리