홈화면 API

package com.example.investment.home.index.controller.dto;

public record KOSDAQResponse(String indexName, String indexValue, String fluctuationRate) {

}

package com.example.investment.home.index.controller.dto;

public record KOSPIResponse(String indexName, String indexValue, String fluctuationRate) {

}

package com.example.investment.home.index.controller;

import com.example.investment.home.index.controller.dto.KOSDAQResponse;
import com.example.investment.home.index.controller.dto.KOSPIResponse;
import com.example.investment.home.index.service.IndexService;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/home/index")
public class IndexController {

    private final IndexService indexService;

    public IndexController(IndexService indexService) {
        this.indexService = indexService;
    }

    @GetMapping("/kospi")
    public KOSPIResponse getKOSPIIndex() {
        return indexService.getKOSPIIndex();
    }

    @GetMapping("/kosdaq")
    public KOSDAQResponse getKOSDAQIndex() {
        return indexService.getKOSDAQIndex();
    }
}

package com.example.investment.home.index.infrastructure;

import com.example.investment.home.index.controller.dto.KOSDAQResponse;
import com.example.investment.home.index.controller.dto.KOSPIResponse;

import org.json.JSONArray;
import org.json.JSONObject;
import org.springframework.stereotype.Component;

@Component
public class IndexParser {

    public KOSPIResponse parseKOSPIResponse(JSONObject jsonObject) {
        JSONArray items = jsonObject
                .getJSONObject("response")
                .getJSONObject("body")
                .getJSONObject("items")
                .getJSONArray("item");
        JSONObject indexData = items.getJSONObject(0);

        String indexName = indexData.getString("idxNm");
        String indexValue = indexData.getString("clpr");
        String fluctuationRate = indexData.getString("fltRt");

        return new KOSPIResponse(indexName, indexValue, fluctuationRate);
    }

    public KOSDAQResponse parseKOSDAQResponse(JSONObject jsonObject) {
        JSONArray items = jsonObject
                .getJSONObject("response")
                .getJSONObject("body")
                .getJSONObject("items")
                .getJSONArray("item");

        JSONObject indexData = items.getJSONObject(0);
        String indexName = indexData.getString("idxNm");
        String indexValue = indexData.getString("clpr");
        String fluctuationRate = indexData.getString("fltRt");

        return new KOSDAQResponse(indexName, indexValue, fluctuationRate);
    }
}

package com.example.investment.home.index.service.client;

import com.example.investment.common.RestTemplateClient;
import com.example.investment.home.index.controller.dto.KOSDAQResponse;
import com.example.investment.home.index.controller.dto.KOSPIResponse;
import org.json.JSONArray;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.stereotype.Component;
import org.springframework.http.ResponseEntity;

import org.json.JSONObject;

@Component
public class IndexFetcher {

    @Value("${serviceKey}")
    private String serviceKey;

    private final RestTemplateClient restTemplateClient;

    public IndexFetcher(final RestTemplateClient restTemplateClient) {
        this.restTemplateClient = restTemplateClient;
    }

    public ResponseEntity<String> getKOSPIIndexData() {
        String url = "https://apis.data.go.kr/1160100/service/GetMarketIndexInfoService/getStockMarketIndex?serviceKey="
                + serviceKey + "&resultType=json&pageNo=1&numOfRows=1&idxNm=코스피";
        HttpHeaders headers = new HttpHeaders();
        return restTemplateClient.exchange(url, HttpMethod.GET, headers, null);
    }

    public ResponseEntity<String> getKOSDAQIndexData() {
        String url = "https://apis.data.go.kr/1160100/service/GetMarketIndexInfoService/getStockMarketIndex?serviceKey="
                + serviceKey + "&resultType=json&pageNo=1&numOfRows=1&idxNm=코스닥";
        HttpHeaders headers = new HttpHeaders();
        return restTemplateClient.exchange(url, HttpMethod.GET, headers, null);
    }

}

package com.example.investment.home.index.service;

