Detaillierte Erläuterung der Socket-Netzwerkprogrammierung

java.net.InetAddress-Klasse: Diese Klasse repräsentiert eine Internet Protocol (IP)-Adresse.

Statische Methode:
static InetAddress getLocalHost() gibt den lokalen Host (Ihren eigenen Computer) zurück.
static InetAddress getByName(String host) Bestimmt die IP-Adresse eines Hosts mit einem Hostnamen.
Nichtstatische Methoden:
String getHostAddress() Gibt die IP-Adresszeichenfolge zurück (als Textdarstellung).
String getHostName() Ruft den Hostnamen dieser IP-Adresse ab.

Das empfangende Ende der UDP-Kommunikation: empfängt das vom sendenden Ende gesendete Datagrammpaket und entpackt es
* UDP-bezogene Klassen:
* java.net.DatagramPacket: Diese Klasse repräsentiert Datenberichtspaket.
* Funktion: Datagrammpakete verwenden, um Daten vom Absender zu empfangen
* java.net.DatagramSocket: Diese Klasse stellt einen Socket dar, der zum Senden und Empfangen von Datagrammpaketen verwendet wird.
* Funktion: Datagrammpakete senden, Datagrammpakete empfangen
* Socket: Netzwerkobjekt, das IP-Adresse und Portnummer bindet
*
* Konstruktionsmethode:
* DatagramPacket( byte[] buf, int Länge)
* Konstruieren Sie DatagramPacket, um Datenpakete mit der Länge Länge zu empfangen.
* DatagramSocket(int port)
* Erstellt einen Datagramm-Socket und bindet ihn an den angegebenen Port auf dem lokalen Host.
*
* Mitgliedsmethoden:
* void keep(DatagramPacket p) Empfängt ein Datagrammpaket von diesem Socket.
*
* Implementierungsschritte:
* 1. Erstellen Sie ein DatagramPacket-Objekt und empfangen Sie das Datagramm vom Absender
* 2. Erstellen Sie ein DatagramSocket-Objekt und ordnen Sie es der vom Sender anzugebenden Portnummer zu System
* 3. Verwenden Sie die Methode „receive“ in DatagramSocket, um das Datagrammpaket vom Absender zu empfangen
* 4. Entpacken
* DatagramPacket verfügt über Methoden, die sich auf Datagrammpakete beziehen
* int getLength() Ermitteln Sie die Länge der Daten vom Absender
* InetAddress getAddress() Ruft das IP-Adressobjekt des Absenders ab
* int getPort() Ruft die Portnummer des Absenders ab (vom System zufällig zugewiesen)
* 5. Ressourcen freigeben

 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     }

Das sendende Ende der UDP-Kommunikation: Packt die Daten und sendet das Datagrammpaket entsprechend der IP-Adresse und dem Port des empfangenden Endes
*
* UDP-bezogene Klassen:
* java.net.DatagramPacket: Diese Klasse repräsentiert ein Datagrammpaket.
* Funktion: Packen Sie die Daten sowie die IP-Adresse und Portnummer des Empfängers
* java.net.DatagramSocket: Diese Klasse stellt einen Socket dar, der zum Senden und Empfangen von Datagrammpaketen verwendet wird.
* Funktion: Datagrammpakete senden, Datagrammpakete empfangen
* Socket: Netzwerkobjekt, das IP-Adresse und Portnummer bindet
*
* Konstruktionsmethode:
* DatagramPacket( byte[] buf, int Länge, InetAddress-Adresse, int Port)
* Konstruieren Sie ein Datagrammpaket, das verwendet wird, um ein Paket der Länge Länge an die angegebene Portnummer auf dem angegebenen Host zu senden.
* DatagramSocket()
* Konstruiert einen Datagramm-Socket und bindet ihn an jeden verfügbaren Port auf dem lokalen Host.
*
* Mitgliedsmethoden:
* void send(DatagramPacket p) Senden Sie ein Datagrammpaket von diesem Socket.
*
* Implementierungsschritte:
* 1. Erstellen Sie ein DatagramPacket-Objekt, kapseln Sie die Daten sowie die IP-Adresse und Portnummer des Empfängers (erstellen Sie einen Container)
* 2. Erstellen Sie einen DatagramSocket Objekt (ein Dock erstellen)
* 3. Verwenden Sie die Methode send in DatagramSocket, um Datagrammpakete zu senden
* 4. Geben Sie Ressourcen frei
*
* UDP-Kommunikation ist für verbindungslose Kommunikation: Daten können unabhängig davon gesendet werden Unabhängig davon, ob es eine Empfangsseite gibt oder nicht, tritt ein Datenverlust auf der Empfangsseite auf.

 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 der TCP-Kommunikation: sendet eine Anforderungsverbindung an den Server und empfängt die zurückgeschriebenen Daten vom Server
*
* stellt die Klasse des Clients dar:
* java.net.Socket: Diese Klasse implementiert Client-Sockets (sie kann auch „Sockets“ genannt werden).
*
* Konstruktor:
* Socket(InetAddress-Adresse, int Port) Erstellt einen Stream-Socket und verbindet ihn mit der angegebenen Portnummer der angegebenen IP-Adresse.
* Socket(String host, int port) Erstellt einen Stream-Socket und verbindet ihn mit der angegebenen Portnummer auf dem angegebenen Host.
*
* Mitgliedsmethoden:
* OutputStream getOutputStream() Gibt den Ausgabestream dieses Sockets zurück.
* InputStream getInputStream() Gibt den Eingabestream dieses Sockets zurück.
*
* Hinweis: Für die Dateninteraktion zwischen dem Client und dem Server können Sie nicht das von Ihnen selbst erstellte Stream-Objekt verwenden. Sie müssen den in Socket bereitgestellten Stream verwenden
*
* Implementierungsschritte:
* 1. Erstellen Sie ein Client-Socket-Objekt und binden Sie die IP-Adresse und die Portnummer des Servers
* 2. Verwenden Sie die Methode getOutputStream im Socket, um den Netzwerkausgabestream abzurufen
* 3. Verwenden Sie die Methode write im OutputStream-Netzwerkstream zum Senden von Daten an den Server
* 4. Verwenden Sie die Methode getInputStream in Socket, um den Netzwerkeingabestream zu erhalten
* 5. Verwenden Sie die Methode read im InputStream-Netzwerkstream, um die vom zurückgeschriebenen Daten zu lesen Server
* 6. Ressourcen freigeben
*
* Hinweis: TCP ist verbindungsorientierte Kommunikation. Der Server muss zuerst gestartet werden, wenn der Server nicht gestartet wird
* , ConnectException wird geworfen: Verbindung verweigert: verbinden

 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     }

 

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Socket-Netzwerkprogrammierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!