JAVA Advanced Learning Socket-Programmierung-javaLernprogramm-php.cn

Dieser Artikel vermittelt Ihnen relevantes Wissen über Java, das hauptsächlich die relevanten Inhalte zur Socket-Programmierung vorstellt. Socket ist eine Schnittstelle oder ein Mechanismus, der von der Netzwerktreiberschicht für die Anwendung bereitgestellt wird hilft allen.

JAVA Advanced Learning Socket-Programmierung

Empfohlenes Lernen: „Java-Video-Tutorial“

1. Socket-Kenntnisse

1. Socket-Übersicht

(1) Java erschien ursprünglich als Netzwerkprogrammiersprache und bietet eine hohe Unterstützung für Netzwerk, wodurch eine reibungslose Kommunikation zwischen Client und Server möglich wird.

(2) In der Netzwerkprogrammierung wird Socket am häufigsten verwendet, und seine Teilnahme ist in jedem praktischen Netzwerkprogramm unverzichtbar.

(3) In der Computernetzwerk-Programmiertechnologie können zwei Prozesse oder zwei Computer Daten über eine Netzwerkkommunikationsverbindung austauschen. Der Endpunkt dieser Kommunikationsverbindung wird als „Socket“ (englischer Name) bezeichnet.

(4) Socket ist eine Schnittstelle oder ein Mechanismus, der von der Netzwerktreiberschicht für Anwendungen bereitgestellt wird.

(5) Verwenden Sie zur Veranschaulichung die Logistik zur Expresszustellung:

—>Der Absender liefert die Ware mit den Adressinformationen des Empfängers an die Expressstation. Der Absender muss sich nicht um die Logistik kümmern Die Sendung wird zur Zustellung an die Express-Zustellstation in der Gegend geschickt, in der sich der Empfänger befindet, und der Empfänger wartet dort auf den Erhalt der Ware.

—> Dieser Prozess veranschaulicht anschaulich den Prozess der Informationsübertragung im Netzwerk. Darunter sind die Waren Dateninformationen und die beiden Express-Lieferstellen sind die beiden Endpunkt-Sockets.

(6) Die Anwendung muss sich nicht darum kümmern, wie Informationen im Netzwerk adressiert und übertragen werden. Sie ist lediglich für die Vorbereitung zum Senden und Empfangen von Daten verantwortlich.

2. Socket-Kommunikationsprinzip

(1) Für Programmierer ist es nicht erforderlich, zu verstehen, wie der zugrunde liegende Mechanismus von Socket Daten überträgt, sondern die Daten direkt an Socket weiterleiten, und Socket leitet sie basierend auf dem relevanten Programm weiter Von der Anwendung bereitgestellte Informationen, eine Reihe von Berechnungen, die Verknüpfung von IP- und Informationsdaten und die Übergabe der Daten an den Treiber zum Senden an das Netzwerk.

(2) Der zugrunde liegende Mechanismus von Socket ist sehr komplex. Die Java-Plattform bietet einige einfache, aber leistungsstarke Klassen, mit denen Socket einfach und effektiv Kommunikationsprogramme entwickeln kann, ohne den zugrunde liegenden Mechanismus zu kennen.

3. java.net-Paket

(1) Das java.net-Paket stellt mehrere Klassen bereit, die socketbasierte Client/Server-Kommunikation unterstützen.

(2) Zu den häufig verwendeten Klassen im java.net-Paket gehören Socket, ServerSocket, DatagramPacket, DatagramSocket, InetAddress, URL, URLConnection und URLEncoder usw.

(3) Um die Verbindungsanfrage des Clients zu überwachen, können Sie die ServerSocket-Klasse verwenden.

(4) Die Socket-Klasse implementiert Sockets für die prozessübergreifende Kommunikation im Netzwerk.

(5) Die DatagramSocket-Klasse verwendet das UDP-Protokoll, um Client- und Server-Sockets zu implementieren.

(6) Die DatagramPacket-Klasse verwendet Objekte der DatagramSocket-Klasse, um Einstellungen und empfangene Datagramme zu kapseln.

(7) Die InetAddress-Klasse repräsentiert eine Internetadresse.

