Merge pull request #81 from Final-Project-Team-Temporary/feature/사용자-이름-추가

Feat 퀴즈 생성 오류 수정

Author: psb3707

src/main/java/com/example/whiplash/global/config/ObjectMapperConfig.java

@@ -2,21 +2,45 @@
 
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
 
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.databind.jsontype.BasicPolymorphicTypeValidator;
+import com.fasterxml.jackson.databind.jsontype.PolymorphicTypeValidator;
 import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
 import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
 
 @Configuration
 public class ObjectMapperConfig {
+
+	/**
+	 * HTTP Request/Response용 ObjectMapper (Primary)
+	 */
 	@Bean
-	ObjectMapper objectMapper() {
-		// ObjectMapper 커스터마이징
+	@Primary
+	public ObjectMapper objectMapper() {
 		ObjectMapper objectMapper = new ObjectMapper();
 
 		setLocalDateTimeModule(objectMapper);
+		setDeserializationConfig(objectMapper);
+		// ⭐ HTTP용은 타입 정보 비활성화 (클라이언트 JSON에 @class 필드 없음)
+
+		return objectMapper;
+	}
+
+	/**
+	 * Redis 직렬화/역직렬화 전용 ObjectMapper
+	 */
+	@Bean("redisObjectMapper")
+	public ObjectMapper redisObjectMapper() {
+		ObjectMapper objectMapper = new ObjectMapper();
+
+		setLocalDateTimeModule(objectMapper);
+		setDeserializationConfig(objectMapper);
+		setPolymorphicTypeValidation(objectMapper);  // ⭐ Redis용은 타입 정보 활성화
 
 		return objectMapper;
 	}
@@ -25,4 +49,24 @@ private static void setLocalDateTimeModule(ObjectMapper objectMapper) {
 		objectMapper.registerModule(new JavaTimeModule());	// ISO 8601로 직렬화
 		objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);	// LocalDateTime을 timestamp 형식으로 직렬화 안함
 	}
+
+	private static void setDeserializationConfig(ObjectMapper objectMapper) {
+		// 알 수 없는 속성이 있어도 무시 (역직렬화 시 유연성 - Redis에서 필요)
+		objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+	}
+
+	private static void setPolymorphicTypeValidation(ObjectMapper objectMapper) {
+		// Redis 역직렬화를 위한 타입 정보 활성화
+		PolymorphicTypeValidator ptv = BasicPolymorphicTypeValidator.builder()
+			.allowIfBaseType(Object.class)
+			.allowIfBaseType(java.util.List.class)
+			.allowIfBaseType(java.util.ArrayList.class)
+			.build();
+
+		objectMapper.activateDefaultTyping(
+			ptv,
+			ObjectMapper.DefaultTyping.NON_FINAL,
+			JsonTypeInfo.As.PROPERTY
+		);
+	}
 }

src/main/java/com/example/whiplash/global/config/RedisConfig.java

