Spring Boot 인메모리 캐시 구조 — 다중 인스턴스 정합성

<cache-template name="default">
    <expiry>
        <ttl unit="seconds">60</ttl>
    </expiry>
    <listeners>
        <listener>
            <class>...CacheEventLogger</class>
            <event-firing-mode>ASYNCHRONOUS</event-firing-mode>
            <events-to-fire-on>CREATED</events-to-fire-on>
            <events-to-fire-on>EXPIRED</events-to-fire-on>
        </listener>
    </listeners>
    <heap>10000</heap>
</cache-template>
 
<!-- 데이터 성격에 따라 TTL을 다르게 설정 -->
<cache alias="WHITE_LIST" uses-template="default">
    <expiry><ttl unit="minutes">10</ttl></expiry>
</cache>
 
<cache alias="static_banners" uses-template="default">
    <expiry><ttl unit="days">1</ttl></expiry>
</cache>
 
<cache alias="external_vendor_status" uses-template="default">
    <expiry><ttl>10</ttl></expiry>   <!-- 10초: 실시간성 필요 -->
</cache>

// 개념 설명용 의사코드 — 실제 기반 클래스는 사내 공통 인프라
public abstract class ReloadableCache<T, Key> {
    protected final ConcurrentMap<Key, T> configMap = new ConcurrentHashMap<>();
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
 
    @PostConstruct
    public abstract void reload();            // 서버 기동 시 자동 로드
    public abstract DataTable watchedTable(); // 이 테이블 변경에 반응
}
 
public abstract class ReloadableKeyedCache<T, Key> extends ReloadableCache<T, Key> {
    protected final List<T> configList = new ArrayList<>();
 
    public void reload() {
        writeLockJob(() -> {
            configList.clear();
            configMap.clear();
            List<T> loaded = loadFromRepo();
            configList.addAll(loaded);
            loaded.forEach(a -> configMap.put(key(a), a));
        });
    }
 
    protected abstract List<T> loadFromRepo();
    protected abstract Key key(T t);
}

// 개념 설명용 의사코드 — 프로그램 목록 캐시
@Component
class ProgramListCache extends ReloadableKeyedCache<ProgramEvent, Long> {
    protected List<ProgramEvent> loadFromRepo() {
        return repository.findAllActive(...).stream()
                .map(Event::toProgramEvent).toList();
    }
    public DataTable watchedTable() { return DataTable.PROGRAM_EVENT; }
}

어드민 백엔드
POST /api/v2/admin/service/refresh
        │
        ▼
   서비스 계층 (reloadMemory(tableName))
        │
        ▼
   DataPublisher.reloadMemory(tableName)
        │
        ▼
   MQ Fanout 발행 (FANOUT_STATIC_DATA 토픽)
        │
   ┌────┴────┐
   ▼         ▼
백엔드 서버1  백엔드 서버2  ... (모두 동시 수신)
        │
        ▼
   리스너가 watchedTable()이 일치하는 캐시만 reload()

// 개념 설명용 의사코드
@RestController
@RequestMapping("/api/v2/admin/service/refresh")
class RefreshResource(private val service: ServiceService) {
 
    @PostMapping
    fun refreshCache(@RequestBody dto: RefreshDto): BaseResponse<*> {
        when (dto.type) {
            MEMORY -> dto.tableNames?.forEach(service::reloadMemory)  // 인메모리 캐시
            EHCACHE -> dto.cacheNames?.forEach(service::reloadCache)  // Ehcache
        }
        return BaseResponse.ok()
    }
}

// 개념 설명용 의사코드
@Configuration
@DataPublisher.rabbitmq   // Profile: !azure
public static class RabbitMqDataPublisher extends DataPublisher {
    public void reloadMemory(DataTable table) {
        template.convertAndSend(EXCHANGE_STATIC_DATA, "",
            ReloadCommand.toJson(ReloadType.MEMORY, table));
    }
}
 
@Configuration
@DataPublisher.azure      // Profile: azure
public static class ServiceBusDataPublisher extends DataPublisher {
    public void reloadMemory(DataTable table) {
        template.convertAndSend(EXCHANGE_STATIC_DATA,
            ReloadCommand.toJson(ReloadType.MEMORY, table));
    }
}

// 개념 설명용 의사코드
public void onReloadStaticData(String json) {
    ReloadCommand cmd = ReloadCommand.fromJson(json);
    switch (cmd.getType()) {
        case ALL_EHCACHE:
            cacheManager.getCacheNames().forEach(n -> cacheManager.getCache(n).clear());
            break;
        case EHCACHE:
            cacheManager.getCache(cmd.getCacheName()).clear();
            break;
        case ALL_MEMORY:
            applicationContext.getBeansOfType(ReloadableCache.class).values()
                .forEach(ReloadableCache::reload);
            break;
        case MEMORY:
            applicationContext.getBeansOfType(ReloadableCache.class).values().stream()
                .filter(c -> c.watchedTable() == cmd.getTable())
                .forEach(ReloadableCache::reload);
            break;
    }
}

// 개념 설명용 의사코드
public void reload() {
    writeLockJob(() -> {      // 쓰기 락: 리로드 중 읽기 차단
        configList.clear();
        configMap.clear();
        List<T> loaded = loadFromRepo();
        configList.addAll(loaded);
        loaded.forEach(a -> configMap.put(key(a), a));
    });
}
 
public List<T> list() {
    return readLockJob(() -> new ArrayList<>(configList));  // 읽기 락
}