J'ai récemment appris la programmation réseau Java. J'en ai déjà entendu parler, mais je ne l'ai jamais compris sérieusement. Ces derniers jours, je me suis soudainement intéressé et j'ai senti que c'était très magique. J'ai soudain eu envie de savoir quelle était la situation spécifique.
Socket, également communément appelé « socket », est utilisé pour décrire les adresses IP et les ports, et constitue le descripteur d'une chaîne de communication. Les hôtes sur Internet exécutent généralement plusieurs logiciels de services et fournissent plusieurs services en même temps. Chaque service ouvre un Socket et est lié à un port. Différents ports correspondent à différents services.
La prise est très similaire à une prise téléphonique. En prenant un réseau téléphonique national comme exemple, les deux parties à l'appel téléphonique sont équivalentes à deux processus communiquant entre elles, et l'indicatif régional est son adresse réseau ; un commutateur dans une unité de la zone est équivalent à un hôte, et l'hôte attribue un numéro intra-bureau à chaque utilisateur, équivalent au numéro de socket. Avant qu'un utilisateur puisse passer un appel, il doit d'abord posséder un téléphone, ce qui équivaut à demander un Socket ; en même temps, il doit connaître le numéro de son interlocuteur, ce qui équivaut à ce que celui-ci ait un Socket fixe. Composez ensuite un appel vers l'autre partie, ce qui équivaut à émettre une demande de connexion (si l'autre partie n'est pas dans la même zone, vous devez également composer l'indicatif régional de l'autre partie, ce qui équivaut à donner une adresse réseau). Si l'autre partie est présente et inactive (ce qui équivaut à ce que l'autre hôte de communication soit allumé et capable d'accepter les demandes de connexion), décrochez le combiné téléphonique et les deux parties peuvent officiellement parler, ce qui équivaut à une connexion réussie. Le processus d'un appel entre les deux parties est le processus par lequel une partie envoie un signal au téléphone et l'autre partie reçoit le signal du téléphone, ce qui équivaut à envoyer des données au Socket et à recevoir des données du Socket. Une fois l'appel terminé, le fait qu'un correspondant raccroche équivaut à fermer le Socket et à annuler la connexion.
Dans le système téléphonique, l'utilisateur moyen ne peut ressentir que l'existence du téléphone local et du numéro de téléphone de l'autre partie. Le processus d'établissement d'un appel, le processus de transmission vocale et les détails techniques de. l'ensemble du système téléphonique lui est entièrement transparent, ce qui est également très similaire au mécanisme Socket. Socket utilise les moyens de communication Internet pour réaliser la communication de processus, mais il ne se soucie pas des détails des moyens de communication. Tant que les moyens de communication peuvent fournir des capacités de communication suffisantes, il est satisfait.
Ce qui précède sont les définitions et explications de l'Encyclopédie Baidu, mais elles sont toujours assez faciles à comprendre, contrairement à certaines explications précédentes qui étaient très difficiles à comprendre. Il y avait trop de termes professionnels et c'était très difficile à comprendre.
Étapes de mise en œuvre de la communication Socket :
1. Créer un ServerSocket et un Socket
2. Ouvrir le flux d'entrée/sortie connecté au Socket
3. Suivre le protocole (généralement TCP/ UDP) Opérations de lecture et d'écriture sur Socket
4. Fermez le flux d'entrée/sortie et fermez Socket
L'un est ServerSocket et l'autre est Socket. Une connexion est établie entre le serveur et le client via Socket, puis ils peuvent communiquer. Tout d'abord, ServerSocket écoutera un certain port côté serveur. Lorsqu'il constatera que le client dispose d'un Socket et essaiera de s'y connecter, il acceptera la demande de connexion du Socket et établira un Socket correspondant côté serveur pour communiquer. avec ça. De cette façon, il existe deux Sockets, un pour le client et un pour le serveur.
La communication entre Sockets est en fait très simple. Le serveur écrit quelque chose dans le flux de sortie du Socket et le client peut lire le contenu correspondant via le flux d'entrée du Socket. Il existe une connexion bidirectionnelle entre Socket et Socket, de sorte que le client peut également écrire des éléments dans le flux de sortie Socket correspondant, puis le flux d'entrée Socket correspondant sur le serveur peut lire le contenu correspondant. 
Ce qui suit est un exemple, lecture et écriture du client et lecture et écriture du serveur
public class Server {
public static void main(String args[]) throws IOException {
//定义一个ServerSocket监听在端口8888上
int port = 8888;
int i=1; //连接计数
//server尝试接收其他Socket的连接请求，
ServerSocket server = new ServerSocket(port);
//server的accept方法是阻塞式的 ,即等待着客户端的请求
Socket socket = server.accept();
System.out.println("连接"+i++);
//跟客户端建立好连接，我们就可以获取socket的InputStream，从中读取客户端发过来的信息。
Reader reader = new InputStreamReader(socket.getInputStream());
char chars[] = new char[64];
int len;
StringBuilder sb = new StringBuilder();
String temp;
int index;
while ((len=reader.read(chars)) != -1) {
temp = new String(chars, 0, len);
if ((index = temp.indexOf("eof")) != -1) { //遇到eof时就结束接收
sb.append(temp.substring(0, index));
break;
}
sb.append(temp);
}
System.out.println("from client: " + sb);
//读完后写数据
Writer writer = new OutputStreamWriter(socket.getOutputStream());
writer.write("Hello Client:我是服务端输入数据");
//释放资源
writer.flush();
writer.close();
reader.close();
socket.close();
server.close();
}
}
L'opération du serveur pour lire les données du InputStream du Socket est également bloquante si aucune donnée n'est lue à partir du flux d'entrée. Le programme de données y restera jusqu'à ce que le client écrive des données dans le flux de sortie du Socket ou ferme le flux de sortie du Socket. Bien entendu, il en va de même pour le Socket du client.
Lisons les données envoyées par le client à partir du flux d'entrée, puis nous écrivons les données dans le flux de sortie du client, puis fermons le fichier de ressources correspondant. En fait, le code ci-dessus peut ne pas fonctionner comme prévu, car la lecture des données du flux d'entrée est une opération bloquante. Dans la boucle while ci-dessus, le corps de la boucle sera exécuté lorsque les données sont lues, sinon il sera bloqué, de sorte que les suivantes. les opérations d'écriture ne seront jamais exécutées. Pour cette situation, nous nous accordons généralement sur une marque de fin. Lorsque les données envoyées par le client contiennent une marque de fin, cela signifie que les données actuelles ont été envoyées, à ce moment-là, nous pouvons en sortir. la boucle.
在上述代码中，当服务端读取到客户端发送的结束标记，即“eof”时就会结束数据的接收，终止循环，这样后续的代码又可以继续进行了。
public class Client {
public static void main(String args[]) throws Exception {
//为了简单起见，所有的异常都直接往外抛
String host = "192.168.74.1"; //要连接的服务端IP地址
int port = 8888; //要连接的服务端对应的监听端口
//与服务端建立连接
Socket client = new Socket(host, port);
//建立连接后就可以往服务端写数据了
Writer writer = new OutputStreamWriter(client.getOutputStream());
writer.write("Hello ,我是客户端输入数据");
writer.write("eof");
writer.flush();//写完后要记得flush
//读取来自服务端数据
Reader reader = new InputStreamReader(client.getInputStream());
char chars[] = new char[64];
int len;
StringBuffer sb = new StringBuffer();
String temp;
int index;
while ((len=reader.read(chars)) != -1) {
temp = new String(chars, 0, len);
if ((index = temp.indexOf("eof")) != -1) {
sb.append(temp.substring(0, index));
break;
}
sb.append(new String(chars, 0, len));
}
System.out.println("from server: " + sb);
writer.close();
reader.close();
client.close();
}
}
过程：先是给服务端发送了一段数据，之后读取服务端返回来的数据，跟之前的服务端一样在读的过程中有可能导致程序一直挂在那里，永远跳不出while循环,解决方法和服务端一样，用一个结束标志。
对于客户端往Socket的输出流里面写数据传递给服务端要注意一点，如果写操作之后程序不是对应着输出流的关闭，而是进行其他阻塞式的操作（比如从输入流里面读数据），记住要flush一下，只有这样服务端才能收到客户端发送的数据，否则可能会引起两边无限的互相等待。在稍后讲到客户端和服务端同时读和写的时候会说到这个问题。
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
