[FEAT] elasticache 연결 및 방문자정보(ipAddress 등) 수집 기능 구현

.github/workflows/deploy.yml

@@ -28,6 +28,12 @@ jobs:
           touch ./src/main/resources/application.yml
           echo "${{ secrets.APPLICATION_YML }}" >> src/main/resources/application.yml
 
+      - name: create application-prod.yml file
+        run: echo "${{ secrets.APPLICATION_PROD_YML }}" > src/main/resources/application-prod.yml
+
+      - name: create application-local.yml file
+        run: echo "${{ secrets.APPLICATION_LOCAL_YML }}" > src/main/resources/application-local.yml
+
       - name: Grant execute permission for gradlew
         run: chmod +x ./gradlew
         shell: bash

.gitignore

@@ -41,4 +41,6 @@ out/
 
 .env
 
-src/main/resources/application.yml
+src/main/resources/application.yml
+src/main/resources/application-local.yml
+src/main/resources/application-prod.yml

build.gradle.kts

@@ -78,7 +78,10 @@ dependencies {
     implementation(Dependency.JDSL.SPRING_DATA_JPA_SUPPORTER)
 
     // Discord
-    implementation (Dependency.Discord.WEB_HOOK)
+    implementation(Dependency.Discord.WEB_HOOK)
+
+    // Redis
+    implementation(Dependency.Redis.STARTER_DATA)
 }
 
 kotlin {

buildSrc/src/main/kotlin/Dependency.kt

@@ -69,4 +69,11 @@ object Dependency {
 
         val WEB_HOOK = "$BASE:spring-boot-starter-webflux"
     }
+
+    object Redis {
+        private const val REDIS_VERSION = "2.7.7"
+        private const val BASE = "org.springframework.boot"
+
+        val STARTER_DATA = "$BASE:spring-boot-starter-data-redis:$REDIS_VERSION"
+    }
 }

src/main/kotlin/com/coffee/api/cafe/application/port/outbound/VisitorRepository.kt

@@ -0,0 +1,10 @@
+package com.coffee.api.cafe.application.port.outbound
+
+import com.coffee.api.cafe.infrastructure.persistence.entity.VisitorEntity
+import java.time.LocalDate
+
+interface VisitorRepository {
+
+    fun existsByUserIpAndDate(userIp: String, date: LocalDate): Boolean
+    fun save(visitor: VisitorEntity): VisitorEntity
+}

src/main/kotlin/com/coffee/api/cafe/domain/Visitor.kt

@@ -0,0 +1,41 @@
+package com.coffee.api.cafe.domain
+
+import com.coffee.api.common.domain.AbstractDomain
+import com.coffee.api.common.domain.UUIDTypeId
+import com.fasterxml.jackson.annotation.JsonCreator
+import java.time.LocalDate
+import java.util.*
+
+class Visitor private constructor(
+    override val id: Id,
+    val userIp: String,
+    val userAgent: String,
+    val date: LocalDate
+) : AbstractDomain<Visitor, Visitor.Id>() {
+
+    companion object {
+        @JsonCreator
+        fun create(
+            id: UUID,
+            userIp: String,
+            userAgent: String,
+            date: LocalDate
+        ): Visitor {
+            return Visitor(
+                id = UUIDTypeId.from(id),
+                userIp = userIp,
+                userAgent = userAgent,
+                date = date
+            )
+        }
+
+        operator fun invoke(
+            id: UUID,
+            userIp: String,
+            userAgent: String,
+            date: LocalDate
+        ): Visitor = create(id, userIp, userAgent, date)
+    }
+
+    data class Id(override val value: UUID) : UUIDTypeId(value)
+}

src/main/kotlin/com/coffee/api/cafe/infrastructure/VisitorConverter.kt

@@ -0,0 +1,30 @@
+package com.coffee.api.cafe.infrastructure
+
+import com.coffee.api.cafe.domain.Visitor
+import com.coffee.api.cafe.infrastructure.persistence.entity.VisitorEntity
+import com.coffee.api.common.infrastructure.persistence.DomainEntityConverter
+import org.springframework.stereotype.Component
+
+@Component
+class VisitorConverter : DomainEntityConverter<Visitor, VisitorEntity>(
+    Visitor::class,
+    VisitorEntity::class
+) {
+    override fun toDomain(entity: VisitorEntity): Visitor {
+        return Visitor(
+            id = entity.id,
+            userIp = entity.userIp,
+            userAgent = entity.userAgent,
+            date = entity.date
+        )
+    }
+
+    override fun toEntity(domain: Visitor): VisitorEntity {
+        return VisitorEntity(
+            id = domain.id.value,
+            userIp = domain.userIp,
+            userAgent = domain.userAgent,
+            date = domain.date
+        )
+    }
+}

src/main/kotlin/com/coffee/api/cafe/infrastructure/persistence/entity/VisitorEntity.kt

@@ -0,0 +1,42 @@
+package com.coffee.api.cafe.infrastructure.persistence.entity
+
+import com.coffee.api.common.infrastructure.persistence.BaseEntity
+import jakarta.persistence.Entity
+import jakarta.persistence.Id
+import jakarta.persistence.Table
+import java.time.LocalDate
+import java.util.UUID
+
+@Entity
+@Table(name = "visitors")
+class VisitorEntity(
+    id: UUID,
+    userIp: String,
+    userAgent: String,
+    date: LocalDate
+) : BaseEntity() {
+
+    @Id
+    var id: UUID = id
+        protected set
+
+    var userIp: String = userIp
+        protected set
+
+    var userAgent: String = userAgent
+        protected set
+    var date: LocalDate = date
+        protected set
+
+
+    companion object {
+        fun of(userIp: String, userAgent: String, date: LocalDate): VisitorEntity {
+            return VisitorEntity(
+                id = UUID.randomUUID(),
+                userIp = userIp,
+                userAgent = userAgent,
+                date = date
+            )
+        }
+    }
+}