import com.example.investment.home.index.controller.dto.KOSDAQResponse;
import com.example.investment.home.index.controller.dto.KOSPIResponse;
import com.example.investment.home.index.infrastructure.IndexParser;
import com.example.investment.home.index.service.client.IndexFetcher;
import jakarta.transaction.Transactional;
import org.json.JSONObject;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;

@Service
@Transactional
public class IndexService {

    private final IndexFetcher indexFetcher;
    private final IndexParser indexParser;

    public IndexService(final IndexFetcher indexFetcher, final IndexParser indexParser) {
        this.indexFetcher = indexFetcher;
        this.indexParser = indexParser;
    }

    public KOSPIResponse getKOSPIIndex() {
        ResponseEntity<String> response = indexFetcher.getKOSPIIndexData();
        JSONObject jsonResponse = new JSONObject(response.getBody());
        return indexParser.parseKOSPIResponse(jsonResponse);
    }

    public KOSDAQResponse getKOSDAQIndex() {
        ResponseEntity<String> response = indexFetcher.getKOSDAQIndexData();
        JSONObject jsonResponse = new JSONObject(response.getBody());
        return indexParser.parseKOSDAQResponse(jsonResponse);
    }
}

package com.example.investment.home.marketCapitalization.controller.dto;

public record MarketCapitalizationDTO(
        String rank,
        String stockPrice,
        String stockName,
        String marketCapitalization) {
}

package com.example.investment.home.marketCapitalization.controller;

import com.example.investment.home.marketCapitalization.controller.dto.MarketCapitalizationDTO;
import com.example.investment.home.marketCapitalization.service.MarketCapitalizationService;

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 java.io.IOException;
import java.util.List;

@RestController
@RequestMapping("/home/marketCapitalization")
public class MarketCapitalizationController {

    private final MarketCapitalizationService marketCapitalizationService;

    public MarketCapitalizationController(final MarketCapitalizationService marketCapitalizationService) {
        this.marketCapitalizationService = marketCapitalizationService;
    }

    @GetMapping
    public ResponseEntity<List<MarketCapitalizationDTO>> getTradingVolume() throws IOException {
        List<MarketCapitalizationDTO> marketCapitalizationDTOList = marketCapitalizationService.getMarketCapitalization();
        return ResponseEntity.ok(marketCapitalizationDTOList);
    }
}

package com.example.investment.home.marketCapitalization.infrastructure;

import com.example.investment.home.marketCapitalization.controller.dto.MarketCapitalizationDTO;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.json.JSONArray;
import org.json.JSONObject;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

@Component
public class MarketCapitalizationParser {

    private final ObjectMapper objectMapper;

    public MarketCapitalizationParser(final ObjectMapper objectMapper) {
        this.objectMapper = objectMapper;
    }

    public List<MarketCapitalizationDTO> parse(String responseBody) throws IOException {
        JsonNode rootNode = objectMapper.readTree(responseBody);
        JsonNode items = rootNode.path("output");

        return extractMarketCapitalizationData(items);
    }

    private List<MarketCapitalizationDTO> extractMarketCapitalizationData(final JsonNode items) {
        List<MarketCapitalizationDTO> marketCapitalizationDTOList = new ArrayList<>();
        Iterator<JsonNode> elements = items.elements();
        int count = 0;

        while (elements.hasNext() && count < 5) {
            JsonNode marketCapitalizationOutput = elements.next();
            String rank = marketCapitalizationOutput.path("data_rank").asText();
            String stockPrice = marketCapitalizationOutput.path("stck_prpr").asText();
            String stockName = marketCapitalizationOutput.path("hts_kor_isnm").asText();
            String marketCapitalization = marketCapitalizationOutput.path("stck_avls").asText();
            marketCapitalizationDTOList.add(new MarketCapitalizationDTO(rank, stockPrice, stockName, marketCapitalization));
            count++;
        }
        return marketCapitalizationDTOList;
    }

}

package com.example.investment.home.marketCapitalization.service.client;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;

@Component
public class MarketCapitalizationFetcher {

