feat: 레디스 도입 및 알림 개수를 캐쉬로 관리

backend/build.gradle

@@ -48,6 +48,10 @@ dependencies {
     implementation 'org.flywaydb:flyway-core'
     implementation 'org.flywaydb:flyway-mysql'
 
+    // Redis
+    implementation 'org.springframework.boot:spring-boot-starter-data-redis'
+    implementation group: 'it.ozimov', name: 'embedded-redis', version: '0.7.2'
+
     asciidoctorExtensions 'org.springframework.restdocs:spring-restdocs-asciidoctor'
 
     testImplementation 'org.springframework.boot:spring-boot-starter-test'

backend/src/main/java/com/woowacourse/kkogkkog/auth/presentation/AuthController.java

@@ -29,16 +29,14 @@ public ResponseEntity<TokenResponse> login(@RequestParam String code) {
     }
 
     @PostMapping("/install/bot")
-    public ResponseEntity<Void> installSlackApp(
-        @RequestBody InstallSlackAppRequest installSlackAppRequest) {
+    public ResponseEntity<Void> installSlackApp(@RequestBody InstallSlackAppRequest installSlackAppRequest) {
         authService.installSlackApp(installSlackAppRequest.getCode());
 
         return ResponseEntity.ok().build();
     }
 
     @PostMapping("/signup/token")
-    public ResponseEntity<MemberCreateResponse> save(
-        @RequestBody MemberCreateRequest memberCreateRequest) {
+    public ResponseEntity<MemberCreateResponse> save(@RequestBody MemberCreateRequest memberCreateRequest) {
         Long id = authService.signUp(memberCreateRequest);
         MemberCreateResponse memberCreateResponse = authService.loginByMemberId(id);
 

backend/src/main/java/com/woowacourse/kkogkkog/common/config/EmbeddedRedisConfig.java

@@ -0,0 +1,40 @@
+package com.woowacourse.kkogkkog.common.config;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+import redis.embedded.RedisServer;
+
+@Slf4j
+@Profile("default")
+@Configuration
+public class EmbeddedRedisConfig {
+
+    private final int redisPort;
+
+    private RedisServer redisServer;
+
+    public EmbeddedRedisConfig(@Value("${spring.redis.port}") final int redisPort) {
+        this.redisPort = redisPort;
+    }
+
+    @PostConstruct
+    public void redisServer() {
+        try {
+            redisServer = new RedisServer(redisPort);
+            redisServer.start();
+        } catch (RuntimeException e) {
+            log.info("{} 포트에 내장 레디스 서버를 구동하는 데 실패하였습니다.", redisPort);
+        }
+    }
+
+    @PreDestroy
+    public void stopRedis() {
+        if (redisServer != null) {
+            redisServer.stop();
+        }
+    }
+}

backend/src/main/java/com/woowacourse/kkogkkog/common/config/RedisConfig.java

@@ -0,0 +1,39 @@
+package com.woowacourse.kkogkkog.common.config;
+
+import org.springframework.beans.factory.annotation.Value;
+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;
+
+@Configuration
+public class RedisConfig {
+
+    private final String redisHost;
+    private final int redisPort;
+    private final String redisPassword;
+
+    public RedisConfig(@Value("${spring.redis.host}") final String redisHost,
+                       @Value("${spring.redis.port}") final int redisPort,
+                       @Value("${spring.redis.password}") final String redisPassword) {
+        this.redisHost = redisHost;
+        this.redisPort = redisPort;
+        this.redisPassword = redisPassword;
+    }
+
+    @Bean
+    public RedisConnectionFactory redisConnectionFactory() {
+        final var redisConfiguration = new RedisStandaloneConfiguration(redisHost, redisPort);
+        redisConfiguration.setPassword(redisPassword);
+        return new LettuceConnectionFactory(redisConfiguration);
+    }
+
+    @Bean
+    public RedisTemplate<?, ?> redisTemplate() {
+        RedisTemplate<byte[], byte[]> redisTemplate = new RedisTemplate<>();
+        redisTemplate.setConnectionFactory(redisConnectionFactory());
+        return redisTemplate;
+    }
+}

backend/src/main/java/com/woowacourse/kkogkkog/coupon/application/CouponService.java

@@ -14,6 +14,7 @@
 import com.woowacourse.kkogkkog.coupon.domain.UnregisteredCouponEventType;
 import com.woowacourse.kkogkkog.coupon.domain.repository.CouponHistoryRepository;
 import com.woowacourse.kkogkkog.coupon.domain.repository.CouponRepository;
+import com.woowacourse.kkogkkog.coupon.domain.repository.NoticeCacheRepository;
 import com.woowacourse.kkogkkog.coupon.domain.repository.UnregisteredCouponRepository;
 import com.woowacourse.kkogkkog.coupon.exception.CouponNotAccessibleException;
 import com.woowacourse.kkogkkog.coupon.exception.UnregisteredCouponNotFoundException;
@@ -39,6 +40,7 @@ public class CouponService {
     private final CouponRepository couponRepository;
     private final UnregisteredCouponRepository unregisteredCouponRepository;
     private final CouponHistoryRepository couponHistoryRepository;
+    private final NoticeCacheRepository noticeCacheRepository;
     private final PushAlarmPublisher pushAlarmPublisher;
 
     @Transactional(readOnly = true)
@@ -137,6 +139,7 @@ private List<Member> findReceivers(List<Long> memberIds) {
 
     private void saveCouponHistory(CouponHistory couponHistory) {
         couponHistory = couponHistoryRepository.save(couponHistory);
+        noticeCacheRepository.increment(couponHistory.getHostMember());
         pushAlarmPublisher.publishEvent(couponHistory);
     }
 

backend/src/main/java/com/woowacourse/kkogkkog/coupon/domain/CouponHistory.java

@@ -81,11 +81,16 @@ public static CouponHistory ofNew(Coupon coupon) {
         return new CouponHistory(historyHostMember, coupon.getSender(), coupon, initEvent, null);
     }
 
-    public static CouponHistory of(Member loginMember, Coupon coupon, CouponEvent event, String message) {
+    public static CouponHistory of(Member loginMember, Coupon coupon, CouponEvent event,
+                                   String message) {
         Member historyHostMember = coupon.getOppositeMember(loginMember);
         return new CouponHistory(historyHostMember, loginMember, coupon, event, message);
     }
 
+    public boolean isRead() {
+        return isRead;
+    }
+
     public void updateIsRead() {
         isRead = true;
     }

backend/src/main/java/com/woowacourse/kkogkkog/coupon/domain/repository/NoticeCacheRepository.java

@@ -0,0 +1,65 @@
+package com.woowacourse.kkogkkog.coupon.domain.repository;
+
+import com.woowacourse.kkogkkog.member.domain.Member;
+import java.util.concurrent.TimeUnit;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.core.ValueOperations;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+@Repository
+public class NoticeCacheRepository {
+
+    private static final String KEY_FORMAT = "unreadNoticeCount:%d";
+    private static final int CACHE_VALIDITY = 600;
+
+    private final RedisTemplate<String, Long> redisTemplate;
+    private final CouponHistoryRepository couponHistoryRepository;
+
+    public NoticeCacheRepository(RedisTemplate<String, Long> redisTemplate,
+                                 CouponHistoryRepository couponHistoryRepository) {
+        this.redisTemplate = redisTemplate;
+        this.couponHistoryRepository = couponHistoryRepository;
+    }
+
+    @Transactional(readOnly = true)
+    public Long get(Member member) {
+        Long unreadCountCache = getCache(member);
+        if (unreadCountCache != null) {
+            return unreadCountCache;
+        }
+        Long unreadCount = couponHistoryRepository.countByHostMemberAndIsReadFalse(member);
+        setCache(member, unreadCount);
+        return unreadCount;
+    }
+
+    public void increment(Member member) {
+        Long unreadCount = getCache(member);
+        if (unreadCount != null) {
+            setCache(member, unreadCount + 1);
+        }
+    }
+
+    public void decrement(Member member) {
+        Long unreadCount = getCache(member);
+        if (unreadCount != null && unreadCount > 0) {
+            setCache(member, unreadCount - 1);
+        }
+    }
+
+    public void reset(Member member) {
+        setCache(member, 0L);
+    }
+
+    private Long getCache(Member member) {
+        ValueOperations<String, Long> valueOperations = redisTemplate.opsForValue();
+        String cacheKey = String.format(KEY_FORMAT, member.getId());
+        return valueOperations.get(cacheKey);
+    }
+
+    private void setCache(Member member, Long unreadCount) {
+        ValueOperations<String, Long> valueOperations = redisTemplate.opsForValue();
+        String cacheKey = String.format(KEY_FORMAT, member.getId());
+        valueOperations.set(cacheKey, unreadCount, CACHE_VALIDITY, TimeUnit.SECONDS);
+    }
+}

backend/src/main/java/com/woowacourse/kkogkkog/member/application/MemberService.java

@@ -5,6 +5,7 @@
 import com.woowacourse.kkogkkog.auth.application.dto.MemberUpdateResponse;
 import com.woowacourse.kkogkkog.coupon.domain.CouponHistory;
 import com.woowacourse.kkogkkog.coupon.domain.repository.CouponHistoryRepository;
+import com.woowacourse.kkogkkog.coupon.domain.repository.NoticeCacheRepository;
 import com.woowacourse.kkogkkog.infrastructure.dto.GoogleUserDto;
 import com.woowacourse.kkogkkog.infrastructure.dto.SlackUserInfo;
 import com.woowacourse.kkogkkog.member.application.dto.MemberHistoryResponse;
@@ -33,6 +34,7 @@ public class MemberService {
     private final MemberRepository memberRepository;
     private final WorkspaceUserRepository workspaceUserRepository;
     private final CouponHistoryRepository memberHistoryRepository;
+    private final NoticeCacheRepository noticeCacheRepository;
 
     public boolean existsMember(SlackUserInfo userInfo) {
         String email = userInfo.getEmail();
@@ -99,11 +101,10 @@ private MemberUpdateResponse integrateNewWorkspaceUser(SlackUserInfo userInfo,
 
     @Transactional(readOnly = true)
     public MyProfileResponse findById(Long memberId) {
-        Member findMember = memberRepository.get(memberId);
-        Long unreadHistoryCount = memberHistoryRepository
-            .countByHostMemberAndIsReadFalse(findMember);
+        Member member = memberRepository.get(memberId);
+        Long unreadCount = noticeCacheRepository.get(member);
 
-        return MyProfileResponse.of(findMember, unreadHistoryCount);
+        return MyProfileResponse.of(member, unreadCount);
     }
 
     @Transactional(readOnly = true)
@@ -142,7 +143,10 @@ public List<MemberHistoryResponse> findHistoryById(Long memberId) {
 
     public void updateIsReadMemberHistory(Long memberHistoryId) {
         CouponHistory memberHistory = memberHistoryRepository.findCouponHistory(memberHistoryId);
-        memberHistory.updateIsRead();
+        if (!memberHistory.isRead()) {
+            memberHistory.updateIsRead();
+            noticeCacheRepository.decrement(memberHistory.getHostMember());
+        }
     }
 
     public void updateAllIsReadMemberHistories(Long memberId) {
@@ -152,5 +156,6 @@ public void updateAllIsReadMemberHistories(Long memberId) {
         for (CouponHistory couponHistory : couponHistories) {
             couponHistory.updateIsRead();
         }
+        noticeCacheRepository.reset(foundMember);
     }
 }

backend/src/main/resources/application.yml

@@ -15,6 +15,10 @@ spring:
     password:
   flyway:
     enabled: false
+  redis:
+    host: localhost
+    port: 6379
+    password: ""
 
 logging:
   level:

backend/src/test/java/com/woowacourse/kkogkkog/acceptance/support/AcceptanceTest.java

@@ -2,6 +2,7 @@
 
 import com.woowacourse.kkogkkog.infrastructure.application.SlackClient;
 import com.woowacourse.kkogkkog.support.common.DatabaseCleaner;
+import com.woowacourse.kkogkkog.support.common.RedisStorageCleaner;
 import io.restassured.RestAssured;
 import org.junit.jupiter.api.BeforeEach;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -19,12 +20,16 @@ public class AcceptanceTest {
     @Autowired
     private DatabaseCleaner databaseCleaner;
 
+    @Autowired
+    private RedisStorageCleaner redisStorageCleaner;
+
     @MockBean
     protected static SlackClient slackClient;
 
     @BeforeEach
     void setUp() {
         RestAssured.port = port;
         databaseCleaner.execute();
+        redisStorageCleaner.execute();
     }
 }