1.网络编程基础
1.1为什么要网络编程？——丰富的网络资源
用户在浏览器中，打开在线网络视频网站，实质是通过网络，获取到网络上的一个视频资源。
与本地打开视频文件相似，只是视频这个资源的来源是网络。
相对于本地资源来说，网络提供了更加丰富的网络资源，如游戏资源，学习资源等。
所谓网络资源，其实就是在网络中可以获取到的各种数据资源。而所有的网络资源，都是通过网络编程来进行数据传输的。
1.2什么是网络编程
网络编程，指网络上的主机，通过不同的进程，以编程的方式实现网络通信（或称为网络数据传输）
当然，我们只要满足进程不同就行；所以即便是同一个主机，只要是不同进程，基于网络来传输数据，也属于网络编程。
特殊的，对于开发来说，在条件有限的情况下，一般也都在一个主机中运行多个进程来完成网络编程。
1.3网络编程中的基本概念
1.3.1发送端和接收端
在一次网络数据传输时：
发送端：数据的发送方进程，称为发送端。发送端主机即网络通信中的源主机。
接收端：数据的接收方进程，称为接收端。接收端主机即网络通信中的目的主机。
收发端：发送端和接收端，也称为收发端。
注意：发送端和接收端只是相对的，只是一次网络数据传输产生数据流之后的概念。
1.3.2请求与相应
一般来说，获取一个网络资源，设计到连个网络传输：
- 第一次：请求数据的发送；
- 第二次：响应数据的发送。
【举个栗子】在一个汉堡店：请求是：我们给老板说来一个汉堡，响应是：老板拿来一个汉堡。
1.3.3客户端和服务端
服务端：在常见的网络数据传输情况下，把提供服务的一方进程，称为服务端，可以提供对外服务
客户端：获取服务的一方进程。
对于服务来说，一般是提供：
- 客户端获取服务资源；
- 客户端保存资源在服务端。
1.3.4常见的客户端服务端模型
常见的场景，客户端是给用户使用的程序，服务端是提供用户服务的程序：
- 客户端先发送请求到服务端；
- 服务端根据请求，执行响应的业务处理；
- 服务端返回响应：发送业务处理结果；
- 客户端根据响应数据，展示处理结果
2.Socket套接字
2.1概念
Socket套接字，是由系统提供用于网络通信的技术，是基于TCP/IP协议的网络通信的基本单元。基于Socket套接字的网络程序开发就是网络编程。
2.2分类
Socket套接字主要针对传输层协议划分为如下三类：
流套接字：使用传输层TCP协议
TCP，即Transmission Control Protocol(传输控制协议），传输层协议。
以下为TCP的特点（后序细讲，这里简单认识）：
- 有链接
- 可靠传输
- 面向字节流
- 有接收缓冲区，也有发送缓冲区
- 大小不限
对于字节流来说，可以简单理解为，传输数据是基于IO流，流式数据的特征就是在IO流没有关闭的情况下，是无边界的数据，可以多次发送，也可以分开多次接收。
数据报套接字：使用UDP协议
UDP，即User Datagram Protocol(用户数据报协议），传输层协议。
以下为UDP的特点（细节后面在学习）：
- 无连接
- 不可靠传输
- 面向数据报
- 有接收缓冲区，无发送缓冲区
- 大小受限：一次最多传输64K
对于数据报来说，可以简单的理解为，传输数据是一块一块的，发送一块数据假设100个字节，必须一次发送，接收也必须一次接收100个字节，而不能分100次，每次接收一个字节。
原始套接字
原始套接字用于自定义传输层协议，用于读行内核没有处理的IP协议数据。
2.3Java数据报套接字通信模型
对于UDP协议来说，具有无连接，面向数据报的特征，即每次都是没有建立连接，并且一次发送全部数据报，一次接收全部的数据报。
Java中使用UDP协议通信，主要基于DatagramSocket类来创建数据报套接字，并使用DatagramPacket作为发送或接收的UDP数据报。对于一次发送即接收UDP数据报的流程如下：
以上只是一次发送端UDP数据报发送，及接收端的数据报接收，并没有返回响应的数据。也就是只有请求没有响应。对于一个服务器来说，重要的是提供给多个客户端的请求处理及响应，流程如下：
3.UDP数据报套接字编程
3.1DatagramSocket API
DatagramSocket是UDP Socket，用于发送和接收UDP数据报。
【构造方法】
| 方法签名 | 方法说明 |
| DatagramSocket() | 创建一个UDP数据报套接字的Socket,绑定到本机任意一个随机端口（一般用于客户端） |
| DatagramSocket(int port) | 创建一个UDP数据报套接字的Socket,绑定到本机指定的端口（一般用于服务端） |
【常用方法】
| 方法签名 | 方法说明 |
|---|---|
| void receive(DatagramPacket p) | 从此套接字接收数据报（如果没有收到数据报，会阻塞等待） |
| void send(DatagramPacket p) | 从此套接字发送数据报（不会阻塞等待，直接发送） |
| void close() | 关闭此数据报套接字 |
3.2DatagramPacket API
DatagramPacket是UDP Socket发送和接收的数据报。
【构造方法】
| 方法签名 | 方法说明 |
|---|---|
| DatagramPacket(byte[] buf, int length) | 构造一个DatagramPacket以用于接收数据报，接收的数据保存在字节数组中(buf),接收指定长度（length) |
| DatagramPacket(byte[] buf, int offset, int length, SocketAddress address) | 构造一个DatagramPacket用于发送数据报，发送的数据为字节数组（buf),从0到指定长度（第二个参数length),address指定目的主机的IP和端口号。 |
【常用方法】
| 方法签名 | 方法说明 |
| InetAddress getAddress() | 从接收的数据报中，获取发送端主机IP地址；或从发送端，获取接收接收端主机IP地址 |
| int getPort() | 从接收的数据报中，获取发送端主机的端口号；或从发送的数据报中，获取接收端主机端口号。 |
| byte[] getData() | 获取数据报中的数据 |
3.3UDP服务端
import java.io.IOException;
import java.net.*;
/**
* Describe:UDP回显服务器的简单实现
* User:lenovo
* Date:2023-04-17
* Time:21:12
*/
public class UdpEchoServer {
//先定义一个socket对象
//通过网络通讯通信必须使用socket对象
private DatagramSocket socket = null;
//绑定一个端口，不一定成功，如果端口被别的端口占用了，操作就会出错。可以结束绑定此端口的进程。
//同一个主机上，一个端口，同一时刻，只能被一个进程绑定。
public UdpEchoServer(int port) throws SocketException {
socket = new DatagramSocket(port);
}
//启动服务器
public void start() throws IOException {
System.out.println("服务器启动！");
//开始无限循环
while(true) {
//每次循环，做三件事情
//1.读取请求并解析
// 构造空饭盒
DatagramPacket requestPacket = new DatagramPacket(new byte[4096], 4096);
// 食堂大妈盛饭（饭从网卡上来）
socket.receive(requestPacket);
// 为了方便处理这个请求，我们把数据转为字符串
String request = new String(requestPacket.getData(), 0, requestPacket.getLength());
//2.根据请求计算响应
String response = process(request);
//3.把返回结果返回到客户端
// 根据response字符串，构造一个DatagramPacket(构造饭盒）
// 和请求不同，此处构造响应的时候，需要指定这个包发给谁
DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), response.getBytes().length, requestPacket.getSocketAddress());
socket.send(responsePacket);
System.out.printf("[%s : %d] req: %s, resp: %s\n",requestPacket.getAddress().toString(), requestPacket.getPort(), request, response);
}
}
//根据请求计算响应
//这个的一个回显服务器
//我们工作的时候可以重写这个方法
public String process(String request) {
return request;
}
public static void main(String[] args) throws IOException{
UdpEchoServer udpEchoServer = new UdpEchoServer(9090);
udpEchoServer.start();
}
}
我们启动服务端，socket.receive()会阻塞等待，直到信息的到来。
3.4UDP客户端
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;
/**
* Describe:UDP回显服务器的客户端
* User:lenovo
* Date:2023-04-18
* Time:14:30
*/
public class UdpEchoClient {
private DatagramSocket socket = null;
private String serverIP;
private int serverPort;
//客户端启动，需要知道服务器的位置
public UdpEchoClient(String serverIP, int serverPort) throws SocketException {
//对于客户端，我们不用手动配置端口，让系统自动分配即可
socket = new DatagramSocket();
this.serverIP = serverIP;
this.serverPort = serverPort;
}
//客户端启动
public void start() throws IOException {
Scanner scanner = new Scanner(System.in);
while(true) {
//1.从控制台读取字符串
// 先打印一个提示符，提示用户需要输入的内容
System.out.print("->");
String request = scanner.next();
//2.把字符串构造成UDP packet并发送
DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
InetAddress.getByName(serverIP), serverPort);
socket.send(requestPacket);
//3.客户端尝试读取服务器返回的请求
DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
socket.receive(responsePacket);
//4.把响应数据转化成String显示出来
String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
System.out.printf("req: %s, resp: %s\n", request, response);
}
}
public static void main(String[] args) throws IOException{
UdpEchoClient udpEchoClient = new UdpEchoClient("127.0.0.1", 9090);
udpEchoClient.start();
}
}
【运行结果】
【全过程】
【注意】发送端和服务端Socket只要创建一次就好。
4.TCP流套接字编程
和刚才UDP相似实现一个回显的功能。
4.1ServerSocket API
ServerSocket是创建TCP服务端Socket的API
【构造方法】
| 方法签名 | 方法说明 |
|---|---|
| ServerSocket（int port) | 创建一个服务端流套接字Socket，并绑定到指定端口。 |
【方法】
| 方法签名 | 方法说明 |
|---|---|
| Socket accept() | 开始监听指定端口（创建时绑定的端口），有客户端连接后，返回一个服务端Socket对象，并基于该Socket建立于客户端的连接，否则阻塞等待 |
| void close() | 关闭此套接字 |
4.2Socket API
Socket是客户端Socket，或者服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket.
不管是客户端还是服务端Socket,都是双方建立连接以后，保存的对端的信息，及用来与对方收发数据的。
【构造方法】
| 方法签名 | 方法说明 |
|---|---|
| Socket(String host, int port) | 创建一个客户端流套接字Socket，并与对应IP的主机上，对应的端口建立连接。 |
【方法】
| 方法签名 | 方法说明 |
|---|---|
| InetAddress getInetAddress() | 发送套接字所连接的地址 |
| InputStream getInputStream() | 返回此套接字的输入流 |
| OutputStream getOutputStream() | 返回此套接字的输出流 |
4.3TCP中的长短连接
TCP发送数据时，需要先建立连接，什么时候关闭连接取决于是短链接还是长连接：
短链接：每次接收到数据并返回响应后，都关闭连接，即短链接。也就是说短链接只能一次收发数据。
长连接：不关闭连接，一直保持连接状态，双方不停的收发数据，即长连接。也就是说，长连接可以多次收发数据。
【对比】
- 建立连接、关闭连接的耗时：短链接每次请求、响应都需要建立连接，关闭连接；而长连接只需要第一次建立连接，之后的请求、响应都可以直接出阿叔。相对来说建立连接，关闭连接也是要耗时的，长连接效率更高。
- 主动发送请求不同，短链接一般是客户端主动向服务器发送请求；而长连接可以是客户端主动发送请求，也可以是服务端主动发。
- 两者的使用场景不同：短链接适用于客户端请求不高的场景，如浏览页面等。长连接适用于客户端与服务器通信频繁的场景，如聊天室，实时游戏等。
4.4长链接（一发一收）
【服务端】
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.*;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* Describe:TCP回显服务端
* User:lenovo
* Date:2023-04-19
* Time:16:32
*/
public class TcpEchoServer {
private ServerSocket serverSocket = null;
public TcpEchoServer(int port) throws IOException {
serverSocket = new ServerSocket(port);
}
public void start() throws IOException {
ExecutorService executorService = Executors.newCachedThreadPool();
System.out.println("服务器启动！");
while(true) {
Socket clientSocket = serverSocket.accept();
executorService.submit(new Runnable() {
@Override
public void run() {
try {
processConnection(clientSocket);
} catch (IOException e) {
e.printStackTrace();
}
}
});
}
}
private void processConnection(Socket clientSocket) throws IOException {
System.out.printf("[%s:%d] 客户端上线\n", clientSocket.getInetAddress().toString(),
clientSocket.getPort());
try(InputStream inputStream = clientSocket.getInputStream();
OutputStream outputStream = clientSocket.getOutputStream()) {
//没有这个scanner和printWriter,完全可以!!,但是代价就是得一个字节一个字节扣，找到那个是请求得结束标志 \n
//为了简单，把字节流包装成更简单得字符流。
Scanner scanner = new Scanner(inputStream);
PrintWriter printWriter = new PrintWriter(outputStream);
while(true) {
//1.读取请求
if(!scanner.hasNext()) {
//读取的流到了结尾了（对端关闭）
System.out.printf("[%s:%d] 客户端下线\n", clientSocket.getInetAddress().toString(),
clientSocket.getPort());
break;
}
//直接使用scanner读取一段字符串
String request = scanner.next();
//2.根据请求计算响应
String response = process(request);
//3.把响应写回客户端，不要忘记，响应里也需要换行
printWriter.println(response);
printWriter.flush();
System.out.printf("[%s:%d] req: %s, resp: %s\n", clientSocket.getInetAddress().toString(),
clientSocket.getPort(), request, response);
}
}catch(IOException e) {
e.printStackTrace();
}finally {
clientSocket.close();
}
}
private String process(String request) {
return request;
}
public static void main(String[] args) throws IOException {
TcpEchoServer tcpEchoServer = new TcpEchoServer(9090);
tcpEchoServer.start();
}
}
【客户端】
import java.io.*;
import java.net.*;
import java.util.Scanner;
/**
* Describe:TCP回显服务器客户端
* User:lenovo
* Date:2023-04-19
* Time:21:21
*/
public class TcpEchoClient {
private Socket socket = null;
public TcpEchoClient(String serverIp, int port) throws IOException {
socket = new Socket(serverIp, port);
}
public void start() {
Scanner scanner = new Scanner(System.in);
try(InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream()) {
PrintWriter printWriter = new PrintWriter(outputStream);
Scanner scannerFormSocket = new Scanner(inputStream);
while(true) {
//1.从键盘读取有用户输入的内容
System.out.print("->");
String request = scanner.next();
//2.把读取的内容构造成请求，发给服务器
printWriter.println(request);
printWriter.flush();
//3.从服务器读取响应的内容
String response = scannerFormSocket.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();
}
}
【运行结果】
3970
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
