Pengaturcaraan soket pembelajaran lanjutan JAVA-javaTutorial-php.cn

Artikel ini membawa anda pengetahuan yang berkaitan tentang java, yang terutamanya memperkenalkan kandungan yang berkaitan tentang pengaturcaraan soket ialah antara muka atau antara muka yang disediakan oleh lapisan pemacu rangkaian kepada aplikasi mekanisme di bawah saya harap ia akan membantu semua orang.

Pengaturcaraan soket pembelajaran lanjutan JAVA

Pembelajaran yang disyorkan: "tutorial video java"

Pengetahuan soket

1. Gambaran Keseluruhan Soket

(1) Java pada asalnya muncul sebagai bahasa pengaturcaraan rangkaian sokongannya yang tinggi untuk rangkaian menjadikan komunikasi lancar antara pelanggan dan pelayan menjadi kenyataan.

(2) Dalam pengaturcaraan rangkaian, Socket adalah yang paling banyak digunakan, dan penyertaannya amat diperlukan dalam setiap program rangkaian praktikal.

(3) Dalam teknologi pengaturcaraan rangkaian komputer, dua proses atau dua komputer boleh bertukar-tukar data melalui sambungan komunikasi rangkaian Titik akhir pautan komunikasi ini dipanggil "soket" "(Nama Inggeris ialah Socket).

(4) Soket ialah antara muka atau mekanisme yang disediakan oleh lapisan pemacu rangkaian kepada aplikasi.

(5) Gunakan contoh logistik untuk menghantar penghantaran ekspres untuk menggambarkan Soket:

--> Pengirim akan menghantar barang dengan maklumat alamat penerima ke stesen ekspres, dan pengirim tidak perlu Memberi perhatian kepada bagaimana logistik dijalankan Barang dihantar ke stesen penghantaran ekspres di kawasan penerima untuk penghantaran, dan penerima hanya menunggu untuk menerima barang.

—> Proses ini menggambarkan dengan jelas proses penghantaran maklumat dalam rangkaian. Antaranya, barangan tersebut adalah maklumat data, dan dua tapak penghantaran ekspres ialah dua Soket titik akhir.

(6) Aplikasi tidak perlu mengambil berat tentang cara maklumat ditangani dan dihantar dalam rangkaian Ia hanya bertanggungjawab untuk menyediakan untuk menghantar data dan menerima data.

2. Prinsip komunikasi soket

(1) Bagi pengaturcara, tidak perlu memahami bagaimana mekanisme asas Socket menghantar data, tetapi menyerahkan data secara langsung kepada Socket, dan Socket akan bertindak balas mengikut aplikasi Maklumat berkaitan yang disediakan oleh program terikat kepada IP dan data maklumat melalui satu siri pengiraan, dan data diserahkan kepada pemandu untuk dihantar ke rangkaian.

(2) Mekanisme asas Socket adalah sangat kompleks Platform Java menyediakan beberapa kelas yang ringkas tetapi berkuasa yang boleh menggunakan Socket dengan mudah dan berkesan untuk membangunkan program komunikasi tanpa mengetahui mekanisme asas.

3. Pakej java.net

(1) Pakej java.net menyediakan beberapa kelas yang menyokong komunikasi pelanggan/pelayan berasaskan soket.

(2) Kelas yang biasa digunakan dalam pakej java.net termasuk Socket, ServerSocket, DatagramPacket, DatagramSocket, InetAddress, URL, URLConnection dan URLEncoder, dsb.

(3) Untuk memantau permintaan sambungan pelanggan, anda boleh menggunakan kelas ServerSocket.

(4) Kelas Socket melaksanakan soket untuk komunikasi antara proses pada rangkaian.

(5) Kelas DatagramSocket menggunakan protokol UDP untuk melaksanakan soket klien dan pelayan.

(6) Kelas DatagramPacket menggunakan objek kelas DatagramSocket untuk merangkum tetapan dan datagram yang diterima.

(7) Kelas InetAddress mewakili alamat Internet.

