Http requestwrapper란?

`requestWrapper`는 일반적으로 API 호출, HTTP 요청 또는 네트워크 통신을 단순화하고, 반복적인 작업을 줄이기 위해 사용되는 디자인 패턴 또는 라이브러리입니다. 이 문서에서는 `requestWrapper`의 개념, 목적, 주요 기능, 구현 방법, 장점 및 단점에 대해 상세히 설명하겠습니다.

### 1. 개념 및 목적

`requestWrapper`는 HTTP 요청을 간편하게 만들고 처리할 수 있도록 도와주는 일종의 추상화 레이어입니다. 이는 개발자가 HTTP 요청을 보낼 때마다 반복적으로 작성해야 하는 코드를 줄이고, 코드의 재사용성을 높이며, 에러 핸들링 및 로깅과 같은 공통 작업을 중앙 집중식으로 관리할 수 있게 합니다.

### 2. 주요 기능

`requestWrapper`의 주요 기능은 다음과 같습니다:

1. **요청 단순화**: GET, POST, PUT, DELETE 등의 다양한 HTTP 메서드를 손쉽게 사용할 수 있도록 함수화하여 제공합니다.
2. **에러 핸들링**: 네트워크 오류, 서버 오류, 타임아웃 등의 다양한 오류를 일관된 방식으로 처리할 수 있습니다.
3. **로깅**: 요청 및 응답 데이터를 로깅하여 디버깅 및 모니터링을 용이하게 합니다.
4. **인증 및 인가**: API 키, OAuth 토큰 등의 인증 정보를 자동으로 추가할 수 있습니다.
5. **재시도 메커니즘**: 일시적인 네트워크 오류 등으로 인해 요청이 실패했을 때, 자동으로 재시도를 시도합니다.
6. **타임아웃 설정**: 요청이 특정 시간 안에 완료되지 않을 경우 타임아웃을 설정하여 불필요한 대기 시간을 줄입니다.
7. **커스텀 헤더**: 필요에 따라 요청 헤더를 쉽게 설정할 수 있습니다.
8. **JSON 파싱 및 직렬화**: JSON 형식의 데이터 송수신을 쉽게 할 수 있도록 도와줍니다.

### 3. 구현 방법

`requestWrapper`는 다양한 언어에서 구현할 수 있으며, 여기서는 Python을 예로 들어 설명하겠습니다. Python에서는 `requests` 라이브러리를 자주 사용하며, 이를 기반으로 `requestWrapper`를 구현할 수 있습니다.

 

```python
import requests
from requests.exceptions import HTTPError, Timeout, RequestException

class RequestWrapper:
    def __init__(self, base_url, headers=None, timeout=30, max_retries=3):
        self.base_url = base_url
        self.headers = headers if headers else {}
        self.timeout = timeout
        self.max_retries = max_retries

    def _make_request(self, method, endpoint, **kwargs):
        url = f"{self.base_url}{endpoint}"
        headers = kwargs.pop("headers", {})
        headers.update(self.headers)
        retries = 0

        while retries < self.max_retries:
            try:
                response = requests.request(method, url, headers=headers, timeout=self.timeout, **kwargs)
                response.raise_for_status()
                return response
            except HTTPError as http_err:
                print(f"HTTP error occurred: {http_err}")
            except Timeout as timeout_err:
                print(f"Request timed out: {timeout_err}")
            except RequestException as req_err:
                print(f"Request error occurred: {req_err}")
            retries += 1
            print(f"Retrying... ({retries}/{self.max_retries})")
        return None

    def get(self, endpoint, **kwargs):
        return self._make_request("GET", endpoint, **kwargs)

    def post(self, endpoint, **kwargs):
        return self._make_request("POST", endpoint, **kwargs)

    def put(self, endpoint, **kwargs):
        return self._make_request("PUT", endpoint, **kwargs)

    def delete(self, endpoint, **kwargs):
        return self._make_request("DELETE", endpoint, **kwargs)

# 사용 예제
if __name__ == "__main__":
    wrapper = RequestWrapper(base_url="https://api.example.com", headers={"Authorization": "Bearer YOUR_TOKEN"})
    response = wrapper.get("/data")
    if response:
        print(response.json())
```

위 예제에서는 기본 URL과 헤더, 타임아웃 및 최대 재시도 횟수를 설정할 수 있는 `RequestWrapper` 클래스를 정의했습니다. 각 HTTP 메서드(GET, POST, PUT, DELETE)는 `_make_request` 메서드를 호출하여 요청을 수행합니다.

### 4. 장점

- **코드 재사용성 증가**: 공통된 HTTP 요청 로직을 하나의 클래스나 함수로 추상화하여, 재사용성을 높입니다.
- **유지보수성 향상**: 모든 HTTP 요청 로직이 한 곳에 집중되므로, 변경 사항을 한 곳에서 관리할 수 있습니다.
- **에러 핸들링 일관성**: 일관된 방식으로 에러를 처리하여, 오류 발생 시 디버깅이 용이합니다.
- **보안**: 인증 정보나 API 키 등을 중앙에서 관리하므로, 보안성을 높일 수 있습니다.
- **가독성 향상**: 코드의 가독성이 높아져, 다른 개발자가 코드를 이해하고 유지보수하는 데 도움이 됩니다.

### 5. 단점

- **추가 복잡성**: 간단한 프로젝트에서는 오히려 불필요한 복잡성을 더할 수 있습니다.
- **성능 오버헤드**: 재시도 로직이나 로깅 등의 부가 기능으로 인해 약간의 성능 오버헤드가 발생할 수 있습니다.
- **유연성 저하**: 모든 상황에 맞추어 일관된 처리가 어려울 수 있으며, 특정 요청에 대해 예외적인 처리가 필요할 수 있습니다.

### 6. 확장 및 고급 기능

더 복잡한 요구사항을 충족하기 위해, `requestWrapper`는 다양한 고급 기능을 추가하여 확장할 수 있습니다:

- **캐싱**: 동일한 요청에 대한 응답을 캐싱하여, 네트워크 요청 횟수를 줄일 수 있습니다.
- **리밋 핸들링**: API 호출 횟수 제한에 도달했을 때, 적절한 대기 시간을 두고 재시도합니다.
- **다양한 인증 방식 지원**: 기본 인증 외에도 OAuth, JWT 등 다양한 인증 방식을 지원합니다.
- **병렬 요청**: 여러 요청을 병렬로 처리하여 성능을 향상시킬 수 있습니다.

### 7. 결론

`requestWrapper`는 HTTP 요청을 보다 효율적이고 일관되게 처리하기 위해 유용한 도구입니다. 이를 통해 코드의 재사용성을 높이고, 에러 핸들링, 로깅, 인증 등의 공통 작업을 중앙에서 관리할 수 있습니다. 그러나 프로젝트의 복잡성에 따라 필요성을 판단하여 사용하는 것이 중요합니다. 이를 적절히 구현하고 확장하면, 네트워크 통신을 보다 안정적이고 효율적으로 처리할 수 있습니다.