src/main/kotlin/com/coffee/api/cafe/infrastructure/persistence/repository/VisitorJpaRepository.kt

@@ -0,0 +1,12 @@
+package com.coffee.api.cafe.infrastructure.persistence.repository
+
+import com.coffee.api.cafe.infrastructure.persistence.entity.VisitorEntity
+import org.springframework.data.jpa.repository.JpaRepository
+import java.time.LocalDate
+import java.util.UUID
+
+interface VisitorJpaRepository : JpaRepository<VisitorEntity, UUID> {
+    fun existsByUserIpAndDate(userIp: String, date: LocalDate): Boolean
+
+    fun save(visitorEntity: VisitorEntity): VisitorEntity
+}

src/main/kotlin/com/coffee/api/cafe/infrastructure/persistence/repository/VisitorRepositoryImpl.kt

@@ -0,0 +1,19 @@
+package com.coffee.api.cafe.infrastructure.persistence.repository
+
+import com.coffee.api.cafe.application.port.outbound.VisitorRepository
+import com.coffee.api.cafe.infrastructure.persistence.entity.VisitorEntity
+import org.springframework.stereotype.Repository
+import java.time.LocalDate
+
+@Repository
+class VisitorRepositoryImpl(
+    private val visitorJpaRepository: VisitorJpaRepository
+) : VisitorRepository {
+    override fun existsByUserIpAndDate(userIp: String, date: LocalDate): Boolean {
+        return visitorJpaRepository.existsByUserIpAndDate(userIp, date)
+    }
+
+    override fun save(visitor: VisitorEntity): VisitorEntity {
+        return visitorJpaRepository.save(visitor)
+    }
+}

src/main/kotlin/com/coffee/api/cafe/presentation/adapter/in/restapi/interceptor/SingleVisitInterceptor.kt

@@ -0,0 +1,30 @@
+package com.coffee.api.cafe.presentation.adapter.`in`.restapi.interceptor
+
+import jakarta.servlet.http.HttpServletRequest
+import jakarta.servlet.http.HttpServletResponse
+import org.springframework.data.redis.core.RedisTemplate
+import org.springframework.data.redis.core.ValueOperations
+import org.springframework.stereotype.Component
+import org.springframework.web.servlet.HandlerInterceptor
+import java.time.LocalDate
+
+@Component
+class SingleVisitInterceptor(
+    private val redisTemplate: RedisTemplate<String, String>
+) : HandlerInterceptor {
+
+    override fun preHandle(request: HttpServletRequest, response: HttpServletResponse, handler: Any): Boolean {
+        val userIp = request.remoteAddr
+        val userAgent = request.getHeader("User-Agent")
+        val today = LocalDate.now().toString()
+        val key = "${userIp}_${today}"
+
+        val valueOperations: ValueOperations<String, String> = redisTemplate.opsForValue()
+
+        if (!redisTemplate.hasKey(key)) {
+            valueOperations.set(key, userAgent)
+        }
+
+        return true
+    }
+}

src/main/kotlin/com/coffee/api/cafe/presentation/adapter/in/scheduler/VisitorScheduler.kt

@@ -0,0 +1,41 @@
+package com.coffee.api.cafe.presentation.adapter.`in`.scheduler
+
+import com.coffee.api.cafe.application.port.outbound.VisitorRepository
+import com.coffee.api.cafe.infrastructure.persistence.entity.VisitorEntity
+import org.slf4j.LoggerFactory
+import org.springframework.context.annotation.Profile
+import org.springframework.data.redis.core.RedisTemplate
+import org.springframework.scheduling.annotation.Scheduled
+import org.springframework.stereotype.Component
+import java.time.LocalDate
+
+@Component
+class VisitorScheduler(
+    private val redisTemplate: RedisTemplate<String, String>,
+    private val visitorRepository: VisitorRepository
+) {
+
+    private val log = LoggerFactory.getLogger(this::class.java)
+
+    @Scheduled(initialDelay = 3000000, fixedDelay = 3000000)
+    fun updateVisitorData() {
+        val keys = redisTemplate.keys("*_*") ?: return
+
+        for (key in keys) {
+            val parts = key.split("_")
+            if (parts.size != 2) continue
+
+            val userIp = parts[0]
+            val date = runCatching { LocalDate.parse(parts[1]) }.getOrNull() ?: continue
+
+            val userAgent = redisTemplate.opsForValue().get(key) ?: continue
+
+            if (!visitorRepository.existsByUserIpAndDate(userIp, date)) {
+                val visitor = VisitorEntity.of(userIp, userAgent, date)
+                visitorRepository.save(visitor)
+            }
+
+            redisTemplate.delete(key)
+        }
+    }
+}

src/main/kotlin/com/coffee/api/config/RedisConfig.kt

@@ -0,0 +1,32 @@
+package com.coffee.api.config
+
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+import org.springframework.context.annotation.Profile
+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.repository.configuration.EnableRedisRepositories
+import java.net.URI
+
+@Configuration
+@EnableRedisRepositories
+class RedisConfig(
+    @Value("\${spring.data.redis.url}")
+    private val redisUrl: String
+) {
+
+    @Bean
+    fun redisConnectionFactory(): RedisConnectionFactory {
+        val uri = URI(redisUrl)
+        return LettuceConnectionFactory(uri.host, uri.port)
+    }
+
+    @Bean
+    fun redisTemplate(): RedisTemplate<Any, Any> {
+        val template = RedisTemplate<Any, Any>()
+        template.connectionFactory = redisConnectionFactory()
+        return template
+    }
+}