(8) Apabila mencipta mesej datagram dan objek Socket, anda boleh menggunakan kelas InetAddress

2. Pengaturcaraan soket berdasarkan protokol TCP

1.Kelas Soket dan kelas ServerSocket

(1) Kedua-dua kelas Socket dan ServerSocket pakej java.net digunakan untuk melaksanakan bahagian klien dan pelayan bagi sambungan selamat dua hala masing-masing pada protokol TCP Apabila bekerja, proses kerja adalah seperti membuat panggilan telefon Hanya apabila kedua-dua pihak disambungkan boleh panggilan bermula.

(2) Semasa komunikasi rangkaian, Socket perlu menggunakan aliran data untuk melengkapkan pemindahan data.

(3) Untuk menghantar data ke aplikasi lain melalui rangkaian, aplikasi hanya mencipta Soket dan kemudian menulis data ke aliran keluaran yang dikaitkan dengan Soket. Sejajar dengan itu, aplikasi penerima mencipta Soket dan membaca data daripada aliran input yang berkaitan.

(4) Nota: Dalam pengaturcaraan Soket berdasarkan protokol TCP, dua titik akhir sering berfungsi sebagai pelanggan dan satu lagi sebagai pelayan, iaitu, mengikuti model pelayan pelanggan.

● Kelas soket

Objek Socket mewujudkan sambungan antara klien dan pelayan. Anda boleh menggunakan kaedah pembina kelas Socket untuk mencipta soket dan menyambungkan soket ini kepada hos dan port yang ditentukan.

(1) Kaedah pembinaan

--> Kaedah pembinaan pertama mengambil nama hos dan nombor port sebagai parameter untuk mencipta objek Soket. UnknownHostException atau IOException mungkin dilemparkan semasa mencipta objek, dan ia mesti ditangkap.

Soket s = Soket baharu(hostName,port);

—>Kaedah pembinaan kedua mengambil objek InetAddress dan nombor port sebagai parameter untuk mencipta objek Soket. Pembina boleh membuang IOException atau UnknownHostException, yang mesti ditangkap dan dikendalikan.

Soket s = Soket baharu(alamat,port);

(2) Kaedah biasa

● Kelas ServerSocket

Objek ServerSocket menunggu klien untuk mewujudkan sambungan dan berkomunikasi selepas sambungan diwujudkan.

(1) Kaedah pembinaan

--> Kaedah pembinaan pertama menerima nombor port sebagai parameter untuk mencipta objek ServerSocket Apabila mencipta objek ini, IOException mungkin dilemparkan mesti ditangkap dan dikendalikan.

ServerSocket ss = ServerSocket(port) baharu;

Bilangan maksimum sambungan pelanggan yang boleh dimiliki sebelum sambungan ditolak.

ServerSocket ss = ServerSocket(port,maxqu);

(2) Kaedah biasa

--> Disenaraikan dalam Kaedah kelas Socket juga memohon kepada kelas ServerSocket.

—>Kelas ServerSocket mempunyai kaedah accept(), yang digunakan untuk menunggu klien memulakan komunikasi supaya objek Socket boleh digunakan untuk penghantaran data selanjutnya.

2. Gunakan pengaturcaraan Soket untuk melaksanakan fungsi log masuk

● Untuk melaksanakan log masuk pengguna tunggal

->Pengaturcaraan rangkaian soket biasanya dibahagikan kepada empat langkah berikut:

(1) Wujudkan sambungan.

(2) Buka aliran input/output yang dikaitkan dengan Soket.

(3) Tulis maklumat dan baca maklumat daripada aliran data.

(4) Tutup semua aliran data dan Soket.

dengan dua kelas untuk mensimulasikan fungsi log masuk pengguna, supaya klien menghantar maklumat log masuk pengguna ke sisi pelayan, dan sisi pelayan memaparkan maklumat ini.

Langkah pelaksanaan pelanggan:

1) Wujudkan sambungan, dan sambungan menghala ke pelayan dan port.