(8) Beim Erstellen von Datagrammnachrichten und Socket-Objekten können Sie die InetAddress-Klasse verwenden.

2. Socket-Programmierung basierend auf dem TCP-Protokoll

1 Zwei Klassen des Pakets, Socket und ServerSocket, werden verwendet, um den Client und den Server für bidirektionale sichere Verbindungen zu implementieren. Der Arbeitsprozess ist wie der Prozess, einen Telefonanruf zu tätigen Teilnehmer verbunden sind, kann der Anruf gestartet werden.

(2) Während der Netzwerkkommunikation muss Socket den Datenfluss nutzen, um die Datenübertragung abzuschließen.

(3) Wenn eine Anwendung Daten über das Netzwerk an eine andere Anwendung senden möchte, erstellt sie einfach einen Socket und schreibt die Daten dann in den mit dem Socket verknüpften Ausgabestream. Dementsprechend erstellt die empfangende Anwendung einen Socket und liest Daten aus dem zugehörigen Eingabestream.

(4) Hinweis: Bei der Socket-Programmierung auf Basis des TCP-Protokolls dienen die beiden Endpunkte häufig als Client und der andere als Server, was bedeutet, dass dem Client-Server-Modell gefolgt wird.

● Socket-Klasse

Socket-Objekte stellen Verbindungen zwischen Clients und Servern her. Sie können die Konstruktormethode der Socket-Klasse verwenden, um einen Socket zu erstellen und diesen Socket mit dem angegebenen Host und Port zu verbinden. (1) Konstruktionsmethode

—>Die erste Konstruktionsmethode verwendet den Hostnamen und die Portnummer als Parameter, um ein Socket-Objekt zu erstellen. Beim Erstellen eines Objekts kann eine UnknownHostException oder IOException ausgelöst werden, die abgefangen werden muss.

Socket s = neuer Socket(hostName,port);

—>Die zweite Konstruktionsmethode verwendet das InetAddress-Objekt und die Portnummer als Parameter, um ein Socket-Objekt zu erstellen. Der Konstruktor kann eine IOException oder UnknownHostException auslösen, die abgefangen und behandelt werden muss.

Socket s = new Socket(address,port);

(2) Gemeinsame Methoden

● ServerSocket-Klasse

ServerSocket-Objekt wartet darauf, dass der Client eine Verbindung herstellt später gemacht werden.

(1) Konstruktionsmethode

— —>Die erste Konstruktionsmethode akzeptiert die Portnummer als Parameter zum Erstellen eines ServerSocket-Objekts. Beim Erstellen dieses Objekts kann eine IOException ausgelöst werden, die abgefangen und behandelt werden muss. S Serversocket SS = Neuer Serversocket (Port);

-& GT; Die zweite konstruierte Methode akzeptiert die Portnummer und die maximale Warteschlangenlänge.

ServerSocket ss = new ServerSocket(port,maxqu);

(2) Allgemeine Methoden using using using using using using -->Die in der Socket-Klasse aufgeführten Methoden sind auch auf die ServerSocket-Klasse anwendbar. —>Die ServerSocket-Klasse verfügt über eine Accept()-Methode, mit der darauf gewartet wird, dass der Client die Kommunikation initiiert, damit das Socket-Objekt für die weitere Datenübertragung verwendet werden kann.

2. Verwenden Sie die Socket-Programmierung, um die Anmeldefunktion zu implementieren

● Um eine Einzelbenutzeranmeldung zu erreichen

- -->Die Socket-Netzwerkprogrammierung ist im Allgemeinen in die folgenden 4 Schritte unterteilt:

(1 ) Stellen Sie eine Verbindung her. (2) Öffnen Sie den mit dem Socket verknüpften Eingabe-/Ausgabestream.

(3) Informationen schreiben und Informationen aus dem Datenstrom lesen.

(4) Schließen Sie alle Datenströme und Sockets. -& gt; Verwenden Sie zwei Klassen, um die Funktion der Benutzeranmeldung zu simulieren, zu realisieren, dass der Client Benutzeranmeldeinformationen an den Server sendet, und die Informationen auf der Serverseite anzuzeigen.步 Client-Implementierungsschritte:

