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

Redis를 활용한 캐싱 구현! (짧고 간단한 영상)

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

동영상

소스

application.yml

server:
  port: 9090
  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: create #create update none
      naming:
        physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
    show-sql: true

  # Redis 세션 설정
  session:
    store-type: redis   # 세션을 Redis에 저장
    redis:
      namespace: session   # Redis에 저장할 세션 데이터의 네임스페이스
      timeout: 1800  # 세션 타임아웃 (초 단위)

# 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-web'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    // Logging
    implementation 'org.bgee.log4jdbc-log4j2:log4jdbc-log4j2-jdbc4.1:1.16'
    // redis
    implementation 'org.springframework.boot:spring-boot-starter-data-redis'
    // swagger
    implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.0.2'
    // cache
    implementation 'org.springframework.boot:spring-boot-starter-cache'
    compileOnly 'org.projectlombok:lombok'
    developmentOnly 'org.springframework.boot:spring-boot-devtools'
    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.rediscashing.user.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.rediscashing.user.controller;

import com.lsy.rediscashing.user.model.User;
import com.lsy.rediscashing.user.service.UserService;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/user")
public class UserController {

    private final UserService service;

    public UserController(@Qualifier("userService1") UserService service) {
        this.service = service;
    }

    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return service.getUserData(id);
    }
}

service

package com.lsy.rediscashing.user.service;

import com.lsy.rediscashing.user.model.User;
import com.lsy.rediscashing.user.repository.UserRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service("userService1")
@Slf4j
@RequiredArgsConstructor
public class UserService {

    private final UserRepository repository;
    private final RedisTemplate redisTemplate;

    public User getUserData(Long id) {

        long startTime = System.currentTimeMillis();
        String cacheKey = "user:" + id;

        // 캐시값 조회
        User cachedData = (User) redisTemplate.opsForValue().get(cacheKey);
        // 캐시값이 있으면 케시값 반환
        if (cachedData != null) {
            log.info("redis data exist~");
            long endTime = System.currentTimeMillis(); // 끝 시간 측정
            long elapsedTime = endTime - startTime; // 시간 차이 (밀리초 단위)
            log.info("Cache retrieval time: {} ms", elapsedTime);
            return cachedData;
        }

        // 캐시값이 없으면 db에서 조회
        log.info("redis data not exist~");
        long dbStartTime = System.currentTimeMillis(); // DB 조회 시작 시간
        User findUser = repository.findById(id).orElse(null);
        // db조회 값이 있으면 레디스에 key, value 저장(만료시간은 400으로)
        if (findUser != null) {
            redisTemplate.opsForValue().set(cacheKey, findUser, 400, TimeUnit.SECONDS);
        }

        long dbEndTime = System.currentTimeMillis(); // DB 조회 끝 시간
        long dbElapsedTime = dbEndTime - dbStartTime; // DB 조회 시간
        long endTime = System.currentTimeMillis(); // 전체 종료 시간
        long totalElapsedTime = endTime - startTime; // 전체 시간

        log.info("DB retrieval time: {} ms", dbElapsedTime);
        log.info("Total time: {} ms", totalElapsedTime);

        return findUser;
    }
}

repository

package com.lsy.rediscashing.user.repository;

import com.lsy.rediscashing.user.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {

}

User

package com.lsy.rediscashing.user.model;

import jakarta.persistence.*;
import lombok.*;
import org.hibernate.annotations.CreationTimestamp;

import java.sql.Timestamp;

@Entity
@Table(name = "user_test")
@Getter @Setter
@NoArgsConstructor
@AllArgsConstructor
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String email;

    @CreationTimestamp
    private Timestamp created_at;

    @Builder
    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }
}

---

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

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

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

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