토큰 갱신

import requests

def refresh_access_token(refresh_token, client_id):
  """
  Refresh Token으로 새로운 Access Token을 발급받습니다.

  Args:
      refresh_token: 이전에 발급받은 Refresh Token
      client_id: 클라이언트 ID

  Returns:
      dict: access_token, refresh_token, expires_in, scope 포함
  """
  try:
      response = requests.post(
          'https://oauth.data.hellogsm.kr/v1/oauth/token',
          headers={'Content-Type': 'application/json'},
          json={
              'grant_type': 'refresh_token',
              'refresh_token': refresh_token,
              'client_id': client_id,
          }
      )
      response.raise_for_status()
      return response.json()
  except requests.exceptions.RequestException as e:
      print(f'Error: {e}')
      raise

# 사용 예시
old_refresh_token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
tokens = refresh_access_token(old_refresh_token, 'your-client-id')

print(f'New Access Token: {tokens["access_token"]}')
print(f'New Refresh Token: {tokens["refresh_token"]}')
print(f'Expires In: {tokens["expires_in"]} seconds')

import java.net.http.*;
import java.net.URI;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.JsonNode;
import java.util.Map;

public class OAuthRefreshService {
  private static final HttpClient client = HttpClient.newHttpClient();
  private static final ObjectMapper mapper = new ObjectMapper();

  public static TokenResponse refreshAccessToken(String refreshToken, String clientId) throws Exception {
      // 요청 본문 생성
      Map<String, String> requestBody = Map.of(
          "grant_type", "refresh_token",
          "refresh_token", refreshToken,
          "client_id", clientId
      );
      String requestBodyJson = mapper.writeValueAsString(requestBody);

      // HTTP 요청 생성
      HttpRequest request = HttpRequest.newBuilder()
          .uri(URI.create("https://oauth.data.hellogsm.kr/v1/oauth/token"))
          .header("Content-Type", "application/json")
          .POST(HttpRequest.BodyPublishers.ofString(requestBodyJson))
          .build();

      // 요청 전송
      HttpResponse<String> response = client.send(
          request,
          HttpResponse.BodyHandlers.ofString()
      );

      // 응답 처리
      if (response.statusCode() != 200) {
          throw new RuntimeException("Failed to refresh token: " + response.body());
      }

      JsonNode jsonNode = mapper.readTree(response.body());
      return new TokenResponse(
          jsonNode.get("access_token").asText(),
          jsonNode.get("refresh_token").asText(),
          jsonNode.get("expires_in").asInt()
      );
  }

  public static class TokenResponse {
      public final String accessToken;
      public final String refreshToken;
      public final int expiresIn;

      public TokenResponse(String accessToken, String refreshToken, int expiresIn) {
          this.accessToken = accessToken;
          this.refreshToken = refreshToken;
          this.expiresIn = expiresIn;
      }
  }

  public static void main(String[] args) throws Exception {
      String oldRefreshToken = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...";
      TokenResponse tokens = refreshAccessToken(oldRefreshToken, "your-client-id");

      System.out.println("New Access Token: " + tokens.accessToken);
      System.out.println("New Refresh Token: " + tokens.refreshToken);
      System.out.println("Expires In: " + tokens.expiresIn + " seconds");
  }
}

import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.net.URI
import com.fasterxml.jackson.annotation.JsonProperty
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import com.fasterxml.jackson.module.kotlin.readValue

data class RefreshRequest(
  val grant_type: String = "refresh_token",
  val refresh_token: String,
  val client_id: String
)

data class TokenResponse(
  @JsonProperty("access_token")
  val accessToken: String,
  @JsonProperty("refresh_token")
  val refreshToken: String,
  @JsonProperty("expires_in")
  val expiresIn: Int
)

class OAuthRefreshService {
  private val client = HttpClient.newHttpClient()
  private val mapper = jacksonObjectMapper()

  fun refreshAccessToken(refreshToken: String, clientId: String): TokenResponse {
      val requestBody = RefreshRequest(
          refresh_token = refreshToken,
          client_id = clientId
      )
      val requestBodyJson = mapper.writeValueAsString(requestBody)

      val request = HttpRequest.newBuilder()
          .uri(URI.create("https://oauth.data.hellogsm.kr/v1/oauth/token"))
          .header("Content-Type", "application/json")
          .POST(HttpRequest.BodyPublishers.ofString(requestBodyJson))
          .build()

      val response = client.send(request, HttpResponse.BodyHandlers.ofString())

      if (response.statusCode() != 200) {
          throw RuntimeException("Failed to refresh token: ${response.body()}")
      }

      return mapper.readValue(response.body())
  }
}

// 사용 예시
fun main() {
  val service = OAuthRefreshService()
  val oldRefreshToken = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
  val tokens = service.refreshAccessToken(oldRefreshToken, "your-client-id")

  println("New Access Token: ${tokens.accessToken}")
  println("New Refresh Token: ${tokens.refreshToken}")
  println("Expires In: ${tokens.expiresIn} seconds")
}