2) Buka aliran input/output yang dikaitkan dengan Soket.

3) Tulis maklumat ke aliran output.

4) Baca maklumat respons daripada aliran input.

5) Tutup semua aliran data dan Soket.

Langkah pelaksanaan bahagian pelayan:

1) Wujudkan sambungan dan dengar pada port.

2) Gunakan kaedah accept() untuk menunggu klien memulakan komunikasi

3) Buka aliran input/output yang dikaitkan dengan Soket.

4) Baca maklumat permintaan daripada aliran input.

5) Tulis maklumat ke aliran output.

6) Tutup semua aliran data dan Soket.

-& gt; interaksi klien dan pelayan, pakai mod menjawab, mulakan pelayan untuk memasuki keadaan pemantauan, tunggu permintaan sambungan pelanggan ", pelayan memberikan ". tindak balas".

Contoh 01: Laksanakan pemindahan maklumat objek.

♥ kelas pengguna

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

}

Salin selepas log masuk

♥ Kelas Log MasukServer

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

Salin selepas log masuk

Kelas Log Masuk Pelanggan

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

Salin selepas log masuk

Contoh 02: Tingkatkan contoh tunjuk cara 01 untuk memindahkan maklumat objek berbilang.

kelas pengguna

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

}

Salin selepas log masuk

Kelas Log MasukServer

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

Salin selepas log masuk

Kelas Pelanggan Masuk

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

Salin selepas log masuk

● Mencapai log masuk pengguna berbilang pelanggan

—>Model satu soalan satu jawapan jelas sekali bukan yang orang mahukan dalam realiti. Pelayan tidak boleh hanya melayani satu pelanggan, tetapi secara amnya menyediakan perkhidmatan kepada banyak pelanggan pada masa yang sama Walau bagaimanapun, pelaksanaan satu benang mestilah hasilnya.

—>Cara untuk menyelesaikan masalah ini adalah dengan menggunakan multi-threading Anda boleh mencipta program perkhidmatan utama aplikasi di bahagian pelayan yang bertanggungjawab secara khusus untuk memantau, dan program thread yang bertanggungjawab secara khusus untuk bertindak balas. . Ini membolehkan multi-threading untuk mengendalikan berbilang permintaan.

->Langkah pelaksanaan pelanggan:

1) Wujudkan sambungan dan sambungan menghala ke pelayan dan port.

2) Buka aliran input/output yang dikaitkan dengan Soket.

3) Tulis maklumat ke aliran output.

4) Baca maklumat respons daripada aliran input.

5) Tutup semua aliran data dan Soket.

—>Langkah pelaksanaan bahagian pelayan:

1) Cipta kelas benang pelayan dan laksanakan pemprosesan respons untuk permintaan dalam kaedah run().

2) Ubah suai kod bahagian pelayan supaya Soket bahagian pelayan sentiasa dalam keadaan mendengar.

3) Setiap kali pelayan mendengar permintaan, ia mencipta objek benang dan memulakannya.

Contoh 03: Naik taraf contoh demo 02 untuk melaksanakan pemprosesan respons berbilang pelanggan.

kelas pengguna

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

}

Salin selepas log masuk

Log MasukThread

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

Salin selepas log masuk

Log MasukServer kelas

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

Salin selepas log masuk

♥ LoginClient1 kelas

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

Salin selepas log masuk

♥ Kelas LoginClient2 dan kelas LoginClient3

Sama seperti kelas LoginClient1, cuma buat objek Pengguna yang berbeza

-->InetAddress dalam pakej java.net Kelas yang digunakan untuk merangkum alamat IP dan DNS. Untuk mencipta contoh kelas InetAddress, anda boleh menggunakan kaedah kilang kerana kelas ini tidak mempunyai pembina.

-& gt; kaedah kilang dalam kelas INetaddress

-& GT;

3 Pengaturcaraan soket berdasarkan protokol UDP

Lambat

TCP

UDP

Sama ada hendak disambungkan

	TCP	UDP
