1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
@Service
@RequiredArgsConstructor
public class UserService {
    private final UserRepository userRepository;
    private final RedisTemplate<String, User> redisTemplate;

    public User getUser(Long userId) {
        String key = "user:" + userId;

        // 1. 캐시 조회
        User cached = redisTemplate.opsForValue().get(key);
        if (cached != null) {
            return cached;  // Cache Hit
        }

        // 2. DB 조회 (Cache Miss)
        User user = userRepository.findById(userId)
                .orElseThrow(() -> new UserNotFoundException(userId));

        // 3. 캐시에 저장
        redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));

        return user;
    }

    public User updateUser(Long userId, UserUpdateRequest request) {
        User user = userRepository.findById(userId)
                .orElseThrow(() -> new UserNotFoundException(userId));
        user.update(request);
        userRepository.save(user);

        // 캐시 무효화 (Invalidation)
        redisTemplate.delete("user:" + userId);

        return user;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public User getUserWithLock(Long userId) {
    String key = "user:" + userId;
    String lockKey = "lock:" + key;

    User cached = redisTemplate.opsForValue().get(key);
    if (cached != null) {
        return cached;
    }

    // 락 획득 시도
    Boolean acquired = redisTemplate.opsForValue()
            .setIfAbsent(lockKey, "1", Duration.ofSeconds(5));

    if (Boolean.TRUE.equals(acquired)) {
        try {
            // 더블 체크 (락 대기 중 다른 스레드가 캐시를 채웠을 수 있음)
            cached = redisTemplate.opsForValue().get(key);
            if (cached != null) return cached;

            User user = userRepository.findById(userId).orElseThrow();
            redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
            return user;
        } finally {
            redisTemplate.delete(lockKey);
        }
    } else {
        // 락 획득 실패 → 잠시 대기 후 재시도
        Thread.sleep(50);
        return getUserWithLock(userId);
    }
}

1
2
3
4
// TTL에 랜덤 값을 추가하여 동시 만료 방지
int baseTtl = 1800; // 30분
int jitter = ThreadLocalRandom.current().nextInt(0, 300); // 0~5분 랜덤
redisTemplate.opsForValue().set(key, user, Duration.ofSeconds(baseTtl + jitter));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public User getUser(Long userId) {
    String key = "user:" + userId;
    ValueOperations<String, Object> ops = redisTemplate.opsForValue();

    Object cached = ops.get(key);
    if (cached != null) {
        if (cached instanceof NullValue) return null;  // 캐싱된 null
        return (User) cached;
    }

    User user = userRepository.findById(userId).orElse(null);

    if (user != null) {
        ops.set(key, user, Duration.ofMinutes(30));
    } else {
        // null도 캐싱 (짧은 TTL)
        ops.set(key, NullValue.INSTANCE, Duration.ofMinutes(5));
    }

    return user;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Bloom Filter로 존재하지 않는 키를 사전 차단
@PostConstruct
public void initBloomFilter() {
    // 모든 유효한 사용자 ID를 Bloom Filter에 등록
    List<Long> allUserIds = userRepository.findAllIds();
    allUserIds.forEach(id -> bloomFilter.add("user:" + id));
}

public User getUser(Long userId) {
    String key = "user:" + userId;

    // Bloom Filter에 없으면 확실히 존재하지 않음
    if (!bloomFilter.mightContain(key)) {
        return null;  // DB 조회 자체를 하지 않음
    }

    // 이후 일반적인 Cache Aside 로직
    // ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// 다단계 캐시: Local Cache (Caffeine) → Redis → DB
@Service
public class MultiLevelCacheService {
    private final Cache<String, User> localCache = Caffeine.newBuilder()
            .maximumSize(10_000)
            .expireAfterWrite(Duration.ofMinutes(5))
            .build();

    private final RedisTemplate<String, User> redisTemplate;
    private final UserRepository userRepository;

    public User getUser(Long userId) {
        String key = "user:" + userId;

        // L1: 로컬 캐시
        User user = localCache.getIfPresent(key);
        if (user != null) return user;

        // L2: Redis
        user = redisTemplate.opsForValue().get(key);
        if (user != null) {
            localCache.put(key, user);
            return user;
        }

        // L3: DB
        user = userRepository.findById(userId).orElseThrow();
        redisTemplate.opsForValue().set(key, user, Duration.ofMinutes(30));
        localCache.put(key, user);
        return user;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
@Configuration
public class RedisConfig {

    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        return new LettuceConnectionFactory();
    }

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

        // 키는 String 직렬화
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());

        // 값은 JSON 직렬화 (GenericJackson2 사용)
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.registerModule(new JavaTimeModule());
        objectMapper.activateDefaultTyping(
                objectMapper.getPolymorphicTypeValidator(),
                ObjectMapper.DefaultTyping.NON_FINAL
        );

        GenericJackson2JsonRedisSerializer jsonSerializer =
                new GenericJackson2JsonRedisSerializer(objectMapper);

        template.setValueSerializer(jsonSerializer);
        template.setHashValueSerializer(jsonSerializer);

        template.afterPropertiesSet();
        return template;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
@Service
@RequiredArgsConstructor
public class ProductCacheService {
    private final RedisTemplate<String, Object> redisTemplate;

    // String 타입
    public void cacheProduct(Product product) {
        redisTemplate.opsForValue()
                .set("product:" + product.getId(), product, Duration.ofHours(1));
    }

    public Product getProduct(Long id) {
        return (Product) redisTemplate.opsForValue().get("product:" + id);
    }

    // Hash 타입
    public void cacheProductAsHash(Product product) {
        String key = "product:hash:" + product.getId();
        redisTemplate.opsForHash().put(key, "name", product.getName());
        redisTemplate.opsForHash().put(key, "price", product.getPrice().toString());
        redisTemplate.expire(key, Duration.ofHours(1));
    }

    // Sorted Set (랭킹)
    public void addToRanking(Long productId, double score) {
        redisTemplate.opsForZSet()
                .add("ranking:products", "product:" + productId, score);
    }

    public Set<Object> getTopProducts(int count) {
        return redisTemplate.opsForZSet()
                .reverseRange("ranking:products", 0, count - 1);
    }

    // Set (좋아요)
    public void likeProduct(Long userId, Long productId) {
        redisTemplate.opsForSet()
                .add("likes:product:" + productId, userId.toString());
    }

    public Long getLikeCount(Long productId) {
        return redisTemplate.opsForSet().size("likes:product:" + productId);
    }

    public boolean hasLiked(Long userId, Long productId) {
        return Boolean.TRUE.equals(redisTemplate.opsForSet()
                .isMember("likes:product:" + productId, userId.toString()));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(30))
                .serializeKeysWith(
                    RedisSerializationContext.SerializationPair
                        .fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(
                    RedisSerializationContext.SerializationPair
                        .fromSerializer(new GenericJackson2JsonRedisSerializer()))
                .disableCachingNullValues();

        return RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(config)
                .withCacheConfiguration("users",
                    config.entryTtl(Duration.ofHours(1)))
                .withCacheConfiguration("products",
                    config.entryTtl(Duration.ofMinutes(10)))
                .build();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
@Service
@RequiredArgsConstructor
public class UserService {
    private final UserRepository userRepository;

    @Cacheable(value = "users", key = "#userId")
    public User getUser(Long userId) {
        // Cache Miss 시에만 실행
        return userRepository.findById(userId)
                .orElseThrow(() -> new UserNotFoundException(userId));
    }

    @CachePut(value = "users", key = "#result.id")
    public User updateUser(Long userId, UserUpdateRequest request) {
        User user = userRepository.findById(userId).orElseThrow();
        user.update(request);
        return userRepository.save(user);
    }

    @CacheEvict(value = "users", key = "#userId")
    public void deleteUser(Long userId) {
        userRepository.deleteById(userId);
    }

    @CacheEvict(value = "users", allEntries = true)
    public void clearUserCache() {
        // 전체 캐시 삭제
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
// Spring에서 Pub/Sub 사용
@Configuration
public class RedisPubSubConfig {

    @Bean
    public MessageListenerAdapter messageListener() {
        return new MessageListenerAdapter(new RedisMessageSubscriber());
    }

    @Bean
    public RedisMessageListenerContainer container(
            RedisConnectionFactory connectionFactory,
            MessageListenerAdapter listenerAdapter) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.addMessageListener(listenerAdapter,
                new ChannelTopic("chat:room1"));
        return container;
    }
}

public class RedisMessageSubscriber implements MessageListener {
    @Override
    public void onMessage(Message message, byte[] pattern) {
        String channel = new String(message.getChannel());
        String body = new String(message.getBody());
        log.info("채널: {}, 메시지: {}", channel, body);
    }
}

// 메시지 발행
@Service
@RequiredArgsConstructor
public class ChatService {
    private final RedisTemplate<String, String> redisTemplate;

    public void sendMessage(String room, String message) {
        redisTemplate.convertAndSend("chat:" + room, message);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
@Service
@RequiredArgsConstructor
public class OrderService {
    private final RedissonClient redissonClient;
    private final OrderRepository orderRepository;
    private final StockRepository stockRepository;

    public void createOrder(Long productId, int quantity) {
        RLock lock = redissonClient.getLock("lock:product:" + productId);

        try {
            // 락 획득 시도 (최대 10초 대기, 락 유지 30초)
            boolean acquired = lock.tryLock(10, 30, TimeUnit.SECONDS);

            if (!acquired) {
                throw new RuntimeException("락 획득 실패");
            }

            // 재고 확인 및 차감 (동시성 보장)
            Stock stock = stockRepository.findByProductId(productId);
            if (stock.getQuantity() < quantity) {
                throw new InsufficientStockException();
            }
            stock.decrease(quantity);
            stockRepository.save(stock);

            // 주문 생성
            Order order = Order.create(productId, quantity);
            orderRepository.save(order);

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("락 대기 중 인터럽트", e);
        } finally {
            // 락 해제 (본인이 잡은 락만 해제)
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DistributedLock {
    String key();                    // SpEL 표현식
    long waitTime() default 5;       // 락 대기 시간 (초)
    long leaseTime() default 10;     // 락 유지 시간 (초)
    TimeUnit timeUnit() default TimeUnit.SECONDS;
}

@Aspect
@Component
@RequiredArgsConstructor
public class DistributedLockAspect {
    private final RedissonClient redissonClient;
    private final ExpressionParser parser = new SpelExpressionParser();

    @Around("@annotation(distributedLock)")
    public Object around(ProceedingJoinPoint joinPoint,
                         DistributedLock distributedLock) throws Throwable {

        String key = parseKey(distributedLock.key(), joinPoint);
        RLock lock = redissonClient.getLock("lock:" + key);

        try {
            boolean acquired = lock.tryLock(
                    distributedLock.waitTime(),
                    distributedLock.leaseTime(),
                    distributedLock.timeUnit()
            );

            if (!acquired) {
                throw new RuntimeException("분산 락 획득 실패: " + key);
            }

            return joinPoint.proceed();
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }

    private String parseKey(String expression, ProceedingJoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        EvaluationContext context = new StandardEvaluationContext();
        String[] paramNames = signature.getParameterNames();
        Object[] args = joinPoint.getArgs();
        for (int i = 0; i < paramNames.length; i++) {
            context.setVariable(paramNames[i], args[i]);
        }
        return parser.parseExpression(expression).getValue(context, String.class);
    }
}

// 사용 예시
@Service
public class StockService {
    @DistributedLock(key = "'product:' + #productId")
    public void decreaseStock(Long productId, int quantity) {
        Stock stock = stockRepository.findByProductId(productId);
        stock.decrease(quantity);
        stockRepository.save(stock);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
@Configuration
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 1800)
public class SessionConfig {
    // 별도 설정 없이도 HttpSession이 자동으로 Redis에 저장
}

// 사용 예시 — 기존 HttpSession 코드 그대로
@RestController
public class LoginController {
    @PostMapping("/login")
    public ResponseEntity<?> login(HttpSession session,
                                    @RequestBody LoginRequest request) {
        User user = authService.authenticate(request);
        session.setAttribute("user", user);
        return ResponseEntity.ok("로그인 성공");
    }

    @GetMapping("/me")
    public ResponseEntity<?> me(HttpSession session) {
        User user = (User) session.getAttribute("user");
        if (user == null) {
            return ResponseEntity.status(401).body("인증 필요");
        }
        return ResponseEntity.ok(user);
    }
}