Javaネットワークプログラミングの基礎: java.netパッケージ徹底解説

java.netパッケージは、Javaプラットフォームにおいてネットワーク関連の機能を提供する中心的なライブラリです。Javaの初期バージョンから存在し、アプリケーションがインターネットや他のネットワークと対話するための基本的なクラス群を提供します。このパッケージを利用することで、開発者は低レベルのソケット通信から高レベルのHTTPリクエストまで、多岐にわたるネットワークプログラミングを実装できます。

具体的には、以下のような機能が含まれています。

この記事では、これらの主要な機能について、基本的な概念から具体的なコード例までを交えながら、詳細に解説していきます。特に、Javaのバージョンアップに伴う変化、例えばJava 11で導入された新しいHTTPクライアントなど、現代的な開発において知っておくべき重要なポイントにも焦点を当てます。

ネットワーク上のリソース（Webページ、画像、APIエンドポイントなど）を扱う上で基本となるのが、その場所を示す識別子です。java.netパッケージでは、そのためにURIとURLという2つのクラスが提供されています。

URIとURLの違い

この2つのクラスは似ていますが、明確な役割の違いがあります。

簡単に言えば、URIは「住所の書き方のルール」、URLは「実際に手紙が届く住所」のような関係です。すべてのURLはURIの構文に従っていますが、すべてのURIがURLであるとは限りません。

URLクラスの基本的な使い方と注意点

URLオブジェクトは、特定のリソースへの接続を作成するための出発点となります。

<?xml version="1.0" encoding="UTF-8"?>
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;

public class UrlExample {
    public static void main(String[] args) {
        String urlString = "https://www.example.com:8080/path/to/resource?key=value#fragment";

        try {
            // 推奨される方法: URI.create() または new URI() を経由する
            URI uri = new URI(urlString);
            URL url = uri.toURL();

            System.out.println("URL: " + url);
            System.out.println("Protocol: " + url.getProtocol()); // https
            System.out.println("Host: " + url.getHost());     // www.example.com
            System.out.println("Port: " + url.getPort());     // 8080
            System.out.println("Path: " + url.getPath());     // /path/to/resource
            System.out.println("Query: " + url.getQuery());   // key=value
            System.out.println("Fragment: " + url.getRef());  // fragment (RefはReferenceの意)

        } catch (URISyntaxException e) {
            System.err.println("URIの構文が正しくありません: " + e.getMessage());
        } catch (MalformedURLException e) {
            System.err.println("不正な形式のURLです: " + e.getMessage());
        } catch (IllegalArgumentException e) {
            System.err.println("不正な引数です: " + e.getMessage());
        }
    }
}

この方法は、まずURIクラスが文字列の構文を厳密にチェックしてくれるため、より安全で堅牢なコードになります。常にURIを経由する方法を習慣づけるようにしましょう。

java.net.HttpURLConnectionは、Javaの初期から提供されている、HTTP通信を行うための基本的なクラスです。Java 11でより高機能なHttpClientが登場しましたが、HttpURLConnectionは外部ライブラリを必要とせず、標準APIのみで手軽に利用できるため、依然として多くの場面で使われています。

HttpURLConnectionは抽象クラスであり、実際のインスタンスはURL.openConnection()メソッドが返すオブジェクトをキャストして取得します。

GETリクエストの送信

GETリクエストは、Webサーバーから情報を取得するための最も一般的なメソッドです。

<?xml version="1.0" encoding="UTF-8"?>
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URI;
import java.net.URL;

public class HttpUrlConnectionGetExample {
    public static void main(String[] args) {
        HttpURLConnection connection = null;
        try {
            URL url = new URI("https://api.github.com/users/google").toURL();
            connection = (HttpURLConnection) url.openConnection();

            // 1. リクエストメソッドの設定 (GETはデフォルトなので省略可能)
            connection.setRequestMethod("GET");

            // 2. タイムアウト設定 (ミリ秒)
            connection.setConnectTimeout(5000); // 接続タイムアウト
            connection.setReadTimeout(5000);    // 読み取りタイムアウト

            // 3. レスポンスコードの確認
            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);

            if (responseCode == HttpURLConnection.HTTP_OK) { // 200 OK
                // 4. レスポンスボディの読み取り
                try (BufferedReader in = new BufferedReader(
                        new InputStreamReader(connection.getInputStream()))) {
                    String inputLine;
                    StringBuilder content = new StringBuilder();
                    while ((inputLine = in.readLine()) != null) {
                        content.append(inputLine);
                    }
                    System.out.println("Response Body: " + content.toString().substring(0, 200) + "...");
                }
            } else {
                System.out.println("GET request not worked");
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                // 5. 接続の解放
                connection.disconnect();
            }
        }
    }
}

POSTリクエストの送信

