DEVOCEAN

//Spring Cahce 
	implementation("org.springframework.boot:sprng-boot-starter-cache")

@Configuration : Bean 설정
@EnableCaching : Spring Cache 사용 설정
@Cacheable : 조회 시 캐시를 먼저 확인하고, 없는 경우 DB 조회해서 결과 생성
@CachePut : 최초 호출 시 캐시 정보 저장, 재호출 시 갱신
@CacheEvict : 캐시 정보 삭제 설정

dependencies {
	implementation("org.springframework.boot:spring-boot-starter-data-redis")
}

    @Bean
    fun cacheConfiguration(): RedisCacheConfiguration {
        return RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofSeconds(10))
            .disableCachingNullValues()
            .serializeKeysWith(SerializationPair.fromSerializer(StringRedisSerializer()))
            .serializeValuesWith(SerializationPair.fromSerializer(GenericJackson2JsonRedisSerializer()))
    }

    @Bean
    fun redisCacheManagerBuilderCustomizer(): RedisCacheManagerBuilderCustomizer {
        return RedisCacheManagerBuilderCustomizer {
            it.withCacheConfiguration(
                "userCache",
                RedisCacheConfiguration.defaultCacheConfig()
                    .entryTtl(Duration.ofSeconds(10))
            )
            it.withCacheConfiguration(
                "projectCache",
                RedisCacheConfiguration.defaultCacheConfig()
                    .entryTtl(Duration.ofSeconds(50))
            )
        }
    }

spring.cache.type=redis
spring.data.redis.host=localhost
spring.data.redis.port=6379

@Cacheable(cacheNames = ["userCache"], key="#id")
    fun findUserById(id: String): User? = userRepository.findUserById(id)

//HazelCast
	implementation("com.hazelcast:hazelcast:5.3.5") //CVE 땜에 5.3.5로 변경
	implementation("com.hazelcast:hazelcast-spring:5.0")

    //HazelCast 설정
    @Bean
    fun hazelcastConfig(): Config {
        val config = Config()
        config.networkConfig = NetworkConfig().apply {
            join.tcpIpConfig.isEnabled = true
            join.tcpIpConfig.addMember("127.0.0.1")
            join.multicastConfig.isEnabled = true
        }
        config.addMapConfig(
            MapConfig().apply {
                name = "user_hazel"
                timeToLiveSeconds = 10
                backupCount = 1
            }
        )
        config.serializationConfig.addSerializerConfig(
            SerializerConfig()
                .setTypeClass(User::class.java)
                .setImplementation(CustomJsonSerializer())

        )
        return config
    }
    @Bean
    fun hazelcastInstance(config: Config): HazelcastInstance {
        return Hazelcast.newHazelcastInstance(config)
    }
    @Bean("hazelcast")
    fun hazelCacheManager(hazelcastInstance: HazelcastInstance): HazelcastCacheManager {
        return HazelcastCacheManager(hazelcastInstance)
    }

public interface StreamSerializer<T> extends Serializer {
    void write(@Nonnull ObjectDataOutput var1, @Nonnull T var2) throws IOException;

    @Nonnull
    T read(@Nonnull ObjectDataInput var1) throws IOException;
}

class CustomJsonSerializer : StreamSerializer<User>{
		//json 처리 담당
    private val objectMapper: ObjectMapper = jacksonObjectMapper()

    override fun getTypeId(): Int {
        return 1
    }

    override fun destroy() {
        // No - op
        // 자원 해제 코드(필요한 경우)
    }


		//역직렬화 바이트 -> 객체 User
    override fun read(input: ObjectDataInput): User {
        val readString = input.readString()
        return objectMapper.readValue(readString, User::class.java)
    }

    override fun write(output: ObjectDataOutput, data: User) {
        output.writeString(objectMapper.writeValueAsString(data))
    }
}

@Cacheable(cacheManager = "hazelcast", cacheNames = ["user_hazel"])
fun findUserById(id: String): User? = userRepository.findUserById(id)

//Caffein 라이브러리 추가
implementation("com.github.ben-manes.caffeine:caffeine:3.1.6")

@Bean
    fun caffeineConfig(): Caffeine<Any, Any> {
        // Caffeine 빌더를 이용하기 위해서 newBuilder() 를 이용한다.
        // exipreAfterWrite를 이용하여 캐시 저장 시간을 20초 으로 지정한다.
        // maximumSize: 캐시 최대 저장 크기를 지정한다. (음수는 될 수 없다. 0이면 바로 삭제된다.)
        return Caffeine.newBuilder()
            .expireAfterWrite(20, TimeUnit.SECONDS)
            .maximumSize(100)
    }
    
    @Bean("caffeine")
    fun caffeineCacheManager(caffeine: Caffeine<Any, Any>): CaffeineCacheManager {
        val cacheManager = CaffeineCacheManager()
        cacheManager.setCaffeine(caffeine)
        return cacheManager
    }

@Cacheable(cacheManager = "caffeine", cacheNames = ["user"])
    fun findUserById(id: String): User? = userRepository.findUserById(id)