Merge pull request #73 from BackEndSchoolPlus3th/SMS-83-feature-keywordnotES

feat: 해쉬태그 자동완성 개선

Author: leemimi

src/main/java/org/com/stocknote/domain/hashtagAutocomplete/RedisSortedSetService.java

@@ -1,27 +1,81 @@
 package org.com.stocknote.domain.hashtagAutocomplete;
 
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.data.redis.core.RedisCallback;
 import org.springframework.data.redis.core.StringRedisTemplate;
 import org.springframework.stereotype.Service;
+import org.springframework.data.domain.Range;
 
-import java.util.Set;
+
+import java.nio.charset.StandardCharsets;
+import java.util.*;
 
 @Service
 @RequiredArgsConstructor
-public class RedisSortedSetService {    //검색어 자동 완성을 구현할 때 사용하는 Redis의 SortedSet 관련 서비스 레이어
+@Slf4j
+public class RedisSortedSetService {
     private final StringRedisTemplate redisTemplate;
-    private String key = "autocorrect"; //검색어 자동 완성을 위한 Redis 데이터
-    private int score = 0;  //Score는 딱히 필요 없으므로 하나로 통일
+    private static final String KEY = "autocorrect";
+    private static final int MAX_RESULTS = 10;
+    private static final String SUFFIX = "*"; // 완전한 단어 구분
+
+    public void addAllToSortedSet(List<String> values) {
+        try {
+            redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
+                byte[] keyBytes = KEY.getBytes(StandardCharsets.UTF_8);
 
-    public void addToSortedSet(String value) {    //Redis SortedSet에 추가
-        redisTemplate.opsForZSet().add(key, value, score);
+                for (String value : values) {
+                    byte[] fullValueBytes = (value + SUFFIX).getBytes(StandardCharsets.UTF_8);
+                    connection.zAdd(keyBytes, 0, fullValueBytes);
+
+                    // 모든 부분 문자열 저장
+                    for (int i = 1; i <= value.length(); i++) {
+                        byte[] substringBytes = value.substring(0, i).getBytes(StandardCharsets.UTF_8);
+                        connection.zAdd(keyBytes, 0, substringBytes);
+                    }
+                }
+                return null;
+            });
+        } catch (Exception e) {
+            log.error("Error in batch add: {}", e.getMessage());
+            throw new RuntimeException("Failed to add values to Redis", e);
+        }
     }
+    public List<String> autocomplete(String keyword) {
+        if (keyword == null || keyword.trim().isEmpty()) {
+            return Collections.emptyList();
+        }
+
+        String searchKeyword = keyword.trim();
+        String min = searchKeyword;
+        String max = searchKeyword + "\uffff";
 
-    public Long findFromSortedSet(String value) {   //Redis SortedSet에서 Value를 찾아 인덱스를 반환
-        return redisTemplate.opsForZSet().rank(key, value);
+        try {
+            List<String> results = redisTemplate.opsForZSet()
+                    .rangeByLex(KEY, Range.rightOpen(min, max))
+                    .stream()
+                    .filter(value -> value.endsWith(SUFFIX)) // 완전한 단어만 필터링
+                    .map(value -> value.replace(SUFFIX, ""))
+                    .limit(MAX_RESULTS)
+                    .toList();
+
+            return results;
+        } catch (Exception e) {
+            log.error("Error in autocomplete: {}", e.getMessage());
+            return Collections.emptyList();
+        }
     }
 
-    public Set<String> findAllValuesAfterIndexFromSortedSet(Long index) {
-        return redisTemplate.opsForZSet().range(key, index, index + 10);   //전체를 다 불러오기 보다는 200개 정도만 가져와도 자동 완성을 구현하는 데 무리가 없으므로 200개로 rough하게 설정
+    public void clearAll() {
+        try {
+            redisTemplate.delete(KEY);
+        } catch (Exception e) {
+            log.error("Error clearing Redis: {}", e.getMessage());
+            throw new RuntimeException("Failed to clear Redis", e);
+        }
     }
 }
+
+
+

src/main/java/org/com/stocknote/domain/hashtagAutocomplete/controller/HashtagAutocompleteController.java

@@ -17,6 +17,6 @@ public class HashtagAutocompleteController {
 
     @GetMapping("/search/{q}")
     public List<String> query(@PathVariable("q") String query) {
-        return hashtagAutocompleteService.autocorrect(query);
+        return hashtagAutocompleteService.autocomplete(query);
     }
 }

src/main/java/org/com/stocknote/domain/hashtagAutocomplete/service/HashtagAutocompleteService.java

@@ -4,56 +4,37 @@
 import org.com.stocknote.domain.stock.repository.StockRepository;
 import org.springframework.transaction.annotation.Transactional;
 import lombok.RequiredArgsConstructor;
-import org.apache.commons.lang3.StringUtils;
 import org.com.stocknote.domain.hashtagAutocomplete.RedisSortedSetService;
 import org.springframework.stereotype.Service;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
+
 
 @Service
 @Transactional(readOnly = true)
 @RequiredArgsConstructor
 public class HashtagAutocompleteService {
     private final StockRepository stockRepository;
     private final RedisSortedSetService redisSortedSetService;
-    private String suffix = "*";    //검색어 자동 완성 기능에서 실제 노출될 수 있는 완벽한 형태의 단어를 구분하기 위한 접미사
-    private int maxSize = 10;    //검색어 자동 완성 기능 최대 개수
+    private static final int MAX_SIZE = 10;
 
     @PostConstruct
-    public void init() {    //이 Service Bean이 생성된 이후에 검색어 자동 완성 기능을 위한 데이터들을 Redis에 저장 (Redis는 인메모리 DB라 휘발성을 띄기 때문)
-        saveAllSubstring(stockRepository.findAllName()); //MySQL DB에 저장된 모든 가게명을 음절 단위로 잘라 모든 Substring을 Redis에 저장해주는 로직
-    }
+    public void init() {
+        redisSortedSetService.clearAll();
 
-    private void saveAllSubstring(List<String> allDisplayName) { //MySQL DB에 저장된 모든 가게명을 음절 단위로 잘라 모든 Substring을 Redis에 저장해주는 로직
-        // long start1 = System.currentTimeMillis(); //뒤에서 성능 비교를 위해 시간을 재는 용도
-        for (String displayName : allDisplayName) {
-            redisSortedSetService.addToSortedSet(displayName + suffix);   //완벽한 형태의 단어일 경우에는 *을 붙여 구분
-
-            for (int i = displayName.length(); i > 0; --i) { //음절 단위로 잘라서 모든 Substring 구하기
-                redisSortedSetService.addToSortedSet(displayName.substring(0, i)); //곧바로 redis에 저장
-            }
+        List<String> allNames = stockRepository.findAllName();
+        if (allNames != null && !allNames.isEmpty()) {
+            redisSortedSetService.addAllToSortedSet(allNames);
         }
-        // long end1 = System.currentTimeMillis(); //뒤에서 성능 비교를 위해 시간을 재는 용도
-        // long elapsed1 = end1 - start1;  //뒤에서 성능 비교를 위해 시간을 재는 용도
     }
 
-    public List<String> autocorrect(String keyword) { //검색어 자동 완성 기능 관련 로직
-        Long index = redisSortedSetService.findFromSortedSet(keyword);  //사용자가 입력한 검색어를 바탕으로 Redis에서 조회한 결과 매칭되는 index
-
-        if (index == null) {
-            return new ArrayList<>();   //만약 사용자 검색어 바탕으로 자동 완성 검색어를 만들 수 없으면 Empty Array 리턴
+    public List<String> autocomplete(String keyword) {
+        if (keyword == null || keyword.trim().isEmpty()) {
+            return Collections.emptyList();
         }
 
-        Set<String> allValuesAfterIndexFromSortedSet = redisSortedSetService.findAllValuesAfterIndexFromSortedSet(index);   //사용자 검색어 이후로 정렬된 Redis 데이터들 가져오기
-
-        List<String> autocorrectKeywords = allValuesAfterIndexFromSortedSet.stream()
-                .filter(value -> value.endsWith(suffix) && value.startsWith(keyword))
-                .map(value -> StringUtils.removeEnd(value, suffix))
-                .limit(maxSize)
-                .toList();  //자동 완성을 통해 만들어진 최대 maxSize개의 키워드들
-
-        return autocorrectKeywords;
+        return redisSortedSetService.autocomplete(keyword.trim());
     }
 }
+
+

src/main/java/org/com/stocknote/domain/post/controller/PostController.java

@@ -46,7 +46,7 @@ public GlobalResponse<Long> createPost(
     ) {
         Member member = principalDetails.user();
         Post post = postService.createPost(postResponseDto, member);
-        PostDoc postDoc= searchDocService.savePostDoc(post);
+        PostDoc postDoc= searchDocService.transformPostDoc(post);
         keywordNotificationElasticService.createKeywordNotification(postDoc);
         return GlobalResponse.success(post.getId());
     }

src/main/java/org/com/stocknote/domain/searchDoc/service/SearchDocService.java

@@ -120,4 +120,24 @@ public Page<PostDoc> searchPosts(PostSearchConditionDto condition, Pageable page
       return Page.empty(pageable);
     }
   }
+
+  public PostDoc transformPostDoc(Post post) {
+    List<Hashtag> hashtags = hashtagRepository.findByPostId(post.getId());
+
+    List<String> hashtagList = hashtags.stream()
+            .map(Hashtag::getName)
+            .collect(Collectors.toList());
+
+    PostDoc postDoc = PostDoc.builder()
+            .id(post.getId().toString())
+            .createdAt(post.getCreatedAt().toString())
+            .modifiedAt(post.getModifiedAt().toString())
+            .title(post.getTitle())
+            .body(post.getBody())
+            .category(post.getCategory())
+            .hashtags(hashtagList) // 본문에서 해시태그 추출하는 메소드 필요
+            .memberDoc(convertToMemberDoc(post.getMember())) // Member를 MemberDoc으로 변환하는 메소드 필요
+            .build();
+    return postDoc;
+  }
 }

src/main/java/org/com/stocknote/domain/stock/repository/StockRepository.java

@@ -22,4 +22,6 @@ public interface StockRepository extends JpaRepository<Stock, String> {
 
   @Query("SELECT s.name FROM Stock s")
   List<String> findAllName();
+
+    List<Stock> findByNameStartingWithIgnoreCase(String searchKeyword);
 }

src/main/java/org/com/stocknote/domain/stock/service/StockService.java

@@ -51,7 +51,7 @@ public List<Stock> searchStocks(String keyword) {
 
         String searchKeyword = keyword.toLowerCase();
         return stockRepository.findByNameContainingIgnoreCaseOrCodeContainingIgnoreCase(searchKeyword,
-            searchKeyword);
+                searchKeyword);
     }
 
     @Transactional