Spring Redis 기본 설정

Redis, REmote DIctionary Server (원격 사전 서버.. 처음알았음..)

 

주로 아래 용도로 많이 사용했다. 그리고 사용 한다고 한다.

1. 캐싱 - 단순한 캐싱시 @Cacheable 어노테이션이 편리함

2. 세션관리

3. 대기열

4. 분산락 (동시성 문제 - 재고관리, 중복결제, 배치 중복 실행 방지) - RedissonClient 사용

5. 레이트 리미터 (트래픽을 조절해 서비스의 안전성 확보)

 

아래 설정으로 스프링 레디스를 사용할 준비 끝~

 

기본 설정

// build.gradle
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-redis'
    implementation 'org.redisson:redisson-spring-boot-starter' // 분산락 사용시
}

// application.yml
spring:
  data:
    redis:
      host: localhost
      port: 6379
      password: yourpassword  # 필요한 경우
      database: 0
      
// CacheConfig.java
@Configuration
@EnableCaching
public class RedisConfig {
    @Bean
    public RedisConnectionFactory redisConnectionFactory(
            @Value("${spring.data.redis.host}") String host,
            @Value("${spring.data.redis.port}") int port) {
        return new LettuceConnectionFactory(host, port);
    }

    // redisTemplate 사용을 위해
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        
        return template;
    }

    // @Cacheable 사용시 key별 ttl 설정을 위해
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheConfiguration defaultConfig = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(30))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));

        Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<>();
        cacheConfigurations.put("userCache", defaultConfig.entryTtl(Duration.ofMinutes(10)));
        cacheConfigurations.put("productCache", defaultConfig.entryTtl(Duration.ofHours(1)));
        cacheConfigurations.put("orderCache", defaultConfig.entryTtl(Duration.ofDays(1)));

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

 

 

서비스에서 사용 방법

@Service
@RequiredArgsConstructor
public class UserService {
    private final RedisTemplate<String, Object> redisTemplate;
    
    @Cacheable(value = "userCache", key = "#userId")
    public User getUserById(Long userId) {
        // DB 조회 로직
        return findUserFromDatabase(userId);
    }

    @Cacheable(value = "userCache", key = "'user:' + #userId + ':profile'")
    public UserProfile getUserProfile(Long userId) {
        return findUserProfileFromDatabase(userId);
    }

    // RedisTemplate 직접 활용 예제
    public void setUserData(String key, User user) {
        redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
    }

    public User getUserData(String key) {
        return (User) redisTemplate.opsForValue().get(key);
    }

    // Hash 타입 활용
    public void setUserHash(String key, String field, Object value) {
        redisTemplate.opsForHash().put(key, field, value);
    }

    public Object getUserHash(String key, String field) {
        return redisTemplate.opsForHash().get(key, field);
    }

    // 캐시 삭제
    @CacheEvict(value = "userCache", key = "#userId")
    public void deleteUserCache(Long userId) {
    }
    
    public void deleteKey(String key) {
        redisTemplate.delete(key);
    }
}