目录
1.什么是网络编程
网络编程,指网络上的主机,通过不同的进程,以编程的方式实现网络通信(或称为网络数据传输)。
注意:也可以是同一个主机的不同进程
网络编程中的基本概念
发送端和接收端
在一次网络数据传输时:发送端 :数据的 发送方进程 ,称为发送端。发送端主机即网络通信中的源主机。接收端 :数据的 接收方进程 ,称为接收端。接收端主机即网络通信中的目的主机。收发端 :发送端和接收端两端,也简称为收发端。注意:发送端和接收端只是相对的,只是一次网络数据传输产生数据流向后的概念。
请求和响应
一般来说,获取一个网络资源,涉及到两次网络数据传输:
- 第一次:请求数据的发送
- 第二次:响应数据的发送。
好比在快餐店点一份炒饭:先要发起请求:点一份炒饭,再有快餐店提供的对应响应:提供一份炒饭
客户端和服务端
服务端 :在常见的网络数据传输场景下,把 提供服务 的一方进程,称为服务端,可以提供对外服务。客户端 : 获取服务 的一方进程,称为客户端。
常见的客户端服务端模型
2.Socket套接字
概念:Socket套接字,是由系统提供用于网络通信的技术,是基于TCP/IP协议的网络通信的基本操作单元。基于Socket套接字的网络程序开发就是网络编程。
Socket套接字分类
Socket套接字主要针对传输层协议分为如下三类:
流套接字:使用传输层TCP协议
TCP,即Transmission Control Protocol(传输控制协议),传输层协议。
TCP特点:
- 有连接
- 可靠传输
- 面向字节流
- 有接收缓冲区,也有发送缓冲区
- 大小不限
传输数据时基于IO流,没有边界,可以多次发送,多次接收。
数据报套接字:使用传输层UDP协议
UDP,即User Datagram Protocol(用户数据报协议),传输层协议。
补充:数据报是通过网络传输的数据的基本单元,包含一个报头(header)和数据本身,其中报头描述了数据的目的地以及和其它数据之间的关系。
UDP特点:
- 无连接
- 不可靠传输
- 面向数据报
- 有接收缓冲区,有发送缓冲区
- 大小受限,一次最多传输64K
传输数据时一个整体的传输,不能分开发送。
原始套接字:原始套接字用于自定义传输层协议,用于读写内核没有处理的IP协议数据。
举例对比TCP和UDP
1.有无连接
TCP相当于打电话(接听放必须要接通电话双方才可以通信)
UDP相当于发短信(对方有没有开机都不重要)
2.可靠传输
打电话时必须要经过拨号,接听后才可以童话,发短信发出去就不管了。如果数据包在传输的过程中丢了,TCP会有重传机制,UDP丢了就是丢了。
3.面向字节流:打电话说一个字对方就可以听到一个字
面向数据报:发短信法一条的信息,对方收到才可以阅读
4.有接收缓冲区,也有发送缓冲区:可以打电话也可以接电话,可以发短信也可以收短信
5.大小不限:电话打完了说好了我挂了啊,时间不受限,短信的大小有限制(有字数限制)
3.UDP数据报套接字编程
DatagramSocket API
DatagramSocket是UDP Socket,用于发送和接收UDP数据报。
DatagramSocket构造方法:
方法签名
|
方法说明
|
DatagramSocket()
|
创建一个
UDP
数据报套接字的
Socket
,绑定到本机任意一个随机端口(一般用于客户端)
|
DatagramSocket(int
port)
|
创建一个
UDP
数据报套接字的
Socket
,绑定到本机指定的端口(一般用于服务端)
|
DatagramSocket方法:
方法签名
|
方法说明
|
void receive(
DatagramPacket
p)
|
从此套接字接收数据报(如果没有接收到数据报,该方法会阻塞等待)
|
void send(
DatagramPacket
p)
|
从此套接字发送数据报包(不会阻塞等待,直接发送)
|
void close()
|
关闭此数据报套接字
|
DatagramPacket API
DatagramPacket是UDP Socket发送和接收的数据报。
DatagramPacket构造方法:
方法签名
| |
DatagramPacket(byte[]buf, int length)
|
构造一个DatagramPacket
用来
接收
数据报,接收的数据保存在
字节数组(第一个参数
buf
)中,接收指定长度(第二个参数length)
|
DatagramPacket(byte[]
buf, int offset, int length,
SocketAddress adress)
|
构造一个DatagramPacket
以用来
发送
数据报,发送的数据为字节
数组(第一个参数
buf
)中,从
0
到指定长度(第二个参数
length
)。
address
指定目的主机的
IP
和端口号
|
DatagramPacket方法:
方法签名
|
方法说明
|
InetAddress getAddress()
|
从接收的数据报中,获取发送端主机
IP
地址;或从发送的数据报中,获取接收端主机
IP
地址
|
int getPort()
|
从接收的数据报中,获取发送端主机的
端口号
;或从发送的数据报中,获
取接收端主机端口号
|
byte[] getData()
|
获取数据报中的数据
|
使用UDP发送的数据报时,需要传入SocketAddress,该对象可以使用InetSocketAddress来创建。
InetSocketAddress API
InetSocketAddress API(SocketAddress的子类)构造方法:
方法签名
|
方法说明
|
InetSocketAddress(InetAddress addr, int port)
|
创建一个
Socket
地址,包含
IP
地址和端口号
|
4.实现一个简单的UDP回显服务器与客户端
回显:客户端发什么服务器就返回什么。
服务端与客户端的执行关系
代码
服务器端
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.nio.charset.StandardCharsets;
public class UDPEchoServer {
// 定义一个用于服务器端的DatagramSocket
private DatagramSocket server;
/**
* 构造方法,完成服务器的初始化
* @param port 端口号
*/
public UDPEchoServer (int port) throws Exception {
if (port > 65535 || port < 1024) {
throw new Exception("端口号必须在1024 ~ 65535之间");
}
// 初始化服务器端的UDP服务
this.server = new DatagramSocket(port);
}
/**
* 对外提供服务
*/
public void start () throws IOException {
System.out.println("服务器已启动....");
// 循环接收用户的请求
while (true) {
// 1. 创建一个用于接收请求数据的DatagramPacket
DatagramPacket requestPacket = new DatagramPacket(new byte[1024], 1024);
// 2. 接收请求, 把真实的内容填充到requestPacket
server.receive(requestPacket);
// 3. 从requestPacket获取数据
String request = new String(requestPacket.getData(), 0, requestPacket.getLength(), "UTF-8");
// 4. 根据请求获取响应
String response = processor (request);
// 5. 把响应封装到DatagramPacket
DatagramPacket responsePacket = new DatagramPacket(response.getBytes(StandardCharsets.UTF_8),
response.getBytes().length, requestPacket.getSocketAddress());
// 6. 发送数据
server.send(responsePacket);
// 7. 打印日志
System.out.printf("[%s:%d] request: %s, response: %s.\n", requestPacket.getAddress().toString(),
requestPacket.getPort(), request, response);
}
}
public String processor(String request) {
return request;
}
public static void main(String[] args) throws Exception {
// 初始化服务器
UDPEchoServer server = new UDPEchoServer(9999);
// 启动服务
server.start();
}
}
客户端
import java.io.IOException;
import java.net.*;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
public class UDPEchoClient {
// 定义一个用于客户端的DatagramSocket
private DatagramSocket client;
// 定义服务器的IP地址
private String serverIp;
// 定义服务器的端口号
private int port;
private SocketAddress address;
/**
* 构造方法,指定服务器的Ip地址和端口号
*
* @param serverIp 服务器IP
* @param port 端口号
*/
public UDPEchoClient (String serverIp, int port) throws SocketException {
this.client = new DatagramSocket();
this.serverIp = serverIp;
this.port = port;
this.address = new InetSocketAddress(serverIp, port);
}
public void start () throws IOException {
System.out.println("客户端已启动.");
// 循环接收用户的输入
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("->");
// 接收用户输入
String request = scanner.next();
// 1. 把请求内容包装成DatagramPacket
DatagramPacket requestPacket = new DatagramPacket(request.getBytes(StandardCharsets.UTF_8),
request.getBytes().length, address);
// 2. 发送数据
client.send(requestPacket);
// 3. 接收响应
DatagramPacket responsePacket = new DatagramPacket(new byte[1024], 1024);
// 4. 在receive方法中填充响应数据
client.receive(responsePacket);
// 5. 解析响应数据
String response = new String(responsePacket.getData(), 0, responsePacket.getLength(), "UTF-8");
// 6. 打印日志
System.out.printf("request: %s, response: %s.\n", request, response);
}
}
public static void main(String[] args) throws IOException {
UDPEchoClient client = new UDPEchoClient("127.0.0.1", 9999);
// 启动服务
client.start();
}
}
运行结果
6.Socket流套接字编程
ServerSocket API
ServerSocket是创建TCP服务端Socket的API。
ServerSocket构造方法:
方法签名
|
方法说明
|
ServerSocket(int port)
|
创建一个服务端流套接字
Socket
,并绑定到指定端口
|
ServerSocket方法:
方法签名
|
方法说明
|
Socket accept()
|
开始监听指定端口(创建时绑定的端口),有客户端连接后,返回一个服务端
Socket对象,并基于该
Socket
建立与客户端的连接,否则阻塞等待
|
void
close()
|
关闭此套接字
|
Socket API
Socket是客户端Socket,或服务端中接收到客户端建立连接(accept方法)的请求后,返回的服务端Socket。
不管是客户端还是服务端Socket,都是双方建立连接以后,保存的对端信息,及用来与对方收发数据的。
Socket构造方法:
方法签名
|
方法说明
|
Socket(String host, int port)
|
创建一个客户端流套接字
Socket
,并与对应
IP
的主机上,对应端口的进程建立连接
|
通过IP和端口可以确定网络上的主机,和进程。
Socket方法:
方法签名
| 方法说明 |
InetAddress getInetAddress()
|
返回套接字所连接的地址
|
InputStream getInputStream()
|
返回此套接字的输入流
|
OutputStream getOutputStream()
|
返回此套接字的输出流
|
TCP中的长短连接
TCP发送数据时,需要先建立连接,什么时候关闭连接就决定是短连接还是长连接。
短连接:每次接收到数据并返回响应后,都关闭连接,即是短连接。也就是说,短连接只能一次收发数据。
长连接:不关闭连接,一直保持连接状态,双方不停的收发数据,即是长连接。也就是说,长连接可以多次收发数据。
7.实现一个基于TCP的回显服务
代码
客户端
public class TCPEchoClient {
// 定义一个用于客户端的Socket对象
private Socket clientSocket;
/**
* 初始化客户端的Socket
*
* @param serverIp 服务器IP地址
* @param serverPort 服务器的端口号
* @throws IOException
*/
public TCPEchoClient (String serverIp, int serverPort) throws IOException {
this.clientSocket = new Socket(serverIp, serverPort);
}
public void start () throws IOException {
System.out.println("客户端已启动...");
// 获取Socket中的输入输出流
try (InputStream inputStream = clientSocket.getInputStream();
OutputStream outputStream = clientSocket.getOutputStream()) {
// 循环处理用户的输入
while (true) {
System.out.println("->");
// 接收用户的输入内容
Scanner requestScanner = new Scanner(System.in);
String request = requestScanner.nextLine();
// 发送用户的请求
PrintWriter printWriter = new PrintWriter(outputStream);
printWriter.println(request);
// 强制刷新缓冲区
printWriter.flush();
// 接收服务器的响应
Scanner responseScanner = new Scanner(inputStream);
// 获取响应数据
String response = responseScanner.nextLine();
// 打印响应内容
System.out.println("接收到服务器的响应:" + response);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
clientSocket.close();
}
}
public static void main(String[] args) throws IOException {
TCPEchoClient client = new TCPEchoClient("127.0.0.1", 9999);
client.start();
}
}
服务端
public class TCPEchoServer {
// 声明一个用于服务端的Socket对象
private ServerSocket server;
/**
* 通过指定端口号实例化服务
*
* @param port 端口号
* @throws IOException
*/
public TCPEchoServer(int port) throws IOException {
if (port < 1025 || port > 65535) {
throw new RuntimeException("端口号要在 1025 ~ 65535之间.");
}
// 实例化ServerSocket并指定端口号
this.server = new ServerSocket(port);
}
public void start() throws IOException {
System.out.println("服务器启动成功...");
// 创建一个线程池
ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(3, 10, 1, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(10));
// 循环接收客户端的连接
while (true) {
Socket clientSocket = server.accept();
// 每接收到一个新连接请求,就创建一个新的子线程
// Thread thread = new Thread(() -> {
// // 处理Socket中的数据
// try {
// processConnections(clientSocket);
// } catch (IOException e) {
// e.printStackTrace();
// }
// });
// // 启动线程
// thread.start();
// 提交任务到线程池中
poolExecutor.submit(() -> {
try {
processConnections(clientSocket);
} catch (IOException e) {
e.printStackTrace();
}
});
}
}
// 处理数据
private void processConnections(Socket clientSocket) throws IOException {
// 打印日志
String clientInfo = MessageFormat.format("[{0}:{1}] 客户端已上线", clientSocket.getInetAddress(),
clientSocket.getPort());
System.out.println(clientInfo);
// 处理数据之前要获取一下输入输出流
try (InputStream inputStream = clientSocket.getInputStream();
OutputStream outputStream = clientSocket.getOutputStream()) {
// 循环处理用户的请求
while (true) {
// 通过Scanner读取用户请求中的数据
Scanner requestScanner = new Scanner(inputStream);
if (!requestScanner.hasNextLine()) {
// 日志
clientInfo = MessageFormat.format("[{0}:{1}] 客户端已下线.", clientSocket.getInetAddress(),
clientSocket.getPort());
System.out.println(clientInfo);
break;
}
// 获取真实的用户请求数据
String request = requestScanner.nextLine();
// 根据请求计算响应
String response = process(request);
// 把响应写回客户端
PrintWriter printWriter = new PrintWriter(outputStream);
// 写入输出流
printWriter.println(response);
// 强制刷新缓冲区
printWriter.flush();
// 打印日志
clientInfo = MessageFormat.format("[{0}:{1}], request: {2}, response: {3}",
clientSocket.getInetAddress(), clientSocket.getPort(), request, response);
System.out.println(clientInfo);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
clientSocket.close();
}
}
private String process(String request) {
System.out.println("收到新消息:" + request);
Scanner scanner = new Scanner(System.in);
String response = scanner.nextLine();
return response;
}
public static void main(String[] args) throws IOException {
TCPEchoServer server = new TCPEchoServer(9999);
server.start();
}
}