Java网络编程套接字
文章目录
- 1、网络编程基础
- 2、Socket套接字
-
- 2.1 Java数据报套接字通信模型
- 2.2 Java流式套接字通信模型
- 2.3 Socket编程注意事项
- 3、UDP数据报套接字编程
- 4、TCP流式套接字编程
1、网络编程基础
在没有网路之前，两个进程只能在同一主机上进行通信，但是无法跨距离实现通信。但是通过网络，进程之间就能跨距离通信。网络是信息传输、接收、共享的虚拟平台，通过它把各个点、面、体的信息联系到一起，从而实现这些网络资源的共享。
所谓的网络资源，其实就是在网络中可以获取的各种数据资源，并且所有的网络资源，都是通过网络编程来进行数据传输的
什么是网络编程？
网络编程，指网络上的主机，通过不同的进程，以编程的方式实现网络通信（或称为网络数据传输）
当然，我们只要满足进程不同就行；所以即便是同一个主机，只要是不同进程，基于网络来传输据，也属于网络编程。
特殊的，对于开发来说，在条件有限的情况下，一般也都是在一个主机中运行多个进程来完成网络编
程
但是，我们一定要明确，我们的目的是提供网络上不同主机，基于网络来传输数据资源：
- 进程A：编程来获取网络资源
- 进程B：编程来提供网络资源
网络编程中的基本概念
发送端和接收端
在一次网络数据传输时：
发送端：数据的发送方进程，称为发送端。发送端主机即网络通信中的源主机。
接收端：数据的接收方进程，称为接收端。接收端主机即网络通信中的目的主机。
收发端：发送端和接收端两端，也简称为收发端。
注意：发送端和接收端只是相对的，只是一次网络数据传输产生数据流向后的概念
请求和响应
一般来说，获取一个网络资源，涉及到两次网络数据传输
- 第一次：请求数据的发送
- 第二次：响应数据的发送
好比冯同学在食堂点了一份麻辣烫(贼香的那种)：
冯同学要发起请求：点一份麻辣烫
其次，食堂阿姨提提供对应的响应：提供一份麻辣烫
客户端和服务端
服务端：在常见的网络数据传输场景下，把提供服务的一方进程，称为服务端，可以提供对外服务
客户端：获取服务的一方进程，称为客户端
对于服务来说，一般是提供：
- 客户端获取服务资源
- 客户端保存资源在服务端
好比在银行办事：
- 银行提供存款服务：用户（客户端）保存资源（现金）在银行（服务端）
- 银行提供取款服务：用户（客户端）获取服务端资源（银行替用户保管的现金）
常见的客户端服务端模型
最常见的场景，客户端是指给用户使用的程序，服务端是提供用户服务的程序：
- 客户端先发送请求到服务端
- 服务端根据请求数据，执行相应的业务处理
- 服务端返回响应：发送业务处理结果
- 客户端根据响应数据，展示处理结果（展示获取的资源，或提示保存资源的处理结果）
2、Socket套接字
概念
Socket套接字，是由系统提供用于网络通信的技术，是基于TCP/IP协议的网络通信的基本操作单元。基于Socket套接字的网络程序开发就是网络编程
分类
Socket套接字主要针对传输层协议划分为如下三类：
流式套接字：使用传输层TCP协议
TCP，即Transmission Control Protocol（传输控制协议），传输层协议
以下为TCP的特点
有连接
可靠传输
面向字节流
有接收缓冲区，也有发送缓冲区
大小不限
对于字节流来说，可以简单的理解为，传输数据是基于IO流，流式数据的特征就是在IO流没有关闭的情况下，是无边界的数据，可以多次发送，也可以分开多次接收
数据报套接字：使用传输层UDP协议
UDP，即User Datagram Protocol（用户数据报协议），传输层协议
以下为UDP的特点
无连接
不可靠传输
面向数据报
有接收缓冲区，无发送缓冲区
大小受限：一次最多传输64k
对于数据报来说，可以简单的理解为，传输数据是一块一块的，发送一块数据假如100个字节，必须一次发送，接收也必须一次接收100个字节，而不能分100次，每次接收1个字节
原始套接字
原始套接字用于自定义传输层协议，用于读写内核没有处理的IP协议数据
2.1 Java数据报套接字通信模型
对于UDP协议来说，具有无连接，面向数据报的特征，即每次都是没有建立连接，并且一次发送全部数据报，一次接收全部的数据报
java中使用UDP协议通信，主要基于 DatagramSocket 类来创建数据报套接字，并使用DatagramPacket 作为发送或接收的UDP数据报。对于一次发送及接收UDP数据报的流程如下：
以上只是一次发送端的UDP数据报发送，及接收端的数据报接收，并没有返回的数据。也就是只有请
求，没有响应。对于一个服务端来说，重要的是提供多个客户端的请求处理及响应，流程如下：
2.2 Java流式套接字通信模型
流式套接字和数据报套接字通信方式有所不同，前者在通信之间需要建立连接，而且支持双向通信
2.3 Socket编程注意事项
- 客户端和服务端：开发时，经常是基于一个主机开启两个进程作为客户端和服务端，但真实的场
景，一般都是不同主机。 - 注意目的IP和目的端口号，标识了一次数据传输时要发送数据的终点主机和进程
- Socket编程我们是使用流套接字和数据报套接字，基于传输层的TCP或UDP协议，但应用层协议也需要考虑，这块我们在后续来说明如何设计应用层协议。
- 关于端口被占用的问题
如果一个进程A已经绑定了一个端口，再启动一个进程B绑定该端口，就会报错，这种情况也叫端
口被占用。对于java进程来说，端口被占用的常见报错信息如下：
此时需要检查进程B绑定的是哪个端口，再查看该端口被哪个进程占用。以下为通过端口号查进程
的方式：
- 在cmd输入 netstat -ano | findstr 端口号 ，则可以显示对应进程的pid。如以下命令显示了9090进程的pid
- 在任务管理器中，通过pid查找进程
解决端口被占用的问题：
如果占用端口的进程A不需要运行，就可以关闭A后，再启动需要绑定该端口的进程B
如果需要运行A进程，则可以修改进程B的绑定端口，换为其他没有使用的端口
3、UDP数据报套接字编程
DatagramSocket API
DatagramSocket 是UDP Socket，用于发送和接收UDP数据报
DatagramSocket 构造方法：
| 方法 | 方法说明 |
|---|---|
| DatagramSocket() | 创建一个UDP数据报套接字的Socket，绑定到本机任意一个随机端口（一般用于客户端） |
| DatagramSocket(intport) | 创建一个UDP数据报套接字的Socket，绑定到本机指定的端口（一般用于服务端） |
DatagramSocket 方法：
| 方法 | 方法说明 |
|---|---|
| void receive(DatagramPacket p) | 从此套接字接收数据报（如果没有接收到数据报，该方法会阻塞等待） |
| void send(DatagramPacketp) | 从此套接字发送数据报包（不会阻塞等待，直接发送） |
| void close() | 关闭此数据报套接字 |
DatagramPacket API
DatagramPacket是UDP Socket发送和接收的数据报
DatagramPacket 构造方法：
| 方法 | 方法说明 |
|---|---|
| DatagramPacket(byte[]buf, int length) | 构造一个DatagramPacket以用来接收数据报，接收的数据保存在一个字节数组(第一个参数buf)中，接收指定长度(第二个参数length) |
| DatagramPacket(byte[]buf, int offset, int length,SocketAddress address) | 构造一个DatagramPacket以用来发送数据报，发送的数据为字节数组（第一个参数buf）中，从0到指定长度（第二个参数length）。address指定目的主机的IP和端口号 |
DatagramPacket 方法：
| 方法 | 方法说明 |
|---|---|
| InetAddressgetAddress() | 从接收的数据报中，获取发送端主机IP地址；或从发送的数据报中，获取接收端主机IP地址 |
| int getPort() | 从接收的数据报中，获取发送端主机的端口号；或从发送的数据报中，获取接收端主机端口号 |
| byte[] getData() | 获取数据报中的数据 |
构造UDP发送的数据报时，需要传入 SocketAddress ，该对象可以使用 InetSocketAddress 来创建
InetSocketAddress API
InetSocketAddress （ SocketAddress 的子类 ）构造方法：
| 方法 | 方法说明 |
|---|---|
| InetSocketAddress(InetAddress addr, int port) | 创建一个Socket地址，包含IP地址和端口号 |
例1：将英文翻译为中文(UDP)
//UdpDictServer.java
package network;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.util.HashMap;
public class UdpDictServer{
private HashMap<String ,String> dict = new HashMap<>();
public String process(String request) {
return dict.getOrDefault(request, "字典中没有该词");
}
//进行网络编程，第一步就是要先准备好socket实例，这是进行网络编程的大前提
private DatagramSocket socket = null;
//这里出现SocketException是因为构造Socket对象有很多失败的可能
//1.端口号被其他进程占用(例如两个人不能有相同的电话号码)
//2.每个进程能够打开的文件个数是有上限的，如果进程之前已经打开了很多文件，就可能导致此处的socket文件不能顺利打开
public UdpDictServer(int port) throws SocketException {
socket = new DatagramSocket(port);
dict.put("cat","小猫");
dict.put("dog", "小狗");
dict.put("hello", "你好");
dict.put("pig","小猪");
dict.put("fengtongxue", "冯同学");
}
//启动服务器
public void start() throws IOException {
System.out.println("启动服务器！");
//UDP不需要建立链接，直接接受从客户端来的数据即可
while (true) {
//1.读取客户端发送来的请求
//DatagramPacket表示一个UDP数据报
//发送一次数据，就是在发送一个DatagramPacket
//接受一次数据，也就在接受一个DatagramPacket
DatagramPacket requestPacket = new DatagramPacket(new byte[1024], 1024);
//如果没收到数据，就会阻塞在receive
socket.receive(requestPacket);//为了接受数据，需要先准备好一个空间的DatagramPacket对象，由receive进行填充数据
//把DatagramPacket解析成一个String
String request = new String(requestPacket.getData(), 0, requestPacket.getLength(), "UTF-8");
//2.根据请求计算响应
String response = process(request);
//3.把响应写会客户端
//IP和端口号合在一起的写法
//response.getBytes().length拿到的是字节个数，不能写成response.length()，因为这是拿到的字符个数
//requestPacket.getSocketAddress()，指定数据要发给谁
DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),
response.getBytes().length, requestPacket.getSocketAddress());
//发送数据
socket.send(responsePacket);
//打印请求的IP地址，端口号，请求以及响应
System.out.printf("%s %d req:%s , resp:%s\n",
requestPacket.getAddress().toString(), requestPacket.getPort(), request, response);
}
}
public static void main(String[] args) throws IOException {
UdpDictServer server = new UdpDictServer(9090);
server.start();
}
}
//UdpEchoClient.java
package network;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;
public class UdpEchoClient {
private DatagramSocket socket = null;
private String serverIP;
private int serverPort;
public UdpEchoClient(String ip, int port) throws SocketException {
//此处的port是服务器的端口
//客户端启动的时候，不需要给socket指定端口，客户端自己的端口是系统随机分配的
//通常写代码的时候，客户端的端口号都是由系统指定的
//而服务器端口号必须手动指定，后续客户端要根据这个端口号访问服务器
//如果让系统随机分配，客户端就不知道服务器的端口号是啥，也就不能访问
socket = new DatagramSocket();
serverIP = ip;
serverPort = port;
}
public void start() throws IOException {
Scanner scanner = new Scanner(System.in);
while (true) {
//1.先从控制台读取用户输入的字符串
System.out.print("->");
String request = scanner.next();
//2.把用户输入的内容，构造成一个UDP请求，再发送数据
// 构造的请求里包含两部分信息
// 1)数据的内容，request 字符串
// 2)数据要发给谁 服务器的IP+端口
//IP和端口号分开的写法
DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),
request.getBytes().length, InetAddress.getByName(serverIP), serverPort);
//发送数据
socket.send(requestPacket);
//3.从服务器读取响应数据，并解析
DatagramPacket responsePacket = new DatagramPacket(new byte[1024], 1024);
socket.receive(responsePacket);
String response = new String(responsePacket.getData(), 0,
responsePacket.getLength(), "UTF-8");
//4.把响应结果显示到控制台上
System.out.printf("req: %s, resp: %s\n", request, response);
}
}
public static void main(String[] args) throws IOException {
//由于服务器和客户端在同一台计算机上，使用的IP仍然是127.0.0.1(本地环回)，如果在不同的计算机上，就需要更改这里的IP地址
UdpEchoClient client = new UdpEchoClient("127.0.0.1", 9090);
client.start();
}
}
问题：为啥服务器上来就是接受，也不是发送呢？
因为，服务器的定义，就是"被动接受请求"的这一放
主动发送请求的一方，叫做客户端
注意：端口被占用的问题
一个服务器可以为很多个客户端提供服务。但是同一时刻服务器能够处理的客户端数目是一定存在上限的，因为服务器处理每个请求，都需要消耗一定的资源(包括但不限于CPU，内存，磁盘，宽带…)
至于是多少个，取决于:
处理一个请求，消耗多少资源
服务器一共有多少资源
在Java中并不容易精确的计算消耗多少资源，JVM里面有很多辅助的功能，也需要消耗额外的资源。在实际开发中，通过性能测试的方式，就知道服务器最大能给多少客户端提供服务
在idea中，当我们想再启动一个客户端时，可能会出现这样的问题
idea会提示我们，需要将上一个启动的实例关掉，才能再次启动。此时需要做以下操作，就可以重复启动实例
第一步：
第二步：
修改完毕后，就能多次启动客户端
通常情况下，一个服务器是要同时给多个客户端提供服务的
但是也有其他情况，一个服务器只给一个客户端提供服务，典型的就是分布式系统，两个节点之间的交互
4、TCP流式套接字编程
ServerSocket API
ServerSocket 是创建TCP服务端Socket的API
ServerSocket 构造方法：
| 方法 | 方法说明 |
|---|---|
| ServerSocket(int port) | 创建一个服务端流套接字Socket，并绑定到指定端口 |
ServerSocket 方法：
| 方法 | 方法说明 |
|---|---|
| Socketaccept() | 开始监听指定端口（创建时绑定的端口），有客户端连接后，返回一个服务端Socket对象，并基于该Socket建立与客户端的连接，否则阻塞等待 |
| voidclose() | 关闭此套接字 |
Socket API
Socket 是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
不管是客户端还是服务端Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。
Socket 构造方法：
| 方法 | 方法说明 |
|---|---|
| Socket(String host, intport) | 创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接 |
Socket 方法：
| 方法 | 方法说明 |
|---|---|
| InetAddress getInetAddress() | 返回套接字所连接的地址 |
| InputStream getInputStream() | 返回此套接字的输入流 |
| OutputStream getOutputStream() | 返回此套接字的输出流 |
例2：将英文翻译为中文(TCP)
//TcpEchoServer.java
package network;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Scanner;
public class TcpEchoServer {
//监听套接字
private ServerSocket serverSocket = null;
private HashMap<String, String> dict = new HashMap<>();
public TcpEchoServer(int port) throws IOException {
serverSocket = new ServerSocket(port);
dict.put("dog","小狗");
dict.put("cat","小猫");
dict.put("pig","小猪");
dict.put("fengtongxue","冯同学");
}
public void start() throws IOException {
System.out.println("服务启动成功");
while (true) {
//如果没有客户端进行请求连接，将阻塞在accept()上
//accept()成功后返回一个Socket对象，称为clientSocket，后续和客户端进行通信，都是通过clientSocket完成的
Socket clientSocket = serverSocket.accept();
//处理通信
processConnection(clientSocket);
//ServerSocket专门负责建立连接，Socket专门负责通信
}
}
private void processConnection(Socket clientSocket) {
System.out.printf("[%s %d] 客户端建立链接\n", clientSocket.getInetAddress().toString(),clientSocket.getPort());
//接下来处理请求和响应
//这里针对tcp socket的读和写跟文件的读和写是一样的
try (InputStream inputStream = clientSocket.getInputStream()) {
try(OutputStream outputStream = clientSocket.getOutputStream()) {
//循环处理每个请求，分别返回响应
Scanner scanner = new Scanner(inputStream);
//1.读取请求
while (true) {
if (!scanner.hasNext()) {
System.out.printf("[%s %d] 客户端断开链接！", clientSocket.getInetAddress(), clientSocket.getPort());
break;
}
//此处用这个Scanner更方便，如果不用Scanner，就用原生的InputStream的read也可以
String request = scanner.next();
//2.根据请求，计算响应
String response = process(request);
//3.把这个响应返回给客户端
//为了方便起见，可以使用PrintWriter把outputStream包裹一下
PrintWriter printWriter = new PrintWriter(outputStream);
//将响应数据发送给客户端
printWriter.println(response);
//刷新缓冲区，如果没有这个刷新，可能客户端就不能第一时间看到响应结果
printWriter.flush();
//打印客户端的IP，端口号，请求和响应
System.out.printf("[%s %d] req:%s resp:%s\n",clientSocket.getInetAddress().toString(),
clientSocket.getPort(), request, response);
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
//记得关闭socket
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private String process(String request) {
return dict.getOrDefault(request, "无该单词");
}
public static void main(String[] args) throws IOException {
TcpEchoServer server = new TcpEchoServer(9090);
server.start();
}
}
//TcpEchoClient.java
package network;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.HashMap;
import java.util.Scanner;
public class TcpEchoClient {
//用普通的 socket即可，不用 ServerSocket
//此处也不用手动给客户端指定端口，让系统自由分配
private Socket socket = null;
public TcpEchoClient(String serverIP, int port) throws IOException {
//其实这里IP和port是可以给的，但是这里给了之后，含义不同
//这里传入的ip和端口号的含义不同表示的不是自己绑定，而是表示和这个ip端口建立链接
//调用这个构造方法，就会和服务器建立链接
socket = new Socket(serverIP, port);
}
public void start() {
System.out.println("和服务器连接成功");
Scanner scanner = new Scanner(System.in);
try (InputStream inputStream = socket.getInputStream()) {
try (OutputStream outputStream = socket.getOutputStream()) {
while (true) {
//1.从控制到读取数据
System.out.print("->");
String request = scanner.next();
//2.根据读取到的字符串，构造请求，把请求发送给服务器
PrintWriter printWriter = new PrintWriter(outputStream);
printWriter.println(request);
printWriter.flush();//如果不刷新，可能服务器无法及时看到数据
//3.从服务读取响应，并解析
Scanner respScanner = new Scanner(inputStream);
String response = respScanner.next();
//4.把结果显示到控制台上
System.out.printf("req:%s , resp:%s\n", request, response);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException {
TcpEchoClient client = new TcpEchoClient("127.0.0.1", 9090);
client.start();
}
}
在上述代码中，针对这里的clientSocket特意关闭了一下，但是对于ServerSocket就没有关闭。
同样的在UDP版本的代码里，也没有针对socket的关闭，这是为什么呢？
因为关闭的目的是为了"释放资源"，释放资源的前提是已经不再使用这个资源了。对于UDP的程序和serversocket来说，这些socket都是贯穿程序始终的，这些资源最迟也就是跟随进程的退出一起释放(进程才是分配资源的基本单位，而线程是CPU调度的基本单位)
先启动Server端，再启动Client端
虽然这个代码已经可以运行，但是此时还有一个很严重的问题，就是当前的服务器，同一时刻只能处理一个连接！
为啥当前的服务器，同一时刻只能处理一个客户端？
能够和客户端交互的前提是，要先调用accept，接受连接，当和第一个客户端建立连接够，会进行相互通信，如果当前这个客户端没有断开连接，就无法再次调用accept，也就不能接受第二个客户端的连接，因此同一时刻只能处理一个客户端。
想要解决上述问题，就得让processConnection的执行，和前面的accept的执行相互不干扰，不能让processConnection里面的循环导致accept无法及时调用，因此，得使用多线程
为啥前面的UDP版本的程序没用多线程，也能处理多个客户端？
因为UDP不需要处理连接，UDP是无连接的，UDP只需要一个循环，就能处理所有的客户端请求。
但是此处，TCP既要处理连接，又要处理一个连接的若干次请求，就需要两个循环，里层循环就会影响到外层循环的进度。
因此，主线程循环调用accept，当有客户端连接上来的时候，就直接让主线程创建一个新线程，由新线程负责对客户端的若干请求提供服务(新线程里，通过while循环来处理请求)。这个时候，多个线程是并发执行，就不会相互干扰。也要注意，每个客户端连上来都得分配一个线程
例3：将英文翻译为中文(TCP)，线程版——只需要进行小小的改动
public void start() throws IOException {
System.out.println("服务启动成功");
while (true) {
//如果没有客户端进行请求连接，将阻塞在accept()上
//accept()成功后返回一个Socket对象，称为clientSocket，后续和客户端进行通信，都是通过clientSocket完成的
Socket clientSocket = serverSocket.accept();
//[改进方法] 在这个地方，每次accept成功，都创建一个新的线程，由这个新线程来执行processConnection方法，进行通信
Thread t = new Thread(()->{
processConnection(clientSocket);
});
t.start();
}
}
看到这里，有同学可能有一个疑问，在没使用多线程的情况下，多个客户端和服务器建立连接时，明明却提示了已经建立连接成功，这和除了第一个客户端能进行通信，其他客户端都不能通信相矛盾，为什么是这样呢？
因为当客户端new Socket成功的时候，其实在操作系统内核层面，已经建立好连接了(TCP三次握手已经成功)，但是应用程序还能接受这个连接
既然能用线程解决这个问题，那么就一定能用线程池解决，并且线程池还能进一步提高效率
例4：将英文翻译为中文(TCP)，线程池版——只需要进行小小的改动
public void start() throws IOException {
System.out.println("服务启动成功");
//创建一个线程池
ExecutorService pool = Executors.newCachedThreadPool();
while (true) {
Socket clientSocket = serverSocket.accept();
//让线程池中的线程处理通信
pool.submit(new Runnable() {
@Override
public void run() {
processConnection(clientSocket);
}
});
}
}