release

build.gradle

@@ -81,6 +81,8 @@ dependencies {
     implementation 'org.flywaydb:flyway-mysql'
     implementation 'com.github.ben-manes.caffeine:caffeine:3.1.8'
 
+    // circuit breaker dependencies
+    implementation 'io.github.resilience4j:resilience4j-spring-boot3:2.2.0'
 }
 
 dependencyManagement {

src/main/java/sevenstar/marineleisure/activity/service/ActivityService.java

@@ -29,7 +29,9 @@
 import sevenstar.marineleisure.global.enums.ActivityCategory;
 import sevenstar.marineleisure.global.enums.TimePeriod;
 import sevenstar.marineleisure.spot.domain.OutdoorSpot;
+import sevenstar.marineleisure.spot.dto.SpotPreviewReadResponse;
 import sevenstar.marineleisure.spot.repository.OutdoorSpotRepository;
+import sevenstar.marineleisure.spot.service.SpotService;
 
 @Service
 @RequiredArgsConstructor
@@ -42,6 +44,8 @@ public class ActivityService {
     private final ScubaRepository scubaRepository;
     private final SurfingRepository surfingRepository;
 
+    private final SpotService spotService;
+
     @Transactional(readOnly = true)
     public Map<String, ActivitySummaryResponse> getActivitySummary(BigDecimal latitude, BigDecimal longitude,
         boolean global) {
@@ -55,90 +59,92 @@ public Map<String, ActivitySummaryResponse> getActivitySummary(BigDecimal latitu
     private Map<String, ActivitySummaryResponse> getLocalActivitySummary(BigDecimal latitude, BigDecimal longitude) {
         Map<String, ActivitySummaryResponse> responses = new HashMap<>();
 
-        Fishing fishingBySpot = null;
-        Mudflat mudflatBySpot = null;
-        Surfing surfingBySpot = null;
-        Scuba scubaBySpot = null;
-
-        LocalDateTime startOfDay = LocalDate.now().atStartOfDay();
-        LocalDateTime endOfDay = startOfDay.plusDays(1);
-
-        List<OutdoorSpot> outdoorSpotList = outdoorSpotRepository.findByCoordinates(latitude, longitude, 10);
-
-        while (fishingBySpot == null || mudflatBySpot == null || surfingBySpot == null || scubaBySpot == null) {
-
-            OutdoorSpot currentSpot;
-            Long currentSpotId;
-
-            try {
-                currentSpot = outdoorSpotList.removeFirst();
-                currentSpotId = currentSpot.getId();
-            } catch (Exception e) {
-                break;
-            }
-
-            if (fishingBySpot == null) {
-                Optional<Fishing> fishingResult = fishingRepository.findFirstBySpotIdAndCreatedAtGreaterThanEqualAndCreatedAtLessThanOrderByCreatedAtDesc(
-                    currentSpotId, startOfDay, endOfDay);
-
-                if (fishingResult.isPresent()) {
-                    fishingBySpot = fishingResult.get();
-                    responses.put("Fishing",
-                        new ActivitySummaryResponse(currentSpot.getName(), fishingResult.get().getTotalIndex()));
-                }
-            }
-
-            if (mudflatBySpot == null) {
-                Optional<Mudflat> mudflatResult = mudflatRepository.findFirstBySpotIdAndCreatedAtGreaterThanEqualAndCreatedAtLessThanOrderByCreatedAtDesc(
-                    currentSpotId, startOfDay, endOfDay);
-
-                if (mudflatResult.isPresent()) {
-                    mudflatBySpot = mudflatResult.get();
-                    responses.put("Mudflat",
-                        new ActivitySummaryResponse(currentSpot.getName(), mudflatResult.get().getTotalIndex()));
-                }
-            }
-
-            if (surfingBySpot == null) {
-                Optional<Surfing> surfingResult = surfingRepository.findFirstBySpotIdAndCreatedAtGreaterThanEqualAndCreatedAtLessThanOrderByCreatedAtDesc(
-                    currentSpotId, startOfDay, endOfDay);
-
-                if (surfingResult.isPresent()) {
-                    surfingBySpot = surfingResult.get();
-                    responses.put("Surfing",
-                        new ActivitySummaryResponse(currentSpot.getName(), surfingResult.get().getTotalIndex()));
-                }
-            }
-
-            if (scubaBySpot == null) {
-                Optional<Scuba> scubaResult = scubaRepository.findFirstBySpotIdAndCreatedAtGreaterThanEqualAndCreatedAtLessThanOrderByCreatedAtDesc(
-                    currentSpotId, startOfDay, endOfDay);
-
-                if (scubaResult.isPresent()) {
-                    scubaBySpot = scubaResult.get();
-                    responses.put("Scuba",
-                        new ActivitySummaryResponse(currentSpot.getName(), scubaResult.get().getTotalIndex()));
-                }
-            }
-        }
+        SpotPreviewReadResponse preview = spotService.preview(latitude.floatValue(), longitude.floatValue());
+        responses.put("Fishing",
+            new ActivitySummaryResponse(preview.fishing().getName(), preview.fishing().getTotalIndex()));
+        responses.put("Mudflat",new ActivitySummaryResponse(preview.mudflat().getName(), preview.mudflat().getTotalIndex()));
+        responses.put("Surfing", new ActivitySummaryResponse(preview.surfing().getName(), preview.surfing().getTotalIndex()));
+        responses.put("Scuba", new ActivitySummaryResponse(preview.scuba().getName(), preview.scuba().getTotalIndex()));
+
+        // Fishing fishingBySpot = null;
+        // Mudflat mudflatBySpot = null;
+        // Surfing surfingBySpot = null;
+        // Scuba scubaBySpot = null;
+        //
+        // LocalDateTime startOfDay = LocalDate.now().atStartOfDay();
+        // LocalDateTime endOfDay = startOfDay.plusDays(1);
+        //
+        // List<OutdoorSpot> outdoorSpotList = outdoorSpotRepository.findByCoordinates(latitude, longitude, 10);
+        //
+        // while (fishingBySpot == null || mudflatBySpot == null || surfingBySpot == null || scubaBySpot == null) {
+        //
+        //     OutdoorSpot currentSpot;
+        //     Long currentSpotId;
+        //
+        //     try {
+        //         currentSpot = outdoorSpotList.removeFirst();
+        //         currentSpotId = currentSpot.getId();
+        //     } catch (Exception e) {
+        //         break;
+        //     }
+        //
+        //     if (fishingBySpot == null) {
+        //         Optional<Fishing> fishingResult = fishingRepository.findFirstBySpotIdAndCreatedAtGreaterThanEqualAndCreatedAtLessThanOrderByCreatedAtDesc(
+        //             currentSpotId, startOfDay, endOfDay);
+        //
+        //         if (fishingResult.isPresent()) {
+        //             fishingBySpot = fishingResult.get();
+        //             responses.put("Fishing",
+        //                 new ActivitySummaryResponse(currentSpot.getName(), fishingResult.get().getTotalIndex()));
+        //         }
+        //     }
+        //
+        //     if (mudflatBySpot == null) {
+        //         Optional<Mudflat> mudflatResult = mudflatRepository.findFirstBySpotIdAndCreatedAtGreaterThanEqualAndCreatedAtLessThanOrderByCreatedAtDesc(
+        //             currentSpotId, startOfDay, endOfDay);
+        //
+        //         if (mudflatResult.isPresent()) {
+        //             mudflatBySpot = mudflatResult.get();
+        //             responses.put("Mudflat",
+        //                 new ActivitySummaryResponse(currentSpot.getName(), mudflatResult.get().getTotalIndex()));
+        //         }
+        //     }
+        //
+        //     if (surfingBySpot == null) {
+        //         Optional<Surfing> surfingResult = surfingRepository.findFirstBySpotIdAndCreatedAtGreaterThanEqualAndCreatedAtLessThanOrderByCreatedAtDesc(
+        //             currentSpotId, startOfDay, endOfDay);
+        //
+        //         if (surfingResult.isPresent()) {
+        //             surfingBySpot = surfingResult.get();
+        //             responses.put("Surfing",
+        //                 new ActivitySummaryResponse(currentSpot.getName(), surfingResult.get().getTotalIndex()));
+        //         }
+        //     }
+        //
+        //     if (scubaBySpot == null) {
+        //         Optional<Scuba> scubaResult = scubaRepository.findFirstBySpotIdAndCreatedAtGreaterThanEqualAndCreatedAtLessThanOrderByCreatedAtDesc(
+        //             currentSpotId, startOfDay, endOfDay);
+        //
+        //         if (scubaResult.isPresent()) {
+        //             scubaBySpot = scubaResult.get();
+        //             responses.put("Scuba",
+        //                 new ActivitySummaryResponse(currentSpot.getName(), scubaResult.get().getTotalIndex()));
+        //         }
+        //     }
+        // }
 
         return responses;
     }
 
     private Map<String, ActivitySummaryResponse> getGlobalActivitySummary() {
         Map<String, ActivitySummaryResponse> responses = new HashMap<>();
 
-        LocalDateTime startOfDay = LocalDate.now().atStartOfDay();
-        LocalDateTime endOfDay = startOfDay.plusDays(1);
+        LocalDate now = LocalDate.now();
 
-        Optional<Fishing> fishingResult = fishingRepository.findTopByCreatedAtGreaterThanEqualAndCreatedAtLessThanOrderByTotalIndexDesc(
-            startOfDay, endOfDay);
-        Optional<Mudflat> mudflatResult = mudflatRepository.findTopByCreatedAtGreaterThanEqualAndCreatedAtLessThanOrderByTotalIndexDesc(
-            startOfDay, endOfDay);
-        Optional<Surfing> surfingResult = surfingRepository.findTopByCreatedAtGreaterThanEqualAndCreatedAtLessThanOrderByTotalIndexDesc(
-            startOfDay, endOfDay);
-        Optional<Scuba> scubaResult = scubaRepository.findTopByCreatedAtGreaterThanEqualAndCreatedAtLessThanOrderByTotalIndexDesc(
-            startOfDay, endOfDay);
+        Optional<Fishing> fishingResult = fishingRepository.findBestTotaIndexFishing(now);
+        Optional<Mudflat> mudflatResult = mudflatRepository.findBestTotaIndexMudflat(now);
+        Optional<Surfing> surfingResult = surfingRepository.findBestTotaIndexSurfing(now);
+        Optional<Scuba> scubaResult = scubaRepository.findBestTotaIndexScuba(now);
 
         if (fishingResult.isPresent()) {
             Fishing fishing = fishingResult.get();
@@ -225,4 +231,6 @@ public ActivityWeatherResponse getWeatherBySpot(Float latitude, Float longitude)
             fishing.getSeaTempMax().toString()
         );
     }
+
+
 }

src/main/java/sevenstar/marineleisure/alert/controller/AlertController.java

@@ -1,13 +1,16 @@
 package sevenstar.marineleisure.alert.controller;
 
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
 import lombok.RequiredArgsConstructor;
+import sevenstar.marineleisure.alert.dto.response.JellyfishResponse;
 import sevenstar.marineleisure.alert.dto.response.JellyfishResponseDto;
 import sevenstar.marineleisure.alert.dto.vo.JellyfishDetailVO;
 import sevenstar.marineleisure.alert.mapper.AlertMapper;
@@ -26,9 +29,11 @@ public class AlertController {
 	 * @return 해파리 발생 관련 정보
 	 */
 	@GetMapping("/jellyfish")
-	public ResponseEntity<BaseResponse<JellyfishResponseDto>> getJellyfishList() {
+	public ResponseEntity<BaseResponse<JellyfishResponse>> getJellyfishList() {
 		List<JellyfishDetailVO> items = jellyfishService.search();
-		JellyfishResponseDto result = alertMapper.toResponseDto(items);
+		Map<String, Set<String>> map = jellyfishService.convert(items);
+
+		JellyfishResponse result = alertMapper.toResponseDto(items.getFirst().getReportDate(), map);
 		return BaseResponse.success(result);
 	}
 

src/main/java/sevenstar/marineleisure/alert/dto/response/JellyfishResponse.java

@@ -0,0 +1,17 @@
+package sevenstar.marineleisure.alert.dto.response;
+
+import java.time.LocalDate;
+import java.util.Map;
+import java.util.Set;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class JellyfishResponse {
+	private LocalDate reposrtDate;
+	private Map<String, Set<String>> jellyfish;
+}

src/main/java/sevenstar/marineleisure/alert/mapper/AlertMapper.java

@@ -1,39 +1,19 @@
 package sevenstar.marineleisure.alert.mapper;
 
 import java.time.LocalDate;
-import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 import org.springframework.stereotype.Component;
 
 import lombok.RequiredArgsConstructor;
-import sevenstar.marineleisure.alert.dto.response.JellyfishResponseDto;
-import sevenstar.marineleisure.alert.dto.vo.JellyfishDetailVO;
-import sevenstar.marineleisure.alert.dto.vo.JellyfishRegionVO;
-import sevenstar.marineleisure.alert.dto.vo.JellyfishSpeciesVO;
-import sevenstar.marineleisure.global.enums.DensityLevel;
-import sevenstar.marineleisure.global.enums.ToxicityLevel;
+import sevenstar.marineleisure.alert.dto.response.JellyfishResponse;
 
 @Component
 @RequiredArgsConstructor
 public class AlertMapper {
 
-	public JellyfishResponseDto toResponseDto(List<JellyfishDetailVO> detailList) {
-		if (detailList.isEmpty()) {
-			return null;
-		}
-		LocalDate reportDate = detailList.get(0).getReportDate();
-
-		List<JellyfishRegionVO> regions = detailList.stream()
-			.map(detail -> new JellyfishRegionVO(
-				detail.getRegion(),
-				new JellyfishSpeciesVO(
-					detail.getSpecies(),
-					ToxicityLevel.valueOf(detail.getToxicity()).getDescription(),
-					DensityLevel.valueOf(detail.getDensityType()).getDescription()
-				)
-			))
-			.toList();
-
-		return new JellyfishResponseDto(reportDate, regions);
+	public JellyfishResponse toResponseDto(LocalDate reportDate, Map<String, Set<String>> map) {
+		return new JellyfishResponse(reportDate, map);
 	}
 }

src/main/java/sevenstar/marineleisure/alert/service/JellyfishService.java

@@ -3,8 +3,13 @@
 import java.io.File;
 import java.io.IOException;
 import java.time.LocalDate;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
+import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.client.RestTemplate;
@@ -56,7 +61,7 @@ public JellyfishSpecies searchByName(String name) {
 	/**
 	 * 웹에서 크롤링 해 Pdf를 DB에 적재합니다.
 	 */
-	// @Scheduled(cron = "0 0 0 ? * FRI")
+	@Scheduled(cron = "0 0 0 ? * FRI")
 	// 금요일 00시에 동작합니다.
 	@Transactional
 	public void updateLatestReport() {
@@ -104,4 +109,15 @@ public void updateLatestReport() {
 		}
 	}
 
+	public Map<String, Set<String>> convert(List<JellyfishDetailVO> jellyfish) {
+		Map<String, Set<String>> map = new HashMap<>();
+		for (JellyfishDetailVO detail : jellyfish) {
+			if (map.containsKey(detail.getSpecies())) {
+				map.get(detail.getSpecies()).add(detail.getRegion());
+			} else {
+				map.put(detail.getSpecies(), new HashSet<>(List.of(detail.getRegion())));
+			}
+		}
+		return map;
+	}
 }

src/main/java/sevenstar/marineleisure/alert/util/JellyfishExtractor.java

@@ -9,6 +9,7 @@
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
 
+import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import sevenstar.marineleisure.alert.dto.vo.ParsedJellyfishVO;
@@ -21,6 +22,7 @@ public class JellyfishExtractor {
 	private final OpenAiChatModel chatModel;
 	private final ObjectMapper objectMapper;
 
+	@CircuitBreaker(name = "openai-api", fallbackMethod = "fallbackExtractJellyfishData")
 	public List<ParsedJellyfishVO> extractJellyfishData(String text) {
 		try {
 			String instruction = """
@@ -71,4 +73,9 @@ public List<ParsedJellyfishVO> extractJellyfishData(String text) {
 			return List.of();
 		}
 	}
+
+	public List<ParsedJellyfishVO> fallbackExtractJellyfishData(String text, Throwable t) {
+		log.error("OpenAI API 호출에 실패하여 fallback 메서드가 실행되었습니다. message: {}", t.getMessage());
+		return List.of();
+	}
 }

src/main/java/sevenstar/marineleisure/forecast/repository/FishingRepository.java

@@ -118,6 +118,15 @@ Optional<Fishing> findFirstBySpotIdAndCreatedAtGreaterThanEqualAndCreatedAtLessT
 		LocalDateTime endDateTime
 	);
 
+	@Query(value = """
+        SELECT *
+        FROM fishing_forecast f
+        WHERE f.forecast_date = :forecastDate
+        ORDER BY f.total_index DESC
+        LIMIT 1
+        """,nativeQuery = true)
+	Optional<Fishing> findBestTotaIndexFishing(@Param("forecastDate") LocalDate forecastDate);
+
 	Optional<Fishing> findTopByCreatedAtGreaterThanEqualAndCreatedAtLessThanOrderByTotalIndexDesc(LocalDateTime start,
 		LocalDateTime end);