发布于   更新于 网络编程 热度 0 喜欢 0

继承程序设计实验，实验说明如图所示：

kaDluL.png

集成程序设计实验

TCP实现

首先说明下基于TCP实现的功能：

（1）能够实现多用户的同时连接

（2）用户执行成功的命令会在其他用户终端上显式说明

（3）当前用户数以及在线情况会在服务端实时显示

（4）实现了对文件的互斥访问，如增、删、查功能

kadCyX.png

整体架构图

实现思路：
（1）实现多用户的同时连接

由于ServerSocket的accept()方法是阻塞的，即服务端在创建成功后会一直阻塞着等待客户端来进行连接，所以将该段代码放在死循环中，一旦有客户端连接成功，继续循环来等待新用户的连接。这里也用到了多线程技术，一旦一个用户连接成功，则会给该用户分配一个线程。

（2）用户执行成功的命令会在其他用户终端上显式说明

用户在连接成功后，执行规定的命令语句可对文件继续操作，在操作成功后（如上传了某个文件），这条命令会在此时连接服务端的其他客户端进行显示。实现思路如下：一旦某个客户端连接成功，那么就记录下该客户端的socket，当命令执行成功时，向除操作成功客户端的其他客户端建立输出流，这里用到的输出流为数据输出流DataOutputStream，使用数据流的writeUTF()和readUTF() 可以进行数据的格式化顺序读写。将该条命令内容发送给其他客户端。当然为了保证其他客户端的收发信息能够并行，这也用到了多线程技术，即收发信息两个线程并行执行，互不影响。

（3）当前用户数以及在线情况会在服务端实时显示

用户一旦连接成功，则在服务端记录下该用户的端口号以及socket，使用static关键字定义一个整型计数器来对连接人数进行计数。一旦某个客户端断开连接， 那么也就意味着之前建立的输入流也断开了，在这里就进行异常处理，一旦断开连接，那么在catch语句中就对计数器减1，并将该客户端的socket在ArrayList中删除。

（4）实现了对文件的互斥访问，如增、删、查功能

多用户对同一文件进行操作时为了防止操作失败，对文件操作进行加锁，若某用户正在对一文件进行操作，那么其他用户对于该文件的操作暂时会被挂起，直到用户处理完文件，文件的锁才会被释放，其他用户才能对该文件进行操作。这里用到了synchronized关键字进行加锁操作。绑定到服务端static final Object someObject的对象。操作成功则会向其他同时在线用户发送执行的指令内容。

增即上传文件，当用户想要上传某个文件时，首先服务端会读出该文件中的内容，接着在自己的文件目录创建一模一样的文件。删即删除文件，当用户执行删除命令时，该文件会在服务端被删除。查即查看文件内容，当用户执行该命令，服务端会把读到的文件内容发送给客户端。

服务端：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package com.lfh.TCP;

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

public class Server {
	// 统计当前连接个数
	static int num = 0;
	static ArrayList<Socket> allSocket = new ArrayList<Socket>();
	// 该对象用于文件同步问题的解决
	static final Object someObject = new Object();