    private final RestTemplate restTemplate;

    public MarketCapitalizationFetcher(final RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @Value("${api.app_secret}")
    private String appSecret;

    @Value("${api.app_key}")
    private String appKey;

    @Value("${api.access_token}")
    private String accessToken;

    @Value("${marketCapitalization.tr_id}")
    private String trId;

    private HttpHeaders setHeader() {
        HttpHeaders headers = new HttpHeaders();
        headers.set("tr_id", trId);
        headers.set("appsecret", appSecret);
        headers.set("appkey", appKey);
        headers.set("Authorization", "Bearer " + accessToken);
        headers.setContentType(MediaType.APPLICATION_JSON);
        return headers;
    }

    public ResponseEntity<String> marketCapitalizationData() {
        String url = "https://openapi.koreainvestment.com:9443/uapi/domestic-stock/v1/ranking/market-cap?" +
                "fid_cond_mrkt_div_code=J&" +
                "fid_cond_scr_div_code=20174&" +
                "fid_div_cls_code=0&" +
                "fid_input_iscd=0000&" +
                "fid_trgt_cls_code=0&" +
                "fid_trgt_exls_cls_code=0&" +
                "fid_input_price_1=&" +
                "fid_input_price_2=&" +
                "fid_vol_cnt=";
        HttpHeaders headers = setHeader();
        HttpEntity<String> entity = new HttpEntity<>(headers);

        return restTemplate.exchange(url, HttpMethod.GET, entity, String.class);
    }
}

 

package com.example.investment.home.marketCapitalization.service;

import com.example.investment.home.marketCapitalization.controller.dto.MarketCapitalizationDTO;
import com.example.investment.home.marketCapitalization.infrastructure.MarketCapitalizationParser;
import com.example.investment.home.marketCapitalization.service.client.MarketCapitalizationFetcher;
import jakarta.transaction.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.List;

@Service
@Transactional
public class MarketCapitalizationService {

    private final MarketCapitalizationFetcher marketCapitalizationFetcher;
    private final MarketCapitalizationParser marketCapitalizationParser;

    @Autowired
    public MarketCapitalizationService(final MarketCapitalizationFetcher marketCapitalizationFetcher, final MarketCapitalizationParser marketCapitalizationParser) {
        this.marketCapitalizationFetcher = marketCapitalizationFetcher;
        this.marketCapitalizationParser = marketCapitalizationParser;
    }

    public List<MarketCapitalizationDTO> getMarketCapitalization() throws IOException {
        ResponseEntity<String> response = marketCapitalizationFetcher.marketCapitalizationData();
        return marketCapitalizationParser.parse(response.getBody());
    }
}

package com.example.investment.home.tradingVolume.controller.dto;

public record TradingVolumeDTO(
        String stockName,
        String rank,
        String currentPrice,
        String totalVolume,
        String prevVolume,
        String volumeChangeRate
) {
}

package com.example.investment.home.tradingVolume.controller;

import com.example.investment.home.tradingVolume.controller.dto.TradingVolumeDTO;
import com.example.investment.home.tradingVolume.service.TradingVolumeService;

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 java.io.IOException;
import java.util.List;

@RestController
@RequestMapping("/home/tradingVolume")
public class TradingVolumeController {

    private final TradingVolumeService tradingVolumeService;

    public TradingVolumeController(TradingVolumeService tradingVolumeService) {
        this.tradingVolumeService = tradingVolumeService;
    }

    @GetMapping
    public ResponseEntity<List<TradingVolumeDTO>> getTradingVolume() throws IOException {
        List<TradingVolumeDTO> tradingVolumes = tradingVolumeService.getTradingVolume();
        return ResponseEntity.ok(tradingVolumes);
    }
}

package com.example.investment.home.tradingVolume.infrastructure;

import com.example.investment.home.tradingVolume.controller.dto.TradingVolumeDTO;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

@Component
public class TradingVolumeParser {

    private final ObjectMapper objectMapper;

    public TradingVolumeParser(final ObjectMapper objectMapper) {
        this.objectMapper = objectMapper;
    }