POSTリクエストは、サーバーにデータを送信して新しいリソースを作成したり、既存のデータを更新したりするために使用されます。

<?xml version="1.0" encoding="UTF-8"?>
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URI;
import java.net.URL;
import java.nio.charset.StandardCharsets;

public class HttpUrlConnectionPostExample {
    public static void main(String[] args) {
        HttpURLConnection connection = null;
        try {
            URL url = new URI("https://jsonplaceholder.typicode.com/posts").toURL();
            connection = (HttpURLConnection) url.openConnection();

            // 1. POSTメソッドの設定
            connection.setRequestMethod("POST");

            // 2. ヘッダーの設定
            connection.setRequestProperty("Content-Type", "application/json; utf-8");
            connection.setRequestProperty("Accept", "application/json");

            // 3. リクエストボディの送信を有効にする
            connection.setDoOutput(true);

            // 4. 送信するJSONデータ
            String jsonInputString = "{\"title\": \"foo\", \"body\": \"bar\", \"userId\": 1}";

            // 5. リクエストボディの書き込み
            try(OutputStream os = connection.getOutputStream()) {
                byte[] input = jsonInputString.getBytes(StandardCharsets.UTF_8);
                os.write(input, 0, input.length);
            }

            // 6. レスポンスの読み取り (GETと同様)
            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);

            try(BufferedReader br = new BufferedReader(
                    new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8))) {
                StringBuilder response = new StringBuilder();
                String responseLine;
                while ((responseLine = br.readLine()) != null) {
                    response.append(responseLine.trim());
                }
                System.out.println("Response Body: " + response.toString());
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
    }
}

Java 11 (2018年9月リリース) で、新しい標準HTTPクライアントAPI (java.net.http.HttpClient) が正式に導入されました。これは、HttpURLConnectionが抱えていたいくつかの課題を解決し、より現代的なアプリケーション開発に適した機能を提供します。

HttpURLConnectionとの比較

HttpClientがHttpURLConnectionに比べて優れている点は以下の通りです。

特別な理由がない限り、新規にJava 11以上で開発を行う場合は、HttpClientの使用が強く推奨されます。

同期的なGETリクエスト

HttpClientを使ったAPI呼び出しは、リクエストの作成、クライアントによる送信、という明確なステップに分かれています。

<?xml version="1.0" encoding="UTF-8"?>
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class HttpClientSyncExample {
    public static void main(String[] args) {
        // 1. HttpClientの作成 (再利用可能)
        HttpClient client = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_2)
                .connectTimeout(Duration.ofSeconds(10))
                .build();

        // 2. HttpRequestの作成
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.github.com/users/google"))
                .header("Accept", "application/vnd.github.v3+json")
                .GET() // メソッド指定 (デフォルトはGET)
                .build();

        try {
            // 3. リクエストの送信とレスポンスの受信
            // BodyHandlersはレスポンスボディをどう処理するかを指定する
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

            // 4. レスポンス情報の取得
            System.out.println("Status Code: " + response.statusCode());
            System.out.println("Headers: " + response.headers());
            System.out.println("Body: " + response.body().substring(0, 200) + "...");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

非同期的なPOSTリクエスト

HttpClientの真価は非同期処理にあります。sendAsync()メソッドはCompletableFutureを返し、UIスレッドをブロックすることなくネットワーク通信を行えます。

<?xml version="1.0" encoding="UTF-8"?>
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class HttpClientAsyncPostExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();

        String json = "{\"title\": \"foo_async\", \"body\": \"bar_async\", \"userId\": 2}";

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://jsonplaceholder.typicode.com/posts"))
                .header("Content-Type", "application/json")
                // BodyPublishersはリクエストボディをどう提供するかを指定する
                .POST(HttpRequest.BodyPublishers.ofString(json))
                .build();

        // 1. 非同期でリクエストを送信
        CompletableFuture<HttpResponse<String>> futureResponse =
                client.sendAsync(request, HttpResponse.BodyHandlers.ofString());

        // 2. レスポンスが返ってきた後の処理を定義 (ラムダ式)
        futureResponse.thenApply(HttpResponse::body)
                      .thenAccept(System.out::println);

        // 3. (デモのため) 処理が終わるまで待機
        futureResponse.join();
    }
}

HTTPのようなアプリケーション層のプロトコルより低いレベル、トランスポート層での通信を直接扱いたい場合、ソケットプログラミングが必要になります。java.netパッケージは、TCPプロトコルによる通信のためのSocketとServerSocketクラスを提供します。

TCPはコネクション指向のプロトコルです。通信を始める前に、クライアントとサーバーの間で「接続」を確立します。これにより、送信したデータが送信した順序で、欠けることなく相手に届くことが保証され、信頼性の高い通信が実現されます。

