recherche

Maison  >  Article  >  Java  >  Programmation de sockets d'apprentissage avancé JAVA

Programmation de sockets d'apprentissage avancé JAVA

WBOY
WBOYavant
2022-11-16 16:17:112317parcourir

Cet article vous apporte des connaissances pertinentes sur java, qui présente principalement le contenu pertinent sur la programmation des sockets. Socket est une interface ou un mécanisme fourni par la couche pilote réseau à l'application. Jetons-y un coup d'œil ensemble. aide tout le monde.

Programmation de sockets d'apprentissage avancé JAVA

Apprentissage recommandé : "Tutoriel vidéo Java"

1. Connaissance de Socket

1. Présentation de Socket

(1) Java est apparu à l'origine comme un langage de programmation réseau et il prend en charge fortement le réseau, faisant d'une communication fluide entre le client et le serveur une réalité.

(2) En programmation réseau, Socket est le plus utilisé, et sa participation est indispensable dans tout programme réseau pratique.

(3) Dans la technologie de programmation de réseaux informatiques, deux processus ou deux ordinateurs peuvent échanger des données via une connexion de communication réseau. Le point final de ce lien de communication est appelé « socket » (nom anglais) C'est-à-dire Socket).

(4) Socket est une interface ou un mécanisme fourni par la couche pilote réseau aux applications.

(5) Utilisez l'exemple de la logistique pour livrer une livraison express pour illustrer Socket :

    —>L'expéditeur livrera les marchandises avec les informations d'adresse du destinataire à la station express. L'expéditeur n'a pas besoin de se soucier de l'état de la logistique. effectué. Il sera envoyé au poste de livraison express de la zone où se trouve le destinataire pour la livraison, et le destinataire attendra simplement de recevoir la marchandise.

    —> Ce processus illustre de manière vivante le processus de transmission de l'information dans le réseau. Parmi eux, les marchandises sont des informations sur les données et les deux sites de livraison express sont les deux Sockets de point final.

(6) L'application n'a pas besoin de se soucier de la manière dont les informations sont adressées et transmises dans le réseau, elle est uniquement responsable de la préparation de l'envoi et de la réception des données.

2. Principe de communication Socket

(1) Pour les programmeurs, il n'est pas nécessaire de comprendre comment le mécanisme sous-jacent de Socket transmet les données, mais de soumettre directement les données à Socket, et Socket les transmettra via un programme basé sur le informations fournies par l'application. Une série de calculs, liant les données IP et d'informations, et transmettant les données au conducteur pour qu'il les envoie au réseau.

(2) Le mécanisme sous-jacent de Socket est très complexe. La plate-forme Java fournit des classes simples mais puissantes qui peuvent utiliser Socket facilement et efficacement pour développer des programmes de communication sans connaître le mécanisme sous-jacent.

3. Package java.net

(1) Le package java.net fournit plusieurs classes qui prennent en charge la communication client/serveur basée sur socket.

(2) Les classes couramment utilisées dans le package java.net incluent Socket, ServerSocket, DatagramPacket, DatagramSocket, InetAddress, URL, URLConnection et URLEncoder, etc.

(3) Afin de surveiller la demande de connexion du client, vous pouvez utiliser la classe ServerSocket.

(4) La classe Socket implémente des sockets pour la communication inter-processus sur le réseau.

(5) La classe DatagramSocket utilise le protocole UDP pour implémenter les sockets client et serveur.

(6) La classe DatagramPacket utilise des objets de la classe DatagramSocket pour encapsuler les paramètres et les datagrammes reçus.

(7) La classe InetAddress représente une adresse Internet.

(8) Lors de la création de messages datagramme et d'objets Socket, vous pouvez utiliser la classe InetAddress

2. Programmation de socket basée sur le protocole TCP

1. Classe Socket et classe ServerSocket

