package org.springframework.cache;

public interface Cache {
  // ...
  
  // 캐시 이름 리턴
  String getName();

  // 캐시에서 Object key 와 매핑된 객체 리턴
  // 리턴되는 객체는 두 번째 인자인 Class<T> type 으로 형변환됨
  @Nullable
  <T> T get(Object key, @Nullable Class<T> type);

  // 캐시에 새로운 데이터 입력
  void put(Object key, @Nullable Object value);

  // 캐시에서 Object key 와 매핑되는 데이터 퇴출(evict)
  void evict(Object key);
}

package org.springframework.cache;

import java.util.Collection;
import org.springframework.lang.Nullable;

public interface CacheManager {
  // 애플리케이션에서 관리하는 여러 개의 캐시 중 name 인자와 매핑되는 Cache 객체 리턴
  @Nullable
  Cache getCache(String name);

  // 애플리케이션에서 사용할 수 있는 캐시 이름들을 리턴
  Collection<String> getCacheNames();
}

@Bean
public Caffeine caffeineConfig() {
  return Caffeine.newBuilder()
        .expireAfterWrite(60, TimeUnit.MINUTES)   // 캐시 데이터의 유효 기간 설정
        .maximumSize(1000); // Caffeine 객체가 관리할 수 있는 캐시 데이터의 최대 개수는 1000개
}

@Bean
public CacheManager cacheManager(Caffeine caffeine) {
  CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager();
  caffeineCacheManager.setCaffeine(caffeine); // Caffeine 스프링 빈을 사용하여 CaffeineCacheManager 스프링 빈 생성
  return caffeineCacheManager;
}

package com.assu.study.chap10.config;

import com.assu.study.chap10.service.HotelKeyGenerator;
import io.lettuce.core.ClientOptions;
import io.lettuce.core.SocketOptions;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;
import java.util.HashMap;
import java.util.Map;

@Configuration
@EnableCaching
public class BasicCacheConfig {

  @Bean
  public RedisConnectionFactory basicCacheRedisConnectionFactory() {
    RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration("127.0.0.1", 6379);

    // 레디스와 클라이언트 사이에 커넥션을 생성할 때 소요되는 최대 시간 설정
    // 설정한 SocketOptions 객체는 ClientOptions 객체에 다시 랩핑함
    // 랩핑한 ClientOptions 는 LettuceClientConfigurationBuilder 의 clientOptions() 메서드를 사용하여 설정 가능
    final SocketOptions socketOptions = SocketOptions.builder().connectTimeout(Duration.ofSeconds(10)).build();
    final ClientOptions clientOptions = ClientOptions.builder().socketOptions(socketOptions).build();

    LettuceClientConfiguration lettuceClientConfiguration = LettuceClientConfiguration.builder()
        .clientOptions(clientOptions)
        .commandTimeout(Duration.ofSeconds(5))  // 레디스 명령어를 실행하고 응답받는 시간 설정
        .shutdownTimeout(Duration.ZERO) // 레디스 클라이언트가 안전하게 종료하려고 애플리케이션이 종료될 때까지 기다리는 최대 시간
        .build();

    return new LettuceConnectionFactory(configuration, lettuceClientConfiguration);
  }

  // 스프링 빈의 이름은 cacheManager
  // 레디스 서버에 캐시 데이터 저장
  @Bean
  public CacheManager cacheManager() {
    // RedisCacheConfigurations 은 캐시 데이터를 저장하는 RedisCache 를 설정하는 기능 제공
    RedisCacheConfiguration defaultConfig = RedisCacheConfiguration.defaultCacheConfig()  // defaultCacheConfig() 는 기본값으로 설정된 RedisCacheConfiguration 객체 리턴
        .entryTtl(Duration.ofHours(1))  // 캐시의 유효 기간을 1시간으로 설정
        .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer())) // 캐시 데이터 key 직렬화 시 문자열로 변환하여 저장
        //.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new Jackson2JsonRedisSerializer<>(Object.class)));  // 캐시 데이터 value 직렬화할 때 JSON 으로 변환하여 저장
        .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));  // 캐시 데이터 value 직렬화할 때 JSON 으로 변환하여 저장

    Map<String, RedisCacheConfiguration> configurations = new HashMap<>();
    // HashMap configuration 객체의 key 는 캐시 이름을 저장하고, value 는 캐시를 설정할 수 있는 RedisConfiguration 저장
    // hotelCache 캐시의 설정은 defaultConfig 설정과 같지만 캐시 데이터의 유효 기간을 30분으로 변경
    // RedisCacheConfiguration 은 불변 객체이므로 entryTtl() 은 새로운 RedisCacheConfiguration 객체를 리턴
    // 즉, 기존 defaultConfig 객체에는 영향이 없음
    configurations.put("hotelCache", defaultConfig.entryTtl(Duration.ofMinutes(30)));
    configurations.put("hotelAddressCache", defaultConfig.entryTtl(Duration.ofDays(1)));

    return RedisCacheManager.RedisCacheManagerBuilder
        .fromConnectionFactory(basicCacheRedisConnectionFactory())  // RedisCacheManager 가 사용할 RedisConnectionFactory 객체 설정
        .cacheDefaults(defaultConfig) // RedisCacheConfiguration 인자를 사용하여 RedisCacheManager 의 기본 캐시 설정
        .withInitialCacheConfigurations(configurations) // RedisCacheManager 생성 시 초기값 설정, 따라서 RedisCacheManager 스프링 빈이 생성되면 hotelCache 와 hotelAddressCache 캐시 값이 설정됨
        .build();
  }

  // 이 내용은 뒤에 나옴
  @Bean
  public HotelKeyGenerator hotelKeyGenerator() {
    return new HotelKeyGenerator();
  }
}

