ZSetOperations<String, Long> zSetOperations = redisTemplate.opsForZSet();

package com.assu.study.chap10.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericToStringSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Slf4j
@Configuration
public class BiddingConfig {
  @Bean
  public RedisConnectionFactory biddingRedisConnectionFactory() {
    RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration("127.0.0.1", 6379);
    return new LettuceConnectionFactory(configuration);
  }

  @Bean(name = "biddingRedisTemplate")
  public RedisTemplate<String, Long> biddingRedisTemplate() {
    // RedisTemplate 는 제네릭 타입 K,V 설정 가능
    // 첫 번째는 레디스 key 에 해당하고, 두 번째는 레디스 value 에 해당함
    // 경매에 참여한 유저 아이디를 저장하기 때문에 value 를 Long 타입으로 설정
    RedisTemplate<String, Long> biddingRedisTemplate = new RedisTemplate<>();
    biddingRedisTemplate.setConnectionFactory(biddingRedisConnectionFactory());

    // key 와 value 값을 직렬화/역직렬화하는 RedisSerializer 구현체 설정
    biddingRedisTemplate.setKeySerializer(new StringRedisSerializer());
    biddingRedisTemplate.setValueSerializer(new GenericToStringSerializer<>(Long.class));

    return biddingRedisTemplate;
  }
}

package com.assu.study.chap10.adapter.bidding;

import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.stream.Collectors;

@Component
@Slf4j
public class BiddingAdapter {
  private final String PREFIX = "HOTEL-BIDDING::";
  private final RedisTemplate<String, Long> biddingRequestTemplate;

  public BiddingAdapter(RedisTemplate<String, Long> biddingRequestTemplate) {
    this.biddingRequestTemplate = biddingRequestTemplate;
  }

  // 이벤트에 참가하는 호텔 아이디를 사용하여 Sorted Set 의 key 를 생성
  // 별도의 RedisSerializer 구현체를 생성하지 않고 이렇게 해도 됨
  private String serializeKey(Long hotelId) {
    return PREFIX + hotelId;
  }

  // 입찰에 참여할 호텔 아이디, 사용자 아이디, 비딩 금액을 받음
  public Boolean createBidding(Long hotelId, Long userId, Double amount) {
    String key = this.serializeKey(hotelId);

    // ZSetOperations 의 add() 메서드를 사용하여 호텔 아이디를 포함한 key, userId 에 value 와 비딩 금액을 score 로 저장
    return biddingRequestTemplate.opsForZSet().add(key, userId, amount);
  }

  // 입찰에 참여한 사용자들의 비딩 금액을 역순으로 정렬한 후 fetchCount 만큼 참가자의 아이디를 리스트 객체로 리턴
  public List<Long> getTopBidders(Long hotelId, Integer fetchCount) {
    String key = this.serializeKey(hotelId);

    // 비딩 금액이 높은 순으로 정렬해야 하기 때문에 score 를 역순으로 조회하는 reverseRangeByScore() 사용
    // 이 때 score 범위를 인자로 설정할 수 있는데 두 번째 인자인 최소값 0D 부터 최대값 Double.MAX_VALUE 까지 설정
    // 네 번째 인자는 순서 인덱스로 0 부터 fetchCount 개수만큼 조회함
    return biddingRequestTemplate
            .opsForZSet()
            .reverseRangeByScore(key, 0D, Double.MAX_VALUE, 0, fetchCount)
            .stream()
            .collect(Collectors.toList());
  }

  // 참여자가 입찰한 금액 조회
  public Double getBigAmount(Long hotelId, Long userId) {
    String key = this.serializeKey(hotelId);

    // score() 로 score 값 조회
    // 따라서 score 에 저장한 입찰 금액 리턴
    return biddingRequestTemplate.opsForZSet().score(key, userId);
  }

  public void clear(Long hotelId) {
    String key = this.serializeKey(hotelId);
    biddingRequestTemplate.delete(key);
  }
}

package com.assu.study.chap10.adapter.bidding;

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

import java.util.List;

@SpringBootTest
class BiddingAdapterTest {
    private final Long firstUserId = 1L;
    private final Long secondUserId = 2L;
    private final Long thirdUserId = 3L;
    private final Long fourthUserId = 4L;
    private final Long fifthUserId = 5L;
    private final Long hotelId = 1000L;

    @Autowired
    private BiddingAdapter biddingAdapter;

    @Test
    public void simulate() {
        biddingAdapter.clear(hotelId);

        biddingAdapter.createBidding(hotelId, firstUserId, 100d);
        biddingAdapter.createBidding(hotelId, secondUserId, 110d);
        biddingAdapter.createBidding(hotelId, thirdUserId, 120d);
        biddingAdapter.createBidding(hotelId, fourthUserId, 130d);
        biddingAdapter.createBidding(hotelId, fifthUserId, 150d);

        biddingAdapter.createBidding(hotelId, secondUserId, 160d);
        biddingAdapter.createBidding(hotelId, firstUserId, 200d);

        List<Long> topBidders = biddingAdapter.getTopBidders(hotelId, 3);

        Assertions.assertEquals(firstUserId, topBidders.get(0));
        Assertions.assertEquals(secondUserId, topBidders.get(1));
        Assertions.assertEquals(fifthUserId, topBidders.get(2));

        Assertions.assertEquals(200d, biddingAdapter.getBigAmount(hotelId, firstUserId));
        Assertions.assertEquals(160d, biddingAdapter.getBigAmount(hotelId, secondUserId));
        Assertions.assertEquals(150d, biddingAdapter.getBigAmount(hotelId, fifthUserId));
    }
}