1) Verbindung herstellen und Verbindung zum Server und Port herstellen.

2) Öffnen Sie den mit dem Socket verknüpften Eingabe-/Ausgabestream.

3) Informationen in den Ausgabestream schreiben.

4) Lesen Sie die Antwortinformationen aus dem Eingabestream.

5) Schließen Sie alle Datenströme und Sockets.

Serverseitige Implementierungsschritte:

1) Eine Verbindung herstellen und den Port abhören.

2) Verwenden Sie die Methode „accept()“, um darauf zu warten, dass der Client die Kommunikation initiiert.

3) Öffnen Sie den mit dem Socket verknüpften Eingabe-/Ausgabestream.

4) Lesen Sie die Anforderungsinformationen aus dem Eingabestream.

5) Informationen in den Ausgabestream schreiben.

6) Schließen Sie alle Datenströme und Sockets. -& gt; Die Interaktion zwischen Client und Server übernimmt einen Antwortmodus. Starten Sie zunächst den Server, um in den Überwachungsstatus zu gelangen, und warten Sie auf die Verbindungsanforderung des Clients.

Beispiel 01: Übertragung von Objektinformationen implementieren.

♥ Benutzerklasse

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;
	}

}

Nach dem Login kopieren

♥ LoginServer-Klasse

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();
			}
		}
	}
}

Nach dem Login kopieren

LoginClient-Klasse

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();
			}
		}
	}
}

Nach dem Login kopieren

Beispiel 02: Upgrade-Demonstrationsbeispiel 01, um die Übertragung mehrerer Objektinformationen zu implementieren.

Benutzerklasse

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;
	}

}

Nach dem Login kopieren

LoginServer-Klasse

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();
			}
		}
	}
}

Nach dem Login kopieren

LoginClient-Klasse

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();
			}
		}
	}
}

Nach dem Login kopieren

● Multi-Client-Benutzeranmeldung realisieren

--> Eine Frage und eine Antwort Muster sind eindeutig keine Personen Realität wollen. Ein Server kann nicht nur einen Client bedienen, sondern stellt im Allgemeinen Dienste für viele Clients gleichzeitig bereit. Das Ergebnis muss jedoch eine Single-Threaded-Implementierung sein.

—>Die Lösung für dieses Problem ist die Verwendung von Multithreading. Sie können auf der Serverseite ein Anwendungshauptdienstprogramm erstellen, das speziell für die Überwachung verantwortlich ist, und ein Thread-Programm, das speziell für die Reaktion verantwortlich ist. Dies ermöglicht Multithreading zur Verarbeitung mehrerer Anfragen. ;-& Gt; Client-Implementierungsschritte:

1) Verbindung herstellen und mit dem Server und Port verbinden.

2) Öffnen Sie den mit dem Socket verknüpften Eingabe-/Ausgabestream.

3) Informationen in den Ausgabestream schreiben.

4) Lesen Sie die Antwortinformationen aus dem Eingabestream.

5) Schließen Sie alle Datenströme und Sockets. -& gt; serverseitige Implementierungsschritte:

1) Erstellen Sie die Server-Thread-Klasse und die Run()-Methode, um eine Antwort auf eine Anfrage zu erhalten.

2) Ändern Sie den serverseitigen Code so, dass sich der serverseitige Socket immer im Überwachungszustand befindet.

3) Jedes Mal, wenn der Server eine Anfrage überwacht, erstellt er ein Thread-Objekt und startet es.

Beispiel 03: Demo-Beispiel 02 aktualisieren, um die Multi-Client-Antwortverarbeitung zu implementieren. ...

—> ;Die Die InetAddress-Klasse im java.net-Paket wird zum Kapseln von IP-Adressen und DNS verwendet. Um eine Instanz der InetAddress-Klasse zu erstellen, können Sie die Factory-Methode verwenden, da diese Klasse keinen Konstruktor hat. -& gt; Factory-Methode in der InetAddress-Klasse

-& gt; Wenn der Host nicht gefunden werden kann, lösen beide Methoden eine UnknownHostnameException aus.

3. Socket-Programmierung basierend auf dem UDP-Protokoll

TCP

UDP

Ob eine Verbindung hergestellt werden soll