package com.assu.study.chap10.service;

import lombok.Getter;
import lombok.ToString;
import org.springframework.cache.annotation.Cacheable;

@Getter
@ToString
@Cacheable
public class HotelRequest {
  private final Long hotelId;

  public HotelRequest(Long hotelId) {
    this.hotelId = hotelId;
  }
}

// CacheManager 의 hotelCache 캐시에 저장됨
// hotelCache 에 정의된 설정값에 따라 캐시 데이터 관리 (BasicCacheConfig 클래스 참고)
// BasicCacheConfig 에서 hotelCache 캐시의 TTL 은 30분으로 설정함
// 미리 설정된 캐시가 없다면 CacheManager 의 기본 설정에 따라 캐시를 생성하고 데이터 저장
@Cacheable(value = "hotelCache")  // 캐시 이름을 hotelCache 로 설정
// 리턴되는 HotelResponse 객체를 사용하여 캐시 데이터 생성
public HotelResponse getHotelById(Long hotelId) { // Long HotelId 메서드 인자의 toString() 을 사용하여 캐시 key 생성
  return new HotelResponse(hotelId, "ASSU Hotel", "seoul");
}

package com.assu.study.chap10.service;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.ToString;

@AllArgsConstructor
@NoArgsConstructor
@Getter
@ToString
public class HotelResponse {
  private Long hotelId;
  private String hotelName;
  private String hotelAddress;
}

package com.assu.study.chap10.service;

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class HotelService {

 // ...

  @Cacheable(
      value = "hotelCache",
      key = "#hotelName",
      condition = "#hotelName > '' && #hotelAddress.length() > 2"
  )
  public HotelResponse getHotelNameAndAddress(String hotelName, String hotelAddress) {
    return new HotelResponse(1111L, hotelName, hotelAddress);
  }
}

package com.assu.study.chap10.service;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class HotelServiceTest {

  @Autowired
  private HotelService hotelService;

  @Test
  void getHotelNameAndAddress() {
    // key: hotelCache::testHotelName
    // value: "{\"@class\":\"com.assu.study.chap10.service.HotelResponse\",\"hotelId\":1111,\"hotelName\":\"testHotelName\",\"hotelAddress\":\"testHotelAddress\"}"
    hotelService.getHotelNameAndAddress("testHotelName2", "testHotelAddress");
    hotelService.getHotelNameAndAddress("testHotelName2", "t");
  }
}

package com.assu.study.chap10.service;

import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.cache.interceptor.SimpleKeyGenerator;

import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Objects;

public class HotelKeyGenerator implements KeyGenerator {
  private final String PREFIX = "HOTEL::";

  @Override
  // 캐시 key 생성 시 KeyGenerator 구현체가 설정되어 있으면 generate() 메서드를 사용하여 key 생성
  // Object target: 애너테이션이 정의된 클래스 객체
  // Method method: 애너테이션이 정의된 메서드
  // Object... params: 메서드의 인자들
  public Object generate(Object target, Method method, Object... params) {
    if (Objects.isNull(params)) {
      return "NULL";
    }

    return Arrays.stream(params)
            // 인자 중에서 HotelRequest 조회
            .filter(param -> param instanceof HotelRequest)
            .findFirst()
            // HotelRequest 클래스 타입인 인자가 있으면 HOTEL:: 문자열과 hotelRequest 객체의 hotelId 값을 결합하여 key 생성
            .map(obj -> (HotelRequest) obj)
            .map(hotelRequest -> PREFIX + hotelRequest.getHotelId())
            // HotelRequest 클래스 타입인 객체가 없다면 스프링 프레임워크에서 기본으로 사용하는 SimpleKeyGenerator 로 캐시 key 생성
            .orElse(SimpleKeyGenerator.generateKey(params).toString());
  }
}

package com.assu.study.chap10.config;

import com.assu.study.chap10.service.HotelKeyGenerator;
import io.lettuce.core.ClientOptions;
import io.lettuce.core.SocketOptions;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;
import java.util.HashMap;
import java.util.Map;

@Configuration
@EnableCaching
public class BasicCacheConfig {
// ...

  @Bean
  public HotelKeyGenerator hotelKeyGenerator() {
    return new HotelKeyGenerator();
  }
}

package com.assu.study.chap10.service;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class HotelServiceTest {

  @Autowired
  private HotelService hotelService;

// ...

  @Test
  void getHotel() {
    // key: hotelCache::HOTEL::2222
    // value: "{\"@class\":\"com.assu.study.chap10.service.HotelResponse\",\"hotelId\":2222,\"hotelName\":\"ASSU2\",\"hotelAddress\":\"seoul2\"}"
    HotelRequest request = new HotelRequest(2222L);
    hotelService.getHotel(request);
  }
}

@Caching(cacheable = {
    @Cacheable(value="primaryHotelCache", keyGenerator="hotelKeyGenerator"),
    @Cacheable(value="secondHotelCache", keyGenerator="hotelKeyGenerator")
})
public HotelResponse getHotel(HotelRequest hotelRequest) {
  // ...  
}