☕ Java

Работа с сетью и HTTP API в Java: подробное руководство

Урок 35 / 37 • Полная теория для чтения

Что это такое и зачем? (аналогия из реальной жизни)

Представь, что ты сидишь в уютном кафе и хочешь заказать пиццу. Ты не идёшь на кухню сам, не лезешь в печь и не трогаешь тесто. Вместо этого ты подзываешь официанта, говоришь: «Мне, пожалуйста, «Маргариту»», — и через некоторое время получаешь готовое блюдо.

Работа с сетью и HTTP API в Java — это ровно то же самое. Твоя программа (клиент) — это ты за столиком. Сервер в интернете — это кухня ресторана. А HTTP-запрос — это официант, который передаёт твой заказ и приносит ответ.

Зачем это нужно? Представь, что ты пишешь приложение для прогноза погоды. Твоя программа не может сама «увидеть» облака или измерить температуру. Но она может отправить запрос на сервер метеослужбы, получить оттуда данные (JSON-файл с градусами и осадками) и показать их пользователю.

Точно так же работают:

Авторизация в соцсетях (твоя программа просит сервер ВКонтакте: «Проверь пароль!»)
Онлайн-банкинг (запрос баланса счёта)
Игры с мультиплеером (отправка координат персонажа)
Любой сайт, который ты открываешь в браузере

💡 Важно: HTTP API — это не «магия», а просто набор правил (протокол), по которым программы общаются через интернет. Как официанты в разных ресторанах знают, что тарелки нужно нести на подносе, так и программы знают, что данные нужно передавать в определённом формате.

Теория: как это работает изнутри

Давай заглянем «под капот» и разберёмся, что происходит, когда Java-программа делает HTTP-запрос.

1. Клиент-серверная архитектура

В любой сетевой коммуникации есть две стороны:

Клиент — тот, кто запрашивает данные (твоя Java-программа)
Сервер — тот, кто эти данные хранит и отдаёт (например, сервер Google)

Клиент и сервер могут находиться на разных континентах. Они общаются через интернет с помощью протокола HTTP (HyperText Transfer Protocol — протокол передачи гипертекста).

2. Структура HTTP-запроса

Когда твоя программа «стучится» к серверу, она отправляет сообщение, которое состоит из трёх частей:

Стартовая строка — содержит метод (GET, POST и др.) и адрес (URL)
Заголовки (Headers) — дополнительная информация: какой браузер, какой формат данных принимаем, есть ли авторизация
Тело (Body) — сами данные (например, логин и пароль при регистрации). Есть не у всех запросов

3. HTTP-методы (глаголы)

Самые популярные методы — это как команды для сервера:

Метод	Что делает	Аналогия в жизни
GET	Запрашивает данные (чтение)	«Дай мне меню»
POST	Отправляет новые данные (создание)	«Запиши мой заказ»
PUT	Обновляет существующие данные	«Замени мою пиццу на другую»
DELETE	Удаляет данные	«Отмени мой заказ»

4. Коды ответа (статусы)

Сервер не молчит в ответ — он всегда присылает трёхзначный код:

Код	Значение	Что это значит
200	OK	Всё отлично, вот твои данные
201	Created	Создано успешно
301	Moved Permanently	Страница переехала на другой адрес
400	Bad Request	Ты отправил что-то не так (ошибка клиента)
401	Unauthorized	Нужна авторизация (ты не представился)
403	Forbidden	Доступ запрещён (у тебя нет прав)
404	Not Found	Такого адреса не существует
500	Internal Server Error	Сервер сломался (ошибка сервера)

⚠️ Запомни: Коды 2xx — это успех, 4xx — ты что-то сделал не так, 5xx — проблемы на сервере. Если видишь 404 — проверь URL. Если 500 — подожди, возможно, сервер перегружен.

5. Форматы данных: JSON и XML

Серверы редко отдают данные в виде красивой HTML-страницы. Чаще всего они используют JSON (JavaScript Object Notation) — лёгкий текстовый формат, похожий на Java-объект:

