Web Analytics

ABOUT ME

-

Today
-
Yesterday
-
Total
-
  • Java Http 요청 HttpURLConnection HttpClient OkHttp 텔레그램 사용 샘플
    개발 2026. 3. 3. 19:03

    목차

      Java Http 요청 HttpURLConnection HttpClient OkHttp 텔레그램 사용 샘플
      Java Http 요청 HttpURLConnection HttpClient OkHttp 텔레그램 사용 샘플



      Java에서 HTTP 요청을 보내는 방법은 두 가지 방법이 있습니다.
      기본 JDK 클래스 사용 혹은 외부 라이브러리 사용입니다.

       


      Http

      Java 내장 라이브러리를 이용한 HttpURLConnection 과 HttpClient 있습니다.
      외부 라이브러리인 Apache HttpClient 나 OkHttp을 이용해 http 전송을 할 수 있습니다.

      항목 HttpURLConnection HttpClient Apache HttpClient OkHttp
      시기 오래된 JDK 기본 API입니다. Java 11부터 공식 포함되었습니다. 오래된 외부 라이브러리 , 엔터프라이즈에서 사용됩니다. 최근 경량 라이브러리 , 안드로이드에서 자주 사용됩니다.
      사용 코드가 장황하고 불편 간결하고 현대적 API 기능 많지만 설정 복잡 직관적이고 간결한 API
      성능 기본적 , 효율성 낮음 효율적 , 비동기 지원 안정적이나 상대적으로 무거움 빠르고 경량 , 효율적
      비동기 직접 구현 필요 내장 지원
       ( CompletableFuture )
      지원 가능 ( 추가 설정 필요 ) 내장 지원
       ( 콜백 , 코루틴 스타일 )
      적합 간단한 테스트 최신 Java 기반 복잡한 요구사항 모바일 앱 , 마이크로서비스




      HttpURLConnection

      [개발] - 텔레그램 API 봇 생성 채널 그룹 개인 메시지 설정 방법

       

      텔레그램 API 봇 생성 채널 그룹 개인 메시지 설정 방법

      텔레그램 API를 사용해서 메시지를 전송하자. 순서1. 텔레그램의 검색창에서 botfather 검색합니다.2. /newbot을 입력합니다.3. 봇의 이름을 입력합니다. 예) tele_send_test4. 봇의 사용자 이름을 입력합니

      crawling.baobtree.com

       

      HttpURLConnection을 이용해서 텔레그램으로 메시지 전송하는 예제입니다.

      import java.io.BufferedReader;                 // 응답 내용을 줄 단위로 읽기 위한 Reader
      import java.io.InputStream;                    // HTTP 응답 바디를 바이트 스트림으로 받는 타입
      import java.io.InputStreamReader;              // 바이트 스트림을 문자 스트림으로 변환하는 Reader
      import java.io.OutputStream;                   // HTTP 요청 바디를 서버로 전송할 때 사용하는 스트림
      import java.net.HttpURLConnection;             // HTTP 요청/응답을 다루는 자바 기본 클래스
      import java.net.URL;                           // 요청할 주소를 표현하는 URL 클래스
      import java.nio.charset.StandardCharsets;      // UTF-8 등의 표준 문자셋 상수 제공
      
      /**
       * 텔레그램 메시지 전송
       * HttpURLConnection
       * @since 2026-03-03
       */
      public class TelegramSendHttpURLConnection {
      
          public static void main(String[] args) {
              // BotFather에서 발급받은 봇 토큰
              String botToken = "123456:ABCDEF...";
      
              // 메시지를 받을 대상 chat_id ( 개인/그룹/채널 ID 또는 @채널아이디 )
              String chatId = "12345678";
      
              // 텔레그램으로 전송할 메시지 본문
              String text = "Java HttpURLConnection 테스트입니다.";
      
              // 네트워크 호출 중 발생할 수 있는 예외를 처리하기 위한 try-catch
              try {
                  // 아래에서 정의한 JSON 방식 메시지 전송 메서드 호출
                  sendTelegramMessageJson(botToken, chatId, text);
              } catch ( Exception e ) {
                  // 예외 발생 시 스택 트레이스를 콘솔에 출력해 디버깅에 활용
                  e.printStackTrace();
              }
          }
      
          /**
           * 텔레그램 sendMessage 엔드포인트로 JSON 바디를 POST해서 메시지를 전송
           * @param botToken       BotFather에서 발급받은 봇 토큰
           * @param chatId         메시지를 받을 대상 chat_id
           * @param text           전송할 텍스트
           */
      	public static void sendTelegramMessageJson(String botToken, String chatId, String text) throws Exception {
              // 텔레그램 Bot API sendMessage 호출 URL 구성 (https://api.telegram.org/bot<token>/sendMessage)
              String apiUrl = "https://api.telegram.org/bot" + botToken + "/sendMessage";
      
              // HTTP 요청에 실을 JSON 문자열을 직접 조합 ( chat_id, text, parse_mode 등 )
              String jsonBody = ""
                      + "{"
                      + "\"chat_id\":\"" + chatId + "\","              // 수신 대상 채팅 ID 필드
                      + "\"text\":\"" + escapeJson(text) + "\","        // 메시지 텍스트 필드 (JSON 이스케이프 적용)
                      + "\"parse_mode\":\"HTML\""                       // 선택 옵션: HTML 포맷 사용 (굵게, 링크 등)
                      + "}";
      
              // JSON 문자열을 UTF-8 바이트 배열로 변환하여 전송 준비
              byte[] bodyBytes = jsonBody.getBytes(StandardCharsets.UTF_8);
      
              // 문자열로 된 주소를 URL 객체로 변환
              @SuppressWarnings("deprecation")
      		URL url = new URL(apiUrl);
      
              // URL에 대한 HTTP 연결을 열고 HttpURLConnection 인스턴스를 획득
              HttpURLConnection conn = (HttpURLConnection) url.openConnection();
      
              // HTTP 메서드를 POST로 지정 (텔레그램 Bot API는 sendMessage에 POST 사용 가능)
              conn.setRequestMethod("POST");
              // 요청 바디를 전송할 것이므로 출력 스트림 사용 가능 플래그 설정
              conn.setDoOutput(true);
              // 서버에 연결할 때까지 기다릴 최대 시간(밀리초) 설정
              conn.setConnectTimeout(10_000);
              // 응답을 읽을 때까지 기다릴 최대 시간(밀리초) 설정
              conn.setReadTimeout(10_000);
              // 요청 바디가 JSON 형식이며 인코딩은 UTF-8임을 서버에 알리는 헤더 설정
              conn.setRequestProperty("Content-Type", "application/json; charset=UTF-8");
              // 바디의 전체 길이(바이트 수)를 Content-Length 헤더로 설정
              conn.setRequestProperty("Content-Length", String.valueOf(bodyBytes.length));
      
              // try-with-resources로 OutputStream을 열어 자동으로 닫히도록 설정
              try ( OutputStream os = conn.getOutputStream() ) {
                  // JSON 바이트 배열 전체를 HTTP 요청 바디로 전송
                  os.write(bodyBytes);
      
                  // 내부 버퍼에 남아 있는 데이터가 있다면 즉시 전송하도록 플러시
                  os.flush();
              }
      
              // 서버가 응답한 HTTP 상태 코드를 읽어옴 (200이면 보통 성공)
              int status = conn.getResponseCode();
      
              // 상태 코드에 따라 정상 응답 스트림 또는 에러 스트림을 선택
              InputStream is = (status >= 200 && status < 300)
                      ? conn.getInputStream()   // 2xx: 성공 응답 바디
                      : conn.getErrorStream();  // 그 외: 에러 응답 바디(가능한 경우)
      
              // 응답 텍스트를 줄 단위로 누적할 StringBuilder 준비
              StringBuilder sb = new StringBuilder();
      
              // 응답 스트림을 UTF-8로 감싸 BufferedReader로 한 줄씩 읽기
              try ( BufferedReader br = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8)) ) {
                  // 현재 읽은 한 줄을 임시로 저장할 변수
                  String line;
      
                  // 더 읽을 줄이 없을 때까지 한 줄씩 반복하여 읽기
                  while ( (line = br.readLine()) != null ) {
                      // 읽은 라인을 결과 버퍼에 추가
                      sb.append(line);
                      // 보기 좋게 줄바꿈 문자도 함께 추가
                      sb.append('\n');
                  }
              }
      
              // HTTP 연결을 명시적으로 종료하여 네트워크 자원을 정리
              conn.disconnect();
      
              // 콘솔에 HTTP 상태 코드를 출력해 호출 성공/실패 여부를 확인
              System.out.println("HTTP Status = " + status);
      
              // Bot API가 반환한 JSON 응답 전체를 콘솔에 출력
              System.out.println("Response = " + sb.toString());
          }
      
          /**
           * JSON 문자열 안에서 사용될 텍스트의 특수문자를 안전하게 이스케이프
           * @param text           전송할 텍스트
           */
          private static String escapeJson(String text) {
              // 결과를 누적할 StringBuilder 생성
              StringBuilder sb = new StringBuilder();
      
              // 입력 문자열을 문자 단위로 순회
              for ( char c : text.toCharArray() ) {
                  // 문자 종류에 따라 이스케이프 규칙을 분기
                  switch ( c ) {
                      // 쌍따옴표는 \" 로 이스케이프
                      case '\"':
                          sb.append("\\\"");
                          break;
                      // 역슬래시는 \\ 로 이스케이프
                      case '\\':
                          sb.append("\\\\");
                          break;
                      // 백스페이스는 \b 로 이스케이프
                      case '\b':
                          sb.append("\\b");
                          break;
                      // 폼 피드는 \f 로 이스케이프
                      case '\f':
                          sb.append("\\f");
                          break;
                      // 줄바꿈은 \n 으로 이스케이프
                      case '\n':
                          sb.append("\\n");
                          break;
                      // 캐리지 리턴은 \r 로 이스케이프
                      case '\r':
                          sb.append("\\r");
                          break;
                      // 탭 문자는 \t 로 이스케이프
                      case '\t':
                          sb.append("\\t");
                          break;
                      // 그 외의 문자에 대해서는 제어 문자 여부만 추가로 검사
                      default:
                          // 0x20 미만의 제어 문자는 uXXXX 형태로 이스케이프
                          if ( c < 0x20 ) {
                              sb.append(String.format("\\u%04x", (int) c));
                          } else {
                              // 일반 문자라면 그대로 결과에 추가
                              sb.append(c);
                          }
                  }
              }
      
              // 이스케이프 처리가 끝난 최종 문자열을 반환
              return sb.toString();
          }
      }

       

       

      HttpURLConnection
      HttpURLConnection
      HttpURLConnection
      HttpURLConnection


      HttpClient

      [개발] - 텔레그램 API 봇 생성 채널 그룹 개인 메시지 설정 방법

       

      텔레그램 API 봇 생성 채널 그룹 개인 메시지 설정 방법

      텔레그램 API를 사용해서 메시지를 전송하자. 순서1. 텔레그램의 검색창에서 botfather 검색합니다.2. /newbot을 입력합니다.3. 봇의 이름을 입력합니다. 예) tele_send_test4. 봇의 사용자 이름을 입력합니

      crawling.baobtree.com

       

       

      HttpClient을 이용해서 텔레그램으로 메시지 전송하는 예제입니다.

      import java.net.URI;                           // HTTP 통신과 URI를 다루기 위한 Java 표준 라이브러리 임포트
      import java.net.http.HttpClient;               // Java 11에서 추가된 HttpClient 클래스 임포트
      import java.net.http.HttpRequest;              // HTTP 요청을 표현하는 HttpRequest 클래스 임포트
      import java.net.http.HttpResponse;             // HTTP 응답을 표현하는 HttpResponse 클래스 임포트
      import java.nio.charset.StandardCharsets;      // UTF-8 등의 표준 문자셋 상수 제공
      
      /**
       * 텔레그램 메시지 전송
       * HttpClient
       * @since 2026-03-03
       */
      public class TelegramSendHttpClient {
      
          public static void main(String[] args) {
              // BotFather에서 발급받은 봇 토큰
              String botToken = "123456:ABCDEF...";
      
              // 메시지를 받을 대상 chat_id ( 개인/그룹/채널 ID 또는 @채널아이디 )
              String chatId = "12345678";
      
              // 텔레그램으로 전송할 메시지 본문
              String text = "Java HttpClient 테스트입니다.";
      
              // 네트워크/IO 작업 중 발생할 수 있는 예외 처리를 위해 try-catch 사용
              try {
                  // 아래에 정의된 JSON 방식 텔레그램 메시지 전송 메서드를 호출
                  sendTelegramMessageWithHttpClient(botToken, chatId, text);
              } catch ( Exception e ) {
                  // 예외가 발생하면 스택 트레이스를 출력하여 디버깅에 활용
                  e.printStackTrace();
              }
          }
      
          /**
           * 텔레그램 sendMessage 엔드포인트로 JSON 바디를 POST해서 메시지를 전송
           * @param botToken       BotFather에서 발급받은 봇 토큰
           * @param chatId         메시지를 받을 대상 chat_id
           * @param text           전송할 텍스트
           */
          public static void sendTelegramMessageWithHttpClient(String botToken, String chatId, String text) throws Exception {
              // 텔레그램 Bot API sendMessage 호출 URL 구성 (https://api.telegram.org/bot<token>/sendMessage)
              String apiUrl = "https://api.telegram.org/bot" + botToken + "/sendMessage";
      
              // HTTP 요청 바디에 담을 JSON 문자열을 직접 생성 (chat_id, text, parse_mode 등)
              String jsonBody = ""
                      + "{"
                      + "\"chat_id\":\"" + chatId + "\","              // 수신 대상 채팅 ID 설정
                      + "\"text\":\"" + escapeJson(text) + "\","        // 전송할 텍스트 (JSON 특수문자 이스케이프 적용)
                      + "\"parse_mode\":\"HTML\""                       // 선택: HTML 포맷 사용 (굵게, 링크 등 텍스트 포맷팅 허용)
                      + "}";
      
              // Java 11 HttpClient 인스턴스를 생성 (커넥션 풀, HTTP/2 등 지원)
              HttpClient httpClient = HttpClient.newHttpClient();
      
              // 요청 URL 문자열을 URI 객체로 변환
              URI uri = URI.create(apiUrl);
      
              // JSON 문자열을 요청 바디로 사용하는 POST HttpRequest를 빌더로 생성 시작
              HttpRequest request = HttpRequest.newBuilder()
                      // 대상 URI 설정
                      .uri(uri)
                      // Content-Type 헤더에 application/json 및 UTF-8 인코딩 명시
                      .header("Content-Type", "application/json; charset=UTF-8")
                      // HTTP POST 메서드 설정 및 JSON 문자열을 바디로 지정
                      .POST(HttpRequest.BodyPublishers.ofString(jsonBody, StandardCharsets.UTF_8))
                      // 빌더를 마무리하여 HttpRequest 인스턴스 생성
                      .build();
      
              // 동기 방식으로 HTTP 요청을 전송하고 문자열 형태의 응답 바디를 받음
              HttpResponse<String> response =
                      httpClient.send(request, HttpResponse.BodyHandlers.ofString());
      
              // 콘솔에 HTTP 상태 코드를 출력해 호출 성공/실패 여부를 확인
              System.out.println("HTTP Status = " + response.statusCode());
      
              // Bot API가 반환한 JSON 응답 전체를 콘솔에 출력
              System.out.println("Response = " + response.body());
          }
      
          /**
           * JSON 문자열 안에서 사용될 텍스트의 특수문자를 안전하게 이스케이프
           * @param text           전송할 텍스트
           */
          private static String escapeJson(String text) {
              // 결과를 누적할 StringBuilder 생성
              StringBuilder sb = new StringBuilder();
      
              // 입력 문자열을 문자 단위로 순회
              for ( char c : text.toCharArray() ) {
                  // 문자 종류에 따라 이스케이프 규칙을 분기
                  switch ( c ) {
                      // 쌍따옴표는 \" 로 이스케이프
                      case '\"':
                          sb.append("\\\"");
                          break;
                      // 역슬래시는 \\ 로 이스케이프
                      case '\\':
                          sb.append("\\\\");
                          break;
                      // 백스페이스는 \b 로 이스케이프
                      case '\b':
                          sb.append("\\b");
                          break;
                      // 폼 피드는 \f 로 이스케이프
                      case '\f':
                          sb.append("\\f");
                          break;
                      // 줄바꿈은 \n 으로 이스케이프
                      case '\n':
                          sb.append("\\n");
                          break;
                      // 캐리지 리턴은 \r 로 이스케이프
                      case '\r':
                          sb.append("\\r");
                          break;
                      // 탭 문자는 \t 로 이스케이프
                      case '\t':
                          sb.append("\\t");
                          break;
                      // 그 외의 문자에 대해서는 제어 문자 여부만 추가로 검사
                      default:
                          // 0x20 미만의 제어 문자는 uXXXX 형태로 이스케이프
                          if ( c < 0x20 ) {
                              sb.append(String.format("\\u%04x", (int) c));
                          } else {
                              // 일반 문자라면 그대로 결과에 추가
                              sb.append(c);
                          }
                  }
              }
      
              // 이스케이프 처리가 끝난 최종 문자열을 반환
              return sb.toString();
          }
      }

       

      HttpClient
      HttpClient
      HttpClient
      HttpClient


      Apache HttpClient

      <dependency>
          <groupId>org.apache.httpcomponents.client5</groupId>
          <artifactId>httpclient5</artifactId>
          <version>5.6</version>
      </dependency>

       

      // Source: https://mvnrepository.com/artifact/org.apache.httpcomponents.client5/httpclient5
      implementation("org.apache.httpcomponents.client5:httpclient5:5.6")

       

       

      [개발] - 텔레그램 API 봇 생성 채널 그룹 개인 메시지 설정 방법

       

      텔레그램 API 봇 생성 채널 그룹 개인 메시지 설정 방법

      텔레그램 API를 사용해서 메시지를 전송하자. 순서1. 텔레그램의 검색창에서 botfather 검색합니다.2. /newbot을 입력합니다.3. 봇의 이름을 입력합니다. 예) tele_send_test4. 봇의 사용자 이름을 입력합니

      crawling.baobtree.com


      Apache HttpClient을 이용해서 텔레그램으로 메시지 전송하는 예제입니다.

      //HTTP POST 요청을 나타내는 HttpPost 클래스 임포트
      import org.apache.hc.client5.http.classic.methods.HttpPost;
      //Apache HttpClient 5.x의 CloseableHttpClient 인터페이스 임포트
      import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
      //HTTP 응답을 나타내는 CloseableHttpResponse 인터페이스 임포트
      import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
      //HttpClient 인스턴스를 생성하는 HttpClients 유틸 클래스 임포트
      import org.apache.hc.client5.http.impl.classic.HttpClients;
      //Content-Type 상수를 제공하는 ContentType 클래스 임포트
      import org.apache.hc.core5.http.ContentType;
      //응답 바디를 문자열로 변환하는 EntityUtils 유틸 클래스 임포트
      import org.apache.hc.core5.http.io.entity.EntityUtils;
      //문자열을 HTTP 엔터티로 감싸는 StringEntity 클래스 임포트
      import org.apache.hc.core5.http.io.entity.StringEntity;
      
      
      /**
       * 텔레그램 메시지 전송
       * Apache HttpClient 5.x
       * @since 2026-03-03
       */
      public class TelegramSendApacheHttpClient {
      
          public static void main(String[] args) {
              // BotFather에서 발급받은 봇 토큰
              String botToken = "123456:ABCDEF...";
      
              // 메시지를 받을 대상 chat_id ( 개인/그룹/채널 ID 또는 @채널아이디 )
              String chatId = "12345678";
      
              // 텔레그램으로 전송할 메시지 본문
              String text = "Java Apache HttpClient 5.x 테스트입니다.";
      
              // 네트워크/IO 작업 중 발생할 수 있는 예외 처리를 위해 try-catch 사용
              try {
                  // 아래에 정의된 JSON 방식 텔레그램 메시지 전송 메서드를 호출
                  sendTelegramMessageWithApacheHttpClient5(botToken, chatId, text);
              } catch ( Exception e ) {
                  // 예외가 발생하면 스택 트레이스를 출력하여 디버깅에 활용
                  e.printStackTrace();
              }
          }
      
          /**
           * 텔레그램 sendMessage 엔드포인트로 JSON 바디를 POST해서 메시지를 전송
           * @param botToken       BotFather에서 발급받은 봇 토큰
           * @param chatId         메시지를 받을 대상 chat_id
           * @param text           전송할 텍스트
           */
          public static void sendTelegramMessageWithApacheHttpClient5(String botToken, String chatId, String text) throws Exception {
              // 텔레그램 Bot API sendMessage 호출 URL 구성 (https://api.telegram.org/bot<token>/sendMessage)
              String apiUrl = "https://api.telegram.org/bot" + botToken + "/sendMessage";
      
              // HTTP 요청 바디에 담을 JSON 문자열을 직접 생성 (chat_id, text, parse_mode 등)
              String jsonBody = ""
                      + "{"
                      + "\"chat_id\":\"" + chatId + "\","              // 수신 대상 채팅 ID 설정
                      + "\"text\":\"" + escapeJson(text) + "\","        // 전송할 텍스트 (JSON 특수문자 이스케이프 적용)
                      + "\"parse_mode\":\"HTML\""                       // 선택: HTML 포맷 사용 (굵게, 링크 등 텍스트 포맷팅 허용)
                      + "}";
      
              // try-with-resources로 CloseableHttpClient를 생성하여 사용 후 자동으로 자원 해제
              try ( CloseableHttpClient httpClient = HttpClients.createDefault())  {
                  // POST 요청을 보낼 HttpPost 객체를 생성하고 URL 설정
                  HttpPost httpPost = new HttpPost(apiUrl);
      
                  // JSON 문자열을 담는 StringEntity를 생성하고 ContentType을 application/json으로 지정
                  StringEntity requestEntity = new StringEntity(jsonBody, ContentType.APPLICATION_JSON);
      
                  // 생성한 JSON 엔터티를 HTTP POST 요청 바디로 설정
                  httpPost.setEntity(requestEntity);
                  // 필요 시 명시적으로 Content-Type 헤더를 추가 설정 (StringEntity에 의해 자동 설정되지만 보강 차원에서 사용 가능)
                  httpPost.setHeader("Content-Type", "application/json; charset=UTF-8");
      
                  // 동기 방식으로 HTTP 요청을 전송하고 응답을 CloseableHttpResponse로 받음
                  try ( @SuppressWarnings("deprecation") CloseableHttpResponse response = httpClient.execute(httpPost) ) {
                      // 응답 상태 코드를 가져와 콘솔에 출력
                      System.out.println("HTTP Status = " + response.getCode());
      
                      // 응답 바디를 문자열로 변환하여 출력 (엔터티가 없을 수도 있으므로 null 체크)
                      if ( response.getEntity() != null ) {
                          // EntityUtils를 사용해 응답 엔터티를 문자열로 변환
                          String responseBody = EntityUtils.toString(response.getEntity());
                          // Bot API가 반환한 JSON 응답 전체를 콘솔에 출력
                          System.out.println("Response = " + responseBody);
                      }
                  }
              }
          }
      
          /**
           * JSON 문자열 안에서 사용될 텍스트의 특수문자를 안전하게 이스케이프
           * @param text           전송할 텍스트
           */
          private static String escapeJson(String text) {
              // 결과를 누적할 StringBuilder 생성
              StringBuilder sb = new StringBuilder();
      
              // 입력 문자열을 문자 단위로 순회
              for ( char c : text.toCharArray() ) {
                  // 문자 종류에 따라 이스케이프 규칙을 분기
                  switch ( c ) {
                      // 쌍따옴표는 \" 로 이스케이프
                      case '\"':
                          sb.append("\\\"");
                          break;
                      // 역슬래시는 \\ 로 이스케이프
                      case '\\':
                          sb.append("\\\\");
                          break;
                      // 백스페이스는 \b 로 이스케이프
                      case '\b':
                          sb.append("\\b");
                          break;
                      // 폼 피드는 \f 로 이스케이프
                      case '\f':
                          sb.append("\\f");
                          break;
                      // 줄바꿈은 \n 으로 이스케이프
                      case '\n':
                          sb.append("\\n");
                          break;
                      // 캐리지 리턴은 \r 로 이스케이프
                      case '\r':
                          sb.append("\\r");
                          break;
                      // 탭 문자는 \t 로 이스케이프
                      case '\t':
                          sb.append("\\t");
                          break;
                      // 그 외의 문자에 대해서는 제어 문자 여부만 추가로 검사
                      default:
                          // 0x20 미만의 제어 문자는 uXXXX 형태로 이스케이프
                          if ( c < 0x20 ) {
                              sb.append(String.format("\\u%04x", (int) c));
                          } else {
                              // 일반 문자라면 그대로 결과에 추가
                              sb.append(c);
                          }
                  }
              }
      
              // 이스케이프 처리가 끝난 최종 문자열을 반환
              return sb.toString();
          }
      }

       

      Apache HttpClient
      Apache HttpClient
      Apache HttpClient
      Apache HttpClient

      반응형

      OkHttp

      <dependency>
          <groupId>com.squareup.okhttp3</groupId>
          <artifactId>okhttp</artifactId>
          <version>4.12.0</version>
      </dependency>

       

      // Source: https://mvnrepository.com/artifact/com.squareup.okhttp3/okhttp
      implementation("com.squareup.okhttp3:okhttp:4.12.0")

       

       

      [개발] - 텔레그램 API 봇 생성 채널 그룹 개인 메시지 설정 방법

       

      텔레그램 API 봇 생성 채널 그룹 개인 메시지 설정 방법

      텔레그램 API를 사용해서 메시지를 전송하자. 순서1. 텔레그램의 검색창에서 botfather 검색합니다.2. /newbot을 입력합니다.3. 봇의 이름을 입력합니다. 예) tele_send_test4. 봇의 사용자 이름을 입력합니

      crawling.baobtree.com

       

       

      OkHttp을 이용해서 텔레그램으로 메시지 전송하는 예제입니다.

      //OkHttp에서 제공하는 HTTP 클라이언트 클래스 임포트
      import okhttp3.OkHttpClient;
      //요청 바디를 표현하는 RequestBody 클래스 임포트
      import okhttp3.RequestBody;
      //HTTP 요청을 표현하는 Request 클래스 임포트
      import okhttp3.Request;
      //HTTP 응답을 표현하는 Response 클래스 임포트
      import okhttp3.Response;
      //Content-Type을 표현하는 MediaType 클래스 임포트
      import okhttp3.MediaType;
      
      
      /**
       * 텔레그램 메시지 전송
       * OkHttp 4.x
       * @since 2026-03-03
       */
      public class TelegramSendOkHttp {
      
          public static void main(String[] args) {
              // BotFather에서 발급받은 봇 토큰
              String botToken = "123456:ABCDEF...";
      
              // 메시지를 받을 대상 chat_id ( 개인/그룹/채널 ID 또는 @채널아이디 )
              String chatId = "12345678";
      
              // 텔레그램으로 전송할 메시지 본문
              String text = "Java OkHttp 4.x 테스트입니다.";
      
              // 네트워크/IO 작업 중 발생할 수 있는 예외 처리를 위해 try-catch 사용
              try {
                  // 아래에 정의된 JSON 방식 텔레그램 메시지 전송 메서드를 호출
                  sendTelegramMessageWithOkHttp(botToken, chatId, text);
              } catch ( Exception e ) {
                  // 예외가 발생하면 스택 트레이스를 출력하여 디버깅에 활용
                  e.printStackTrace();
              }
          }
      
          /**
           * OkHttp를 사용해 텔레그램 sendMessage 엔드포인트에
           * JSON 바디를 POST해서 메시지를 전송
           *
           * @param botToken BotFather에서 발급받은 봇 토큰
           * @param chatId   메시지를 받을 대상 chat_id
           * @param text     전송할 텍스트
           */
          public static void sendTelegramMessageWithOkHttp(String botToken, String chatId, String text) throws Exception {
              // 텔레그램 Bot API sendMessage 호출 URL 구성 (https://api.telegram.org/bot<token>/sendMessage) [web:15][web:55]
              String apiUrl = "https://api.telegram.org/bot" + botToken + "/sendMessage";
      
              // HTTP 요청 바디에 담을 JSON 문자열을 직접 생성 (chat_id, text, parse_mode 등) [web:55]
              String jsonBody = ""
                      + "{"
                      + "\"chat_id\":\"" + chatId + "\","               // 수신 대상 채팅 ID 설정
                      + "\"text\":\"" + escapeJson(text) + "\","         // 전송할 텍스트 (JSON 특수문자 이스케이프 적용)
                      + "\"parse_mode\":\"HTML\""                        // 선택: HTML 포맷 사용 (굵게, 링크 등 텍스트 포맷팅 허용) [web:15]
                      + "}";
      
              // OkHttpClient 인스턴스를 생성 (커넥션 풀, 타임아웃 설정 등 가능) [web:67][web:54]
              OkHttpClient client = new OkHttpClient();
      
              // JSON 문자열과 MediaType을 사용해 RequestBody 생성 [web:62][web:63][web:67]
              RequestBody body = RequestBody.create(jsonBody, MediaType.parse("application/json; charset=utf-8"));
      
              // 요청 URL과 POST 바디를 설정해 Request 객체 빌드
              Request request = new Request.Builder()
                      // 대상 URL 설정
                      .url(apiUrl)
                      // HTTP POST 메서드 및 요청 바디 지정
                      .post(body)
                      // Content-Type 헤더는 RequestBody의 MediaType으로 자동 설정됨
                      .build();
      
              // 동기 방식으로 HTTP 요청을 전송하고 응답을 Response로 받음 [web:67][web:71]
              try ( Response response = client.newCall(request).execute() ) {
                  // 응답 코드(HTTP 상태 코드)를 콘솔에 출력
                  System.out.println("HTTP Status = " + response.code());
      
                  // 응답 바디가 존재한다면 문자열로 변환하여 출력
                  if ( response.body() != null ) {
                      String responseBody = response.body().string();
                      // Bot API가 반환한 JSON 응답 전체를 콘솔에 출력
                      System.out.println("Response = " + responseBody);
                  }
              }
          }
      
          /**
           * JSON 문자열 안에서 사용될 텍스트의 특수문자를 안전하게 이스케이프
           * @param text           전송할 텍스트
           */
          private static String escapeJson(String text) {
              // 결과를 누적할 StringBuilder 생성
              StringBuilder sb = new StringBuilder();
      
              // 입력 문자열을 문자 단위로 순회
              for ( char c : text.toCharArray() ) {
                  // 문자 종류에 따라 이스케이프 규칙을 분기
                  switch ( c ) {
                      // 쌍따옴표는 \" 로 이스케이프
                      case '\"':
                          sb.append("\\\"");
                          break;
                      // 역슬래시는 \\ 로 이스케이프
                      case '\\':
                          sb.append("\\\\");
                          break;
                      // 백스페이스는 \b 로 이스케이프
                      case '\b':
                          sb.append("\\b");
                          break;
                      // 폼 피드는 \f 로 이스케이프
                      case '\f':
                          sb.append("\\f");
                          break;
                      // 줄바꿈은 \n 으로 이스케이프
                      case '\n':
                          sb.append("\\n");
                          break;
                      // 캐리지 리턴은 \r 로 이스케이프
                      case '\r':
                          sb.append("\\r");
                          break;
                      // 탭 문자는 \t 로 이스케이프
                      case '\t':
                          sb.append("\\t");
                          break;
                      // 그 외의 문자에 대해서는 제어 문자 여부만 추가로 검사
                      default:
                          // 0x20 미만의 제어 문자는 uXXXX 형태로 이스케이프
                          if ( c < 0x20 ) {
                              sb.append(String.format("\\u%04x", (int) c));
                          } else {
                              // 일반 문자라면 그대로 결과에 추가
                              sb.append(c);
                          }
                  }
              }
      
              // 이스케이프 처리가 끝난 최종 문자열을 반환
              return sb.toString();
          }
      }

       

      OkHttp
      OkHttp
      OkHttp
      OkHttp


      요약

      1. 오래된 기본 HttpURLConnection 
      2. Java 11 이상 HttpClient
      3. Apache HttpClient implementation("org.apache.httpcomponents.client5:httpclient5:5.6")
      4. OkHttp implementation("com.squareup.okhttp3:okhttp:4.12.0")

      반응형
    Designed by Tistory.