(1) java.net Le deux classes du package, Socket et ServerSocket, sont utilisées respectivement pour implémenter le client et le serveur de connexions sécurisées bidirectionnelles. Elles fonctionnent sur la base du protocole TCP. Le processus de travail est comme le processus d'appel téléphonique uniquement lorsque les deux. les correspondants sont connectés, l'appel peut-il démarrer.

(2) Pendant la communication réseau, Socket doit utiliser le flux de données pour terminer le transfert de données.

(3) Pour envoyer des données à une autre application via le réseau, une application crée simplement un Socket puis écrit les données dans le flux de sortie associé au Socket. En conséquence, l'application réceptrice crée un Socket et lit les données du flux d'entrée associé.

(4) Remarque : Dans la programmation Socket basée sur le protocole TCP, les deux points de terminaison servent souvent de client et l'autre de serveur, ce qui implique de suivre le modèle client-serveur.

weight Classe Socket

Les objets Socket établissent des connexions entre les clients et les serveurs. Vous pouvez utiliser la méthode constructeur de la classe Socket pour créer un socket et connecter ce socket à l'hôte et au port spécifiés.

(1) Méthode de construction

    —>La première méthode de construction prend le nom d'hôte et le numéro de port comme paramètres pour créer un objet Socket. UnknownHostException ou IOException peuvent être levées lors de la création d'un objet et doivent être interceptées.

Socket s = new Socket(hostName,port);

   —>La deuxième méthode de construction prend l'objet InetAddress et le numéro de port comme paramètres pour créer un objet Socket. Le constructeur peut lancer IOException ou UnknownHostException, qui doivent être interceptés et gérés.

Socket s = new Socket(address,port);

(2) Méthodes courantes

weight Classe ServerSocket

L'objet ServerSocket attend que le client établisse une connexion, la connexion est établie La correspondance sera être faite plus tard.

(1) Méthode de construction

  — —>La première méthode de construction accepte le numéro de port comme paramètre pour créer un objet ServerSocket Lors de la création de cet objet, une IOException peut être levée, et elle doit être interceptée et gérée. #                                                                       ServerSocket ss = nouveau ServerSocket (port) ;       .

                          ServerSocket ss = new ServerSocket(port,maxqu);

(2) Méthodes courantes

                                   use using using ss en utilisant le ss en utilisant le ss pour utiliser le ss à utiliser dans la classe Socket.

     —>La classe ServerSocket a une méthode accept(), qui est utilisée pour attendre que le client initie la communication afin que l'objet Socket puisse être utilisé pour une transmission de données ultérieure.

2. Utilisez la programmation Socket pour implémenter la fonction de connexion

weight Pour obtenir une connexion mono-utilisateur

- -->La programmation réseau Socket est généralement divisée en 4 étapes suivantes :

(1 ) Établissez une connexion.

(2) Ouvrez le flux d'entrée/sortie associé au Socket.

(3) Écrivez des informations et lisez des informations à partir du flux de données.

(4) Fermez tous les flux de données et sockets. -& gt; utiliser deux classes pour simuler la fonction de connexion de l'utilisateur, réaliser que le client envoie les informations de connexion de l'utilisateur côté serveur et afficher les informations côté serveur.步 Étapes de mise en œuvre du client :

1) Établissez la connexion et connectez-vous au serveur et au port.

2) Ouvrez le flux d'entrée/sortie associé au Socket.

3) Écrivez les informations dans le flux de sortie.

4) Lisez les informations de réponse à partir du flux d'entrée.

5) Fermez tous les flux de données et Sockets.

Étapes d'implémentation côté serveur :

1) Établissez une connexion et écoutez sur le port.

2) Utilisez la méthode accept() pour attendre que le client initie la communication

3) Ouvrez le flux d'entrée/sortie associé au Socket.

4) Lisez les informations de la demande à partir du flux d'entrée.

