외부 API 호출과 데이터 처리

@Component  
public class DataParser {  
  
    private static final String CSV_FILE = "src/main/resources/location_mapping.csv";  
    private static final String DELIMITER = ",";  
  
    /*  
     * CSV 파일을 읽고 PlaceInfo 객체로 변환한다  
     */    public List<PlaceInfo> readCSV() {  
       List<PlaceInfo> placeInfos;  
  
       try (final BufferedReader reader = Files.newBufferedReader(Paths.get(CSV_FILE))) {  
          placeInfos = reader.lines()  
             .skip(1) // skip header  
             .map(line -> line.split(DELIMITER)) // split by delimiter  
             .map(tokens -> new PlaceInfo(  
                new AreaInfo(tokens[1], tokens[2]),  
                new LocationInfo(tokens[3], tokens[4]),  
                new WeatherInfo(tokens[5], tokens[6])  
             ))// map to PlaceInfo  
             .toList();  
       } catch (IOException e) {  
          throw new RuntimeException(e);  
       }  
  
       return placeInfos;  
    }  
}

@Component  
@RequiredArgsConstructor  
public class DataStore {  
  
    private final DataParser dataParser;  
    private List<PlaceInfo> placeInfos;  
  
    @PostConstruct  
    public void initializeData() {  
       placeInfos = dataParser.readCSV();  
    }
}

@Component  
@RequiredArgsConstructor  
public class DataProcessor {  
  
    private final WeatherService weatherService;  
    private final CongestionService congestionService;  
    private final DataSaveService dataSaveService;  
    private final CSVDataStore csvDataStore;  
  
    public void process() {  
       final List<PlaceInfo> placeInfos = csvDataStore.getPlaceInfos();  
       final List<Place> places = new ArrayList<>();  
  
       for (final PlaceInfo placeInfo : placeInfos) {  
          final Place place = aggregatePlace(placeInfo);  
          places.add(place);  
          break;  
       }  
  
       dataSaveService.saveAll(places);  
    }  
  
    private Place aggregatePlace(final PlaceInfo placeInfo) {  
       final AreaInfo areaInfo = placeInfo.areaInfo();  
       final LocationInfo locationInfo = placeInfo.locationInfo();  
       final WeatherInfo weatherInfo = placeInfo.weatherInfo();  
  
       final Congestion congestion = congestionService.fetch(areaInfo.areaCode());  
       final Weather weather = weatherService.fetch(weatherInfo.latitude(), weatherInfo.longitude());  
       final Location location = Location.of(Double.valueOf(locationInfo.latitude()), Double.valueOf(locationInfo.longitude()));  
  
       return PlaceMapper.toPlace(areaInfo.areaName(), location, weather, congestion);  
    }
}

public void process() {  
    final List<Place> places = dataQueryService.findAllPlaces();  
    final List<CompletableFuture<WeatherAndCongestion>> futures = new ArrayList<>();  
  
    for (final Place place : places) {  
       futures.add(toFuture(place));  
    }  
  
    final List<WeatherAndCongestion> weatherAndCongestions = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))  
       .thenApply(Void -> futures.stream()  
          .map(CompletableFuture::join)  
          .filter(Objects::nonNull)  
          .toList())  
       .join();  
  
    dataQueryService.saveAllWeatherAndCongestions(weatherAndCongestions);  
}  
  
private CompletableFuture<WeatherAndCongestion> toFuture(final Place place) {  
    return CompletableFuture.supplyAsync(() -> fetch(place), weatherCongestionAPIThreadPool)  
       .exceptionally(exception -> {  
          log.debug("외부 API 호출 및 가져오기에 실패했습니다: 장소: {}. Error: {}. 현재 시간 : {}", place, exception, LocalDateTime.now());  
          return null;  
       });  
}  
  
private WeatherAndCongestion fetch(final Place place) {  
    final PlaceNameAndCode placeNameAndCode = place.placeNameAndCode();  
    final WeatherPosition weatherPosition = place.weatherPosition();  
  
    final Congestion congestion = congestionFetchService.fetch(placeNameAndCode.code());  
    final Weather weather = weatherFetchService.fetch(weatherPosition.weatherX(), weatherPosition.weatherY());  
  
    return new WeatherAndCongestion(place.id(), weather, congestion);  
}

@Override  
public void saveAll(final List<WeatherAndCongestion> weatherAndCongestions) {  
    final List<CongestionEntity> congestionEntities = toEntities(weatherAndCongestions);  
  
    final String sql = """  
       INSERT INTO congestion (place_id, current_people, congestion_indicator, created_at, updated_at)  
       VALUES (?, ?, ?, now(), now())  
       """;  
  
    jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {  
       @Override  
       public void setValues(PreparedStatement ps, int i) throws SQLException {  
          final CongestionEntity congestion = congestionEntities.get(i);  
          ps.setLong(1, congestion.getPlaceId());  
          ps.setInt(2, congestion.getCurrentPeople());  
          ps.setString(3, congestion.getCongestionIndicator());  
       }  
  
       @Override  
       public int getBatchSize() {  
          return congestionEntities.size();  
       }  
    });  
}

public void process() {  
    dataQueryService.deleteAllPlaceInfos();    
    final InputStream fetch = placeInfoService.fetch();  
    List<PlaceInfo> placeInfos;  
    try {  
       Map<String, byte[]> fileMap = dataParser.processZipFile(fetch);  
       placeInfos = dataParser.parse(fileMap, fileName);  
    } catch (Exception e) {  
       throw new FailReadingFileException(e);  
    }  
    dataQueryService.saveAllPlaceInfos(placeInfos);  
}

public class PlaceEntity {
	//
	private int version;
	//
}

public class PlaceEntity {
	//
	@Column(length = 10, unique = true)  
	private String code;
	//
}

final String sql = """  
    INSERT INTO place (name, code, latitude, longitude, weatherX, weatherY, created_at, updated_at)  
    VALUES (?, ?, ?, ?, ?, ?, now(), now())  
    ON DUPLICATE KEY UPDATE  
    name = VALUES(name),  
    latitude = VALUES(latitude),  
    longitude = VALUES(longitude),  
    weatherX = VALUES(weatherX),  
    weatherY = VALUES(weatherY),  
    updated_at = now()  
    """;