是否连接	面向连接	面向非连接
传输可靠性	可靠	不可靠
速度	慢	快

Berorientasikan sambungan

Tidak berorientasikan sambungan

Kebolehpercayaan penghantaran

Boleh Dipercayai

Tidak boleh dipercayai

Kelajuan

Cepat

1. Kelas DatagramPacket dan kelas DatagramSocket

(1) Komunikasi rangkaian berasaskan TCP adalah selamat dan dua hala Sama seperti membuat panggilan telefon, ia memerlukan pelayan terlebih dahulu sambungan dua hala, Mulakan sahaja komunikasi data.

(2) Komunikasi rangkaian berasaskan UDP hanya memerlukan menyatakan alamat pihak lain dan kemudian menghantar data, tanpa sambungan terlebih dahulu. Komunikasi rangkaian sedemikian tidak selamat, jadi ia hanya digunakan dalam situasi seperti sistem sembang dan sistem perundingan.

(3) Datagram ialah sejenis mesej yang mewakili komunikasi Apabila menggunakan datagram untuk komunikasi, tidak perlu mewujudkan sambungan terlebih dahulu.

(4) Terdapat dua kelas dalam Java yang boleh menggunakan datagram untuk mencapai komunikasi, iaitu DatagramPacket dan DatagramSocket.

(5) Kelas DatagramPacket memainkan peranan sebagai bekas, dan kelas DatagramSocket digunakan untuk menghantar atau menerima DatagramPacket.

(6)Kelas DatagramPacket tidak menyediakan kaedah untuk menghantar atau menerima data, manakala kelas DatagramSocket menyediakan kaedah hantar() dan terima() kaedah Penggunaan Untuk menghantar dan menerima datagram melalui soket.

● Kelas DatagramPacket

(1) Kaedah pembinaan

—>Pelanggan mahu menghantar data keluar mesti mencipta objek DatagramPacket dahulu dan kemudian menggunakan objek DatagramSocket untuk menghantarnya.

(2) Kaedah biasa

● Kelas DatagramSocket

(1) Kaedah pembinaan

—>Kelas DatagramSocket tidak mengekalkan status sambungan dan tidak menjana aliran data input/output. Satu-satunya fungsinya ialah menerima dan menghantar datagram yang dikapsulkan oleh objek DatagramPacket.

(2) Kaedah biasa

2. Gunakan pengaturcaraan Socket untuk melaksanakan perundingan pelanggan

->Dua titik akhir yang berkomunikasi menggunakan UDP adalah sama, yang bermaksud bahawa hubungan antara kedua-dua atur cara komunikasi adalah sama, tiada keutamaan, malah kod mereka boleh betul-betul sama Ini berbeza daripada yang berdasarkan pengaturcaraan Socket Protokol TCP dibezakan.

--> Pengaturcaraan rangkaian soket berdasarkan protokol UDP secara amnya mengikut empat langkah berikut:

(1) Gunakan objek DatagramPacket untuk merangkum paket data.

(2) Gunakan objek DatagramSocket untuk menghantar paket data.

(3) Gunakan objek DatagramSocket untuk menerima paket data.

(4) Gunakan objek DatagramPacket untuk memproses paket data.

--> Simulasikan fungsi perundingan pelanggan, membenarkan pengirim menghantar soalan perundingan, dan penerima menerima dan memaparkan soalan perundingan yang dihantar.

Langkah pelaksanaan penghantar:

1) Dapatkan objek InetAddress hos tempatan.

2) Buat objek DatagramPacket untuk merangkum maklumat yang akan dihantar.

3) Gunakan objek DatagramSocket untuk menghantar data objek DatagramPacket.

Langkah pelaksanaan penerima:

1) Cipta objek DatagramPacket dan sediakan untuk menerima data terkapsul.

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

Salin selepas log masuk

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

Salin selepas log masuk

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

Atas ialah kandungan terperinci Pengaturcaraan soket pembelajaran lanjutan JAVA. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!