Merge pull request #135 from Team-Capple/feat/#126/apnsSetting

[FEAT] 애플 푸시 알림 구현

build.gradle

@@ -62,6 +62,8 @@ dependencies {
 
 //  https://mvnrepository.com/artifact/com.google.code.findbugs/jsr305
 	implementation 'com.google.code.findbugs:jsr305:3.0.2'
+//	webflux
+	implementation 'org.springframework.boot:spring-boot-starter-webflux'
 }
 
 dependencyManagement {

src/main/java/com/server/capple/CappleApplication.java

@@ -4,6 +4,7 @@
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.cloud.openfeign.EnableFeignClients;
 import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
 import org.springframework.scheduling.annotation.EnableScheduling;
@@ -16,6 +17,7 @@
 @EnableFeignClients
 @EnableConfigurationProperties
 @EnableScheduling
+@EnableCaching
 public class CappleApplication {
 
 	public static void main(String[] args) {

src/main/java/com/server/capple/config/RedisConfig.java

@@ -1,14 +1,23 @@
 package com.server.capple.config;
 
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.cache.CacheManager;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+import org.springframework.data.redis.cache.RedisCacheConfiguration;
+import org.springframework.data.redis.cache.RedisCacheManager;
 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;
 import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.RedisSerializationContext;
 import org.springframework.data.redis.serializer.StringRedisSerializer;
 
+import java.time.Duration;
+
 @Configuration
 public class RedisConfig {
 
@@ -18,13 +27,25 @@ public class RedisConfig {
     private int port;
     @Value("${spring.data.redis.database}")
     private int database;
+    @Value("${redis-cloud.host}")
+    private String redisCloudHost;
+    @Value("${redis-cloud.port}")
+    private int redisCloudPort;
+    @Value("${redis-cloud.database}")
+    private int redisCloudDatabase;
+    @Value("${redis-cloud.username}")
+    private String redisCloudUsername;
+    @Value("${redis-cloud.password}")
+    private String redisCloudPassword;
 
     @Bean
+    @Primary
     public RedisConnectionFactory redisConnectionFactory() {
         LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(host, port);
         connectionFactory.setDatabase(database);
         return connectionFactory;
     }
+
     @Bean
     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
@@ -35,4 +56,25 @@ public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisC
 
         return redisTemplate;
     }
+
+    @Bean
+    public RedisConnectionFactory redisCloudConnectionFactory() {
+        RedisStandaloneConfiguration redisConfiguration = new RedisStandaloneConfiguration(redisCloudHost, redisCloudPort);
+        redisConfiguration.setUsername(redisCloudUsername);
+        redisConfiguration.setPassword(redisCloudPassword);
+        LettuceConnectionFactory apnsRedisConnectionFactory = new LettuceConnectionFactory(redisConfiguration);
+        apnsRedisConnectionFactory.setDatabase(redisCloudDatabase);
+        apnsRedisConnectionFactory.start();
+        return apnsRedisConnectionFactory;
+    }
+
+    @Bean
+    @Qualifier("redisCloudConnectionFactory")
+    public CacheManager apnsJwtCacheManager(RedisConnectionFactory redisCloudConnectionFactory) {
+        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
+            .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
+            .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
+            .entryTtl(Duration.ofMinutes(30));
+        return RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(redisCloudConnectionFactory).cacheDefaults(redisCacheConfiguration).build();
+    }
 }

src/main/java/com/server/capple/config/apns/config/ApnsClientConfig.java

@@ -0,0 +1,44 @@
+package com.server.capple.config.apns.config;
+
+import io.netty.handler.ssl.SslContext;
+import io.netty.handler.ssl.SslContextBuilder;
+import io.netty.handler.timeout.WriteTimeoutHandler;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import reactor.netty.http.HttpProtocol;
+import reactor.netty.http.client.HttpClient;
+import reactor.netty.resources.ConnectionProvider;
+
+import javax.net.ssl.SSLException;
+import java.time.Duration;
+import java.util.concurrent.TimeUnit;
+
+@Configuration
+public class ApnsClientConfig {
+    @Bean("apnsSslContext")
+    public SslContext getApnsSslContext() throws SSLException {
+        return SslContextBuilder.forClient().protocols("TLSv1.2").build(); // SSL 설정
+    }
+
+    @Bean("apnsConnectionProvider")
+    public ConnectionProvider getApnsConnectionProvider() {
+        return ConnectionProvider.builder("apns")
+            .maxConnections(10) // 최대 커낵션 수
+            .pendingAcquireMaxCount(-1) // 재시도 횟수 (-1 : 무한대)
+            .pendingAcquireTimeout(java.time.Duration.ofSeconds(10)) // 커넥션 풀에 사용 가능한 커넥션 없을 때의 대기 시간
+            .maxIdleTime(java.time.Duration.ofSeconds(5)) // 최대 유휴 시간
+            .maxLifeTime(java.time.Duration.ofSeconds(300)) // 최대 생명 시간
+            .lifo() // 후입선출
+            .build();
+    }
+
+    @Bean("apnsH2HttpClient")
+    public HttpClient getApnsH2HttpClient(ConnectionProvider apnsConnectionProvider, SslContext apnsSslContext) {
+        return HttpClient.create(apnsConnectionProvider) // reactor HttpClient 생성
+            .keepAlive(true) // keep-alive 활성화
+            .protocol(HttpProtocol.H2) // HTTP/2 활성화
+            .doOnConnected(connection -> connection.addHandlerLast(new WriteTimeoutHandler(10, TimeUnit.SECONDS))) // 쓰기 타임 아웃
+            .responseTimeout(Duration.ofSeconds(10)) // 응답 타임 아웃
+            .secure(sslSpec -> sslSpec.sslContext(apnsSslContext)); // SSL 활성화
+    }
+}

src/main/java/com/server/capple/config/apns/dto/ApnsClientRequest.java

@@ -0,0 +1,93 @@
+package com.server.capple.config.apns.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.*;
+
+public class ApnsClientRequest {
+
+    @Getter
+    @NoArgsConstructor
+    @ToString
+    public static class SimplePushBody {
+        private Aps aps;
+
+        public SimplePushBody(String title, String subTitle, String body, Integer badge, String threadId, String targetContentId) {
+            this.aps = new Aps(new Aps.Alert(title, subTitle, body), badge, threadId, targetContentId);
+        }
+
+        @ToString
+        @Getter
+        @AllArgsConstructor
+        @NoArgsConstructor
+        public static class Aps {
+            private Alert alert;
+            private Integer badge;
+            @JsonProperty("thread-id")
+            private String threadId;
+            @JsonProperty("target-content-id")
+            private String targetContentId; // 프론트 측 작업 필요함
+
+            @ToString
+            @Getter
+            @AllArgsConstructor
+            @NoArgsConstructor
+            public static class Alert {
+                private String title;
+                private String subtitle;
+                private String body;
+            }
+        }
+    }
+
+    @Getter
+    @AllArgsConstructor
+    @NoArgsConstructor
+    @Builder
+    @ToString
+    public static class FullAlertBody {
+        private Aps aps;
+
+        @Getter
+        @AllArgsConstructor
+        @NoArgsConstructor
+        @Builder
+        @ToString
+        public static class Aps {
+            private Alert alert; // alert 정보
+            private Integer badge; // 앱 아이콘에 표시할 뱃지 숫자
+            @Schema(defaultValue = "default")
+            private String sound; // Library/Sounds 폴더 내의 파일 이름
+            @Schema(defaultValue = "thread-id")
+            private String threadId; // 알림 그룹화를 위한 thread id (UNNotificationContent 객체의 threadIdentifier와 일치해야 함)
+            private String category; // 알림 그룹화를 위한 category, (UNNotificationCategory 식별자와 일치해야 함)
+            @Schema(defaultValue = "0")
+            @JsonProperty("content-available")
+            private Integer contentAvailable; // 백그라운드 알림 여부, 1이면 백그라운드 알림, 0이면 포그라운드 알림 (백그라운드일 경우 alert, badge, sound는 넣으면 안됨)
+            @Schema(defaultValue = "0")
+            @JsonProperty("mutable-content")
+            private Integer mutableContent; // 알림 서비스 확장 플래그
+            @Schema(defaultValue = "")
+            @JsonProperty("target-content-id")
+            private String targetContentId; // 알림이 클릭되었을 때 가져올 창의 식별자, UNNotificationContent 객체에 채워짐
+
+            @Getter
+            @AllArgsConstructor
+            @NoArgsConstructor
+            @Builder
+            @ToString
+            public static class Alert {
+                @Schema(defaultValue = "title")
+                private String title;
+                @Schema(defaultValue = "subTitle")
+                private String subtitle;
+                @Schema(defaultValue = "body")
+                private String body;
+                @Schema(defaultValue = "")
+                @JsonProperty("launch-image")
+                private String launchImage; // 실행시 보여줄 이미지 파일, 기본 실행 이미지 대신 입력한 이미지 또는 스토리보드가 켜짐
+            }
+        }
+    }
+
+}

src/main/java/com/server/capple/config/apns/service/ApnsService.java

@@ -0,0 +1,10 @@
+package com.server.capple.config.apns.service;
+
+import java.util.List;
+
+public interface ApnsService {
+    <T> Boolean sendApns(T request, String ... deviceTokens);
+    <T> Boolean sendApns(T request, List<String> deviceTokenList);
+    <T> Boolean sendApnsToMembers(T request, Long ... memberIds);
+    <T> Boolean sendApnsToMembers(T request, List<Long> memberIdList);
+}

src/main/java/com/server/capple/config/apns/service/ApnsServiceImpl.java

@@ -0,0 +1,101 @@
+package com.server.capple.config.apns.service;
+
+import com.server.capple.config.security.jwt.service.JwtService;
+import com.server.capple.domain.member.repository.DeviceTokenRedisRepository;
+import jakarta.annotation.PostConstruct;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.client.reactive.ReactorClientHttpConnector;
+import org.springframework.stereotype.Service;
+import org.springframework.web.reactive.function.client.WebClient;
+import reactor.netty.http.client.HttpClient;
+
+import java.util.List;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class ApnsServiceImpl implements ApnsService {
+    private final JwtService jwtService;
+    private final HttpClient apnsH2HttpClient;
+    private final DeviceTokenRedisRepository deviceTokenRedisRepository;
+    private WebClient defaultApnsWebClient;
+
+    @Value("${apns.base-url}")
+    private String apnsBaseUrl;
+    @Value("${apns.base-sub-url}")
+    private String apnsBaseSubUrl;
+    @Value("${apple-auth.client_id}")
+    private String apnsTopic;
+    private final String apnsAlertPushType = "alert";
+
+    @PostConstruct
+    public void init() {
+        defaultApnsWebClient = WebClient.builder()
+            .clientConnector(new ReactorClientHttpConnector(apnsH2HttpClient))
+            .baseUrl(apnsBaseUrl)
+            .defaultHeader("apns-topic", apnsTopic)
+            .defaultHeader("apns-push-type", apnsAlertPushType)
+            .build();
+    }
+
+    @Override
+    public <T> Boolean sendApns(T request, String... deviceToken) {
+        return sendApns(request, List.of(deviceToken));
+    }
+
+    @Override
+    public <T> Boolean sendApns(T request, List<String> deviceToken) {
+        WebClient tmpWebClient = defaultApnsWebClient.mutate()
+            .defaultHeader("authorization", "bearer " + jwtService.createApnsJwt())
+            .build();
+
+        WebClient tmpSubWebClient = tmpWebClient.mutate()
+            .baseUrl(apnsBaseSubUrl)
+            .build();
+
+        deviceToken.parallelStream()
+            .forEach(token -> {
+                tmpWebClient
+                    .method(HttpMethod.POST)
+                    .uri(token)
+                    .bodyValue(request)
+                    .retrieve()
+                    .bodyToMono(Void.class)
+                    .doOnDiscard(Void.class, response -> {// 거절 시 보조 채널로 재시도
+                        tmpSubWebClient
+                            .method(HttpMethod.POST)
+                            .uri(token)
+                            .bodyValue(request)
+                            .retrieve()
+                            .bodyToMono(Void.class)
+                            .subscribe();
+                        log.info("APNs 전송 거절 발생");
+                    })
+                    .doOnError(e -> { // 에러 발생 시 보조 채널로 재시도
+                        tmpSubWebClient
+                            .method(HttpMethod.POST)
+                            .uri(token)
+                            .bodyValue(request)
+                            .retrieve()
+                            .bodyToMono(Void.class)
+                            .subscribe();
+                        log.error("APNs 전송 중 오류 발생", e);
+                    })
+                    .subscribe();
+            });
+        return true;
+    }
+
+    @Override
+    public <T> Boolean sendApnsToMembers(T request, Long... memberIds) {
+        return sendApns(request, deviceTokenRedisRepository.getDeviceTokens(List.of(memberIds)));
+    }
+
+    @Override
+    public <T> Boolean sendApnsToMembers(T request, List<Long> memberIdList) {
+        return sendApns(request, deviceTokenRedisRepository.getDeviceTokens(memberIdList));
+    }
+}

src/main/java/com/server/capple/config/security/jwt/service/JwtService.java

@@ -16,4 +16,5 @@ public interface JwtService {
     Boolean isExpired(String token);
     Boolean checkJwt(String token);
     MemberResponse.Tokens refreshTokens(Long memberId, Role role);
+    String createApnsJwt();
 }