Feat/#49 service search

build.gradle

@@ -70,6 +70,10 @@ dependencies {
 //	implementation 'org.mongodb:mongodb-driver-sync'
 //	implementation 'org.mongodb:mongodb-driver-core'
 
+	// Caffeine
+	implementation 'org.springframework.boot:spring-boot-starter-cache'
+	implementation 'com.github.ben-manes.caffeine:caffeine'
+
 	// redis
 	implementation 'org.springframework.boot:spring-boot-starter-data-redis'
 

src/main/java/com/hyetaekon/hyetaekon/UserInterest/repository/UserInterestRepository.java

@@ -4,7 +4,25 @@
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 
+import java.util.Arrays;
+import java.util.List;
+
 @Repository
 public interface UserInterestRepository extends JpaRepository<UserInterest, Long> {
+    /**
+     * 사용자 ID에 해당하는 모든 관심사 항목을 조회합니다.
+     *
+     * @param userId 사용자 ID
+     * @return 사용자의 관심사 목록
+     */
+    List<UserInterest> findByUserId(Long userId);
+
+    /**
+     * 사용자 ID로 관심사 존재 여부 확인
+     *
+     * @param userId 사용자 ID
+     * @return 관심사 존재 여부
+     */
+    boolean existsByUserId(Long userId);
 
 }

src/main/java/com/hyetaekon/hyetaekon/bookmark/service/BookmarkService.java

@@ -5,6 +5,7 @@
 import com.hyetaekon.hyetaekon.common.exception.GlobalException;
 import com.hyetaekon.hyetaekon.publicservice.entity.PublicService;
 import com.hyetaekon.hyetaekon.publicservice.repository.PublicServiceRepository;
+import com.hyetaekon.hyetaekon.publicservice.service.PublicServiceHandler;
 import com.hyetaekon.hyetaekon.user.entity.User;
 import com.hyetaekon.hyetaekon.user.repository.UserRepository;
 import jakarta.transaction.Transactional;
@@ -20,6 +21,7 @@ public class BookmarkService {
     private final BookmarkRepository bookmarkRepository;
     private final UserRepository userRepository;
     private final PublicServiceRepository publicServiceRepository;
+    private final PublicServiceHandler publicServiceHandler;
 
     public void addBookmark(String serviceId, Long userId) {
         User user = userRepository.findById(userId)
@@ -42,6 +44,9 @@ public void addBookmark(String serviceId, Long userId) {
 
         // 북마크 수 증가
         publicService.increaseBookmarkCount();
+
+        // 인기 서비스 캐시 무효화
+        publicServiceHandler.refreshPopularServices();
     }
 
     @Transactional
@@ -54,5 +59,8 @@ public void removeBookmark(String serviceId, Long userId) {
         // 북마크 수 감소
         PublicService publicService = bookmark.getPublicService();
         publicService.decreaseBookmarkCount();
+
+        // 인기 서비스 캐시 무효화
+        publicServiceHandler.refreshPopularServices();
     }
 }

src/main/java/com/hyetaekon/hyetaekon/common/config/CacheConfig.java

@@ -0,0 +1,35 @@
+package com.hyetaekon.hyetaekon.common.config;
+
+import com.github.benmanes.caffeine.cache.Caffeine;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.cache.caffeine.CaffeineCacheManager;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import com.hyetaekon.hyetaekon.publicservice.entity.mongodb.CacheType;
+
+import java.time.Duration;
+import java.util.Arrays;
+
+@Configuration
+@EnableCaching
+public class CacheConfig {
+    @Bean
+    public CacheManager cacheManager() {
+        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
+
+        // 각 캐시 타입에 대한 설정 등록
+        Arrays.stream(CacheType.values())
+            .forEach(cacheType -> {
+                cacheManager.registerCustomCache(cacheType.getCacheName(),
+                    Caffeine.newBuilder()
+                        .recordStats()   // 캐시 통계 기록
+                        .expireAfterWrite(Duration.ofHours(cacheType.getExpiredAfterWrite()))  // 항목 만료 시간
+                        .maximumSize(cacheType.getMaximumSize())  // 최대 크기
+                        .build()
+                );
+            });
+
+        return cacheManager;
+    }
+}

src/main/java/com/hyetaekon/hyetaekon/common/config/SecurityPath.java

@@ -14,7 +14,9 @@ public class SecurityPath {
       "/api/services/popular",
       "/api/services/category/*",
       "/api/services/detail/*",
-      "/api/public-data/serviceList/test"
+      "/api/public-data/serviceList/test",
+      "/api/mongo/services/search",
+      "/api/mongo/services/search/autocomplete"
   };
 
   // hasRole("USER")
@@ -31,7 +33,7 @@ public class SecurityPath {
 
   // hasRole("ADMIN")
   public static final String[] ADMIN_ENDPOINTS = {
-      "/api/admin/users/**",
+      "/api/admin/**",
       "/api/public-data/serviceDetailList",
       "/api/public-data/supportConditionsList",
       "/api/public-data/serviceList"

src/main/java/com/hyetaekon/hyetaekon/common/publicdata/mongodb/repository/PublicDataMongoRepository.java

@@ -2,12 +2,19 @@
 
 import com.hyetaekon.hyetaekon.common.publicdata.mongodb.document.PublicData;
 import org.springframework.data.mongodb.repository.MongoRepository;
+import org.springframework.data.mongodb.repository.Query;
 import org.springframework.stereotype.Repository;
 
+import java.util.Collection;
 import java.util.List;
 import java.util.Optional;
 
 @Repository
 public interface PublicDataMongoRepository extends MongoRepository<PublicData, String> {
     Optional<PublicData> findByPublicServiceId(String publicServiceId);
+    List<PublicData> findAllByPublicServiceId(String publicServiceId);
+    List<PublicData> findAllByPublicServiceIdIn(Collection<String> publicServiceIds);
+
+    @Query(value = "{}", fields = "{ 'publicServiceId' : 1 }")
+    List<String> findAllPublicServiceIds();
 }

src/main/java/com/hyetaekon/hyetaekon/common/publicdata/mongodb/service/PublicDataMongoService.java

@@ -3,10 +3,20 @@
 import com.hyetaekon.hyetaekon.common.publicdata.mongodb.document.PublicData;
 import com.hyetaekon.hyetaekon.common.publicdata.mongodb.repository.PublicDataMongoRepository;
 import com.hyetaekon.hyetaekon.publicservice.entity.PublicService;
+import jakarta.annotation.PostConstruct;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.domain.Sort;
 import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.aggregation.Aggregation;
+import org.springframework.data.mongodb.core.aggregation.AggregationResults;
+import org.springframework.data.mongodb.core.index.Index;
+import org.springframework.data.mongodb.core.index.IndexInfo;
+import org.bson.Document;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
 import java.util.Map;
@@ -29,17 +39,6 @@ public PublicData saveToMongo(PublicService publicService) {
         return mongoRepository.save(document);
     }
 
-    /**
-     * 여러 공공서비스 엔티티를 MongoDB에 저장
-     */
-    public List<PublicData> saveAllToMongo(List<PublicService> publicServices) {
-        List<PublicData> documents = publicServices.stream()
-            .map(this::convertToDocument)
-            .collect(Collectors.toList());
-
-        return mongoRepository.saveAll(documents);
-    }
-
     /**
      * 공공서비스 엔티티를 MongoDB 문서로 변환
      */
@@ -109,29 +108,129 @@ public PublicData updateOrCreateDocument(PublicService publicService) {
     /**
      * 여러 서비스 문서 업데이트 또는 생성
      */
-    public List<PublicData> updateOrCreateBulkDocuments(List<PublicService> services) {
-        // 기존 ID 목록 가져오기
+    public void updateOrCreateBulkDocuments(List<PublicService> services) {
+        // 모든 service ID 목록
         List<String> serviceIds = services.stream()
             .map(PublicService::getId)
             .collect(Collectors.toList());
 
-        // ID에 해당하는 문서 맵 생성
-        Map<String, PublicData> existingDocsMap = mongoRepository.findAllById(serviceIds).stream()
-            .collect(Collectors.toMap(PublicData::getPublicServiceId, doc -> doc, (a, b) -> a));
+        // publicServiceId로 기존 문서 조회 (중요: findAllByPublicServiceId를 사용)
+        Map<String, PublicData> existingDocsMap = mongoRepository.findAllByPublicServiceIdIn(serviceIds).stream()
+            .collect(Collectors.toMap(
+                PublicData::getPublicServiceId,
+                doc -> doc,
+                (a, b) -> a  // 중복 시 첫 번째 문서 유지
+            ));
 
-        // 각 서비스 처리
+        // 처리할 문서 준비
         List<PublicData> docsToSave = services.stream()
             .map(service -> {
                 PublicData doc = convertToDocument(service);
                 if (existingDocsMap.containsKey(service.getId())) {
-                    // 기존 문서 ID 유지
+                    // 기존 문서의 ID 유지
                     doc.setId(existingDocsMap.get(service.getId()).getId());
                 }
                 return doc;
             })
             .collect(Collectors.toList());
 
-        // 일괄 저장
-        return mongoRepository.saveAll(docsToSave);
+        // 저장
+        mongoRepository.saveAll(docsToSave);
+    }
+
+    // 첫 실행 시에만 중복 제거 및 인덱스 생성
+    @PostConstruct
+    public void ensureIndexes() {
+        try {
+            // 1. 기존 인덱스 확인
+            boolean hasUniqueIndex = false;
+            for (IndexInfo indexInfo : mongoTemplate.indexOps("service_info").getIndexInfo()) {
+                if ("publicServiceId_1".equals(indexInfo.getName())) {
+                    hasUniqueIndex = indexInfo.isUnique();
+                    break;
+                }
+            }
+
+            // 2. 유니크 인덱스가 없는 경우만 처리
+            if (!hasUniqueIndex) {
+                // 2.1 일반 인덱스 존재 여부 확인
+                boolean hasNonUniqueIndex = false;
+                for (IndexInfo indexInfo : mongoTemplate.indexOps("service_info").getIndexInfo()) {
+                    if ("publicServiceId_1".equals(indexInfo.getName()) && !indexInfo.isUnique()) {
+                        hasNonUniqueIndex = true;
+                        break;
+                    }
+                }
+
+                // 2.2 일반 인덱스가 있다면 삭제
+                if (hasNonUniqueIndex) {
+                    mongoTemplate.indexOps("service_info").dropIndex("publicServiceId_1");
+                    log.info("기존 비유니크 인덱스 삭제: publicServiceId_1");
+                }
+
+                // 2.3 최적화된 중복 제거 실행
+                deduplicateMongoDocuments();
+
+                // 2.4 유니크 인덱스 생성
+                mongoTemplate.indexOps("service_info").ensureIndex(
+                    new Index().on("publicServiceId", Sort.Direction.ASC).unique()
+                );
+                log.info("MongoDB 인덱스 설정 완료: publicServiceId (unique)");
+            } else {
+                log.info("MongoDB 유니크 인덱스 이미 존재함: publicServiceId_1");
+            }
+        } catch (Exception e) {
+            log.error("MongoDB 인덱스 설정 중 오류 발생: {}", e.getMessage());
+            // 인덱스 생성 실패해도 애플리케이션은 시작되도록 함
+        }
+    }
+
+    @Transactional
+    public void deduplicateMongoDocuments() {
+        log.info("MongoDB 문서 중복 제거 시작 (최적화 버전)");
+
+        // 모든 publicServiceId와 해당 문서 ID를 그룹화하여 한 번에 조회
+        AggregationResults<Document> results = mongoTemplate.aggregate(
+            Aggregation.newAggregation(
+                Aggregation.group("publicServiceId")
+                    .first("_id").as("firstId")
+                    .push("_id").as("allIds")
+                    .count().as("count")
+            ),
+            "service_info",
+            Document.class
+        );
+
+        int totalProcessed = 0;
+        int totalRemoved = 0;
+
+        for (Document doc : results.getMappedResults()) {
+            int count = doc.getInteger("count");
+
+            // 중복이 있는 경우에만 처리
+            if (count > 1) {
+                String publicServiceId = doc.getString("_id");
+                List<Object> allIds = (List<Object>) doc.get("allIds");
+                Object firstId = doc.get("firstId");
+
+                // 첫 번째 문서를 제외한 나머지 문서 삭제
+                for (int i = 0; i < allIds.size(); i++) {
+                    Object currentId = allIds.get(i);
+                    if (!currentId.equals(firstId)) {
+                        mongoTemplate.remove(Query.query(Criteria.where("_id").is(currentId)), "service_info");
+                        totalRemoved++;
+                    }
+                }
+            }
+
+            totalProcessed++;
+            if (totalProcessed % 1000 == 0) {
+                log.info("중복 제거 진행 중: {}/{} 그룹 처리, {}개 제거됨",
+                    totalProcessed, results.getMappedResults().size(), totalRemoved);
+            }
+        }
+
+        log.info("MongoDB 문서 중복 제거 완료: 총 {}개 그룹 중 {}개 중복 제거됨",
+            totalProcessed, totalRemoved);
     }
 }

src/main/java/com/hyetaekon/hyetaekon/common/publicdata/service/PublicServiceDataServiceImpl.java

@@ -240,17 +240,15 @@ public List<PublicServiceDataDto.Data> upsertServiceData(List<PublicServiceDataD
             // 배치 처리 최적화: 1000개 단위로 저장
             if (entitiesToSave.size() >= 1000) {
                 List<PublicService> savedEntities = publicServiceRepository.saveAll(entitiesToSave);
-
-                publicDataMongoService.saveAllToMongo(savedEntities);
+                publicDataMongoService.updateOrCreateBulkDocuments(savedEntities);
                 entitiesToSave.clear();
             }
         }
 
         // 나머지 데이터 저장
         if (!entitiesToSave.isEmpty()) {
             List<PublicService> savedEntities = publicServiceRepository.saveAll(entitiesToSave);
-
-            publicDataMongoService.saveAllToMongo(savedEntities);
+            publicDataMongoService.updateOrCreateBulkDocuments(savedEntities);
         }
 
         log.info("공공서비스 목록 데이터 {}건 저장 완료", validatedData.size());
@@ -296,17 +294,15 @@ public List<PublicServiceDetailDataDto.Data> upsertServiceDetailData(List<Public
             // 배치 처리 최적화: 1000개 단위로 저장
             if (entitiesToSave.size() >= 1000) {
                 List<PublicService> savedEntities = publicServiceRepository.saveAll(entitiesToSave);
-
-                publicDataMongoService.saveAllToMongo(savedEntities);
+                publicDataMongoService.updateOrCreateBulkDocuments(savedEntities);
                 entitiesToSave.clear();
             }
         }
 
         // 나머지 데이터 저장
         if (!entitiesToSave.isEmpty()) {
             List<PublicService> savedEntities = publicServiceRepository.saveAll(entitiesToSave);
-
-            publicDataMongoService.saveAllToMongo(savedEntities);
+            publicDataMongoService.updateOrCreateBulkDocuments(savedEntities);
         }
 
         log.info("공공서비스 상세정보 데이터 {}건 저장 완료", validatedData.size());
@@ -356,17 +352,15 @@ public List<PublicServiceConditionsDataDto.Data> upsertSupportConditionsData(Lis
             // 배치 처리 최적화: 1000개 단위로 저장
             if (entitiesToSave.size() >= 1000) {
                 List<PublicService> savedEntities = publicServiceRepository.saveAll(entitiesToSave);
-
-                publicDataMongoService.saveAllToMongo(savedEntities);
+                publicDataMongoService.updateOrCreateBulkDocuments(savedEntities);
                 entitiesToSave.clear();
             }
         }
 
         // 나머지 데이터 저장
         if (!entitiesToSave.isEmpty()) {
             List<PublicService> savedEntities = publicServiceRepository.saveAll(entitiesToSave);
-
-            publicDataMongoService.saveAllToMongo(savedEntities);
+            publicDataMongoService.updateOrCreateBulkDocuments(savedEntities);
         }
 
         log.info("공공서비스 지원조건 데이터 {}건 저장 완료", validatedData.size());

src/main/java/com/hyetaekon/hyetaekon/post/dto/MyPostListResponseDto.java

@@ -15,7 +15,7 @@ public class MyPostListResponseDto {
     private Long postId;
     private String title;
     private String content;
-    private Long nickName;  // 작성자 닉네임
+    private String nickName;  // 작성자 닉네임
     private LocalDateTime createdAt;
     private int recommendCnt;
     private int commentCnt;