{
  "name": "Иван",
  "age": 25,
  "isStudent": false
}

Java не понимает JSON «из коробки», поэтому мы используем специальные библиотеки (например, Gson или Jackson), чтобы превратить JSON в Java-объект и наоборот.

Синтаксис в Java: все формы и варианты

В Java есть несколько способов работать с HTTP. Мы рассмотрим два самых популярных:

HttpURLConnection — встроенный класс (не требует установки библиотек)
HttpClient — современный API (появился в Java 11)

HttpURLConnection (старый, но надёжный)

Этот класс живёт в пакете java.net. Он немного громоздкий, но работает везде, даже на очень старых версиях Java.

Основные шаги:

Создать объект URL
Открыть соединение (получить HttpURLConnection)
Настроить метод (GET, POST и т.д.)
Отправить запрос
Прочитать ответ
Закрыть соединение

HttpClient (новый, удобный)

Появился в Java 11. Он более современный, поддерживает асинхронные запросы и работает в стиле «построителя» (Builder).

Основные классы:

java.net.http.HttpClient — сам клиент
java.net.http.HttpRequest — запрос
java.net.http.HttpResponse — ответ

Справочник методов (шпаргалка)

Действие	HttpURLConnection	HttpClient
Создать клиента	`new URL("...").openConnection()`	`HttpClient.newHttpClient()`
Установить метод	`setRequestMethod("GET")`	`GET()` или `POST()` в билдере
Добавить заголовок	`setRequestProperty("Key", "Value")`	`.header("Key", "Value")`
Отправить тело	`getOutputStream().write(bytes)`	`.POST(HttpRequest.BodyPublishers.ofString(json))`
Получить ответ	`getInputStream()` + чтение	`send(request, BodyHandlers.ofString())`
Обработать ошибку	`getResponseCode()` + `getErrorStream()`	`response.statusCode()`

Примеры кода — от простого к сложному

Все примеры ниже — полностью рабочие. Ты можешь скопировать их и запустить у себя (нужно только подключение к интернету).

Пример 1: Простой GET-запрос (HttpURLConnection)

Запрашиваем случайный факт о котах с бесплатного API.

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class SimpleGet {
    public static void main(String[] args) throws Exception {
        // 1. Создаём URL-объект с адресом API
        URL url = new URL("https://catfact.ninja/fact");
        
        // 2. Открываем соединение и приводим к HttpURLConnection
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        
        // 3. Устанавливаем метод запроса (по умолчанию GET, но для ясности пишем явно)
        connection.setRequestMethod("GET");
        
        // 4. Добавляем заголовок — говорим серверу, что принимаем JSON
        connection.setRequestProperty("Accept", "application/json");
        
        // 5. Получаем код ответа (200 = успех)
        int responseCode = connection.getResponseCode();
        System.out.println("Код ответа: " + responseCode);
        
        // 6. Если всё хорошо — читаем ответ
        if (responseCode == 200) {
            // Создаём BufferedReader для чтения потока данных
            BufferedReader reader = new BufferedReader(
                new InputStreamReader(connection.getInputStream())
            );
            
            // Читаем построчно и собираем в одну строку
            StringBuilder response = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            reader.close(); // Всегда закрываем читатель!
            
            // Выводим результат
            System.out.println("Ответ сервера: " + response.toString());
        } else {
            System.out.println("Ошибка! Код: " + responseCode);
        }
        
        // 7. Закрываем соединение
        connection.disconnect();
    }
}

Пример 2: GET-запрос с HttpClient (Java 11+)

То же самое, но короче и современнее.

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class SimpleGetHttpClient {
    public static void main(String[] args) throws Exception {
        // 1. Создаём HTTP-клиента
        HttpClient client = HttpClient.newHttpClient();
        
        // 2. Строим запрос: указываем URL и метод GET
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://catfact.ninja/fact"))
                .header("Accept", "application/json")
                .GET()
                .build();
        
        // 3. Отправляем запрос и получаем ответ (тело ответа — строка)
        HttpResponse response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());
        
        // 4. Выводим код и тело ответа
        System.out.println("Код: " + response.statusCode());
        System.out.println("Тело: " + response.body());
    }
}

