Compréhension approfondie de l'analyse de la communication Java Socket

Cet article présente principalement une compréhension approfondie de Java Socket. La communication réseau en Java est implémentée via Socket. Socket est divisé en deux catégories : ServerSocket et Socket. Ceux qui sont intéressés peuvent en savoir plus

<.> Brève description

Socket en Java est divisé en deux types : Socket ordinaire et NioSocket Voici une introduction à Socket.

Nous pouvons comparer Socket à un moyen de transport entre deux villes. Avec lui, vous pouvez faire la navette entre les deux villes. Il existe de nombreux types de moyens de transport, et chaque moyen de transport a également une correspondance. règles de circulation. Il en va de même pour les Sockets, il en existe de nombreux types. Dans la plupart des cas, des sockets de flux TCP/IP sont utilisés, ce qui constitue un protocole de communication stable. (Comparaison de TCP/IP et UDP)

La communication réseau en Java est implémentée via Socket. Socket est divisé en deux catégories : ServerSocket et Socket est utilisé côté serveur pour écouter les requêtes via la méthode d'acceptation. . Le Socket est renvoyé après la requête. Le Socket est utilisé pour terminer spécifiquement la transmission de données. Le client utilise directement le Socket pour lancer une requête et transmettre des données.

L'utilisation de ServerSocket peut être divisée en trois étapes :

1. Créer ServerSocket. Il existe au total 5 méthodes de construction de ServerSocket. ServerSocket (port int) est généralement utilisé, et seul le numéro de port (port) est requis.

2. Appelez la méthode accept du ServerSocket créé pour écouter. La méthode accept est une méthode bloquante, ce qui signifie qu'après avoir appelé la méthode accept, le programme s'arrêtera et attendra la demande de connexion, et le programme ne continuera pas jusqu'à ce que la demande soit reçue. Lors de la réception de la demande, la méthode accept renverra un Socket.

3. Utilisez le Socket renvoyé par la méthode accept pour communiquer avec le client.

Châtaigne

Client :

package IO;

import java.io.*;
import java.net.Socket;
import java.util.Date;

/**
 * Created by zhengbin06 on 2017/2/2.
 */
public class Client {
  public static void main(String[] args) {
    String msg = "Client Data";
    try {
      Socket socket = new Socket("127.0.0.1", 9090);

      // 先写、再读
      PrintWriter printWriter = new PrintWriter(socket.getOutputStream());
      // 发送数据
      printWriter.println(msg);
      printWriter.flush();
      // 获得服务端返回的数据
      BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
      String line = bufferedReader.readLine();
      System.out.println("received from server: " + line + "\ttime=" + new Date().getTime());
      // 关闭资源
      printWriter.close();
      bufferedReader.close();
      socket.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Serveur :

package IO;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;

/**
 * Created by zhengbin06 on 2017/2/2.
 */
public class Server {
  private static Socket socket = null;
  private static ServerSocket serverSocket = null;
  public static void main(String[] args) throws IOException {
    BufferedReader bufferedReader = null;
    PrintWriter printWriter = null;
    try {
      // 创建一个ServerSocket监听9090端口
      serverSocket = new ServerSocket(9090);
      while (true) {
        System.out.println("开始等待请求。。。。");
        // 等待请求
        // 监听并接受到此套接字的连接。此方法在连接传入之前一直阻塞。
        socket = serverSocket.accept();
        System.out.println("接收到请求:" + socket.toString() + "\ttime=" + new Date().getTime());
        // 接收到请求后使用socket进行通信, 创建BufferedReader用于读取数据
        bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String line = bufferedReader.readLine();
        System.out.println("received from client: " + line + "\ttime=" + new Date().getTime());
  
        // 创建PrintWriter, 用于发送数据
        printWriter = new PrintWriter(socket.getOutputStream());
        printWriter.println("received data: " + line + "\ttime=" + new Date().getTime());
        printWriter.flush();
      }
    } finally {
      // 关闭所有资源
      bufferedReader.close();
      printWriter.close();
      socket.close();
      serverSocket.close();
    }
  }
}

Détails

Demande d'écoute :

Quand Lorsqu'une nouvelle demande Socket arrive, une nouvelle structure de données socket sera créée pour cette connexion. Les informations sur les données socket contiennent l'adresse et le port de l'adresse et du port source de la demande formelle. Cette structure de données nouvellement créée sera associée à une liste de structures de données de connexion en suspens dans l'instance ServerSocket. Notez que l'instance Socket correspondante du serveur n'a pas été créée pour le moment. L'instance Socket du serveur ne reviendra pas tant que la négociation à trois avec le client n'est pas terminée, et la structure de données correspondant à l'instance Socket ne sera pas Les déplacements dans la liste sont effectués dans la liste.

Transmission de données :

Lorsque la connexion a été établie avec succès, le serveur et le client auront une instance Socket, et chaque instance Socket aura un InputStream et un OutputStream . Et échangez des données via ces deux objets.

Vous devez savoir que les E/S réseau sont transmises sous forme de flux d'octets. Lors de la création d'un objet Socket, le système d'exploitation allouera une zone tampon d'une certaine taille pour l'écriture et la lecture des données InputStream et OutputStream. sont complétés via cette zone de cache.

L'extrémité d'écriture écrit les données dans la file d'attente SendQ correspondant au OutputStream. Lorsque la file d'attente est pleine, les données seront transférées vers la file d'attente RecvQ du InputStream à l'autre extrémité du RecvQ. est pleine à ce moment-là, la méthode d'écriture de OutputStream se bloquera jusqu'à ce que la file d'attente RecvQ dispose de suffisamment d'espace pour accueillir les données envoyées par SendQ. Le processus est illustré dans la figure ci-dessous :

Ce qui précède est une compréhension approfondie de l'analyse de la communication Java Socket. Pour plus de contenu connexe, veuillez payer. attention au site PHP chinois (www.php.cn) !