• ServerSocket: サーバー側で使用します。特定のポート番号でクライアントからの接続要求を待ち受けます（listen）。
• Socket: サーバーとクライアントの両方で使用されます。クライアント側ではサーバーに接続するために生成し、サーバー側ではServerSocketが接続要求を受け入れた（accept）結果として生成されます。実際のデータ交換は、このSocketの入出力ストリームを介して行われます。

シンプルなエコーサーバーの実装例

クライアントから送られてきたメッセージを、そのままクライアントに送り返す「エコーサーバー」と、そのクライアントの例を見てみましょう。

サーバー側コード (EchoServer.java)

<?xml version="1.0" encoding="UTF-8"?>
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class EchoServer {
    public static void main(String[] args) {
        int port = 12345;
        System.out.println("サーバーがポート " + port + " で起動しました。");

        try (ServerSocket serverSocket = new ServerSocket(port)) {
            System.out.println("クライアントからの接続を待っています...");

            // accept()はクライアントが接続してくるまで処理をブロックする
            try (Socket clientSocket = serverSocket.accept();
                 PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
                 BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()))) {

                System.out.println("クライアントが接続しました: " + clientSocket.getRemoteSocketAddress());
                out.println("ようこそ！メッセージを送ってください。'exit'で終了します。");

                String inputLine;
                while ((inputLine = in.readLine()) != null) {
                    System.out.println("クライアントからのメッセージ: " + inputLine);
                    if ("exit".equalsIgnoreCase(inputLine)) {
                        out.println("さようなら。");
                        break;
                    }
                    // エコーバック
                    out.println("Echo: " + inputLine);
                }
            }
            System.out.println("クライアントとの接続を終了しました。");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

クライアント側コード (EchoClient.java)

<?xml version="1.0" encoding="UTF-8"?>
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

public class EchoClient {
    public static void main(String[] args) {
        String hostname = "localhost";
        int port = 12345;

        try (Socket socket = new Socket(hostname, port);
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
             BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
             BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in))) {

            System.out.println("サーバーに接続しました。");

            // サーバーからの最初のメッセージを受信
            System.out.println("サーバー: " + in.readLine());

            String userInput;
            while ((userInput = stdIn.readLine()) != null) {
                // ユーザーが入力したメッセージをサーバーに送信
                out.println(userInput);

                // サーバーからのエコーメッセージを受信して表示
                String serverResponse = in.readLine();
                System.out.println("サーバー: " + serverResponse);

                if ("さようなら。".equals(serverResponse)) {
                    break;
                }
            }
        } catch (Exception e) {
            System.err.println(hostname + ":" + port + "への接続に失敗しました。");
            e.printStackTrace();
        }
    }
}

TCPとは対照的に、UDP (User Datagram Protocol) はコネクションレスのプロトコルです。事前に接続を確立せず、一方的にデータをパケット（データグラム）として送りつけます。

この方式には以下のような特徴があります。

• 高速性: 接続・切断のオーバーヘッドがないため、通信が高速です。
• 信頼性の欠如: 送信したパケットが相手に届く保証はありません。また、パケットが送信した順序通りに届くとも限りませんし、同じパケットが複数回届く可能性もあります。

そのため、データの信頼性よりも速度やリアルタイム性が重視される用途、例えばDNSの名前解決、DHCP、オンラインゲームのプレイヤー位置情報、ビデオや音声のストリーミングなどに利用されます。

Javaでは、UDP通信のために以下のクラスを使用します。

• DatagramSocket: UDPパケットを送受信するためのソケット（通信の端点）。
• DatagramPacket: 送受信されるデータそのものと、宛先または送信元のIPアドレス・ポート番号を格納するコンテナ。

シンプルなUDP送受信の実装例

受信側コード (UdpReceiver.java)

