Programmation réseau Java


La programmation réseau fait référence à l'écriture de programmes qui s'exécutent sur plusieurs appareils (ordinateurs) tous connectés via un réseau.

L'API J2SE du package java.net contient des classes et des interfaces qui fournissent des détails de communication de bas niveau. Vous pouvez utiliser ces classes et interfaces directement pour vous concentrer sur la résolution de problèmes plutôt que sur les détails de la communication.

Le package java.net prend en charge deux protocoles réseau courants :

  • TCP : TCP est l'abréviation de Transmission Control Protocol, il garantit communication fiable entre deux applications. Couramment utilisé pour les protocoles Internet, appelés TCP/IP.

  • UDP : UDP est l'abréviation de User Datagram Protocol, un protocole sans connexion. Fournit des paquets de données à envoyer entre les applications.

Ce tutoriel explique principalement les deux sujets suivants.

  • Socket Programmation  : Il s'agit du concept de réseau le plus largement utilisé et il a été expliqué en détail

  • URL Traitement : Cette partie sera abordée dans un autre espace. Cliquez ici pour en savoir plus sur le traitement des URL en langage Java.

Programmation de sockets

Les sockets fournissent un mécanisme de communication entre deux ordinateurs utilisant TCP. Le programme client crée un socket et tente de se connecter au socket du serveur.

Lorsque la connexion est établie, le serveur créera un objet Socket. Le client et le serveur peuvent désormais communiquer en écrivant et en lisant dans l'objet Socket.

La classe java.net.Socket représente un socket, et la classe java.net.ServerSocket fournit un mécanisme permettant aux programmes serveur d'écouter les clients et d'établir des connexions avec eux.

Les étapes suivantes se produisent lors de l'établissement d'une connexion TCP entre deux ordinateurs à l'aide de sockets :

  • Le serveur instancie un objet ServerSocket, qui représente la communication via un port sur le serveur.

  • Le serveur appelle la méthode accept() de la classe ServerSocket, qui attend que le client se connecte au port donné sur le serveur.

  • Pendant que le serveur attend, un client instancie un objet Socket, spécifiant le nom du serveur et le numéro de port pour demander une connexion.

  • Le constructeur de la classe Socket tente de connecter le client au serveur et au numéro de port spécifiés. Si la communication est établie, un objet Socket est créé sur le client pour communiquer avec le serveur.

  • Côté serveur, la méthode accept() renvoie une nouvelle référence de socket sur le serveur connecté au socket du client.


Une fois la connexion établie, la communication est effectuée à l'aide de flux d'E/S. Chaque socket possède un flux de sortie et un flux d’entrée. Le flux de sortie du client est connecté au flux d'entrée du serveur et le flux d'entrée du client est connecté au flux de sortie du serveur.


TCP est un protocole de communication bidirectionnel, de sorte que les données peuvent être envoyées via deux flux de données en même temps. Ce qui suit est un ensemble complet de méthodes utiles fournies par certaines classes à implémenter. prises.

Méthodes de la classe ServerSocket

L'application serveur utilise la classe java.net.ServerSocket pour obtenir un port et écouter les requêtes des clients.

La classe ServerSocket a quatre constructeurs :

序号方法描述
1public ServerSocket(int port) throws IOException
创建绑定到特定端口的服务器套接字。
2public ServerSocket(int port, int backlog) throws IOException
利用指定的 backlog 创建服务器套接字并将其绑定到指定的本地端口号。
3public ServerSocket(int port, int backlog, InetAddress address) throws IOException
使用指定的端口、侦听 backlog 和要绑定到的本地 IP 地址创建服务器。
4public ServerSocket() throws IOException
创建非绑定服务器套接字。

Créez un socket serveur indépendant. Si la méthode de construction ServerSocket ne lève pas d'exception, cela signifie que votre application s'est liée avec succès au port spécifié et écoute les demandes des clients.

Voici quelques méthodes courantes de la classe ServerSocket :

序号方法描述
1public int getLocalPort()
  返回此套接字在其上侦听的端口。
2public Socket accept() throws IOException
侦听并接受到此套接字的连接。
3public void setSoTimeout(int timeout)
 通过指定超时值启用/禁用 SO_TIMEOUT，以毫秒为单位。
4public void bind(SocketAddress host, int backlog)
将 ServerSocket 绑定到特定地址（IP 地址和端口号）。

Méthodes de la classe Socket

La classe java.net.Socket représente le socket utilisé à la fois par le client et le serveur pour communiquer entre eux. Le client obtient un objet Socket via l'instanciation et le serveur obtient un objet Socket via la valeur de retour de la méthode accept().

La classe Socket dispose de cinq méthodes de construction.

序号方法描述
1public Socket(String host, int port) throws UnknownHostException, IOException.
创建一个流套接字并将其连接到指定主机上的指定端口号。
2public Socket(InetAddress host, int port) throws IOException
创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
3public Socket(String host, int port, InetAddress localAddress, int localPort) throws IOException.
创建一个套接字并将其连接到指定远程主机上的指定远程端口。
4public Socket(InetAddress host, int port, InetAddress localAddress, int localPort) throws IOException.
创建一个套接字并将其连接到指定远程地址上的指定远程端口。
5public Socket()
通过系统默认类型的 SocketImpl 创建未连接套接字

