스프링(Spring) Redis 연동 정리(설치, 설정)

                                    저는 기존 MySQL과 같은 DB는 무조건 Disk에 in-memory DB는 무조건 Memory에 저장되는 줄 알았습니다.
하지만 MySQL과 같은 DB도 memory에 올려서 사용합니다.

💡 중요한건 Redis는 서버일 뿐이며, 개발자가 직접적으로 Memory에 데이터를 올려다 쓰는 개념이
아니라는 점이 중요합니다.

                                    💡 String, BitMap, hashs, set, sorted set과 같은 다양한 자료구조를 가집니다.

                                    sudo apt update
sudo apt install lsb-release curl -y

                                    // Redis GPG 키 등록 Redis 저장소 추가
curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list

                                    // 저장소 목록 업데이트 후 Redis 설치
sudo apt update
sudo apt install redis -y

                                    // 설치 확인
redis-server --version

                                    // conf 파일 열기
sudo nano /etc/redis/redis.conf

                                    // 🔑 설정하기

// 외부 포트 열기
bind = 0.0.0.0

// pw 설정하기
protected-mode yes
requirepass [pw 설정]

                                    // 재시작 명령어
sudo sytemctl restart redis-server.service

                                    // redis 실행 테스트
redis-cli -h [hostserver ip] -P 6379
AUTH [pw]

ping -> pong 응답시 서버 정상 작동

                                    spring:
  data:
    redis:
      host: [linux server ip]
      port: 6379
      password: [redis conf에 설정한 pw]

                                    👉 현재 로직
* User Profile에 해당하는 DTO를 클라이언트가 전달받는 상황

1. Clinet의 요청에 FrontServer는 DB에서 Entity를 찾고 이후 dto를 만들어 client에게 전달한다
- dto를 만드는 과정에서 api 호출이 들어감 (user 팔로잉, 팔로워 수 등)

                                    👉 Redis가 도입된 이후 로직

1. Client의 요청에 FrontServer는 우선적으로 Redis에서 Dto를 찾는다.
-- DTO가 존재한다면 바로 Client에게 전달한다.

2. DTO가 없다면 기존 로직 처럼 dto를 만들어서 보낸다.
-- 보낸 이후에 해당 user에 대한 dto를 redis Server로 전달하여 저장한다.

                                    package com.example.frontServer.service.user

import com.example.frontServer.dto.user.response.UserProfileGetResult
import com.fasterxml.jackson.databind.ObjectMapper
import io.github.oshai.kotlinlogging.KotlinLogging
import org.springframework.data.redis.core.RedisTemplate
import org.springframework.stereotype.Service

@Service
class RedisUserService(
    private val objectMapper: ObjectMapper,
    private val redisTemplate: RedisTemplate<String, String>
) {
    private val logger = KotlinLogging.logger {}

    fun save(redisDto: UserProfileGetResult) {
        val json = objectMapper.writeValueAsString(redisDto)
        redisTemplate.opsForValue().set("user:profile:${redisDto.id}", json)
    }

    fun findByUserId(userId: Long): UserProfileGetResult? {
        val key = "user:profile:${userId}"
        val json: String? = redisTemplate.opsForValue().get(key)

        return json?.let {
            objectMapper.readValue(it, UserProfileGetResult::class.java)
        }?: run {
            logger.error { "can't find user- id: $userId" }
            null
        }
    }
}

// in board Service
@Transactional
    fun findMainUserProfile(request: UserProfileGetRequest): UserProfileGetResult{
        // first find in redis
        val cachedResult = redisUserService.findByUserId(request.userId)
        cachedResult?.let {
            return it
        }

        // find user
        val user = userRepository.findById(request.userId).orElse(null)

        // find following, follower count
        if (user != null) {
            val newProfileResult = UserProfileGetResult.of(
                user,
                userFollowService.findFollowCount(request.userId)
            )

            // save in redis
            redisUserService.save(newProfileResult)

            return newProfileResult

        } else {
            throw NotFoundEntityException(
                entityType = EntityType.USER.code,
                id = request.userId
            )
        }
    }

                                    👉 key의 경우 Redis Insight와 같은 도구들에서 : 을 기준으로 데이터를 분류해 줍니다.
실제 개발자들은 key를 : 로 구분해서 넣는 경우가 많다고 합니다.

공식적인 규칙은 아니지만, 실제 업무상에서 암묵적으로 만들어진 규칙이라고 보시면 됩니다.

                                    👉 noeviction: 메모리 초과시 새로운 데이터 쓰기를 거부합니다.

👉 allkeys-lru: 모든 키를 대상으로 최근에 덜 사용한 데이터를 우선 삭제합니다.

👉🔑 volatile-lru : TTL이 설정된 키를 대상으로 최근에 가장 덜 삭제된 키를 삭제합니다.

👉 allkeys-random: key를 random으로 삭제합니다

👉 volatile-random: TTL이 설정된 키를 대상으로 random 삭제합니다.

👉 volatile = TTL이 가장 짧은 키부터 삭제합니다.

                                    fun save(redisDto: UserProfileGetResult) {
        val json = objectMapper.writeValueAsString(redisDto)
        redisTemplate.opsForValue().set("user:profile:${redisDto.id}", json, 60, TimeUnit.MINUTES)
    }

                                    👉 Hash를 사용하면 다음과 같이 데이터가 저장된다고 보면 된다.

{
   // key
  "user:100": { //value
    "name": "Alice",
    "age": "30",
    "email": "alice@example.com"
  }
}

😯 근데 문제는 Transaction 지원이 안되기 때문에 각 필드의 값이 모두 개별적으로 전달된다.
-- 이는 서버에 과한 오버헤드를 야기한다.