<?xml version="1.0" encoding="UTF-8"?>
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UdpReceiver {
    public static void main(String[] args) {
        int port = 54321;
        System.out.println("UDPレシーバーがポート " + port + " で待機中...");

        try (DatagramSocket socket = new DatagramSocket(port)) {
            byte[] buffer = new byte; // 受信用のバッファ

            while (true) {
                // 1. 受信用のDatagramPacketを作成
                DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

                // 2. パケットを受信するまでブロック
                socket.receive(packet);

                // 3. 受信したデータを文字列に変換
                String receivedMessage = new String(packet.getData(), 0, packet.getLength());
                InetAddress senderAddress = packet.getAddress();
                int senderPort = packet.getPort();

                System.out.println("受信: [" + senderAddress.getHostAddress() + ":" + senderPort + "] " + receivedMessage);

                if ("exit".equalsIgnoreCase(receivedMessage)) {
                    System.out.println("終了コマンドを受信しました。");
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

送信側コード (UdpSender.java)

<?xml version="1.0" encoding="UTF-8"?>
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

public class UdpSender {
    public static void main(String[] args) {
        String hostname = "localhost";
        int port = 54321;

        try (DatagramSocket socket = new DatagramSocket(); // 送信側はポート指定不要
             Scanner scanner = new Scanner(System.in)) {

            InetAddress address = InetAddress.getByName(hostname);

            System.out.println("送信するメッセージを入力してください ('exit'で終了):");
            while (scanner.hasNextLine()) {
                String message = scanner.nextLine();
                byte[] buffer = message.getBytes();

                // 1. 送信用のDatagramPacketを作成 (データ、長さ、宛先アドレス、宛先ポート)
                DatagramPacket packet = new DatagramPacket(buffer, buffer.length, address, port);

                // 2. パケットを送信
                socket.send(packet);
                System.out.println("送信: " + message);

                if ("exit".equalsIgnoreCase(message)) {
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

ネットワークプログラミングにおいて、通信相手を特定するためにはIPアドレスが必要ですが、人間にとってはwww.google.comのようなホスト名の方がはるかに覚えやすく、扱いやすいです。このホスト名とIPアドレスの対応付けを管理しているのがDNS (Domain Name System) であり、ホスト名からIPアドレスを調べることを名前解決と呼びます。

Javaのjava.net.InetAddressクラスは、この名前解決を行うための機能を提供します。このクラスのインスタンスはIPアドレスを表しますが、ホスト名に関する情報も保持することができます。

InetAddressにはコンストラクタがなく、静的ファクトリメソッドを使ってインスタンスを取得します。

主な使い方

<?xml version="1.0" encoding="UTF-8"?>
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Arrays;

public class InetAddressExample {
    public static void main(String[] args) {
        try {
            // 1. ホスト名からInetAddressインスタンスを取得
            // DNSに問い合わせが行われる
            InetAddress googleAddress = InetAddress.getByName("www.google.com");
            System.out.println("--- www.google.com の情報 ---");
            System.out.println("Host Name: " + googleAddress.getHostName());
            System.out.println("IP Address: " + googleAddress.getHostAddress());
            System.out.println();

            // 2. 1つのホスト名に複数のIPアドレスが関連付けられている場合
            InetAddress[] allGoogleAddresses = InetAddress.getAllByName("www.google.com");
            System.out.println("--- www.google.com の全てのIPアドレス ---");
            // Arrays.stream(allGoogleAddresses).forEach(System.out::println); とも書ける
            for (InetAddress addr : allGoogleAddresses) {
                System.out.println(addr.getHostAddress());
            }
            System.out.println();

            // 3. 自身のローカルホスト情報を取得
            InetAddress localHost = InetAddress.getLocalHost();
            System.out.println("--- ローカルホストの情報 ---");
            System.out.println("Host Name: " + localHost.getHostName());
            System.out.println("IP Address: " + localHost.getHostAddress());
            System.out.println();

            // 4. IPアドレス文字列からInetAddressインスタンスを取得
            // この場合、逆引きが行われない限りホスト名はIPアドレスのまま
            InetAddress specificAddress = InetAddress.getByName("8.8.8.8");
            System.out.println("--- 8.8.8.8 の情報 ---");
            System.out.println("Host Name (逆引き試行後): " + specificAddress.getHostName());
            System.out.println("IP Address: " + specificAddress.getHostAddress());


        } catch (UnknownHostException e) {
            System.err.println("ホストが見つかりません: " + e.getMessage());
        }
    }
}

本記事では、Javaのネットワークプログラミングの根幹をなすjava.netパッケージについて、その主要なクラスと機能を紹介しました。

高レベルなHTTP通信から見ていくと、

• URL/URI: ネットワーク上のリソースを特定するための基本。Java 20以降はURI経由でURLを生成する方法が推奨されます。
• HttpURLConnection: 伝統的でシンプルなHTTPクライアント。標準ライブラリのみで動作する手軽さがあります。
• HttpClient (Java 11+): HTTP/2や非同期処理をサポートするモダンで高機能なクライアント。新規開発ではこちらの利用が第一候補となります。

より低レベルな通信では、

• Socket/ServerSocket: 信頼性の高いTCP通信を実現するための基本。コネクションを確立し、ストリームベースでデータをやり取りします。
• DatagramSocket/DatagramPacket: 高速なUDP通信を実現します。パケット単位でデータを送受信し、信頼性はアプリケーション側で担保する必要があります。
• InetAddress: ホスト名とIPアドレスの相互変換を行い、通信相手を特定する上で不可欠な機能です。

java.netパッケージを使いこなすことで、単純なAPIクライアントから、複雑なP2Pアプリケーション、高性能なネットワークサーバーまで、Javaで実現できることの幅は大きく広がります。それぞれのクラスの特性を理解し、目的に応じて適切なツールを選択することが、効果的なネットワークプログラミングへの第一歩となるでしょう。