网络编程 p4 TCP编程 - ToB企服应用市场:ToB评测及商务社交产业平台

netstat指令

netstat -an可以查看当前主机网络情况，包括端口监听情况和网络连接情况；
netstat -an|more可以分页显示；
要求在dos控制台下执行（win+r）
说明：
- Listening 表示某个端口在监听；
- 如果有一个外部程序（客户端）连接到该端口，就会显示一条连接信息；

注意事项

当客户端连接到服务端后，实际上客户端也是通过一个端口和服务端进行通讯的，这端口是TCP/IP来分配的，是随机的；

应用案例

客户端
1. package com.hspedu.socket;
3. import java.io.*;
4. import java.net.InetAddress;
5. import java.net.Socket;
7. /**
8. * @author: 86199
9. * @date: 2023/5/15 15:18
10. * @description: 字符流
11. */
12. public class SocketTCP03Client {
13. public static void main(String[] args) throws IOException {
14. //思路
15. //1. 连接服务端（ip，端口）
16. //解读：连接本机的 9999 端口，如果连接成功，返回Socket对象
17. Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
18. System.out.println("客户端 socket返回 = " + socket.getClass());
19. //2. 连接上后，生成Socket，通过socket.getOutputStream()
20. // 得到和socket对象关联的输出流对象
21. BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
22. //3. 通过输出流，写入数据到数据通道
23. bufferedWriter.write("hello, server");
24. bufferedWriter.newLine();//写入一个换行符，表示写入内容结束，要求对方使用readLine的方式来读
25. bufferedWriter.flush();//如果使用的字符流，需要手动刷新否则数据不会写入数据通道
28. //4. 通过socket.个体InputStream()读取客户端写入到数据通道的数据，显示
29. BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
30. String s = bufferedReader.readLine();
31. System.out.println(s);
33. //5. 关闭流对象和socket，必须关闭
34. bufferedReader.close();
35. bufferedWriter.close();
36. socket.close();
38. }
39. }
复制代码
服务端
1. package com.hspedu.socket;
3. import java.io.*;
4. import java.net.ServerSocket;
5. import java.net.Socket;
7. /**
8. * @author: 86199
9. * @date: 2023/5/15 15:18
10. * @description: 字符流
11. */
12. public class SocketTCP03Server {
13. public static void main(String[] args) throws IOException {
14. //思路
15. //1. 在本机的9999端口监听，等待连接
16. // 细节：要求本机没有其他服务在监听9999
17. // 这个 ServerSocket 可以通过accept() 返回多个Socket[多个客户端连接服务器的并发]
18. ServerSocket serverSocket = new ServerSocket(9999);
19. System.out.println("服务端，在9999端口监听，等待连接...");
20. //2. 当没有客户端连接9999端口时程序会阻塞，等待连接
21. // 如果有客户端连接，则会返回Socket对象，程序继续
22. Socket accept = serverSocket.accept();
24. System.out.println("服务端 socket = " + accept.getClass());
26. //3. 通过socket.个体InputStream()读取客户端写入到数据通道的数据，显示
27. BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(accept.getInputStream()));//读不到内容会阻塞
28. //4. IO读取
29. String s = bufferedReader.readLine();
30. System.out.println(s);
34. //5. 通过输出流，写入数据到数据通道
35. BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
36. bufferedWriter.write("hello, client");
37. bufferedWriter.newLine();//写入一个换行符，表示写入内容结束，要求对方使用readLine的方式来读
38. bufferedWriter.flush();//如果使用的字符流，需要手动刷新否则数据不会写入数据通道
39. //设置结束标记
41. //6. 关闭流对象和socket，必须关闭
42. bufferedWriter.close();
43. bufferedReader.close();
44. accept.close();
45. serverSocket.close();
46. }
47. }
复制代码

StreamUtils类
1. package com.hspedu.upload;
3. import java.io.BufferedReader;
4. import java.io.ByteArrayOutputStream;
5. import java.io.InputStream;
6. import java.io.InputStreamReader;
8. /**
9. * @author: 86199
10. * @date: 2023/5/16 14:57
11. * @description: 工具类
12. */
13. public class StreamUtils {
14. public static byte[] streamToByteArray(InputStream is) throws Exception {
15. // 创建输出流对象
16. ByteArrayOutputStream bos = new ByteArrayOutputStream();
17. // 字节数组
18. byte[] b = new byte[1024];
19. int len;
20. while ((len = is.read(b)) != -1) {
21. // 循环读取
22. // 把读取到的数据，写入 bos
23. bos.write(b, 0, len);
24. }
25. byte[] array = bos.toByteArray();
26. bos.close();
27. return array;
28. }
30. public static String streamToString(InputStream is) throws Exception {
31. BufferedReader reader = new BufferedReader(new InputStreamReader(is));
32. StringBuilder builder = new StringBuilder();
33. String line;
34. while ((line = reader.readLine()) != null) {
35. builder.append(line + "\r\n");
36. }
37. return builder.toString();
38. }
39. }
复制代码
服务端
1. package com.hspedu.upload;
3. import java.io.*;
4. import java.net.ServerSocket;
5. import java.net.Socket;
7. /**
8. * @author: 86199
9. * @date: 2023/5/15 16:24
10. * @description:
11. */
12. public class TCPFileUploadServer {
13. public static void main(String[] args) throws Exception {
14. ServerSocket serverSocket = new ServerSocket(8888);
15. System.out.println("服务端在8888等待连接......");
16. Socket accept = serverSocket.accept();
18. String filePath = "D:\\program\\javaProject\\Idea_Java_Project\\chapter21\\src\\copy.jpg";
20. BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
21. BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));
23. byte[] bytes = StreamUtils.streamToByteArray(bis);
25. bos.write(bytes);
26. bos.close();
28. //向客户端回复“收到图片”
29. BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
30. bufferedWriter.write("收到图片");
31. bufferedWriter.flush();
32. accept.shutdownOutput();
34. //关闭流和socket
35. bis.close();
36. accept.close();
37. serverSocket.close();
38. }
39. }
复制代码
客户端
1. package com.hspedu.upload;
3. import java.io.*;
4. import java.net.InetAddress;
5. import java.net.Socket;
8. /**
9. * @author: 86199
10. * @date: 2023/5/15 16:24
11. * @description:
12. */
13. public class TCPFileUploadClient {
14. public static void main(String[] args) throws Exception {
16. Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
17. String filePath = "e:\\qie.jpg";
19. BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
20. BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
22. byte[] bytes = StreamUtils.streamToByteArray(bis);
23. bos.write(bytes);
24. bos.flush();
25. //没有手动调用flush方法，也没有调用close方法关闭流，数据复制失败，
26. //因为数据还在内部缓冲区，并没有输出 (因为内部缓冲区没有被放满，不调用flush方法，不会输出）
27. bis.close();
28. socket.shutdownOutput();
30. //接收消息
31. InputStream inputStream = socket.getInputStream();
32. String s = StreamUtils.streamToString(inputStream);
33. System.out.println(s);
35. //关闭流和socket
36. inputStream.close();
37. bos.close();
38. socket.close();
39. }
40. }
复制代码