Explication détaillée de la programmation réseau Socket

Classe java.net.InetAddress : Cette classe représente une adresse IP (Internet Protocol).

Méthode statique :
static InetAddress getLocalHost() renvoie l'hôte local (votre propre ordinateur).
static InetAddress getByName(String host) Détermine l'adresse IP d'un hôte à partir d'un nom d'hôte.
Méthodes non statiques :
String getHostAddress() Renvoie la chaîne d'adresse IP (sous forme de représentation textuelle).
String getHostName() Obtient le nom d'hôte de cette adresse IP.

L'extrémité réceptrice de la communication UDP : reçoit le paquet de datagramme envoyé par l'extrémité émettrice et le décompresse
* Classes liées à UDP :
* java.net.DatagramPacket : Cette classe représente Package de rapports de données.
* Fonction : Utiliser des paquets de datagramme pour recevoir des données de l'expéditeur
* java.net.DatagramSocket : Cette classe représente un socket utilisé pour envoyer et recevoir des paquets de datagramme.
* Fonction : envoyer des paquets de datagramme, recevoir des paquets de datagramme
* Socket : adresse IP et numéro de port de liaison d'objet réseau
*
* Méthode de construction :
* DatagramPacket( byte[] buf, int length)
* Construisez DatagramPacket pour recevoir des paquets de données de longueur length.
* DatagramSocket(int port)
* Crée un socket datagramme et le lie au port spécifié sur l'hôte local.
*
* Méthodes membres :
* void contain(DatagramPacket p) Reçoit un paquet de datagramme de ce socket.
*
* Étapes de mise en œuvre :
* 1. Créez un objet DatagramPacket et recevez le datagramme de l'expéditeur
* 2. Créez un objet DatagramSocket et faites-le correspondre avec le numéro de port à spécifier par le système
* 3. Utilisez la méthode de réception dans DatagramSocket pour recevoir le paquet de datagramme de l'expéditeur
* 4. Déballage
* DatagramPacket a des méthodes liées aux paquets de datagramme
* int getLength() Obtenez la longueur des données de l'expéditeur
* InetAddress getAddress() Obtient l'objet adresse IP de l'expéditeur
* int getPort() Obtient le numéro de port de l'expéditeur (attribué aléatoirement par le système)
* 5. Libérer les ressources

 1 public static void main(String[] args) throws IOException { 2         //1.创建DatagramPacket对象,接收发送端的数据报 3         byte[] bytes = new byte[1024];//数据最大传输64kb  1024*64 4         DatagramPacket dp = new DatagramPacket(bytes, bytes.length); 5         //2.创建DatagramSocket对象,并且和系统要指定的端口号 6         DatagramSocket ds = new DatagramSocket(8888); 7         //3.使用DatagramSocket中的方法receive发送端接收数据报包 8         ds.receive(dp); 9         //4.拆包10         //int getLength()  获取发送端数据的长度11         int length = dp.getLength();12         //InetAddress getAddress() 获取发送端的IP地址对象13         String ip = dp.getAddress().getHostAddress();14         //int getPort()  获取发送端的端口号(系统随机分配的)15         int port = dp.getPort();16         17         System.out.println(new String(bytes,0,length)+"ip:"+ip+",端口号"+port);18         //5.释放资源19         ds.close();20     }

L'extrémité émettrice de la communication UDP : emballe les données et envoie le package de datagramme en fonction de l'adresse IP et du port de l'extrémité réceptrice
*
* Classes liées à UDP :
* java.net.DatagramPacket : Cette classe représente un paquet de datagramme.
* Fonction : Pack les données ainsi que l'adresse IP et le numéro de port de l'extrémité de réception
* java.net.DatagramSocket : Cette classe représente un socket utilisé pour envoyer et recevoir des paquets de datagrammes.
* Fonction : envoyer des paquets de datagramme, recevoir des paquets de datagramme
* Socket : adresse IP et numéro de port de liaison d'objet réseau
*
* Méthode de construction :
* DatagramPacket( byte[] buf, int length, adresse InetAddress, port int)
* Construire un paquet de datagramme, qui est utilisé pour envoyer un paquet de longueur length au numéro de port spécifié sur l'hôte spécifié.
* DatagramSocket()
* Construit un socket de datagramme et le lie à n'importe quel port disponible sur l'hôte local.
*
* Méthodes membres :
* void send(DatagramPacket p) Envoie un paquet de datagramme à partir de ce socket.
*
* Étapes de mise en œuvre :
* 1. Créez un objet DatagramPacket, encapsulez les données ainsi que l'adresse IP et le numéro de port du destinataire (créez un conteneur)
* 2. Créez un DatagramSocket objet (créer un dock)
* 3. Utiliser la méthode send dans DatagramSocket pour envoyer des paquets de datagrammes
* 4. Libérer des ressources
*
* La communication UDP est sans connexion : les données peuvent être envoyées indépendamment de qu'il y ait une extrémité réceptrice ou non. La perte de données se produira à l'extrémité réceptrice

 1 public static void main(String[] args) throws IOException { 2         //1.创建DatagramPacket对象,封装数据和接收端的IP地址,端口号(创建集装箱) 3         byte[] bytes = "你好UDP!".getBytes(); 4         InetAddress address = InetAddress.getByName("127.0.0.1"); 5         DatagramPacket dp = new DatagramPacket(bytes, bytes.length, address, 8888); 6         //2.创建DatagramSocket对象(创建码头) 7         DatagramSocket ds = new DatagramSocket(); 8         //3.使用DatagramSocket中的方法send发送数据报包 9         ds.send(dp);10         //4.释放资源11         ds.close();12     }

Client de la communication TCP : envoie une demande de connexion au serveur et reçoit les données écrites. par le serveur
*
* représente la Classe du client :
* java.net.Socket : Cette classe implémente les sockets client (elle peut aussi être appelée "sockets").
*
* Constructeur :
* Socket (adresse InetAddress, port int) Crée un socket de flux et le connecte au numéro de port spécifié de l'adresse IP spécifiée.
* Socket(String host, int port) Crée un socket de flux et le connecte au numéro de port spécifié sur l'hôte spécifié.
*
* Méthodes membres :
* OutputStream getOutputStream() Renvoie le flux de sortie de ce socket.
* InputStream getInputStream() Renvoie le flux d'entrée de cette socket.
*
* Remarque : Pour l'interaction des données entre le client et le serveur, vous ne pouvez pas utiliser l'objet stream créé par vous-même. Vous devez utiliser le flux fourni dans Socket
*
* Étapes de mise en œuvre :
* 1. Créez un objet Socket client et liez l'adresse IP et le numéro de port du serveur
* 2. Utilisez la méthode getOutputStream dans le Socket pour obtenir le flux de sortie réseau
* 3. Utilisez la méthode write dans le Flux réseau OutputStream pour envoyer des données au serveur
* 4. Utilisez la méthode getInputStream dans Socket pour obtenir le flux d'entrée réseau
* 5. Utilisez la méthode read dans le flux réseau InputStream pour lire les données réécrites par le serveur
* 6. Libérer les ressources
*
* Remarque : TCP est une communication orientée connexion. Le serveur doit d'abord être démarré après le démarrage du client, si le serveur n'est pas démarré
* , ConnectException. sera lancé : Connexion refusée : connecter

 1 public static void main(String[] args) throws IOException { 2         //1.创建客户端Socket对象,绑定服务器的IP地址和端口号 3         Socket socket = new Socket("127.0.0.1", 9999); 4         //2.使用Socket中的方法getOutputStream获取网络输出流 5         OutputStream os = socket.getOutputStream(); 6         //3.使用OutputStream网络流中的方法write给服务器发送数据 7         os.write("你好服务器".getBytes()); 8         //4.使用Socket中的方法getInputStream获取网络输入流 9         InputStream is = socket.getInputStream();10         //5.使用InputStream网络流中的方法read读取服务器回写的数据11         byte[] bytes = new byte[1024];12         int len = is.read(bytes);13         System.out.println(new String(bytes,0,len));14         //6.释放资源15         socket.close();16     }

TCP通信的服务器端:接收客户端的发送的数据,给客户端回写数据
*
* 表示服务器的类:
* java.net.ServerSocket:此类实现服务器套接字。
*
* 构造方法:
* ServerSocket(int port) 创建绑定到特定端口的服务器套接字。
*
* 有一件特别重要的事:服务器必须的知道是哪个客户端请求的服务器
* 所有可以使用accept方法获取请求的客户端
* 成员方法:
* Socket accept() 侦听并接受到此套接字的连接。
*
* 实现步骤:
* 1.创建ServerSocket对象,和系统要指定的端口号
* 2.使用ServerSocket中的方法accept获取请求的客户端对象
* 3.使用Socket中的方法getInputStream获取网络输入流
* 4.使用InputStream网络流中的方法read读取客户端发送的数据
* 5.使用Socket中的方法getOutputStream获取网络输出流
* 6.使用OutputStream网络流中的方法write给客户端回写数据
* 7.释放资源(ServerSocket,Socket)

 1 public static void main(String[] args) throws IOException { 2         //1.创建ServerSocket对象,和系统要指定的端口号 3         ServerSocket server = new ServerSocket(9999); 4         //2.使用ServerSocket中的方法accept获取请求的客户端对象 5         Socket socket = server.accept(); 6         //3.使用Socket中的方法getInputStream获取网络输入流 7         InputStream is = socket.getInputStream(); 8         byte[] bytes = new byte[1024]; 9         //4.使用InputStream网络流中的方法read读取客户端发送的数据10         int len = is.read(bytes);11         System.out.println(new String(bytes,0,len));12         //5.使用Socket中的方法getOutputStream获取网络输出流13         OutputStream os = socket.getOutputStream();14         //6.使用OutputStream网络流中的方法write给客户端回写数据15         os.write("收到".getBytes());16         //7.释放资源(ServerSocket,Socket)17         socket.close();18         server.close();19     }

 

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!