Пример 3: POST-запрос с отправкой JSON

Отправляем данные на сервер (например, создаём нового пользователя).

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class SimplePost {
    public static void main(String[] args) throws Exception {
        // Создаём клиента
        HttpClient client = HttpClient.newHttpClient();
        
        // Формируем JSON-строку вручную (на практике используют библиотеки)
        String json = """
                {
                    "name": "Алиса",
                    "job": "программист"
                }
                """;
        
        // Строим POST-запрос
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://reqres.in/api/users"))
                .header("Content-Type", "application/json") // Говорим, что отправляем JSON
                .POST(HttpRequest.BodyPublishers.ofString(json))
                .build();
        
        // Отправляем и получаем ответ
        HttpResponse response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());
        
        System.out.println("Код: " + response.statusCode());
        System.out.println("Ответ: " + response.body());
    }
}

Пример 4: Обработка ошибок и разных кодов ответа

import java.net.HttpURLConnection;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

public class ErrorHandling {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://api.github.com/users/несуществующий_пользователь");
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            
            int code = conn.getResponseCode();
            System.out.println("Код ответа: " + code);
            
            // В зависимости от кода выбираем, откуда читать
            InputStream inputStream;
            if (code >= 200 && code < 300) {
                // Успех — читаем из обычного потока
                inputStream = conn.getInputStream();
            } else {
                // Ошибка — читаем из потока ошибок
                inputStream = conn.getErrorStream();
            }
            
            // Читаем поток
            BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
            StringBuilder response = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            reader.close();
            
            System.out.println("Тело ответа: " + response.toString());
            conn.disconnect();
            
        } catch (Exception e) {
            System.out.println("Произошла ошибка: " + e.getMessage());
        }
    }
}

Пример 5: Работа с параметрами в URL (GET с query)

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;

public class GetWithParams {
    public static void main(String[] args) throws Exception {
        // Параметры запроса (например, поиск)
        String city = "Москва";
        String apiKey = "твой_ключ"; // Замени на реальный ключ
        
        // Кодируем параметры (чтобы русские буквы корректно передались)
        String encodedCity = URLEncoder.encode(city, StandardCharsets.UTF_8);
        
        // Собираем URL с параметрами
        String url = "https://api.openweathermap.org/data/2.5/weather?q=" 
                     + encodedCity + "&appid=" + apiKey;
        
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .GET()
                .build();
        
        HttpResponse response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());
        
        System.out.println("Погода в " + city + ": " + response.body());
    }
}

Пример 6: Асинхронный запрос (не блокирует программу)

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;

public class AsyncRequest {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://catfact.ninja/fact"))
                .GET()
                .build();
        
        // Отправляем запрос асинхронно (не ждём ответа, а продолжаем работу)
        CompletableFuture> futureResponse = 
            client.sendAsync(request, HttpResponse.BodyHandlers.ofString());
        
        System.out.println("Запрос отправлен, ждём ответа...");
        
        // Делаем что-то ещё, пока ответ не пришёл
        for (int i = 0; i < 5; i++) {
            System.out.println("Делаем другую работу: " + i);
            Thread.sleep(500); // Имитация работы
        }
        
        // Получаем ответ (если он уже пришёл — сразу, если нет — ждём)
        HttpResponse response = futureResponse.get();
        System.out.println("Ответ получен: " + response.body());
    }
}

Пример 7: Использование библиотеки Gson для парсинга JSON

// Для этого примера нужно добавить библиотеку Gson в проект
// Если используешь Maven, добавь зависимость:
// com.google.code.gson:gson:2.10.1

