Java网络编程

2026-03-15

在JavaSE阶段，我们学习了I/O流，既然I/O流如此强大，那么能否跨越不同的主机进行I/O操作呢？这就要提到Java的网络编程了。

计算机网络基础

利用通信线路和通信设备，将地理位置不同的、功能独立的多台计算机互连起来，以功能完善的网络软件来实现资源共享和信息传递，就构成了计算机网络系统。
示意图
通过将我们的设备连接到路由器，来实现对互联网的访问。

我们的路由器连接在互联网上，而我们的设备又连接了路由器，这样我们的设备就可以通过路由器访问到互联网了。

通过网络，我们可以直接访问互联网上的另一台主机，比如我们要把QQ的消息发送给我们的朋友，或是通过远程桌面管理来操作另一台电脑，也可以是连接本地网络上的打印机。

IP地址

那么如何区别不同的计算机呢？通过IP地址，我们就可以区分不同的计算机了：
示意图
每一台电脑在同一个网络上都有一个自己的IP地址，用于区别于其他的电脑，我们可以通过对方主机的IP地址对其进行访问。

IPv4

IP地址分为IPv4和IPv6，IPv4类似于192.168.0.11，我们上面提到的例子都是使用的IPv4，它一共有四组数字，每组数字占8个bit位，IPv4地址0.0.0.0表示为2进制就是：00000000.00000000.00000000.00000000，共32个bit，最大为255.255.255.255

IPv6

实际上，IPv4能够表示的所有地址，早就已经被用完了。IPv6能够保存128个bit位，因此它也可以表示更多的IP地址，一个IPv6地址看起来像这样：1030::C9B4:FF12:48AA:1A2B，目前也正在向IPv6的阶段过度。

端口号

而我们的电脑上可能运行着大量的程序，每一个程序可能都需要通过网络来访问其他计算机，那这时该如何区分呢？我们可以通过端口号来区分：
示意图
因此，我们一般看到的是这样的：192.168.0.11:8080，通过IP:端口的形式来访问目标主机上的一个应用程序服务。注意端口号只能是0-65535之间的值！

TCP与UDP传输层协议

TCP：当一台计算机想要与另一台计算机通讯时，两台计算机之间的通信需要畅通且可靠（会进行三次握手，断开也会进行四次挥手），这样才能保证正确收发数据，因此TCP更适合一些可靠的数据传输场景。
UDP：它是一种无连接协议，数据想发就发，而且不会建立可靠传输，也就是说传输过程中有可能会导致部分数据丢失，但是它比TCP传输更加简单高效，适合视频直播之类的。

认识Socket

通过Socket技术（它是计算机之间进行通信的一种约定或一种方式），我们就可以实现两台计算机之间的通信，是操作系统底层提供的一项通信技术，它支持TCP和UDP。而Java就对socket底层支持进行了一套完整的封装，我们可以通过Java来实现Socket通信。

JAVA使用Socket会更方便，但是必须得在一个网络下，要不然找不到。

要实现Socket通信，我们必须创建一个数据发送者和一个数据接收者，也就是客户端和服务端，我们需要提前启动服务端，来等待客户端的连接，而客户端只需要随时启动去连接服务端即可。

//服务端
import java.io.IOException;  
import java.net.ServerSocket;  
import java.net.Socket;  
  