Lorsque le constructeur Socket revient, il n'instancie pas simplement un objet Socket, il essaiera en fait de se connecter au serveur et au port spécifiés.

Certaines méthodes intéressantes sont répertoriées ci-dessous. Notez que le client et le serveur ont tous deux un objet Socket, donc le client et le serveur peuvent appeler ces méthodes.

序号方法描述
1public void connect(SocketAddress host, int timeout) throws IOException
将此套接字连接到服务器，并指定一个超时值。
2public InetAddress getInetAddress()
 返回套接字连接的地址。
3public int getPort()
返回此套接字连接到的远程端口。
4public int getLocalPort()
返回此套接字绑定到的本地端口。
5public SocketAddress getRemoteSocketAddress()
返回此套接字连接的端点的地址，如果未连接则返回 null。
6public InputStream getInputStream() throws IOException
返回此套接字的输入流。
7public OutputStream getOutputStream() throws IOException
返回此套接字的输出流。
8public void close() throws IOException
关闭此套接字。

Méthodes de la classe InetAddress

Cette classe représente une adresse IP (Internet Protocol). Voici une liste des méthodes les plus utiles pour la programmation Socket :

序号方法描述
1static InetAddress getByAddress(byte[] addr)
在给定原始 IP 地址的情况下，返回 InetAddress 对象。
2static InetAddress getByAddress(String host, byte[] addr)
根据提供的主机名和 IP 地址创建 InetAddress。
3static InetAddress getByName(String host)
在给定主机名的情况下确定主机的 IP 地址。
4String getHostAddress() 
返回 IP 地址字符串（以文本表现形式）。
5String getHostName() 
 获取此 IP 地址的主机名。
6static InetAddress getLocalHost()
返回本地主机。
7String toString()
将此 IP 地址转换为 String。

Instance client Socket

Le GreetingClient suivant est un programme client qui se connecte au serveur via socket et envoie une demande, puis attend une réponse. 

// 文件名 GreetingClient.java

import java.net.*;
import java.io.*;
 
public class GreetingClient
{
   public static void main(String [] args)
   {
      String serverName = args[0];
      int port = Integer.parseInt(args[1]);
      try
      {
         System.out.println("Connecting to " + serverName
                             + " on port " + port);
         Socket client = new Socket(serverName, port);
         System.out.println("Just connected to "
                      + client.getRemoteSocketAddress());
         OutputStream outToServer = client.getOutputStream();
         DataOutputStream out =
                       new DataOutputStream(outToServer);
 
         out.writeUTF("Hello from "
                      + client.getLocalSocketAddress());
         InputStream inFromServer = client.getInputStream();
         DataInputStream in =
                        new DataInputStream(inFromServer);
         System.out.println("Server says " + in.readUTF());
         client.close();
      }catch(IOException e)
      {
         e.printStackTrace();
      }
   }
}

Instance de serveur Socket

Le programme GreetingServer suivant est une application côté serveur qui utilise Socket pour écouter un port spécifié. 

// 文件名 GreetingServer.java

import java.net.*;
import java.io.*;

public class GreetingServer extends Thread
{
   private ServerSocket serverSocket;
   
   public GreetingServer(int port) throws IOException
   {
      serverSocket = new ServerSocket(port);
      serverSocket.setSoTimeout(10000);
   }

   public void run()
   {
      while(true)
      {
         try
         {
            System.out.println("Waiting for client on port " +
            serverSocket.getLocalPort() + "...");
            Socket server = serverSocket.accept();
            System.out.println("Just connected to "
                  + server.getRemoteSocketAddress());
            DataInputStream in =
                  new DataInputStream(server.getInputStream());
            System.out.println(in.readUTF());
            DataOutputStream out =
                 new DataOutputStream(server.getOutputStream());
            out.writeUTF("Thank you for connecting to "
              + server.getLocalSocketAddress() + "\nGoodbye!");
            server.close();
         }catch(SocketTimeoutException s)
         {
            System.out.println("Socket timed out!");
            break;
         }catch(IOException e)
         {
            e.printStackTrace();
            break;
         }
      }
   }
   public static void main(String [] args)
   {
      int port = Integer.parseInt(args[0]);
      try
      {
         Thread t = new GreetingServer(port);
         t.start();
      }catch(IOException e)
      {
         e.printStackTrace();
      }
   }
}

Compilez le code Java ci-dessus et exécutez la commande suivante pour démarrer le service, en utilisant le numéro de port 6066 : 

$ java GreetingServer 6066
Waiting for client on port 6066...
Démarrez le client comme suit : 
$ java GreetingClient localhost 6066
Connecting to localhost on port 6066
Just connected to localhost/127.0.0.1:6066
Server says Thank you for connecting to /127.0.0.1:6066
Goodbye!