Java之TCP编程综合案例

1.反转案例

搭建一个TCP客户端，从键盘录入整行数据（遇到quit结束录入）然后发送给服务器，再接收服务器返回的数据并输出。

package com.briup.chap12;

public class Test064_ReversalClient {
	public static void main(String[] args) throws Exception {
		//1.创建Socket对象(指定服务器ip port) 连接到服务器
		Socket socket = new Socket("127.0.0.1",8989);
		System.out.println("成功连接到 8989服务器，socket: " + socket);
		
		//2.获取数据传输的IO流
		InputStream is = socket.getInputStream();
		OutputStream os = socket.getOutputStream();
		
		//定义增强流 更好的实现功能
		// 打印流 写
		PrintStream ps = new PrintStream(os);
		// 缓冲流 读取
		Reader r = new InputStreamReader(is);
		BufferedReader br = new BufferedReader(r);
		
		//3.核心业务：数据传输
		// 从键盘录入整行数据 发送给服务器，遇到quit结束录入
		Scanner sc = new Scanner(System.in);
		System.out.println("请录入发送数据: ");
		String line = null;
		while(true) {
			//录入数据  并发送
			line = sc.nextLine();
			ps.println(line);
			System.out.println("发送数据成功");
			
			if("quit".equals(line)) 
				break;
			
			//从服务器接收 返回的信息(反转字符串)
			String msg = br.readLine();
			System.out.println("接收信息: " + msg);
		}
		
		//4.关闭资源
		System.out.println("客户端即将关闭");
		br.close();
		ps.close();
		socket.close();
	}
}

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

搭建一个TCP服务器，逐行接收从客户端发送过来的字符串（读取到quit字符串则结束读取），然后对字符串进行反转，最后把反转的字符串返回给客户端。

public class Test064_ReversalServer {
	//StringBuffer类测试
	public static void main00(String[] args) {
		StringBuffer sb = new StringBuffer();
		//追加内容
		sb.append("hello world");
		System.out.println(sb);
		
		//反转
		sb.reverse();
		System.out.println("反转后: " + sb);
		
		//获取长度
		int len = sb.length();
		
		//清空
		sb.delete(0, len);
		System.out.println("清空后: " + sb);
	}
	
	public static void main(String[] args) throws Exception {
		//1.搭建服务器
		ServerSocket server = new ServerSocket(8989);
		System.out.println("服务器成功启动，端口: 8989");
		
		//2.接收客户端连接
		Socket socket = server.accept(); 
		System.out.println("客户端成功连接: " + socket);
		
		//3.获取IO流并增强
		PrintStream ps = 
				new PrintStream(socket.getOutputStream());
		// 缓冲流 读取
		BufferedReader br = 
				new BufferedReader(new InputStreamReader(socket.getInputStream()));
		
		//4.业务操作
		//  4.1 逐行收取数据
		String line = null;
		// 可变字符序列类，类似String
		StringBuffer sb = new StringBuffer();
		while(true) {
			//清空序列
			sb.delete(0, sb.length());
			
			line = br.readLine();
			System.out.println("read: " + line);
			
			//读取到quit,则结束
			if("quit".equals(line))
				break;
			
			// 4.2 对收取的数据 进行 反转
			sb.append(line);
			//反转
			sb.reverse();
			//获取字符序列 包含的 字符串
			String msg = sb.toString();
			
			//4.3 将反转的字符串 返回给 客户端
			ps.println(msg);
			System.out.println("服务器 成功发送 反转信息...");
		}
		
		//5.关闭资源
		System.out.println("服务器即将关闭!");
		ps.close();
		br.close();
		socket.close();
		server.close();
	}
}
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

2. 传输对象

准备一个stud.txt文件，放到src/dir目录下，内容如下：

010.tom.19
001.zs.21
003.lucy.19
002.jack.20
1
2
3
4

搭建TCP客户端，逐行读取stud.txt中数据，然后转化为Student对象，最后将所有对象发送到服务器端。

Student基础类：

package com.briup.chap12;

//注意，必须实现序列化接口
public class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    
    private String id;
	private String name;
	private int age;
    
    //省略...
}
1
2
3
4
5
6
7
8
9
10
11
12

客户端代码：

package com.briup.chap12;

/*
 * 逐行读取stud.txt中 数据 --> Student对象
 * 再将所有对象 发送到 服务器
 */