Verbindungsorientiert

Auf Nicht-Verbindung ausgerichtet „Zuverlässige Übertragung.“

1. DatagramPacket-Klasse und DatagramSocket-Klasse

(1) TCP-basierte Netzwerkkommunikation ist sicher und bidirektional. Genau wie bei einem Telefonanruf ist zunächst ein Server erforderlich und es wird eine bidirektionale Verbindung hergestellt, bevor die Datenkommunikation erfolgen kann beginnen.

(2) Für die UDP-basierte Netzwerkkommunikation ist lediglich die Angabe der Adresse der anderen Partei und das anschließende Senden der Daten ohne vorherige Verbindung erforderlich. Eine solche Netzwerkkommunikation ist unsicher und wird daher nur in Situationen wie Chat-Systemen und Beratungssystemen verwendet.

(3) Datagramm ist eine Art Nachricht, die Kommunikation darstellt. Bei der Verwendung von Datagrammen ist es nicht erforderlich, im Voraus eine Verbindung herzustellen. Es basiert auf dem UDP-Protokoll.

(4) Es gibt zwei Klassen in Java, die Datagramme zur Implementierung der Kommunikation verwenden können, nämlich DatagramPacket und DatagramSocket.

(5) Die DatagramPacket-Klasse spielt die Rolle eines Containers und die DatagramSocket-Klasse wird zum Senden oder Empfangen von DatagramPacket verwendet. Die Klasse „DatagramPacket“ stellt keine Methoden zum Senden oder Empfangen von Daten bereit, während die Klasse „DatagramSocket“ die Methoden „send()“ und „receive()“ zum Senden und Empfangen von Datagrammen über Sockets bereitstellt. R ● DataGrampacket-Klasse

(1) Konstruktionsmethode -& gt; Der Client muss zuerst ein DataGrampacket-Objekt erstellen und dann das DataGramsocket-Objekt senden.

(2) Allgemeine Methoden

● DatagramSocket-Klasse

(1) Konstruktionsmethode

--> Die DatagramSocket-Klasse verwaltet keinen Verbindungsstatus und generiert keine Eingabe-/Ausgabedatenströme Die einzige Funktion besteht darin, vom DatagramPacket-Objekt gekapselte Datagramme zu empfangen und zu senden.

(2) Gängige Methoden

2. Verwenden Sie die Socket-Programmierung, um die Kundenberatung umzusetzen

Bei Peer-to-Peer gibt es keinen Unterschied zwischen primär und sekundär, und selbst ihre Codes können genau die gleichen sein Dies sollte von der Socket-Programmierung basierend auf dem TCP-Protokoll unterschieden werden. -& gt; Die auf dem UDP-Protokoll basierende Socket-Netzwerkprogrammierung basiert im Allgemeinen auf den folgenden 4 Schritten:

(1) Verwenden Sie das DataGrampacket-Objekt, um das Datenpaket zu kapseln.

(2) Verwenden Sie das DatagramSocket-Objekt, um Datenpakete zu senden.

(3) Verwenden Sie das DatagramSocket-Objekt, um Datenpakete zu empfangen.

(4) Verwenden Sie das DatagramPacket-Objekt, um Datenpakete zu verarbeiten.

—>Simulieren Sie die Kundenberatungsfunktion, sodass der Absender Beratungsfragen senden kann und der Empfänger die gesendeten Beratungsfragen empfangen und anzeigen kann.

Schritte zur Senderimplementierung:

1) Rufen Sie das InetAddress-Objekt des lokalen Hosts ab.

2) Erstellen Sie ein DatagramPacket-Objekt, um die zu sendenden Informationen zu kapseln.

3) Verwenden Sie das DatagramSocket-Objekt, um die Daten des DatagramPacket-Objekts zu senden.

Schritte zur Empfängerimplementierung:

1) Erstellen Sie ein DatagramPacket-Objekt und bereiten Sie den Empfang der gekapselten Daten vor.

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();
		}
	}
}

Nach dem Login kopieren

♥ 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();
		}
	}
}

Nach dem Login kopieren

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

Das obige ist der detaillierte Inhalt vonJAVA Advanced Learning Socket-Programmierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!