import com.google.gson.Gson;
import com.google.gson.JsonObject;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ParseJsonWithGson {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.github.com/users/octocat"))
                .GET()
                .build();
        
        HttpResponse response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());
        
        // Создаём объект Gson
        Gson gson = new Gson();
        
        // Превращаем JSON-строку в Java-объект
        JsonObject jsonObject = gson.fromJson(response.body(), JsonObject.class);
        
        // Извлекаем отдельные поля
        String login = jsonObject.get("login").getAsString();
        String name = jsonObject.get("name").getAsString();
        int publicRepos = jsonObject.get("public_repos").getAsInt();
        
        System.out.println("Логин: " + login);
        System.out.println("Имя: " + name);
        System.out.println("Публичных репозиториев: " + publicRepos);
    }
}

Сравнение с Python: чем похоже и чем отличается

Если ты уже знаком с Python, тебе будет проще. Давай сравним подходы.

Характеристика	Java	Python
Встроенная поддержка HTTP	Есть (HttpURLConnection, HttpClient)	Есть (urllib)
Популярная библиотека	OkHttp, Retrofit (для Android)	Requests (самая популярная)
Синтаксис	Многословный, нужно много boilerplate-кода	Лаконичный, 2-3 строки
Работа с JSON	Нужна внешняя библиотека (Gson, Jackson)	Встроенный модуль json
Асинхронность	Встроенная (CompletableFuture)	asyncio + aiohttp
Типизация	Строгая, всё известно на этапе компиляции	Динамическая, ошибки могут всплыть в рантайме

Пример на Python для сравнения:

import requests

# GET-запрос — одна строка!
response = requests.get("https://catfact.ninja/fact")
print(response.status_code)
print(response.json())  # Автоматически парсит JSON

💡 Вывод: Python проще для быстрых скриптов и прототипов. Java даёт больше контроля, безопасности и производительности для больших проектов. Выбор зависит от задачи.

Типичные ошибки и подводные камни

1. Забыл закрыть соединение

Если не вызвать disconnect() или не закрыть поток, программа может «подтекать» памятью. В новых версиях Java (HttpClient) это происходит автоматически, но со старым HttpURLConnection нужно быть внимательным.

2. Неправильный Content-Type

Если ты отправляешь JSON, но забыл указать заголовок Content-Type: application/json, сервер может не понять твои данные и вернуть ошибку 400.

3. Игнорирование кодировки

Русские буквы, пробелы и спецсимволы в URL нужно кодировать с помощью URLEncoder.encode(). Иначе сервер увидит кракозябры или вернёт 404.

4. Блокировка основного потока

Если делать синхронный запрос в графическом приложении (например, на Android), интерфейс «зависнет» на время ожидания ответа. Используй асинхронные запросы или отдельные потоки.

5. Не проверяешь код ответа

Всегда проверяй response.statusCode() или getResponseCode(). Сервер может вернуть 200, но в теле ответа будет сообщение об ошибке — это плохая практика, но так бывает.

6. Слишком много запросов (Rate Limiting)

Многие API ограничивают количество запросов в минуту. Если превысить лимит, сервер вернёт 429 (Too Many Requests). Решение: добавлять задержки между запросами (Thread.sleep()).

7. Не обрабатываешь исключения

Сеть — ненадёжная штука. Соединение может оборваться, сервер может упасть, DNS может не ответить. Всегда оборачивай сетевые вызовы в try-catch.

Лучшие практики и советы профессионалов

1. Используй HttpClient вместо HttpURLConnection

Если твой проект использует Java 11 или новее — забудь про старый HttpURLConnection. HttpClient удобнее, безопаснее и производительнее.

2. Выноси URL и ключи в конфигурацию

Не пиши URL и API-ключи прямо в коде. Используй файлы .properties, переменные окружения или конфигурационные классы. Это облегчит тестирование и смену окружения.

3. Используй библиотеки для JSON

Не парси JSON вручную через String.split() или indexOf() — это путь к ошибкам. Используй Gson, Jackson или Fastjson. Они делают всю работу за тебя.

4. Добавляй таймауты