public class Server {  
    public static void main(String[] args){  
  
        try {  
            ServerSocket server = new ServerSocket(8080); //绑定端口  
            System.out.println("正在等待客户端的连接");  
            Socket socket1 = server.accept(); //等待客户端的连接，客户端发送请求后才会被唤醒，然后返回一个socket对象  
            System.out.println("客户端已连接，IP地址为："+socket1.getInetAddress().getHostAddress()); //这里getInetAddress返回的是一个对象，打印其属性字符串还需要getHostAddress  
            server.close();//服务器不关闭的话，端口会被一直占用，除非重启电脑  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }

//客户端
import java.io.IOException;  
import java.net.Socket;  
  
public class Client {  
    public static void main(String[] args) {  
        try (Socket socket = new Socket("localhost",8080)){  //输入地址和端口，Socket类可以直接在try括号中创建然后当try运行完后被释放  
            System.out.println("已连接到服务端");  
        } catch (IOException e) {  
            System.out.println("服务端连接失败");  
            e.printStackTrace();  
        }  
    }  
}

实际上它就是一个TCP连接过程
示意图
一旦TCP连接建立，服务端和客户端之间就可以相互发送数据，直到客户端主动关闭连接。

当然，服务端不仅仅只可以让一个客户端进行连接，我们可以尝试让服务端一直运行来不断接受客户端的连接：

public static void main(String[] args) {
    try(ServerSocket server = new ServerSocket(8080)){    //将服务端创建在端口8080上
        System.out.println("正在等待客户端连接...");
        while (true){   //无限循环等待客户端连接
            Socket socket = server.accept();
            System.out.println("客户端已连接，IP地址为："+socket.getInetAddress().getHostAddress());
        }
    }catch (IOException e){
        e.printStackTrace();
    }
}

现在我们就可以多次去连接此服务端了。

使用Socket进行数据传输

通过Socket对象，我们就可以获取到对应的I/O流进行网络数据传输。

我们会使用Socket.getOutputStream从Socket连接中获取一个OutputStream(字节输出流)，但是这个流本身只能外放原始字节，也就是单个字节或者字节数组，所以无法直接发送字符/字符串，于是我们可以用OutputStreamWriter将你要发送的字符 / 字符串（比如 “Hello”）按照指定的编码（默认是系统编码，如 UTF-8）转换成字节，再交给底层的 OutputStream 发送出去，也就是把把 OutputStream（字节流）包装成 OutputStreamWriter（字符流）。

这么要说的话，其实连接就是传送带，而我们的输出流就是我们伟大二游明日方舟终末地协议中枢仓库输出端嘛😋
示意图|64
当我们把要传输的数据放在writer.write("")中后是存在在缓冲区中的，并不会立马发送到网络，所以我们可以直接调用writer.flush()方法来强制把缓冲区里的所有数据推出去

这里要明确下缓存区机制：OutputStreamWriter 自带缓冲区机制，而基础的 OutputStream（Socket 对应的 SocketOutputStream）本身没有内置缓冲区（或仅有极小的底层缓冲区，对上层开发无影响）。

客户端向服务端发送

//客户端
import java.io.IOException;  
import java.io.OutputStream;  
import java.io.OutputStreamWriter;  
import java.net.Socket;  
import java.util.Scanner;  
  
public class Client {  
    public static void main(String[] args) {  
        try (Socket socket = new Socket("localhost",8080);  
             Scanner scanner = new Scanner(System.in)){  //输入地址和端口，Socket类可以直接在try括号中创建然后当try运行完后被释放  
            System.out.println("已连接到服务端");  
            OutputStreamWriter writer =  new OutputStreamWriter(socket.getOutputStream()); //OutputStreamWriter 是一个 “翻译官”—— 它能把你要发送的字符 / 字符串（比如 “Hello”）按照指定的编码（默认是系统编码，如 UTF-8）转换成字节，再交给底层的 OutputStream 发送出去。  
            writer.write(scanner.nextLine()+"\n");  
            writer.flush();  
            System.out.println("数据已发送");  
        } catch (IOException e) {  
            System.out.println("服务端连接失败");  
            e.printStackTrace();  
        }  
    }  
}

//服务端
import java.io.BufferedReader;  
import java.io.IOException;  
import java.io.InputStreamReader;  
import java.net.ServerSocket;  
import java.net.Socket;  
  
public class Server {  
    public static void main(String[] args){  
  
        try ( ServerSocket server = new ServerSocket(8080);){  
            System.out.println("正在等待客户端的连接");  
            Socket socket1 = server.accept(); //等待客户端的连接，客户端发送请求后才会被唤醒，然后返回一个socket对象  
            System.out.println("客户端已连接，IP地址为："+socket1.getInetAddress().getHostAddress()); //这里getInetAddress返回的是一个对象，打印其属性字符串还需要getHostAddress  
            System.out.println("读取客户端数据：");  
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket1.getInputStream()));  
            System.out.println(reader.readLine());//readLine会一直等客户端发数据  
            socket1.close();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}

服务端响应客户端

//客户端
import java.io.*;  
import java.net.Socket;  
import java.util.Scanner;  
  
public class Client {  
    public static void main(String[] args) {  
        try (Socket socket = new Socket("localhost",8080);  
             Scanner scanner = new Scanner(System.in)){  //输入地址和端口，Socket类可以直接在try括号中创建然后当try运行完后被释放  
            System.out.println("已连接到服务端");  
            OutputStreamWriter writer =  new OutputStreamWriter(socket.getOutputStream()); //OutputStreamWriter 是一个 “翻译官”—— 它能把你要发送的字符 / 字符串（比如 “Hello”）按照指定的编码（默认是系统编码，如 UTF-8）转换成字节，再交给底层的 OutputStream 发送出去。  
            writer.write(scanner.nextLine()+"\n");  
            writer.flush();  
            System.out.println("数据已发送等待服务端确认");  
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));  
            System.out.println(reader.readLine());//readLine会一直等客户端发数据  
        } catch (IOException e) {  
            System.out.println("服务端连接失败");  
            e.printStackTrace();  
        }  
    }  
}

//服务端
import java.io.BufferedReader;  
import java.io.IOException;  
import java.io.InputStreamReader;  
import java.io.OutputStreamWriter;  
import java.net.ServerSocket;  
import java.net.Socket;  
  
public class Server {  
    public static void main(String[] args){  
  
        try ( ServerSocket server = new ServerSocket(8080);){  
            System.out.println("正在等待客户端的连接");  
            Socket socket1 = server.accept(); //等待客户端的连接，客户端发送请求后才会被唤醒，然后返回一个socket对象  
            System.out.println("客户端已连接，IP地址为："+socket1.getInetAddress().getHostAddress()); //这里getInetAddress返回的是一个对象，打印其属性字符串还需要getHostAddress  
            System.out.println("读取客户端数据：");  
            BufferedReader reader = new BufferedReader(new InputStreamReader(socket1.getInputStream()));  
            System.out.println(reader.readLine());//readLine会一直等客户端发数据  
            OutputStreamWriter writer = new OutputStreamWriter(socket1.getOutputStream());  
            writer.write("收到\n");  
            writer.flush();  
            socket1.close();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}

额外知识

我们可以手动关闭单向的流：

1 2	socket.shutdownOutput(); //关闭输出方向的流 socket.shutdownInput(); //关闭输入方向的流

如果我们不希望服务端等待太长客户端发数据的时间，我们可以通过调用setSoTimeout()方法来设定IO超时时间：

1	socket.setSoTimeout(3000);

这个是从连接后开始算的，当超过设定时间都依然没有收到客户端或是服务端的数据时，会抛出异常：

java.net.SocketTimeoutException: Read timed out
	at java.net.SocketInputStream.socketRead0(Native Method)
	at java.net.SocketInputStream.socketRead(SocketInputStream.java:116)
	at java.net.SocketInputStream.read(SocketInputStream.java:171)
	at java.net.SocketInputStream.read(SocketInputStream.java:141)
	at sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:284)
	at sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:326)
	at sun.nio.cs.StreamDecoder.read(StreamDecoder.java:178)
	at java.io.InputStreamReader.read(InputStreamReader.java:184)
	at java.io.BufferedReader.fill(BufferedReader.java:161)
	at java.io.BufferedReader.readLine(BufferedReader.java:324)
	at java.io.BufferedReader.readLine(BufferedReader.java:389)
	at com.test.Main.main(Main.java:41)

我们之前使用的都是通过构造方法直接连接服务端，那么是否可以等到我们想要的时候再去连接呢？

1
2
3

try (Socket socket = new Socket(); //调用无参构造不会自动连接
     Scanner scanner = new Scanner(System.in)){ 
    socket.connect(new InetSocketAddress("localhost", 8080), 1000);  //手动调用connect方法进行连接，这里的1000是1000ms没连接上就抛出异常

如果连接的双方发生意外而通知不到对方（比如客户端崩溃了），导致一方还持有连接，这样就会占用资源，因此我们可以使用setKeepAlive()方法来防止此类情况发生：

1	socket.setKeepAlive(true);

当客户端连接后，如果设置了keeplive为 true，当对方没有发送任何数据过来，超过一个时间(看系统内核参数配置)，那么我们这边会发送一个ack探测包发到对方，探测双方的TCP/IP连接是否有效。（看看兄弟你似了没，欸兄弟你怎么似了）

P在传输过程中，实际上会有一个缓冲区用于数据的发送和接收：
示意图
通过缓冲区可以提升程序的执行效率，缓冲区默认大小为：8192，我们可以手动调整其大小来优化传输效率，了解即可：

1 2	socket.setReceiveBufferSize(25565); //TCP接收缓冲区 socket.setSendBufferSize(25565); //TCP发送缓冲区

使用Socket传输文件

客户端传输文件

import java.io.*;  
import java.net.Socket;  
  
public class Client {  
    public static void main(String[] args) {  
        try (Socket socket = new Socket("localhost",8080)){  
            FileInputStream fileInputStream = new FileInputStream("test.txt");  
            OutputStream outputStream = socket.getOutputStream();  
            byte[] bytes = new byte[1024];  
            int i;  
            while((i = fileInputStream.read(bytes)) != -1){  
                outputStream.write(bytes,0,i);  
            }  
            outputStream.flush();  
            outputStream.close();  
        } catch (IOException e) {  
            System.out.println("服务端连接失败");  
            e.printStackTrace();  
        }  
    }  
}

服务端接受文件

import java.io.*;  
import java.net.ServerSocket;  
import java.net.Socket;  
  
public class Server {  
    public static void main(String[] args){  
  
        try ( ServerSocket server = new ServerSocket(8080);){  
            Socket socket = server.accept();  
            InputStream inputStream = socket.getInputStream();  
  
            FileOutputStream fileOutputStream = new FileOutputStream("./new/data.txt");  
            byte[] bytes = new byte[1024];  
            int i;  
            while((i = inputStream.read(bytes))!=-1){  
                fileOutputStream.write(bytes,0,i);  
            }  
            fileOutputStream.flush();  
            fileOutputStream.close();  
            socket.close();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}

注意

核心保障：inputStream.read(bytes) 是「阻塞方法」，没读到数据 / 没读到流结束标记，就不会返回，服务端会一直等；
退出循环的唯一条件：客户端发完所有数据并关闭输出流，服务端 read() 返回 -1；
执行顺序：服务端的 close() 只有在客户端完成所有数据发送后才会执行，完全不用担心服务端「提前关闭」的问题。
流的方向是「相对于当前程序」而言的，不是相对于文件 / 网络。

核心结论

「读取文件」用 FileInputStream（输入流）：数据从「文件」流向「你的程序」→ 对程序来说是「输入」；
「写入文件」用 FileOutputStream（输出流）：数据从「你的程序」流向「文件」→ 对程序来说是「输出」；

流的类型	数据流向（相对于你的 Java 程序）	核心作用	例子
输入流（InputStream/Reader）	外部 → 程序	从外部读取数据到程序里	`FileInputStream`（文件→程序）、`socket.getInputStream()`（网络→程序）
输出流（OutputStream/Writer）	程序 → 外部	把程序的数据写到外部	`FileOutputStream`（程序→文件）、`socket.getOutputStream()`（程序→网络）

使用浏览器访问Socket服务器

服务器获取浏览器内容

在了解了如何使用Socket传输文件后，我们来看看，浏览器是如何向服务器发起请求的：

public static void main(String[] args) {
        try(ServerSocket server = new ServerSocket(8080)){    //将服务端创建在端口8080上
            System.out.println("正在等待客户端连接...");
            Socket socket = server.accept();
            System.out.println("客户端已连接，IP地址为："+socket.getInetAddress().getHostAddress());
            InputStream in = socket.getInputStream();  //通过
            System.out.println("接收到客户端数据：");
            while (true){
                int i = in.read();
                if(i == -1) break;
                System.out.print((char) i);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

我们现在打开浏览器，输入http://localhost:8080或是[点我打开][127.0.0.1:8080]

GET / HTTP/1.1
Host: 127.0.0.1:8080
Connection: keep-alive
Cache-Control: max-age=0
sec-ch-ua: "Chromium";v="94", "Google Chrome";v="94", ";Not A Brand";v="99"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "macOS"
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.81 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9,und;q=0.8,en;q=0.7

实际上这些内容都是Http协议规定的请求头内容。HTTP是一种应用层协议，全称为超文本传输协议，它本质也是基于TCP协议进行数据传输，因此我们的服务端能够读取HTTP请求。但是Http协议并不会保持长连接，在得到我们响应的数据后会立即关闭TCP连接。

服务器响应浏览器从而显示页面

既然使用的是Http连接，如果我们的服务器要支持响应HTTP请求，那么就需要按照HTTP协议的规则，返回一个规范的响应文本，首先是响应头，它至少要包含一个响应码：

1	HTTP/1.1 200 Accpeted

然后就是响应内容（注意一定要换行再写），我们尝试来编写一下支持HTTP协议的响应内容：

public static void main(String[] args) {
    try(ServerSocket server = new ServerSocket(8080)){    //将服务端创建在端口8080上
        System.out.println("正在等待客户端连接...");
        Socket socket = server.accept();
        System.out.println("客户端已连接，IP地址为："+socket.getInetAddress().getHostAddress());
        OutputStreamWriter writer = new OutputStreamWriter(socket.getOutputStream());
        writer.write("HTTP/1.1 200 Accepted\r\n");   //200是响应码，Http协议规定200为接受请求，400为错误的请求，404为找不到此资源（不止这些，还有很多）
        writer.write("\r\n");   //在请求头写完之后还要进行一次换行，然后写入我们的响应实体（会在浏览器上展示的内容）
        writer.write("lbwnb!");
        writer.flush();
    }catch (Exception e){
        e.printStackTrace();
    }
}

HTTP 协议规定 \r\n 是行结束符，其中：

\r（回车）：先把「解析光标」拉回当前行开头，标记「这一行的内容到此为止」；
\n（换行）：再把光标移到下一行，准备解析下一行内容。
HTTP 是「跨平台的应用层协议」，设计时要兼容不同操作系统的换行习惯：
Windows 系统的换行是 \r\n；
Linux/macOS 是 \n；
早期系统（如老 Mac）是 \r。

为了统一标准，HTTP 强制要求所有行分隔符用 \r\n—— 不管服务器 / 客户端运行在什么系统上，都必须按这个规则解析。