    public List<TradingVolumeDTO> getTradingVolume(String responseBody) throws IOException {
        JsonNode rootNode = objectMapper.readTree(responseBody);
        JsonNode items = rootNode.path("output");
        return extractTradingVolumeData(items);
    }

    private List<TradingVolumeDTO> extractTradingVolumeData(final JsonNode items) {
        List<TradingVolumeDTO> tradingVolumeList = new ArrayList<>();
        Iterator<JsonNode> elements = items.elements();
        int count = 0;

        while (elements.hasNext() && count < 5) {
            JsonNode tradingVolumeItem = elements.next();

            String stockName = tradingVolumeItem.path("hts_kor_isnm").asText();
            String rank = tradingVolumeItem.path("data_rank").asText();
            String currentPrice = tradingVolumeItem.path("stck_prpr").asText();
            String totalVolume = tradingVolumeItem.path("acml_vol").asText();
            String prevVolume = tradingVolumeItem.path("prdy_vol").asText();
            String volumeChangeRate = tradingVolumeItem.path("vol_inrt").asText();

            tradingVolumeList.add(new TradingVolumeDTO(stockName, rank, currentPrice, totalVolume, prevVolume, volumeChangeRate));
            count++;
        }

        return tradingVolumeList;

    }
}

package com.example.investment.home.tradingVolume.service.client;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Component;

import org.springframework.web.client.RestTemplate;

@Component
public class TradingVolumeFetcher {

    private final RestTemplate restTemplate;

    public TradingVolumeFetcher(final RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @Value("${api.app_secret}")
    private String appSecret;

    @Value("${api.app_key}")
    private String appKey;

    @Value("${api.access_token}")
    private String accessToken;

    @Value("${api.tr_id}")
    private String trId;



    public ResponseEntity<String> fetchTradingVolumeData() {
        String url = "https://openapi.koreainvestment.com:9443/uapi/domestic-stock/v1/quotations/volume-rank?FID_COND_MRKT_DIV_CODE=J&FID_COND_SCR_DIV_CODE=20171&FID_INPUT_ISCD=0000&FID_DIV_CLS_CODE=0&FID_BLNG_CLS_CODE=0&FID_TRGT_CLS_CODE=111111111&FID_TRGT_EXLS_CLS_CODE=0000000000&FID_INPUT_PRICE_1=0&FID_INPUT_PRICE_2=0&FID_VOL_CNT=0&FID_INPUT_DATE_1=0";
        HttpHeaders headers = new HttpHeaders();
        headers.set("tr_id", trId);
        headers.set("appsecret", appSecret);
        headers.set("appkey", appKey);
        headers.set("Authorization", "Bearer " + accessToken);
        HttpEntity<String> entity = new HttpEntity<>(headers);
        return restTemplate.exchange(url, HttpMethod.GET, entity, String.class);
    }

}

package com.example.investment.home.tradingVolume.service;

import com.example.investment.home.tradingVolume.controller.dto.TradingVolumeDTO;
import com.example.investment.home.tradingVolume.infrastructure.TradingVolumeParser;
import com.example.investment.home.tradingVolume.service.client.TradingVolumeFetcher;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;

import jakarta.transaction.Transactional;
import java.io.IOException;
import java.util.List;

@Service
@Transactional
public class TradingVolumeService {

    private final TradingVolumeFetcher tradingVolumeFetcher;
    private final TradingVolumeParser tradingVolumeParser;

    @Autowired
    public TradingVolumeService(TradingVolumeFetcher tradingVolumeFetcher, TradingVolumeParser tradingVolumeParser) {
        this.tradingVolumeFetcher = tradingVolumeFetcher;
        this.tradingVolumeParser = tradingVolumeParser;
    }

    public List<TradingVolumeDTO> getTradingVolume() throws IOException {
        ResponseEntity<String> response = tradingVolumeFetcher.fetchTradingVolumeData();
        return tradingVolumeParser.getTradingVolume(response.getBody());
    }
}