• Java学习笔记（三十一）

    在完成对C语言的学习后，我最近开始了对C++和Java的学习，目前跟着视频学习了一些语法，也跟着敲了一些代码，有了一定的掌握程度。现在将跟着视频做的笔记进行整理。本篇博客是整理Java知识点的第三十一篇博客。

    本篇博客介绍了Java的利用TCP进行网络编程。

    本系列博客所有Java代码都使用IntelliJ IDEA编译运行，版本为2022.1。所用JDK版本为JDK11。

    目录

    利用TCP进行网络编程

    TCP通信原理

    TCP发送数据

    TCP接收数据

    TCP通信程序练习服务器给出反馈

    TCP通信程序练习客户端数据来自键盘录入

    TCP通信程序练习服务器数据写入文本文件

    TCP通信程序练习客户端数据来自文本文件

    TCP通信程序练习上传文件服务器给出反馈

    TCP通信程序练习多线程实现文件上传

    利用TCP进行网络编程

    这一部分接上一篇博客介绍网络编程，但是内容全部与TCP有关。

    TCP通信原理

    TCP通信协议在通信两端各建立一个Socket对象，形成网络虚拟链路，随后就可以通过虚拟链路进行通信。

    Java对基于TCP协议的网络提供了良好的封装，使用Socket对象代表两端的通信端口，通过Socket产生IO流进行网络通信。Java为客户端提供了Socket类，为服务器端提供ServerSocker类。

    TCP发送数据

    发送数据需要创建一个客户端的Socket对象（需要导包，import java.net.Socket），然后获取输出流，写数据，最后释放资源（用close）。

    创建客户端的Socket对象的方法是：

    Socket(String host,int port)

    host是主机名或IP地址，port是端口。

    写数据的方法是：

    OutputStream getOutputStream()

    TCP接收数据

    接收数据首先创建服务器端的Socket对象ServerSocket（需要导包，import java.net.ServerSocket），然后获取输入流，读数据，把数据显示在控制台，最后释放资源（用close）

    创建服务器端的Socket对象的方法是：

    ServerSocket(int port)

    port是端口。

    然后要监听客户端连接，返回一个Socket对象：

    Socket accept()

    获取输入流读数据的方法是：

    InputStream getInputStream()

    1. import java.io.IOException;
    2. import java.net.Socket;
    3. import java.io.OutputStream;
    4. public class tcpoutput {
    5.     public static void main(String[] args) throws IOException {
    6.         Socket s = new Socket("LAPTOP",10000);
    7.         OutputStream os = s.getOutputStream();
    8.         os.write("Hello Java".getBytes());
    9.         os.close();
    10.     }
    11. }

    这是发送数据的代码，将Hello Java发送。

    1. import java.io.IOException;
    2. import java.net.Socket;
    3. import java.net.ServerSocket;
    4. import java.io.InputStream;
    5. public class tcpinput {
    6.     public static void main(String[] args) throws IOException {
    7.         ServerSocket ss = new ServerSocket(10000);
    8.         Socket s = ss.accept();
    9.         InputStream is = s.getInputStream();
    10.         byte[] data = new byte[1024];
    11.         int len = is.read(data);
    12.         System.out.println(new String(data,0,len));
    13.         is.close();
    14.     }
    15. }

    这是接收数据的代码。

    下面是先执行tcpinput类，随后执行tcpoutput类后的结果：

    tcpinput类的输出：

    Hello Java

    tcpoutput类无输出。

    TCP通信程序练习服务器给出反馈

    要求服务器获取数据后给出反馈。

    1. import java.io.IOException;
    2. import java.io.InputStream;
    3. import java.io.OutputStream;
    4. import java.net.Socket;
    5. public class tcptest1A {
    6.     public static void main(String[] args) throws IOException {
    7.         Socket s = new Socket("LAPTOP",10000);
    8.         OutputStream os = s.getOutputStream();
    9.         os.write("TCP test 1 2022/07/23".getBytes());
    10.  
    11.         InputStream is = s.getInputStream();
    12.         byte[] data = new byte[1024];
    13.         int len = is.read(data);
    14.         System.out.println(new String(data,0,len));
    15.         is.close();
    16.         os.close();
    17.     }
    18. }

    这是对应客户端，先发送数据，然后接收反馈并进行输出。

    1. import java.io.IOException;
    2. import java.net.Socket;
    3. import java.net.ServerSocket;
    4. import java.io.InputStream;
    5. import java.io.OutputStream;
    6. public class tcptest1B {
    7.     public static void main(String[] args) throws IOException {
    8.         ServerSocket ss = new ServerSocket(10000);
    9.         Socket s = ss.accept();
    10.         InputStream is = s.getInputStream();
    11.         byte[] data = new byte[1024];
    12.         int len = is.read(data);
    13.         System.out.println(new String(data, 0, len));
    14.  
    15.         OutputStream os = s.getOutputStream();
    16.         os.write("Done".getBytes());
    17.         os.close();
    18.         is.close();
    19.     }
    20. }

    这是对应服务器端，先接收数据并输出，然后给出反馈。

    下面是先执行tcptest1B类，随后执行tcptest1A类的结果：

    tcptest1A类的结果是：

    Done

    tcptest1B类的结果是：

    TCP test 1 2022/07/23

    TCP通信程序练习客户端数据来自键盘录入

    要求客户端的数据是从键盘录入的。

    1. import java.io.*;
    2. import java.net.Socket;
    3. public class tcptest2A {
    4.     public static void main(String[] args) throws IOException {
    5.         Socket s = new Socket("LAPTOP",10000);
    6.         InputStream is = System.in;
    7.         InputStreamReader isr = new InputStreamReader(is);
    8.         BufferedReader br = new BufferedReader(isr);
    9.  
    10.         String str;
    11.         while((str = br.readLine()) != null){
    12.             if(str.equals("886")){
    13.                 break;
    14.             }
    15.             OutputStream os = s.getOutputStream();
    16.             OutputStreamWriter osw = new OutputStreamWriter(os);
    17.             BufferedWriter bw = new BufferedWriter(osw);
    18.             bw.write(str);
    19.             bw.newLine();
    20.             bw.flush();
    21.         }
    22.         br.close();
    23.         s.close();
    24.     }
    25. }


    这是客户端内容，要求只要输入的不是886，就一直发送输入的内容。

    1. import java.io.*;
    2. import java.net.Socket;
    3. import java.net.ServerSocket;
    4.  
    5. public class tcptest2B {
    6.     public static void main(String[] args) throws IOException {
    7.         ServerSocket ss = new ServerSocket(10000);
    8.         Socket s = ss.accept();
    9.  
    10.         InputStream is = s.getInputStream();
    11.         InputStreamReader isr = new InputStreamReader(is);
    12.         BufferedReader br = new BufferedReader(isr);
    13.         String str;
    14.         while((str = br.readLine())!=null) {
    15.             System.out.println(str);
    16.         }
    17.         ss.close();
    18.     }
    19. }

    这是服务器端内容，只要有输入就一直显示在屏幕上。

    下面是先执行tcptest2B类，随后执行tcptest2A类的结果：

    这是tcptest2A类的输入：

    Hello world
    Hello Java
    TCP test
    886

    这是tcptest2B类的输出：

    Hello world
    Hello Java
    TCP test

    TCP通信程序练习服务器数据写入文本文件

    要求服务器将数据写入文本文件。

    1. import java.io.*;
    2. import java.net.Socket;
    3. public class tcptest3A {
    4.     public static void main(String[] args) throws IOException {
    5.         Socket s = new Socket("LAPTOP",10000);
    6.         InputStream is = System.in;
    7.         InputStreamReader isr = new InputStreamReader(is);
    8.         BufferedReader br = new BufferedReader(isr);
    9.  
    10.         String str;
    11.         while((str = br.readLine()) != null){
    12.             if(str.equals("886")){
    13.                 break;
    14.             }
    15.             OutputStream os = s.getOutputStream();
    16.             OutputStreamWriter osw = new OutputStreamWriter(os);
    17.             BufferedWriter bw = new BufferedWriter(osw);
    18.             bw.write(str);
    19.             bw.newLine();
    20.             bw.flush();
    21.         }
    22.         br.close();
    23.         s.close();
    24.     }
    25. }

    这是客户端内容，要求只要输入的不是886，就一直发送输入的内容。

    1. import java.io.*;
    2. import java.net.Socket;
    3. import java.net.ServerSocket;
    4.  
    5. public class tcptest3B {
    6.     public static void main(String[] args) throws IOException {
    7.         ServerSocket ss = new ServerSocket(10000);
    8.         Socket s = ss.accept();
    9.  
    10.         InputStream is = s.getInputStream();
    11.         InputStreamReader isr = new InputStreamReader(is);
    12.         BufferedReader br = new BufferedReader(isr);
    13.         BufferedWriter bw = new BufferedWriter(new FileWriter("test1.txt"));
    14.         String str;
    15.         while((str = br.readLine())!=null) {
    16.             bw.write(str);
    17.             bw.newLine();
    18.             bw.flush();
    19.         }
    20.         br.close();
    21.         bw.close();
    22.         ss.close();
    23.     }
    24. }

    这是服务器端，只要读取有数据就写入文件。

    下面是先执行tcptest3B类，随后执行tcptest3A类的结果：

    这是tcptest3A类的输入：

    Hello Java
    TCP test
    Today is  August 20th in 2022
    It is about 21 o'clock
    886

    tcptest3B类无输出，文件test1.txt的内容是：

    Hello Java
    TCP test
    Today is  August 20th in 2022
    It is about 21 o'clock

    TCP通信程序练习客户端数据来自文本文件

    要求客户端从文本文件中获取要发送的信息。

    1. import java.io.*;
    2. import java.net.Socket;
    3. public class tcptest4A {
    4.     public static void main(String[] args) throws IOException {
    5.         Socket s = new Socket("LAPTOP",10000);
    6.         BufferedReader br = new BufferedReader(new FileReader("test1.txt"));
    7.  
    8.         String str;
    9.         while((str = br.readLine()) != null){
    10.             if(str.equals("886")){
    11.                 break;
    12.             }
    13.             OutputStream os = s.getOutputStream();
    14.             OutputStreamWriter osw = new OutputStreamWriter(os);
    15.             BufferedWriter bw = new BufferedWriter(osw);
    16.             bw.write(str);
    17.             bw.newLine();
    18.             bw.flush();
    19.         }
    20.         br.close();
    21.         s.close();
    22.     }
    23. }

    这是客户端内容，只要文件中没有读到886就一直发送读到的数据。

    1. import java.io.*;
    2. import java.net.Socket;
    3. import java.net.ServerSocket;
    4.  
    5. public class tcptest4B {
    6.     public static void main(String[] args) throws IOException {
    7.         ServerSocket ss = new ServerSocket(10000);
    8.         Socket s = ss.accept();
    9.  
    10.         InputStream is = s.getInputStream();
    11.         InputStreamReader isr = new InputStreamReader(is);
    12.         BufferedReader br = new BufferedReader(isr);
    13.         BufferedWriter bw = new BufferedWriter(new FileWriter("test2.txt"));
    14.         String str;
    15.         while((str = br.readLine())!=null) {
    16.             bw.write(str);
    17.             bw.newLine();
    18.             bw.flush();
    19.         }
    20.         bw.close();
    21.         ss.close();
    22.     }
    23. }

    这是服务器端内容，只要有数据传入，就输出到另一个文件。

    test1.txt准备的内容是：

    Hello Java
    TCP test
    Today is  August 20th in 2022
    It is about 21 o'clock
    886

    下面是先执行tcptest4B类，随后执行tcptest4A类的结果：

    tcptest4A类和tcptest4B类均无输出。

    下面是test2.txt的内容：

    Hello Java
    TCP test
    Today is  August 20th in 2022
    It is about 21 o'clock
     

    TCP通信程序练习上传文件服务器给出反馈

    要求服务器接收完毕后给出反馈。

    1. import java.io.*;
    2. import java.net.Socket;
    3. public class tcptest5A {
    4.     public static void main(String[] args) throws IOException {
    5.         Socket s = new Socket("LAPTOP",10000);
    6.         BufferedReader br = new BufferedReader(new FileReader("test1.txt"));
    7.  
    8.         String str;
    9.         while((str = br.readLine()) != null){
    10.             if(str.equals("886")){
    11.                 break;
    12.             }
    13.             OutputStream os = s.getOutputStream();
    14.             OutputStreamWriter osw = new OutputStreamWriter(os);
    15.             BufferedWriter bw = new BufferedWriter(osw);
    16.             bw.write(str);
    17.             bw.newLine();
    18.             bw.flush();
    19.         }
    20.  
    21.         s.shutdownOutput();
    22.         InputStream is = s.getInputStream();
    23.         byte[] data = new byte[1024];
    24.         int len = is.read(data);
    25.         System.out.println(new String(data,0,len));
    26.         br.close();
    27.         s.close();
    28.         is.close();
    29.     }
    30. }

    这是客户端内容，只要文件中没有读到886就一直发送读到的数据，发送完毕后输出得到的反馈。

    1. import java.io.*;
    2. import java.net.Socket;
    3. import java.net.ServerSocket;
    4.  
    5. public class tcptest5B {
    6.     public static void main(String[] args) throws IOException {
    7.         ServerSocket ss = new ServerSocket(10000);
    8.         Socket s = ss.accept();
    9.  
    10.         InputStream is = s.getInputStream();
    11.         InputStreamReader isr = new InputStreamReader(is);
    12.         BufferedReader br = new BufferedReader(isr);
    13.         BufferedWriter bw = new BufferedWriter(new FileWriter("test2.txt"));
    14.         String str;
    15.         while((str = br.readLine())!=null) {
    16.             bw.write(str);
    17.             bw.newLine();
    18.             bw.flush();
    19.         }
    20.  
    21.         OutputStream os = s.getOutputStream();
    22.         os.write("Done".getBytes());
    23.         os.close();
    24.         bw.close();
    25.         ss.close();
    26.     }
    27. }

    这是服务器端内容，只要有数据传入，就输出到另一个文件，接收完毕后给出反馈。

    这是test1.txt准备的内容：

    Hello Java
    TCP test
    Today is  August 20th in 2022
    It is about 21 o'clock
    886

    下面是先执行tcptest5B类，随后执行tcptest5A类的结果：

    tcptest5B类无输出。tcptest5A类的输出是：

    Done

    下面是test2.txt的内容：

    Hello Java
    TCP test
    Today is  August 20th in 2022
    It is about 21 o'clock

    TCP通信程序练习多线程实现文件上传

    要求用多线程实现文件上传。

    1. import java.io.*;
    2. import java.net.Socket;
    3. public class tcptest6A {
    4.     public static void main(String[] args) throws IOException {
    5.         Socket s = new Socket("LAPTOP",10000);
    6.         BufferedReader br = new BufferedReader(new FileReader("test1.txt"));
    7.  
    8.         String str;
    9.         while((str = br.readLine()) != null){
    10.             if(str.equals("886")){
    11.                 break;
    12.             }
    13.             OutputStream os = s.getOutputStream();
    14.             OutputStreamWriter osw = new OutputStreamWriter(os);
    15.             BufferedWriter bw = new BufferedWriter(osw);
    16.             bw.write(str);
    17.             bw.newLine();
    18.             bw.flush();
    19.         }
    20.  
    21.         s.shutdownOutput();
    22.         br.close();
    23.         InputStream is = s.getInputStream();
    24.         byte[] data = new byte[1024];
    25.         int len = is.read(data);
    26.         System.out.println(new String(data,0,len));
    27.         s.close();
    28.         is.close();
    29.     }
    30. }

    这是客户端内容，只要文件中没有读到886就一直发送读到的数据，发送完毕后输出得到的反馈。

    1. import java.io.*;
    2. import java.net.ServerSocket;
    3. import java.net.Socket;
    4.  
    5. public class tcptestthread implements Runnable{
    6.     private Socket s;
    7.     public tcptestthread(){}
    8.     public tcptestthread(Socket s){
    9.         this.s = s;
    10.     }
    11.  
    12.     public void run(){
    13.         try {
    14.             InputStream is = s.getInputStream();
    15.             InputStreamReader isr = new InputStreamReader(is);
    16.             BufferedReader br = new BufferedReader(isr);
    17.             BufferedWriter bw = new BufferedWriter(new FileWriter("test2.txt"));
    18.             String str;
    19.             while ((str = br.readLine()) != null) {
    20.                 bw.write(str);
    21.                 bw.newLine();
    22.                 bw.flush();
    23.             }
    24.  
    25.             OutputStream os = s.getOutputStream();
    26.             os.write("Done".getBytes());
    27.             s.close();
    28.         }catch (IOException e) {
    29.             throw new RuntimeException(e);
    30.         }
    31.     }
    32. }

    这是实现多线程的类，将数据写入文件，并给出反馈。

    1. import java.io.*;
    2. import java.net.Socket;
    3. import java.net.ServerSocket;
    4.  
    5. public class tcptest6B {
    6.     public static void main(String[] args) throws IOException {
    7.         ServerSocket ss = new ServerSocket(10000);
    8.         while(true){
    9.             Socket s = ss.accept();
    10.             tcptestthread ttt = new tcptestthread(s);
    11.             Thread t = new Thread(ttt);
    12.             t.start();
    13.         }
    14.     }
    15. }

    这是服务器端，接收数据并启动tcptestthread的多线程。

    这是test1.txt准备的内容：

    Hello Java
    TCP test
    Today is  August 20th in 2022
    It is about 21 o'clock
    886

    下面是先执行tcptest6B类，随后执行tcptest6A类的结果（在文件传输完毕后结束了tcptest6B类）：

    tcptest6B类无输出。tcptest6A类的输出是：

    Done

    下面是test2.txt的内容：

    Hello Java
    TCP test
    Today is  August 20th in 2022
    It is about 21 o'clock

  • 相关阅读:
    Docker+Jmeter+InfluxDB+Grafana 搭建性能监控平台
    大模型部署手记（2）baichuan2+Windows GPU
    从零开始学JAVA（05）：面向对象编程--01
    【深度学习】数竹签演示软件系统
    【计算机体系知识】操作系统笔记（持续更新）
    网络安全（黑客）自学
    k8s环境设置-pod下载及重启策略
    鸿蒙HarmonyOS实战-ArkUI动画（页面转场动画）
    KiKi知道了什么是质数，他现在想知道所有三位整数中，有多少个质数
    Linux shell printf命令小例子
  • 原文地址：https://blog.csdn.net/m0_71007572/article/details/126444027