Redis 직렬화 전략 — JSON, 바이너리, 커스텀 직렬화의 트레이드오프

public interface RedisSerializer<T> {
    byte[] serialize(T value);    // 객체 → 바이트
    T deserialize(byte[] bytes);  // 바이트 → 객체
}

// 별도 설정 없이 RedisTemplate을 사용하면 이 직렬화기가 적용됨
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(factory);
    // 기본값: JdkSerializationRedisSerializer
    return template;
}

127.0.0.1:6379> GET "\xac\xed\x00\x05t\x00\x04user:1"
"\xac\xed\x00\x05sr\x00\x1ecom.example.dto.UserDto..."

template.setKeySerializer(new StringRedisSerializer());

127.0.0.1:6379> GET "user:1"
"심정훈"

// 특정 클래스를 명시해야 함
Jackson2JsonRedisSerializer<UserDto> serializer =
    new Jackson2JsonRedisSerializer<>(UserDto.class);

template.setValueSerializer(serializer);

{"id": 1, "name": "심정훈", "email": "test@example.com"}

GenericJackson2JsonRedisSerializer serializer =
    new GenericJackson2JsonRedisSerializer();

template.setValueSerializer(serializer);

{
  "@class": "com.example.dto.UserDto",
  "id": 1,
  "name": "심정훈",
  "email": "test@example.com"
}

// 보안 강화: 허용 타입을 명시적으로 제한
ObjectMapper mapper = new ObjectMapper();
mapper.activateDefaultTyping(
    mapper.getPolymorphicTypeValidator(),
    ObjectMapper.DefaultTyping.NON_FINAL,
    JsonTypeInfo.As.PROPERTY
);

// Kryo 기반 커스텀 RedisSerializer 예시
public class KryoRedisSerializer<T> implements RedisSerializer<T> {

    private static final ThreadLocal<Kryo> kryoLocal = ThreadLocal.withInitial(() -> {
        Kryo kryo = new Kryo();
        kryo.setRegistrationRequired(false);
        return kryo;
    });

    @Override
    public byte[] serialize(T value) {
        if (value == null) return new byte[0];
        Output output = new Output(1024, -1);
        kryoLocal.get().writeClassAndObject(output, value);
        return output.toBytes();
    }

    @Override
    @SuppressWarnings("unchecked")
    public T deserialize(byte[] bytes) {
        if (bytes == null || bytes.length == 0) return null;
        Input input = new Input(bytes);
        return (T) kryoLocal.get().readClassAndObject(input);
    }
}

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        // 키는 문자열로 — CLI에서 읽을 수 있도록
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());

        // 값은 JSON으로 — 가독성과 유연성 확보
        GenericJackson2JsonRedisSerializer jsonSerializer =
            new GenericJackson2JsonRedisSerializer();
        template.setValueSerializer(jsonSerializer);
        template.setHashValueSerializer(jsonSerializer);

        return template;
    }
}

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory factory) {
        // Jackson ObjectMapper 커스터마이징
        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(new JavaTimeModule()); // LocalDateTime 지원
        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

        GenericJackson2JsonRedisSerializer serializer =
            new GenericJackson2JsonRedisSerializer(mapper);

        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .serializeKeysWith(
                RedisSerializationContext.SerializationPair
                    .fromSerializer(new StringRedisSerializer()))
            .serializeValuesWith(
                RedisSerializationContext.SerializationPair
                    .fromSerializer(serializer))
            .entryTtl(Duration.ofMinutes(30)); // 기본 TTL 30분

        return RedisCacheManager.builder(factory)
            .cacheDefaults(config)
            .build();
    }
}

// 새 직렬화기로 읽기 시도 → 실패 시 이전 직렬화기로 fallback
public <T> T getWithFallback(String key, Class<T> type) {
    try {
        return newSerializer.deserialize(redisOps.get(key));
    } catch (SerializationException e) {
        // 이전 직렬화기로 재시도
        T value = oldSerializer.deserialize(redisOps.get(key));
        // 새 직렬화 방식으로 덮어쓰기 (점진적 마이그레이션)
        redisOps.set(key, newSerializer.serialize(value));
        return value;
    }
}

v1:user:1  → JDK 직렬화로 저장된 데이터
v2:user:1  → JSON으로 저장된 데이터