Сервер может зависнуть. Устанавливай таймауты на соединение и чтение, чтобы программа не «висла» вечно:

HttpClient client = HttpClient.newBuilder()
    .connectTimeout(Duration.ofSeconds(10)) // Таймаут на соединение
    .build();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("..."))
    .timeout(Duration.ofSeconds(30)) // Таймаут на весь запрос
    .GET()
    .build();

5. Логируй запросы и ответы

На этапе разработки всегда выводи в консоль URL, заголовки и тело ответа. Это поможет быстро найти ошибку. В продакшене используй библиотеки логирования (Log4j, SLF4J).

6. Используй try-with-resources для автоматического закрытия

// Для HttpURLConnection
try (BufferedReader reader = new BufferedReader(
        new InputStreamReader(connection.getInputStream()))) {
    // Читаем ответ
} // reader автоматически закроется

7. Соблюдай принцип единственной ответственности

Вынеси сетевые вызовы в отдельный класс (например, ApiClient). Не смешивай логику HTTP с логикой интерфейса или бизнес-логикой.

Вопросы для самопроверки

Что такое HTTP-запрос и из каких частей он состоит?
Ответ: Это сообщение от клиента к серверу. Состоит из стартовой строки (метод + URL), заголовков и тела (необязательно).
Чем отличается GET от POST?
Ответ: GET — для получения данных (нет тела), POST — для отправки данных (есть тело). GET безопаснее для чувствительных данных, так как параметры видны в URL.
Что означает код ответа 404?
Ответ: Not Found — сервер не нашёл ресурс по указанному URL. Нужно проверить адрес.
Какой класс в Java 11+ используется для HTTP-запросов?
Ответ: java.net.http.HttpClient вместе с HttpRequest и HttpResponse.
Зачем нужен заголовок Content-Type?
Ответ: Чтобы сервер знал, в каком формате клиент отправляет данные (JSON, XML, форма и т.д.).
Что такое JSON и как с ним работать в Java?
Ответ: JSON — текстовый формат для передачи данных. В Java его парсят с помощью библиотек Gson или Jackson.
Почему важно устанавливать таймауты?
Ответ: Чтобы программа не зависала навсегда, если сервер не отвечает. Таймаут прерывает соединение через заданное время.
Что такое асинхронный запрос?
Ответ: Запрос, который не блокирует выполнение программы. Программа продолжает работать, а ответ обрабатывается, когда придёт.
Как обработать ошибку, если сервер вернул 500?
Ответ: Проверить код ответа, прочитать тело ошибки (через getErrorStream()), залогировать и, возможно, повторить запрос позже.
Чем Java-подход к HTTP отличается от Python?
Ответ: Java требует больше кода и часто внешних библиотек для JSON, но даёт больше контроля и безопасности. Python лаконичнее, но медленнее в больших проектах.

Итог и что изучить дальше

Мы прошли большой путь: от аналогии с официантом до асинхронных запросов и парсинга JSON. Теперь ты знаешь:

Как работает клиент-серверное взаимодействие
Какие бывают HTTP-методы и коды ответов
Как отправлять GET и POST-запросы в Java
Как обрабатывать ошибки и JSON
Какие лучшие практики используют профессионалы

Что изучать дальше?

Библиотеки для HTTP: OkHttp (популярна в Android), Retrofit (удобная обёртка)
REST API: Изучи принципы REST — как правильно проектировать API
Spring Boot: Если хочешь писать серверные приложения на Java, изучи Spring Boot и его модуль WebClient
Безопасность: JWT-токены, OAuth2, HTTPS и шифрование
WebSockets: Для real-time приложений (чаты, онлайн-игры)

🎯 Главный совет: Не бойся экспериментировать. Найди любой бесплатный API (например, список на github.com/public-apis) и напиши свою программу, которая получает оттуда данные. Теория без практики — просто текст. Удачи в кодинге!

← Предыдущая Многопоточность и асинхронность в Java: подробное Вперёд → Тестирование кода в Java: подробное руководство