	public static void main(String[] args) throws IOException {
		// 服务端打开端口6667
		ServerSocket serverSocket = new ServerSocket(6667);
		// 在6667端口上监听，看是否有连接请求过来
		System.out.println("监听在端口号:6667");
		while (true) {
			Socket socket = serverSocket.accept();
			System.out.println("第" + (++num) + "客户端连接成功,端口号为：" + socket.getPort());
			// 将该socket加入到ArrayList中
			allSocket.add(socket);
			// 为每一个客端端建立一个线程
			new JoinThread(socket).start();
		}

	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
package com.lfh.TCP;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class JoinThread extends Thread {
	private Socket socket;

	JoinThread(Socket socket) {
		this.socket = socket;
	}

	public void forwardMsg(int localPort, String msg) {
		// 将收到的数据转发给其他的客户端
		for (Socket socket : Server.allSocket) {
			if (this.socket == socket)
				continue;
			OutputStream outputStream;
			try {
				outputStream = socket.getOutputStream();
				DataOutputStream dataOutputStream = new DataOutputStream(outputStream);
				dataOutputStream.writeUTF("端口为" + localPort + "执行命令：" + msg);
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	public void fileDeal(String msg, int localPort) {
		OutputStream outputStream = null;
		DataOutputStream dataOutputStream = null;

		try {
			outputStream = this.socket.getOutputStream();
			dataOutputStream = new DataOutputStream(outputStream);
			// 输入help调出FTP查看系统
			if (msg.trim().equals("help")) {
				String detailMsg = "upload+文件名：上传指定的文件;\n" + "delete+文件名：删除指定的文件;\n" + "update+文件名：更新指定的文件;\n"
						+ "list all：文件列表;\n";
				dataOutputStream.writeUTF(detailMsg);
			} else if (msg.trim().equals("show all")) {

				synchronized (Server.someObject) {
					String allFilename = "";
					// 读取所有的文件名
					File file = new File("D:\\Desktop\\Folder");
					for (String filename : file.list()) {
						allFilename += filename + "\n";
					}
					// 相关输出信息只会自己显示
					dataOutputStream.writeUTF(allFilename);
					// 成功之后向其他在线的人发送信息
					this.forwardMsg(localPort, msg);
				}
			} else {
				// 在这进行文件的处理（上传、删除、修改、查看），注意多用户处理文件要进行加锁操作
				String preMsg = msg.trim();
				if (preMsg.contains(" ")) {
					String instructions = preMsg.substring(0, preMsg.indexOf(" "));
					String filename = preMsg.substring(preMsg.indexOf(" ") + 1, preMsg.length());
					if (instructions.equals("upload")) {

						synchronized (Server.someObject) {
							// 读取文件内容发送给指定的客户端
							String storename = filename.substring(filename.lastIndexOf("/") + 1, filename.length());
							File file = new File("D:/Desktop/Folder/" + storename);
							if (file.exists()) {
								// 相关输出信息只会自己显示
								dataOutputStream.writeUTF("该文件已在服务端存在");
							} else {
								File f = new File(filename);
								// 创建基于文件的Reader
								try (FileReader fr = new FileReader(f)) {
									// 创建字符数组，其长度就是文件的长度
									char[] all = new char[(int) f.length()];
									// 以字符流的形式读取文件所有内容
									fr.read(all);
									// 开始上传，实际为复制信息
									File uploadfile = new File("D:/Desktop/Folder/" + storename);
									// 创建基于文件的Writer
									try (FileWriter fw = new FileWriter(uploadfile)) {
										// 以字符流的形式把数据写入到文件
										fw.write(all);
										dataOutputStream.writeUTF("写入文件成功");
										// 成功之后向其他在线的人发送信息
										this.forwardMsg(localPort, msg);
									} catch (IOException e) {
										// TODO Auto-generated catch block
										dataOutputStream.writeUTF("写入文件出错");
									}

								} catch (IOException e) {
									// TODO Auto-generated catch block
									// e.printStackTrace();
									// 相关输出信息只会自己显示
									dataOutputStream.writeUTF("找不到该文件");
								}
							}
						}
					} else if (instructions.equals("delete")) {
						synchronized (Server.someObject) {
							// 读取文件内容发送给指定的客户端
							File file = new File("D:/Desktop/Folder/" + filename);
							if (file.exists()) {
								if (file.delete()) {
									dataOutputStream.writeUTF("删除成功");
									// 成功之后向其他在线的人发送信息
									this.forwardMsg(localPort, msg);
								} else {
									dataOutputStream.writeUTF("删除失败");
								}

							} else {
								// 相关输出信息只会自己显示
								dataOutputStream.writeUTF("该文件不存在");
							}
						}
					} else if (instructions.equals("update")) {
						// 读取文件内容发送给指定的客户端
						File file = new File("D:/Desktop/Folder/" + filename);
						if (file.exists()) {
							dataOutputStream.writeUTF("对不起，我还没想好怎么做这个接口");
						} else {
							// 相关输出信息只会自己显示
							dataOutputStream.writeUTF("该文件不存在");
						}
					} else if (instructions.equals("list")) {
						// 读取文件内容发送给指定的客户端
						File file = new File("D:/Desktop/Folder/" + filename);
						if (file.exists()) {
							try (FileReader fileReader = new FileReader(file)) {
								// 创建字符数组，其长度就是文件的长度
								char[] all = new char[(int) file.length()];
								// 以字符流的形式读取文件所有内容
								fileReader.read(all);
								String str = new String(all);
								// 相关输出信息只会自己显示
								dataOutputStream.writeUTF(str);

								// 成功之后向其他在线的人发送信息
								this.forwardMsg(localPort, msg);
							} catch (IOException e) {
								// TODO Auto-generated catch block
								e.printStackTrace();
							}

						} else {
							// 相关输出信息只会自己显示
							dataOutputStream.writeUTF("该文件不存在");
						}

					} else {
						// 输入命令有错
						dataOutputStream.writeUTF("命令错误");
					}

				} else {
					// 输入命令有错
					dataOutputStream.writeUTF("命令错误");
				}
			}

		} catch (IOException e) {
			// 关闭
			try {
				dataOutputStream.close();
				outputStream.close();
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public void run() {
		InputStream inputStream = null;
		DataInputStream dataInputStream = null;
		int localPort = -1;
		try {
			// 首先建立输入通道
			inputStream = socket.getInputStream();
			// 转换成数据流传输数据
			dataInputStream = new DataInputStream(inputStream);
			localPort = socket.getPort();
			while (true) {
				// 收到发到服务端的数据
				String msg = dataInputStream.readUTF();
				// 进入文件处理方法,处理完转发给其他连接的人
				this.fileDeal(msg, localPort);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			try {
				dataInputStream.close();
				inputStream.close();
				// 将该套接字在所有中删除
				Server.allSocket.remove(this.socket);
				System.out.println("端口为" + localPort + "已退出");
				Server.num--;
				System.out.println("当前的总在线人数为：" + Server.num);
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
		}
	}
}

客户端：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.lfh.TCP;

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

public class Client {
	public static void main(String[] args) throws IOException {
		// 连接到本机的6666端口
		Socket socket = new Socket("127.0.0.1", 6667);
		System.out.println("本机的端口" + socket.getLocalPort());
		//启动发送消息线程
        new SendThread(socket).start();
        //启动接受消息线程
        new ReceiveThread(socket).start();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package com.lfh.TCP;

import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;

public class SendThread extends Thread {
	private Socket socket;

	SendThread(Socket s) {
		this.socket = s;
	}

	public void run() {
		OutputStream outputStream = null;
		DataOutputStream dataOutputStream = null;
		try {
			outputStream = socket.getOutputStream();
			dataOutputStream = new DataOutputStream(outputStream);

			while (true) {
				Scanner sc = new Scanner(System.in);
				//使得可以接受空格
				sc.useDelimiter("\n");
				String str = sc.next();
				dataOutputStream.writeUTF(str);
			}
		} catch (IOException e) {
			try {
				dataOutputStream.close();
				outputStream.close();
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package com.lfh.TCP;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;

public class ReceiveThread extends Thread {
	private Socket socket;

	ReceiveThread(Socket s) {
		this.socket = s;
	}

	public void run() {
		InputStream in = null;
		DataInputStream inputStream = null;
		try {
			in = socket.getInputStream();
			inputStream = new DataInputStream(in);

			while (true) {
				String msg = inputStream.readUTF();
				System.out.println(msg);
			}

		} catch (IOException e) {
			// TODO Auto-generated catch block
			try {
				inputStream.close();
				in.close();
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
		}
	}
}

UDP实现

基于UDP的实现：

由于TCP是无连接的，除了DatagramSocket的send以及receive方法，无其他阻塞型方法，所以没有实现多人同时在线的功能。

kb2lX1.png

整体架构图

目前实现的功能有：

（1）实现了对文件增、删、查功能

使用UDP通讯时遇到的问题：
（1）中文乱码：这个问题是因为中文和英文字符所占的字节数不相同造成的。所以都在转换为字符串之后，传递的长度应该变为转换后字节数组的长度。

如下代码所示：

1
DatagramPacket datagramPacket = new DatagramPacket(sentence.getBytes(),sentence.getBytes().length,packet.getAddress(), packet.getPort());

（2）读出结果显示错误

另外，字节数组一定要放在死循环内部，否则上次的读出结果会残留在字节数组中，到这次读也会出现。解决方法就是每次生成新的字节数组对象来代替掉之前的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
while (true) {
			byte[] data = new byte[1024];
			DatagramPacket receiveData = new DatagramPacket(data, data.length);
			try {
				client.receive(receiveData);
				String sentence = new String(receiveData.getData());
				System.out.println(sentence);

			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}

服务端：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
package com.lfh.UDP;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.util.ArrayList;

public class UDPServer {
	static int num = 0;
	// 该对象用于文件同步问题的解决
	static final Object someObject = new Object();
	// 因为都是本机发送的，所以暂时不考虑地址问题
	static ArrayList<Integer> port = new ArrayList<Integer>();

	public static void main(String[] args) throws SocketException {
		UDPServer server = new UDPServer();
		DatagramSocket serverSocket = new DatagramSocket(8800);
		// 在6667端口上监听，看是否有连接请求过来
		System.out.println("监听在端口号:8800");

		while (true) {
			try {
				byte[] dataLen = new byte[1024];
				DatagramPacket packet = new DatagramPacket(dataLen, dataLen.length);
				serverSocket.receive(packet);
				String data = new String(packet.getData());
				server.fileDeal(data, packet, serverSocket);

			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

	}

	private void fileDeal(String msg, DatagramPacket packet, DatagramSocket serverSocket) throws IOException {
		if (msg.trim().equals("help")) {
			String sentence = "upload+文件名：上传指定的文件;\n" + "delete+文件名：删除指定的文件;\n" + "update+文件名：更新指定的文件;\n"
					+ "list all：文件列表;\n";
			DatagramPacket datagramPacket = new DatagramPacket(sentence.getBytes(), sentence.getBytes().length,
					packet.getAddress(), packet.getPort());
			serverSocket.send(datagramPacket);
		} else if (msg.trim().equals("show all")) {
			synchronized (UDPServer.someObject) {
				String allFilename = "";
				// 读取所有的文件名
				File file = new File("D:\\Desktop\\Folder");
				for (String filename : file.list()) {
					allFilename += filename + "\n";
				}
				// 相关输出信息只会自己显示
				DatagramPacket datagramPacket = new DatagramPacket(allFilename.getBytes(),
						allFilename.getBytes().length, packet.getAddress(), packet.getPort());
				serverSocket.send(datagramPacket);

			}
		} else {
			// 在这进行文件的处理（上传、删除、修改、查看），注意多用户处理文件要进行加锁操作
			String preMsg = msg.trim();
			if (preMsg.contains(" ")) {
				String instructions = preMsg.substring(0, preMsg.indexOf(" "));
				String filename = preMsg.substring(preMsg.indexOf(" ") + 1, preMsg.length());
				if (instructions.equals("upload")) {

					synchronized (UDPServer.someObject) {
						// 读取文件内容发送给指定的客户端
						String storename = filename.substring(filename.lastIndexOf("/") + 1, filename.length());
						File file = new File("D:/Desktop/Folder/" + storename);
						if (file.exists()) {
							// 相关输出信息只会自己显示
							String tips = "该文件已在服务端存在";
							DatagramPacket datagramPacket = new DatagramPacket(tips.getBytes(), tips.getBytes().length,
									packet.getAddress(), packet.getPort());
							serverSocket.send(datagramPacket);
						} else {
							File f = new File(filename);
							// 创建基于文件的Reader
							try (FileReader fr = new FileReader(f)) {
								// 创建字符数组，其长度就是文件的长度
								char[] all = new char[(int) f.length()];
								// 以字符流的形式读取文件所有内容
								fr.read(all);
								// 开始上传，实际为复制信息
								File uploadfile = new File("D:/Desktop/Folder/" + storename);
								// 创建基于文件的Writer
								try (FileWriter fw = new FileWriter(uploadfile)) {
									// 以字符流的形式把数据写入到文件
									fw.write(all);
									String tips = "写入文件成功";
									DatagramPacket datagramPacket = new DatagramPacket(tips.getBytes(),
											tips.getBytes().length, packet.getAddress(), packet.getPort());
									serverSocket.send(datagramPacket);

								} catch (IOException e) {
									// TODO Auto-generated catch block

									String tips = "写入文件出错";
									DatagramPacket datagramPacket = new DatagramPacket(tips.getBytes(),
											tips.getBytes().length, packet.getAddress(), packet.getPort());
									serverSocket.send(datagramPacket);

								}

							} catch (IOException e) {
								// TODO Auto-generated catch block
								// e.printStackTrace();
								// 相关输出信息只会自己显示
								String tips = "找不到该文件";
								DatagramPacket datagramPacket = new DatagramPacket(tips.getBytes(),
										tips.getBytes().length, packet.getAddress(), packet.getPort());
								serverSocket.send(datagramPacket);
							}
						}
					}
				} else if (instructions.equals("delete")) {
					synchronized (UDPServer.someObject) {
						// 读取文件内容发送给指定的客户端
						File file = new File("D:/Desktop/Folder/" + filename);
						if (file.exists()) {
							if (file.delete()) {

								String tips = "删除成功";
								DatagramPacket datagramPacket = new DatagramPacket(tips.getBytes(),
										tips.getBytes().length, packet.getAddress(), packet.getPort());
								serverSocket.send(datagramPacket);

							} else {

								String tips = "删除失败";
								DatagramPacket datagramPacket = new DatagramPacket(tips.getBytes(),
										tips.getBytes().length, packet.getAddress(), packet.getPort());
								serverSocket.send(datagramPacket);

							}

						} else {
							// 相关输出信息只会自己显示
							String tips = "该文件不存在";
							DatagramPacket datagramPacket = new DatagramPacket(tips.getBytes(), tips.getBytes().length,
									packet.getAddress(), packet.getPort());
							serverSocket.send(datagramPacket);
						}
					}
				} else if (instructions.equals("update")) {
					// 读取文件内容发送给指定的客户端
					File file = new File("D:/Desktop/Folder/" + filename);
					if (file.exists()) {

						// 相关输出信息只会自己显示
						String tips = "对不起，我还没想好怎么做这个接口";
						DatagramPacket datagramPacket = new DatagramPacket(tips.getBytes(), tips.getBytes().length,
								packet.getAddress(), packet.getPort());
						serverSocket.send(datagramPacket);

					} else {
						// 相关输出信息只会自己显示
						String tips = "该文件不存在";
						DatagramPacket datagramPacket = new DatagramPacket(tips.getBytes(), tips.getBytes().length,
								packet.getAddress(), packet.getPort());
						serverSocket.send(datagramPacket);
					}
				} else if (instructions.equals("list")) {
					// 读取文件内容发送给指定的客户端
					File file = new File("D:/Desktop/Folder/" + filename);
					if (file.exists()) {
						try (FileReader fileReader = new FileReader(file)) {
							// 创建字符数组，其长度就是文件的长度
							char[] all = new char[(int) file.length()];
							// 以字符流的形式读取文件所有内容
							fileReader.read(all);
							String str = new String(all);
							// 相关输出信息只会自己显示
							DatagramPacket datagramPacket = new DatagramPacket(str.getBytes(), str.getBytes().length,
									packet.getAddress(), packet.getPort());
							serverSocket.send(datagramPacket);

						} catch (IOException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}

					} else {
						// 相关输出信息只会自己显示
						String tips = "该文件不存在";
						DatagramPacket datagramPacket = new DatagramPacket(tips.getBytes(), tips.getBytes().length,
								packet.getAddress(), packet.getPort());
						serverSocket.send(datagramPacket);
					}
				} else {
					String tips = "命令有错误";
					DatagramPacket datagramPacket = new DatagramPacket(tips.getBytes(), tips.getBytes().length,
							packet.getAddress(), packet.getPort());
					serverSocket.send(datagramPacket);
				}

			} else {
				// 命令有错误
				String tips = "命令有错误";
				DatagramPacket datagramPacket = new DatagramPacket(tips.getBytes(), tips.getBytes().length,
						packet.getAddress(), packet.getPort());
				serverSocket.send(datagramPacket);
			}
		}
	}
}

客户端：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.lfh.UDP;

import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

public class Client {
	public static void main(String[] args) throws SocketException, UnknownHostException {
		DatagramSocket client = new DatagramSocket();
		System.out.println("本机端口：" + client.getLocalPort());
		InetAddress inetAddress = InetAddress.getByName("localhost");
//		启动发送线程
		new UDPSend(client,inetAddress).start();
//		启动接收线程
		new UDPReceive(client).start();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.lfh.UDP;

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

public class UDPReceive extends Thread {
	private DatagramSocket client;

	UDPReceive(DatagramSocket client) {
		this.client = client;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (true) {
			byte[] data = new byte[1024];
			DatagramPacket receiveData = new DatagramPacket(data, data.length);
			try {
				client.receive(receiveData);
				String sentence = new String(receiveData.getData());
				System.out.println(sentence);

			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}

	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package com.lfh.UDP;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

public class UDPSend extends Thread {
	private DatagramSocket client;
	private InetAddress inetAddress;

	UDPSend(DatagramSocket client, InetAddress inetAddress) {
		this.client = client;
		this.inetAddress = inetAddress;
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (true) {
			Scanner sc = new Scanner(System.in);
			// 使得可以接受空格
			sc.useDelimiter("\n");
			String str = sc.next();
			DatagramPacket sendData = null;
			sendData = new DatagramPacket(str.getBytes(), str.getBytes().length, inetAddress, 8800);
			try {
				client.send(sendData);
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}
相关文章
评论
分享
返回顶部
  • Python网络编程

    三月 7日, 2020

    网络编程从大的方面说就是对信息的发送到接收，中间传输为物理线路的作用。 它的含义是使用套接字来达到进程间的通信。套接字可以看成是两个网络应用程序进行通信时，各自通信连接中的一个端点。 套接字Socket=（IP地址：端口号） 端口号是...

    Python网络编程
  • Centos安装

    三月 6日, 2020

    虚拟机下载及安装1.进入VMware官网，转到下载页面 https://my.vmware.com/cn/web/vmware/info/slug/desktop_end_user_computing/vmware_workstati...

    Centos安装
  • Windows下neo4j的安装

    三月 30日, 2020

    neo4j是一个高性能的NOSQL图形数据库，他将结构化数据存储在网络上而不是表中。他是一个嵌入式的、基于磁盘的、具备完全的事物特性的Java持久化引擎，neo4j也可看做是一个高性能的图引擎，该引擎具有成熟数据库的所有特性。——百度...

    Windows下neo4j的安装
  • Java中的流

    三月 13日, 2020

    流是个抽象的概念，是对输入输出设备的抽象，Java程序中，对于数据的输入输出都是以流的方式进行。设备可以是文件、网络、内存等。 I/O字节流InputStream字节输入流OutputStream字节输出流用于以字节的形式读取和写入数...

    Java中的流
  • eclipse使用

    三月 12日, 2020

    Eclipse是一个开放源代码的、基于Java的可拓展开发平台。 常用快捷键 快捷键 作用 alt+/ 代码快速补全 ctrl+1 快速修复 ctrl+shift+f 代码格式化 ctrl+d 删除一行代码 ...

    eclipse使用
  • JavaEE开发准备

    三月 5日, 2020

    个人电脑硬件配置： Windows 10 64位家庭中文版 8G运行内存 Intel(R) Core(TM) i5-7300HQ CPU @ 2.50GHz 1.Java JDK安装及配置（1）下载和安装首先进入oracle网站中Ja...

    JavaEE开发准备
  • Python进阶学习

    二月 14日, 2020

    假期补习补习Python，防止以后用到炸锅。 闭包在Python语言中，一切皆对象。 闭包：一个函数定义中引用了函数外定义的变量，并且该函数可以在其定义环境外被执行。 闭包 = 函数 + 环境变量 123456789101...

    Python进阶学习
  • 推荐算法研究（一）

    一月 17日, 2020

    推荐算法大体分为3类：基于系统过滤的推荐、基于内容的推荐、混合推荐 1.基于协同过滤的推荐系统（Collaborative Filtering）使用行为数据，利用集体智慧来推荐。属于有监督学习。基于用户的协同过滤（找和你兴趣相似的人所...

    推荐算法研究（一）
  • dart中HTTP请求的处理

    一月 15日, 2020

    dio是一个强大的Dart Http请求库，支持Restful API、FormData、拦截器、请求取消、Cookie管理、文件上传/下载、超时、自定义适配器等… ，最重要的是国人开发，牛皮。 （1）添加dio库 找到项目中的pu...

    dart中HTTP请求的处理
  • dart底部导航栏的简单编写

    一月 15日, 2020

    底部导航栏目前在手机应用中非常常见，可见其对于软件设计来说非常的有必要和重要。下面简单总结使用flutter和dart如何实现底部导航栏的制作。 首先值得注意的是底部导航栏为动态的组件，所以继承的话应该是StatefulWidget类...

    dart底部导航栏的简单编写
Please check the comment setting in config.yml of hexo-theme-Annie!
ESC