Spring Boot + Redis로 실시간 랭킹 구현 (테스트 영상 & 소스 코드 포함)

Redis를 활용한 실시간 랭킹 구현! (짧고 간단한 영상)

역시나 레디스 공부한 것 까먹기 싫어 기록으로 남긴다.

동영상

소스

application.yml

server:
  port: 8081
  servlet:
    context-path: /
    encoding:
      charset: UTF-8
      enabled: true
      force: true

spring:
  cache:
    type: redis
  devtools:
    livereload.enabled: true
    restart.enabled: true
  datasource:
    driver-class-name: net.sf.log4jdbc.sql.jdbcapi.DriverSpy
    url: jdbc:log4jdbc:mysql://localhost:3309/db명
    hikari:
      username: 사용자
      password: 비밀번호
      connectionTimeout: 10000
      maximum-pool-size: 15
      max-lifetime: 600000
      readOnly: false
      connection-test-query: SELECT 1
  jpa:
    hibernate:
      ddl-auto: update #create update none
      naming:
        physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
    show-sql: true
# Redis 설정 추가
data:
  redis:
    host: localhost   # Redis 서버 주소
    port: 6379        # Redis 포트
    password:         # (필요하면 비밀번호 추가)
    timeout: 6000     # 연결 타임아웃 (ms)
    lettuce:
      pool:
        max-active: 8  # 최대 활성 연결 수
        max-idle: 8    # 최대 유휴 연결 수
        min-idle: 0    # 최소 유휴 연결 수
        max-wait: -1   # 최대 대기 시간 (무제한)

build.gradle

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.3.9'
    id 'io.spring.dependency-management' version '1.1.7'
}

group = 'com.lsy'
version = '0.0.1-SNAPSHOT'

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    // Logging
    implementation 'org.bgee.log4jdbc-log4j2:log4jdbc-log4j2-jdbc4.1:1.16'
    // swagger
    implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.0.2'
    // redis
    implementation 'org.springframework.boot:spring-boot-starter-data-redis'
    compileOnly 'org.projectlombok:lombok'
    runtimeOnly 'com.mysql:mysql-connector-j'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}

tasks.named('test') {
    useJUnitPlatform()
}

RedisConfig

package com.lsy.realtimetest1.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.EnableCaching;
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.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
@EnableCaching
public class RedisConfig {

    @Value("${data.redis.host}")
    private String host;
    @Value("${data.redis.port}")
    private int port;

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

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

        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());

        return redisTemplate;
    }
}

controller

package com.lsy.realtimetest1.controller;

import com.lsy.realtimetest1.service.RankService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/rank")
@RequiredArgsConstructor
public class RankController {

    private final RankService service;

    // 점수 추가 API
    @PostMapping("/add")
    public void addScore(@RequestParam String player, @RequestParam double score) {
        service.addScore(player, score);
    }

    // 점수 증가 API
    @PostMapping("/increase")
    public void increaseScore(@RequestParam String player, @RequestParam double score) {
        service.increaseScore(player, score);
    }

    // 상위 랭킹 조회 API
    @GetMapping("/top")
    public List<String> getTopPlayers(@RequestParam(defaultValue = "10") int limit) {
        return service.getTopPlayers(limit);
    }

    // 특정 플레이어 순위 조회 API
    @GetMapping("/rank")
    public Long getPlayerRank(@RequestParam String player) {
        return service.getPlayerRank(player);
    }
}

service

package com.lsy.realtimetest1.service;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Service;

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

@Service
@RequiredArgsConstructor
@Slf4j
public class RankService {

    private final RedisTemplate redisTemplate;
    private final String leaderboardKey = "rank";

    // 점수 추가 (ZADD)
    public void addScore(String player, double score) {
        String playerKey = "rank:" + player;  // playerID에 "rank:" 접두어 추가
        redisTemplate.opsForZSet().add(leaderboardKey, playerKey, score);
    }

    // 점수 증가 (ZINCRBY)
    public void increaseScore(String player, double score) {
        String playerKey = "rank:" + player;  // playerID에 "rank:" 접두어 추가
        redisTemplate.opsForZSet().incrementScore(leaderboardKey, playerKey, score);
    }

    // 상위 랭킹 조회 (ZREVRANGE WITHSCORES)
    public List<String> getTopPlayers(int limit) {
        Set<ZSetOperations.TypedTuple<String>> orgResult =
                redisTemplate.opsForZSet().reverseRangeWithScores(leaderboardKey, 0, limit - 1);

        return orgResult.stream()
                .map(tuple -> tuple.getValue().replace("rank:", "") + " (Score: " + tuple.getScore() + ")")
                .collect(Collectors.toList());
    }

    // 특정 플레이어의 순위 조회 (ZRANK)
    public Long getPlayerRank(String player) {
        String playerKey = "rank:" + player;
        Long rank = redisTemplate.opsForZSet().reverseRank(leaderboardKey, playerKey);
        return (rank != null) ? rank + 1 : null; // 0부터 시작 → 1부터 시작하도록 변환 변환
    }
}

---

개인 스터디 기록을 메모하는 공간이라 틀린점이 있을 수 있습니다.

틀린 점 있을 경우 댓글 부탁드립니다.

Spring Boot + Redis로 세션 공유하기 (테스트 영상 & 소스 코드 포함)

Spring Boot + Redis 캐싱 구현하기 (테스트 영상 & 소스 코드 포함)