5) Écrivez les informations dans le flux de sortie.

            6) Fermez tous les flux de données et Sockets. -& gt; L'interaction du client et du serveur, adoptez un mode de réponse, démarrez d'abord le serveur pour entrer dans l'état de surveillance, attendez la demande de connexion du client.

Exemple 01 : Implémenter le transfert d'informations sur les objets.

♥ classe d'utilisateurs 

package cn.bdqn.demo02;

import java.io.Serializable;

public class User implements Serializable {

	private static final long serialVersionUID = 1L;
	/** 用户名 */
	private String loginName;
	/** 用户密码 */
	private String pwd;

	public User() {
		super();
	}

	public User(String loginName, String pwd) {
		super();
		this.loginName = loginName;
		this.pwd = pwd;
	}

	public String getLoginName() {
		return loginName;
	}

	public void setLoginName(String loginName) {
		this.loginName = loginName;
	}

	public String getPwd() {
		return pwd;
	}

	public void setPwd(String pwd) {
		this.pwd = pwd;
	}

}

♥ classe LoginServer 

package cn.bdqn.demo02;

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class LoginServer {

	public static void main(String[] args) {
		ServerSocket serverSocket = null;
		Socket socket = null;
		InputStream is = null;
		ObjectInputStream ois = null;
		OutputStream os = null;
		try {
			// 建立一个服务器Socket（ServerSocket），指定端口8800并开始监听
			serverSocket = new ServerSocket(8800);
			// 使用accept()方法等待客户端发起通信
			socket = serverSocket.accept();
			// 打开输入流
			is = socket.getInputStream();
			// 反序列化
			ois = new ObjectInputStream(is);
			// 获取客户端信息，即从输入流读取信息
			User user = (User) ois.readObject();
			if (user != null) {
				System.out.println("我是服务器，客户登录信息为：" + user.getLoginName() + "，"
						+ user.getPwd());
			}

			// 给客户端一个响应，即向输出流中写入信息
			String reply = "欢迎你，登录成功";
			os = socket.getOutputStream();
			os.write(reply.getBytes());
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			// 关闭资源
			try {
				os.close();
				ois.close();
				is.close();
				socket.close();
				serverSocket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

classe LoginClient 

package cn.bdqn.demo02;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class LoginClient {

	/*
	 * 示例02：升级演示示例01，实现传递对象信息。
	 */
	
	public static void main(String[] args) {
		Socket socket = null;
		OutputStream os = null;
		ObjectOutputStream oos = null;
		InputStream is = null;
		BufferedReader br = null;
		try {
			// 建立客户端Socket连接，指定服务器的位置为本机以及端口为8800
			socket = new Socket("localhost", 8800);
			// 打开输出流
			os = socket.getOutputStream();
			// 对象序列化
			oos = new ObjectOutputStream(os);
			// 发送客户端信息，即向输出流中写入信息
			User user = new User("Tom", "123456");
			oos.writeObject(user);
			socket.shutdownOutput();

			// 接收服务器端的响应，即从输入流中读取信息
			is = socket.getInputStream();
			br = new BufferedReader(new InputStreamReader(is));
			String reply;
			while ((reply = br.readLine()) != null) {
				System.out.println("我是客户端，服务器的响应为：" + reply);
			}
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				br.close();
				is.close();
				oos.close();
				os.close();
				socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

Exemple 02 : Mettre à niveau l'exemple de démonstration 01 pour implémenter la transmission d'informations sur plusieurs objets.

classe d'utilisateurs 

package cn.bdqn.demo03;

import java.io.Serializable;

public class User implements Serializable {

	private static final long serialVersionUID = 1L;
	/** 用户名 */
	private String loginName;
	/** 用户密码 */
	private String pwd;

	public User() {
		super();
	}

	public User(String loginName, String pwd) {
		super();
		this.loginName = loginName;
		this.pwd = pwd;
	}

	public String getLoginName() {
		return loginName;
	}

	public void setLoginName(String loginName) {
		this.loginName = loginName;
	}

	public String getPwd() {
		return pwd;
	}

	public void setPwd(String pwd) {
		this.pwd = pwd;
	}

}

classe LoginServer 

package cn.bdqn.demo03;

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class LoginServer {

	public static void main(String[] args) {
		ServerSocket serverSocket = null;
		Socket socket = null;
		InputStream is = null;
		ObjectInputStream ois = null;
		OutputStream os = null;
		try {
			// 建立一个服务器Socket（ServerSocket），指定端口8800并开始监听
			serverSocket = new ServerSocket(8800);
			// 使用accept()方法等待客户端发起通信
			socket = serverSocket.accept();
			// 打开输入流
			is = socket.getInputStream();
			// 反序列化
			ois = new ObjectInputStream(is);
			// 获取客户端信息，即从输入流读取信息
			User[] users = (User[]) ois.readObject();
			for (int i = 0; i < users.length; i++) {
				System.out.println("我是服务器，客户登录信息为：" + users[i].getLoginName()
						+ "，" + users[i].getPwd());
			}

			// 给客户端一个响应，即向输出流中写入信息
			String reply = "欢迎你，登录成功";
			os = socket.getOutputStream();
			os.write(reply.getBytes());
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			// 关闭资源
			try {
				os.close();
				ois.close();
				is.close();
				socket.close();
				serverSocket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

classe LoginClient 

package cn.bdqn.demo03;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class LoginClient {

	/*
	 * 示例02：升级演示示例01，实现传递对象信息。
	 */
	
	public static void main(String[] args) {
		Socket socket = null;
		OutputStream os = null;
		ObjectOutputStream oos = null;
		InputStream is = null;
		BufferedReader br = null;
		try {
			// 建立客户端Socket连接，指定服务器的位置为本机以及端口为8800
			socket = new Socket("localhost", 8800);
			// 打开输出流
			os = socket.getOutputStream();
			// 对象序列化
			oos = new ObjectOutputStream(os);
			// 发送客户端信息，即向输出流中写入信息
			User user1 = new User("Tom", "123456");
			User user2 = new User("bob", "123456");
			User user3 = new User("lisa", "123456");
			User[] users = {user1,user2,user3};
			oos.writeObject(users);
			socket.shutdownOutput();

			// 接收服务器端的响应，即从输入流中读取信息
			is = socket.getInputStream();
			br = new BufferedReader(new InputStreamReader(is));
			String reply;
			while ((reply = br.readLine()) != null) {
				System.out.println("我是客户端，服务器的响应为：" + reply);
			}
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				br.close();
				is.close();
				oos.close();
				os.close();
				socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

weight Réaliser une connexion utilisateur multi-client

--> ne sont clairement pas des personnes en réalité vouloir. Un serveur ne peut pas servir qu'un seul client, mais fournit généralement des services à plusieurs clients en même temps. Cependant, une implémentation monothread doit en résulter.

    —>La façon de résoudre ce problème est d'utiliser le multithreading. Vous pouvez créer un programme de service principal d'application côté serveur qui est spécifiquement responsable de la surveillance, et un programme de thread qui est spécifiquement responsable de la réponse. Cela permet au multithread de gérer plusieurs requêtes. ;-& Gt; Étapes de mise en œuvre du client :

1) Créez une connexion et connectez-vous au serveur et au port.

2) Ouvrez le flux d'entrée/sortie associé au Socket.

3) Écrivez les informations dans le flux de sortie.

4) Lisez les informations de réponse à partir du flux d'entrée.

5) Fermez tous les flux de données et Sockets. -& gt; étapes d'implémentation côté serveur :

1) Créez la classe de thread du serveur et la méthode Run() pour obtenir une réponse à une requête.

2) Modifiez le code côté serveur afin que le Socket côté serveur soit toujours en état d'écoute.

3) Chaque fois que le serveur écoute une requête, il crée un objet thread et le démarre.

Exemple 03 : Mettez à niveau l'exemple de démonstration 02 pour implémenter le traitement des réponses multi-clients.

classe d'utilisateur

package cn.bdqn.demo04;

import java.io.Serializable;

public class User implements Serializable {

	private static final long serialVersionUID = 1L;
	/** 用户名 */
	private String loginName;
	/** 用户密码 */
	private String pwd;

	public User() {
		super();
	}

	public User(String loginName, String pwd) {
		super();
		this.loginName = loginName;
		this.pwd = pwd;
	}

	public String getLoginName() {
		return loginName;
	}

	public void setLoginName(String loginName) {
		this.loginName = loginName;
	}

	public String getPwd() {
		return pwd;
	}

	public void setPwd(String pwd) {
		this.pwd = pwd;
	}

}
LoginThread

package cn.bdqn.demo04;

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.OutputStream;
import java.net.Socket;

public class LoginThread extends Thread {
	/*
	 * 示例03：升级示例02，实现多客户端的响应处理。
	 * 
	 * 分析如下：
	 * 	（1）创建服务器端线程类，run()方法中实现对一个请求的响应处理。
	 * 	（2）修改服务器端代码，让服务器端Socket一直处于监听状态。
	 * 	（3）服务器端每监听到一个请求，创建一个线程对象并启动
	 */
	
	Socket socket = null;
	//每启动一个线程，连接对应的Socket

	public LoginThread(Socket socket) {
		this.socket = socket;
	}
	
	//启动线程，即响应客户请求
	public void run() {
		InputStream is = null;
		ObjectInputStream ois = null;
		OutputStream os = null;
		try {
			//打开输入流
			is = socket.getInputStream();
			//反序列化
			ois = new ObjectInputStream(is);
			//获取客户端信息，即从输入流读取信息
			User user = (User)ois.readObject();
			if(user!=null){
				System.out.println("我是服务器，客户登录信息为："+user.getLoginName()+"，"+user.getPwd());
			}
			
			//给客户端一个响应，即向输出流中写入信息
			os = socket.getOutputStream();
			String reply = "欢迎你，登录成功";
			os.write(reply.getBytes());
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}finally{
			try {
				os.close();
				ois.close();
				is.close();
				socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}			
		}	
	}	
}
classe LoginServer

package cn.bdqn.demo04;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class LoginServer {
	
	public static void main(String[] args) {
		
		ServerSocket serverSocket = null;
		try {
			// 建立一个服务器Socket(ServerSocket)指定端口并开始监听
			serverSocket = new ServerSocket(8800);

			// 监听一直进行中
			while (true) {
				// 使用accept()方法等待客户发起通信
				Socket socket = serverSocket.accept();
				LoginThread loginThread = new LoginThread(socket);
				loginThread.start();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}
♥ classe LoginClient1

package cn.bdqn.demo04;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class LoginClient01 {
	/*
	 * 客户端通过输出流向服务器端发送请求信息
	 * 服务器侦听客户端的请求得到一个Socket对象，将这个Socket对象传递给线程类
	 * 线程类通过输入流获取客户端的请求并通过输出流向客户端发送响应信息
	 * 客户端通过输入流读取服务器发送的响应信息
	 * 
	 */

	/*
	 * 示例03：升级演示示例02，实现多客户端的响应处理
	 */
	public static void main(String[] args) {
		
		Socket socket = null;
		OutputStream os = null;
		ObjectOutputStream oos = null;
		InputStream is = null;
		BufferedReader br = null;
		try {
			// 建立客户端Socket连接，指定服务器的位置为本机以及端口为8800
			socket = new Socket("localhost", 8800);
			// 打开输出流
			os = socket.getOutputStream();
			// 对象序列化
			oos = new ObjectOutputStream(os);
			// 发送客户端信息，即向输出流中写入信息
			User user = new User("Tom", "123456");
			oos.writeObject(user);
			socket.shutdownOutput();

			// 接收服务器端的响应，即从输入流中读取信息
			is = socket.getInputStream();
			br = new BufferedReader(new InputStreamReader(is));
			String reply;
			while ((reply = br.readLine()) != null) {
				System.out.println("我是客户端，服务器的响应为：" + reply);
			}
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				br.close();
				is.close();
				oos.close();
				os.close();
				socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}
♥ classe LoginClient2 et classe LoginClient3

Identique à la classe LoginClient1, créez un utilisateur différent l'objet peut

    —> ;Le La classe InetAddress du package java.net est utilisée pour encapsuler les adresses IP et DNS. Pour créer une instance de la classe InetAddress, vous pouvez utiliser la méthode factory puisque cette classe n'a pas de constructeur. -& gt; méthode d'usine dans la classe InetAddress

-& gt; Si l'hôte ne peut pas être trouvé, les deux méthodes généreront des anomalies UnknownHostnameException.

3. Programmation de socket basée sur le protocole UDP

TCP UDPOrienté vers la connexion

 S'il faut se connecter
Orienté vers la non-Connexion Transmission fiable Sexe

1. Classe DatagramPacket et classe DatagramSocket

(1) La communication réseau basée sur TCP est sécurisée et bidirectionnelle, tout comme pour un appel téléphonique, un serveur est d'abord requis et une connexion bidirectionnelle est établie avant que la communication de données puisse être effectuée. commencer.

(2) La communication réseau basée sur UDP nécessite uniquement de spécifier l'adresse de l'autre partie puis d'envoyer les données, sans connexion préalable. Une telle communication réseau n'est pas sûre et n'est donc utilisée que dans des situations telles que les systèmes de chat et les systèmes de consultation.

(3) Le datagramme est un type de message qui représente la communication. Lorsque vous utilisez un datagramme pour la communication, il n'est pas nécessaire d'établir une connexion à l'avance. Il est basé sur le protocole UDP.

(4) Il existe deux classes en Java qui peuvent utiliser des datagrammes pour implémenter la communication, à savoir DatagramPacket et DatagramSocket.

(5) La classe DatagramPacket joue le rôle de conteneur, et la classe DatagramSocket est utilisée pour envoyer ou recevoir DatagramPacket.

(6)La classe DatagramPacket ne fournit pas de méthodes pour envoyer ou recevoir des données, tandis que la classe DatagramSocket fournit la méthode send() et la méthode receive() pour envoyer et recevoir des datagrammes via des sockets. R ● Classe DataGrampacket

(1) Méthode de construction

-& gt; Le client doit envoyer des données vers l'extérieur. Vous devez d'abord créer un objet DataGrampacket, puis envoyer l'objet DataGramsocket.

(2) Méthodes courantes

Quantity DatagramSocket classe

(1) Méthode de construction

--> . La seule fonction est de recevoir et d'envoyer des datagrammes encapsulés par l'objet DatagramPacket.

(2) Méthodes courantes

2. Utiliser la programmation Socket pour mettre en œuvre la consultation des clients

                                                                                                                             avec le peer-to-peer, il n'y a aucune distinction entre primaire et secondaire, et même leurs codes peuvent être exactement les mêmes. pareil. Cela doit être distingué de la programmation Socket basée sur le protocole TCP. -& gt; La programmation réseau Socket basée sur le protocole UDP repose généralement sur les 4 étapes suivantes :

(1) Utiliser l'objet DataGrampacket pour encapsuler le paquet de données.

              (2) Utilisez l'objet DatagramSocket pour envoyer des paquets de données.

              (3) Utilisez l'objet DatagramSocket pour recevoir des paquets de données.

              (4) Utilisez l'objet DatagramPacket pour traiter les paquets de données.

      —> Simulez la fonction de consultation client, permettant à l'expéditeur d'envoyer des questions de consultation et au destinataire de recevoir et d'afficher les questions de consultation envoyées.             Étapes de mise en œuvre de l'expéditeur :

                    1) Obtenez l'objet InetAddress de l'hôte local.

2) Créez un objet DatagramPacket pour encapsuler les informations à envoyer.

3) Utilisez l'objet DatagramSocket pour envoyer les données de l'objet DatagramPacket.

Étapes de mise en œuvre du récepteur : 1) Créez un objet DatagramPacket et préparez-vous à recevoir les données encapsulées.

                2）创建DatagramSocket对象，接收数据保存于DatagramPacket对象中。

                3）利用DatagramPacket对象处理数据。

示例04：发送方发送咨询问题，接收方回应咨询。

♥ Receive类

package cn.bdqn.demo05;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketAddress;
import java.net.SocketException;

public class Receive {

	public static void main(String[] args) {
		/*
		 * 示例06：发送方发送咨询问题，接收方回应咨询。
		 * 
		 * 接收方实现步骤如下： 
		 * （1）创建DatagramPacket对象，准备接收封装的数据。
		 * （2）创建DatagramSocket对象，接收数据保存于DatagramPacket对象中。
		 * （3）利用DatagramPacket对象处理数据。
		 */

		DatagramSocket ds = null;
		DatagramPacket dp = null;
		DatagramPacket dpto = null;
		// 创建DatagramPacket对象，用来准备接收数据
		byte[] buf = new byte[1024];
		dp = new DatagramPacket(buf, 1024);
		try {
			// 创建DatagramSocket对象，接收数据
			ds = new DatagramSocket(8800);
			ds.receive(dp);
			// 显示接收到的信息
			String mess = new String(dp.getData(), 0, dp.getLength());
			System.out.println(dp.getAddress().getHostAddress() + "说：" + mess);

			String reply = "你好，我在，请咨询！";
			// 显示与本地对话框
			System.out.println("我  说：" + reply);
			// 创建DatagramPacket对象，封装数据
			SocketAddress sa = dp.getSocketAddress();
			dpto = new DatagramPacket(reply.getBytes(),
					reply.getBytes().length, sa);
			ds.send(dpto);
		} catch (SocketException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			ds.close();
		}
	}
}

♥ Send类

package cn.bdqn.demo05;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

public class Send {
	/*
	 * 示例06：升级示例05，发送方发送咨询问题，接收方回应咨询。
	 * 
	 * 发送方实现步骤如下： 
	 * （1）获取本地主机的InetAddress对象。 
	 * （2）创建DatagramPacket对象，封装要发送的信息。
	 * （3）利用DatagramSocket对象将DatagramPacket对象数据发送出去。
	 */

	public static void main(String[] args) {
		DatagramSocket ds = null;
		InetAddress ia = null;
		String mess = "你好，我想咨询一个问题。";
		System.out.println("我说：" + mess);
		try {
			// 获取本地主机地址
			ia = InetAddress.getByName("localhost");
			// 创建DatagramPacket对象，封装数据
			DatagramPacket dp = new DatagramPacket(mess.getBytes(),
					mess.getBytes().length, ia, 8800);
			// 创建DatagramSocket对象，向服务器发送数据
			ds = new DatagramSocket();
			ds.send(dp);

			byte[] buf = new byte[1024];
			DatagramPacket dpre = new DatagramPacket(buf, buf.length);
			ds.receive(dpre);
			// 显示接收到的信息
			String reply = new String(dpre.getData(), 0, dpre.getLength());
			System.out.println(dpre.getAddress().getHostAddress() + "说："
					+ reply);
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (SocketException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			ds.close();
		}
	}
}

推荐学习：《java视频教程》

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!

Java 封装 接口 .net 线程 多线程 对象 udp
Déclaration：
Cet article est reproduit dans:. en cas de violation, veuillez contacter admin@php.cn Supprimer
Article précédent：Résumé des points de connaissances Java : bases du multithreadingArticle suivant：Résumé des points de connaissances Java : bases du multithreading

Articles Liés

Voir plus