@@ -1,5 +1,6 @@
 package com.example.whiplash.global.config;
 
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -18,7 +19,6 @@
 @RequiredArgsConstructor
 @Configuration
 public class RedisConfig {
-    private final ObjectMapper objectMapper;
 
     @Bean
     public RedisConnectionFactory redisConnectionFactory(
@@ -42,14 +42,17 @@ public RedisConnectionFactory redisConnectionFactory(
     }
 
     @Bean
-    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
+    public RedisTemplate<String, Object> redisTemplate(
+            RedisConnectionFactory factory,
+            @Qualifier("redisObjectMapper") ObjectMapper redisObjectMapper) {
+
         RedisTemplate<String, Object> template = new RedisTemplate<>();
         template.setConnectionFactory(factory);
 
         // Key는 StringSerializer
         StringRedisSerializer stringSerializer = new StringRedisSerializer();
-        // Value는 JSON
-        GenericJackson2JsonRedisSerializer jsonSerializer = new GenericJackson2JsonRedisSerializer(objectMapper);
+        // Value는 JSON (Redis 전용 ObjectMapper 사용)
+        GenericJackson2JsonRedisSerializer jsonSerializer = new GenericJackson2JsonRedisSerializer(redisObjectMapper);
 
         template.setKeySerializer(stringSerializer);
         template.setValueSerializer(jsonSerializer);

src/main/java/com/example/whiplash/quiz/client/AiServerClient.java

@@ -47,7 +47,7 @@ public QuizResDto generateQuiz(String keyword, int count) {
                         return Mono.error(new RuntimeException("AI 서버 응답 실패"));
                     })
                     .bodyToMono(QuizResDto.class)
-                    .timeout(Duration.ofSeconds(10))
+                    .timeout(Duration.ofSeconds(100))
                     .block();  // 동기 방식으로 대기
 
             if (response != null) {

src/main/java/com/example/whiplash/quiz/controller/QuizController.java

@@ -147,4 +147,29 @@ public ApiResponse<WeeklyChallengeResDto.MyAttemptInfo> submitChallenge(
 
         return ApiResponse.onSuccess(result);
     }
+
+    /**
+     * ⭐ 퀴즈 캐시 초기화 (디버깅용)
+     */
+    @DeleteMapping("/cache")
+    @Operation(summary = "퀴즈 캐시 초기화", description = "사용자의 모든 퀴즈 캐시를 삭제합니다 (역직렬화 오류 해결용)")
+    public ApiResponse<String> clearQuizCache(
+            @AuthenticationPrincipal UserPrincipal principal,
+            @RequestParam(required = false) String term
+    ) {
+
+        Long userId = principal.getUserId();
+
+        if (term != null && !term.isBlank()) {
+            // 특정 용어의 캐시만 삭제
+            mixedQuizService.clearTermQuizCache(userId, term);
+            log.info("용어 퀴즈 캐시 삭제: userId={}, term={}", userId, term);
+            return ApiResponse.onSuccess("용어 '" + term + "'의 캐시가 삭제되었습니다.");
+        } else {
+            // 모든 퀴즈 캐시 삭제
+            mixedQuizService.clearUserQuizCache(userId);
+            log.info("모든 퀴즈 캐시 삭제: userId={}", userId);
+            return ApiResponse.onSuccess("모든 퀴즈 캐시가 삭제되었습니다.");
+        }
+    }
 }

src/main/java/com/example/whiplash/quiz/dto/response/QuizResDto.java

@@ -1,6 +1,7 @@
 package com.example.whiplash.quiz.dto.response;
 
 import com.example.whiplash.quiz.dto.QuizDto;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
@@ -12,6 +13,7 @@
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
+@JsonIgnoreProperties(ignoreUnknown = true)
 public class QuizResDto implements Serializable {
 
     private List<QuizDto> quizzes;

src/main/java/com/example/whiplash/quiz/service/MixedQuizService.java

@@ -83,16 +83,43 @@ private List<QuizDto> getQuizzesForTerm(Long userId, String term) {
         String cacheKey = CACHE_KEY_PREFIX + userId + ":" + term;
 
         // 1. 캐시 확인
-        QuizResDto cached = (QuizResDto) redisTemplate.opsForValue().get(cacheKey);
+        Object cachedData = redisTemplate.opsForValue().get(cacheKey);
 
-        if (cached != null) {
+        if (cachedData != null) {
             log.debug("캐시 히트: userId={}, term={}", userId, term);
-            return cached.getQuizzes();
+
+            try {
+                // Redis에서 QuizResDto로 역직렬화 (타입 정보 포함)
+                if (cachedData instanceof QuizResDto) {
+                    QuizResDto cached = (QuizResDto) cachedData;
+                    log.info("캐싱 데이터: term={}, count={}", term, cached.getQuizzes().size());
+                    return cached.getQuizzes();
+                } else {
+                    log.warn("예상치 못한 캐시 타입: {}", cachedData.getClass().getName());
+                    // 잘못된 타입이면 캐시 삭제 후 재생성
+                    redisTemplate.delete(cacheKey);
+                    return generateAndCacheQuiz(userId, term, cacheKey);
+                }
+            } catch (Exception e) {
+                // 역직렬화 실패 시 캐시 삭제 후 재생성
+                log.warn("캐시 역직렬화 실패 - 캐시 삭제 후 재생성: userId={}, term={}, error={}",
+                         userId, term, e.getMessage());
+                redisTemplate.delete(cacheKey);
+
+                // 재생성 후 반환
+                return generateAndCacheQuiz(userId, term, cacheKey);
+            }
         }
 
         // 2. 캐시 미스 - AI 서버 실시간 생성
         log.warn("캐시 미스 - 실시간 생성: userId={}, term={}", userId, term);
+        return generateAndCacheQuiz(userId, term, cacheKey);
+    }
 
+    /**
+     * 퀴즈 생성 및 캐싱 (공통 로직 분리)
+     */
+    private List<QuizDto> generateAndCacheQuiz(Long userId, String term, String cacheKey) {
         try {
             QuizResDto freshQuiz = aiServerClient.generateQuiz(term, 3);
 
@@ -103,11 +130,14 @@ private List<QuizDto> getQuizzesForTerm(Long userId, String term) {
                     java.time.Duration.ofDays(7)
             );
 
+            log.info("퀴즈 생성 및 캐싱 완료: userId={}, term={}, count={}",
+                     userId, term, freshQuiz.getQuizzes().size());
+
             return freshQuiz.getQuizzes();
 
         } catch (Exception e) {
             log.error("퀴즈 생성 실패: userId={}, term={}", userId, term, e);
-            throw new RuntimeException("퀴즈를 생성할 수 없습니다: " + term);
+            throw new RuntimeException("퀴즈를 생성할 수 없습니다: " + term, e);
         }
     }
 
@@ -132,4 +162,33 @@ private List<QuizDto> selectRandomQuizzes(List<QuizDto> quizzes, int count) {
     private int calculateEstimatedTime(int totalQuestions) {
         return (int) Math.ceil(totalQuestions * 0.5);  // 0.5분 = 30초
     }
+
+    /**
+     * 특정 사용자의 모든 퀴즈 캐시 삭제
+     */
+    public void clearUserQuizCache(Long userId) {
+        String pattern = CACHE_KEY_PREFIX + userId + ":*";
+
+        // 패턴에 맞는 키 찾기
+        var keys = redisTemplate.keys(pattern);
+
+        if (keys != null && !keys.isEmpty()) {
+            redisTemplate.delete(keys);
+            log.info("퀴즈 캐시 삭제 완료: userId={}, count={}", userId, keys.size());
+        } else {
+            log.info("삭제할 캐시가 없음: userId={}", userId);
+        }
+    }
+
+    /**
+     * 특정 용어의 퀴즈 캐시 삭제
+     */
+    public void clearTermQuizCache(Long userId, String term) {
+        String cacheKey = CACHE_KEY_PREFIX + userId + ":" + term;
+
+        Boolean deleted = redisTemplate.delete(cacheKey);
+
+        log.info("용어 퀴즈 캐시 삭제: userId={}, term={}, deleted={}",
+                 userId, term, deleted);
+    }
 }