public class Test065_ObjectClient {
	public static void main(String[] args) throws Exception {
		//1.搭建客户端
		Socket socket = new Socket("127.0.0.1",8989);
		System.out.println("客户端成功连接，socket: " + socket);
		
		//2.获取流对象 并包装增强
		OutputStream os = socket.getOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(os);
		
		//3.解析文件 得到对象 并发送
		BufferedReader br = 
				new BufferedReader(new FileReader("src/dir/stud.txt"));
		String line = null;
		List<Student> list = new ArrayList<>();
		while((line = br.readLine()) != null) {
			//拆分数据 001.zs.20
			String[] arr = line.split("[.]");
			String id = arr[0];
			String name = arr[1];
			int age = Integer.parseInt(arr[2]);
			
			//封装学生对象 并添加到 list集合
			Student s = new Student(id,name,age);
			list.add(s);
		}
		
		// 发送集合(含所有学生)
		oos.writeObject(list);
		System.out.println("学生发送成功，数量: " + list.size());
		
		//4.关闭资源
		System.out.println("客户端即将关闭");
		oos.close();
		socket.close();
	}
}
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

搭建TCP服务器，接收从客户端发送过来的所有学生，然后遍历输出。

package com.briup.chap12;

/*
 * 搭建服务器，接收从客户端发送过来的所有学生
 * 遍历输出
 */
public class Test065_ObjectServer {
	public static void main(String[] args) throws Exception {
		//1.搭建服务器，指定端口
		ServerSocket server = new ServerSocket(8989);
		System.out.println("服务器启动成功  端口 8989...");
		
		//2.接收客户端的连接
		Socket socket = server.accept();
		System.out.println("客户端成功连接：" + socket);
		
		//3.获取输入流 并 包装增强
		InputStream is = socket.getInputStream();
		ObjectInputStream ois = new ObjectInputStream(is);
		
		//4.接收 遍历数据
		List<Student> list = (List<Student>)ois.readObject();
		System.out.println("成功接收学生数量: " + list.size());
		for (Student s : list) {
			System.out.println(s);
		}
		
		//5.资源关闭
		System.out.println("服务器即将终止");
		ois.close();
		socket.close();
		server.close();
	}
}

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

3. 多线程案例

搭建一个TCP客户端，读取键盘信息，然后发送给服务器，遇到quit退出。

package com.briup.chap12;

/*
 * 接盘录入信息  然后发给服务器，遇到quit结束
 */
public class Test066_ChatClient {
	public static void main(String[] args) throws Exception {
		//1.搭建客户端
		Socket socket = new Socket("127.0.0.1",8989);
		System.out.println("客户端成功连接，socket: " + socket);
		
		//2.封装得到IO流
		PrintStream ps = new PrintStream(socket.getOutputStream());
		
		//3.读取键盘信息 然后发送给服务器
		Scanner sc = new Scanner(System.in);
		String line = null;
		while(true) {
			line = sc.nextLine();
			if("quit".equals(line))
				break;
			
			ps.println(line);
		}
		
		//4.关闭资源
		System.out.println("客户端即将关闭");
		ps.close();
		socket.close();
	}
}
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

搭建TCP服务器，分离多线程接收客户端发送过来的数据，然后进行输出。

package com.briup.chap12;

public class Test066_ChatServer {
	//多线程 服务器
	public static void main(String[] args) throws Exception {
		//1.搭建服务器，指定端口
		ServerSocket server = new ServerSocket(8989);
		System.out.println("服务器启动成功  端口 8989...");
		
		while(true) {
			//2.接收客户端的连接
			Socket socket = server.accept();
			System.out.println("客户端成功连接：" + socket);
			
			// 单独分离子线程 为 当前客户端提供服务
			Thread th = new Thread() {
				@Override
				public void run() {
					//1.获取IO流
					BufferedReader br = null;
					try {
						br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
						//2.数据操作
						String line = null;
						while((line = br.readLine()) != null) {
							System.out.println("read: " + line);
						}
					}catch(Exception e) {
						e.printStackTrace();
					}finally {
						//3.关闭资源
						System.out.println("客户端对应资源即将关闭!");
						try {
							if(br != null)
								br.close();
						} catch (IOException e) {
							e.printStackTrace();
						}
						try {
							if(socket != null)
								socket.close();
						} catch (IOException e) {
							e.printStackTrace();
						}
					}
				}
			};
			th.start();
		}
	}
	
	//实现 单线程服务器，接收多个客户端 聊天信息
	public static void main01(String[] args) throws Exception {
		//1.搭建服务器，指定端口
		ServerSocket server = new ServerSocket(8989);
		System.out.println("服务器启动成功  端口 8989...");
		
		while(true) {
			//2.接收客户端的连接
			Socket socket = server.accept();
			System.out.println("客户端成功连接：" + socket);
			
			//3.封装IO流对象，逐行读取聊天信息并输出
			BufferedReader br = 
					new BufferedReader(new InputStreamReader(socket.getInputStream()));
			String line = null;
			while((line = br.readLine()) != null) {
				System.out.println("read: " + line);
			}
			
			//4.关闭资源
			System.out.println("客户端即将关闭: " + socket);
			br.close();
			socket.close();
			//能否关闭 server
		}
	}
}
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