目录：
前言
基于UDP实现客户端服务器的网络通信程序
基于TCP实现客户端服务器的网络通信程序
前言
网络编程的核心是Socket API，它是操作系统给应用程序提供的网络编程API，可以认为是socket api是和传输层密切相关的。在传输层里面，提供了两个最核心的协议，UDP和TCP。因此，socket api 也提供了两种风格（UDP和TCP）。
先来对UDP和TCP做一个简单的总结：
UDP：无连接、不可靠传输、面向数据报、全双工
TCP：有连接、可靠传输、面向字节流、全双工
关于有无连接，可以用打电话和发微信来类比，打电话就是有连接，有无接通可以被感知，而发微信就是无连接，对方是否已经看到消息是无感知的。
关于可靠与不可靠传输，还是可以用打电话和发微信来类比，打电话就是可靠传输，对方接通并回应就是确认收到了，发微信就是不可靠传输，消息发送出去并不知道对方已经确认收到，就是不可靠传输。
面向字节流：数据传输就和文件读写类似，是“流式”的。
面向数据报：数据传输则以一个个的“数据报”为基本单位，一个数据报可能是若干个字节且带有一定格式。
全双工：一个通信通道，可以双向传输，既可以发送也可以接受。比如一根水管，是单向传输的，就是半双工。
基于UDP实现客户端服务器的网络通信程序
使用DatagramSocket这个类，表示一个socket对象。在操作系统中，把这个socket对象也是当成一个文件来处理的，相当于是文件描述符表上的一项。其中普通的文件对应的硬件设备是硬盘，socket文件对应的硬件设备是网卡。一个socket对象就可以和另外一台主机进行网络通信了，如果需要和多个不同的主机通信，则需要创建多个socket对象。
DatagramSocket(): 无参数就是没有指定端口，系统则会自动分配一个空闲的端口
DatagramSocket(int port): 传入了一个端口号，就是让当前的socket对象和这个指定的端口关联起来。从本质上来说，不是进程和端口来建立联系，而是进程中的socket对象和端口建立了联系。
DatagramPacket：表示UDP中传输的一个报文，也是UDP传输数据的基本单位。
receive(DatagramPacket p)：此处传入的是一个空的对象，空的报文，receive方法内部会对参数的这个空对象进行内容填充，从而构造出数据。
send(DatagramPacket p): 将构造好的报文发送出去。
下面这里将写一个简单的回显客户端服务器，当然对于服务器来说，对于请求的处理，即业务逻辑的处理是最核心最复杂的，我们这里就回显设置，重点在于理解整个通信过程。
服务器端代码：
public class UdpEchoServer {
// 网络编程, 本质上是要操作网卡.
// 但是网卡在操作系统内核中，不方便直接操作，使用了"socket" 这样的文件来抽象表示网卡
// 因此进行网络通信, 必需要先有一个 socket 对象
private DatagramSocket socket = null;
// 对于服务器来说, 创建 socket 对象的同时, 要让它绑定上一个具体的端口号，服务器一定要关联上一个具体的端口
// 服务器在网络传输中才知道此时客户端的端口, 才能进行通信
public UdpEchoServer(int port) throws SocketException {
socket = new DatagramSocket(port);
}
public void start() throws IOException {
System.out.println("服务器启动！");
// 服务器不是只给一个客户端提供服务就完了，需要服务很多客户端，所以需要用到循环
while (true){
//1.读取客服端发来的请求
//receive方法的参数是一个输出型参数, 需要先构造好个空白的 DatagramPacket 对象，交给 receive 来进行填充
DatagramPacket requestPack = new DatagramPacket(new byte[4096],4096);
socket.receive(requestPack);
//把数据拿出来, 构造成一个字符串
String request = new String(requestPack.getData(),0,requestPack.getLength());
//2.根据请求计算响应，此时为回显服务器，所以写得比较简单，请求和响应相同
String response = process(request);
//3.把响应写回客户端
//send 的参数也是 DatagramPacket,也是需要把这个 Packet 对象构造好
//此处构造的响应对象, 不能是用空的字节数组构造了, 而是要使用响应数据来构造
DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,
requestPack.getSocketAddress());
socket.send(responsePacket);
//4.打印当前这次请求响应的处理结果
System.out.printf("[%s:%d] req: %s; resp: %s\n",requestPack.getAddress().toString(),
requestPack.getPort(),request,response);
}
}
private String process(String request) {
return request;
}
public static void main(String[] args) throws IOException {
UdpEchoServer server = new UdpEchoServer(9090);
server.start();
}
}
客户端代码：
public class UdpEchoClient {
private DatagramSocket socket = null;
private String serverIp = null;
private int serverPort = 0;
// 服务器 ip 和 端口 也需要告诉客户端. 才能顺利把消息发个服务器
public UdpEchoClient(String serverIp,int serverPort) throws SocketException {
socket = new DatagramSocket();
this.serverIp = serverIp;
this.serverPort = serverPort;
}
public void start() throws IOException {
System.out.println("客户端启动！");
Scanner scanner = new Scanner(System.in);
while (true){
//1.从控制台读取数据
System.out.print("=>:");
String request = scanner.next();
if (request.equals("exit")){
System.out.println("goodBye!");
break;
}
//2.构造UDP请求并发送
//构造这个 Packet 的时候, 需要把 serverIp 和 port 都传入过来，此处 IP 地址需要填写的是一个 32位的整数形式.
//上述的 IP 地址是一个字符串，需要使用 InetAddress.getByName 来进行一个转换
DatagramPacket requestPack = new DatagramPacket(request.getBytes(),request.getBytes().length,
InetAddress.getByName(serverIp),serverPort);
socket.send(requestPack);
//3.读取服务器的UDP响应并解析
DatagramPacket responsePack = new DatagramPacket(new byte[4096],4096);
socket.receive(responsePack);
String response = new String(responsePack.getData(),0,responsePack.getLength());
//4.打印解析的结果
System.out.println(response);
}
}
public static void main(String[] args) throws IOException {
UdpEchoClient client = new UdpEchoClient("127.0.0.1",9090);
client.start();
}
}
通信逻辑顺序图：
基于TCP实现客户端服务器的网络通信程序
TCP提供的API主要是两个类：
ServerSocket：专给服务器使用的Socket对象
Socket：既会给服务器使用，也会给客户端使用。
TCP的传输与UDP有所不同，它并不是以数据报为单位进行传输的，而是以字节的方式，流式传输。
// 使用这个 clientSocket 和具体的客户端进行交流
Socket clientSocket = serverSocket.accept();
accept的作用就是接受连接，客户端在构造Socket对象的时候就会指定服务器的IP和端口，如果没有客户端来连接，此时accept就会阻塞。只要任意一个客户端连接上来，服务器这边都会创建一个Socket对象，每次创建一个Socket对象，就要占用一个文件描述符表的一个位置，因此在使用完毕后要进行释放。前面我们写的UDP就不存在这个情况，一方面是因为UDP中的Socket对象的生命周期是跟随整个程序的，声明周期更长，另一方面是Socket数量不是很多。
一次连接只能处理一个客户端的请求，那么同时有非常多的客户端发出请求，也就是高并发，此时可以用多线程来解决，为了避免线程频繁的创建和销毁，也可以用线程池。
while (true){
// 使用这个 clientSocket 和具体的客户端进行交流
Socket clientSocket = serverSocket.accept();
//多线程版本
/* Thread t = new Thread(()->{
processConnection(clientSocket);
});
t.start();*/
//线程池版本
threadPool.submit(()->{
processConnection(clientSocket);
});
}但是对于特别量大的客户端，多线程和线程池也是不行的，可以多开服务器可以解决，但是毕竟成本高，还有一种方式就是IO多路复用。大概逻辑就是：给一个线程安排一个集合，这个集合里面放了一堆连接，这个线程就负责监听这个集合，哪一个连接有数据来了，这个线程就先处理哪个连接。IO多路复用本质上来说，就是充分利用等待的时间来做别的事情。
服务器端代码：
public class TcpEchoServer {
private ServerSocket serverSocket = null;
public TcpEchoServer(int port) throws IOException {
serverSocket = new ServerSocket(port);
}
public void start() throws IOException {
System.out.println("启动服务器！");
// 此处使用 CachedThreadPool, 使用 FixedThreadPool的时候线程数是固定的，不太合适
ExecutorService threadPool = Executors.newCachedThreadPool();
while (true){
// 使用这个 clientSocket 和具体的客户端进行交流
Socket clientSocket = serverSocket.accept();
//多线程版本
/* Thread t = new Thread(()->{
processConnection(clientSocket);
});
t.start();*/
//线程池版本
threadPool.submit(()->{
processConnection(clientSocket);
});
}
}
private void processConnection(Socket clientSocket) {
System.out.printf("[%s:%d]客户端上线！\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
// 基于上述 socket 对象和客户端进行通信
try (InputStream inputStream = clientSocket.getInputStream();
OutputStream outputStream = clientSocket.getOutputStream()){
// 由于要处理多个请求和响应, 也是使用循环来进行
while (true){
//1.读取请求
Scanner scanner =new Scanner(inputStream);
if (!scanner.hasNext()){
System.out.printf("[%s:%d]客户端下线！\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
break;
}
//此处使用 next 是一直读取到换行符/空格/其他空白符结束, 但是最终返回结果里不包含上述换行符/空格/其他空白符
String request = scanner.next();
//2.根据请求构造响应
String response = process(request);
//3.返回响应结果
PrintWriter printWriter = new PrintWriter(outputStream);
// 此处使用 println 来写入,让结果中带有一个 \n 换行. 方便对端来接收解析
printWriter.println(response);
// flush 用来刷新缓冲区, 保证当前写入的数据是真正发送出去了
printWriter.flush();
//4.打印当前这次请求响应的处理结果
System.out.printf("[%s:%d] req: %s; resp: %s\n",clientSocket.getInetAddress().toString(),
clientSocket.getPort(),request,response);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
clientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private String process(String request) {
return request;
}
public static void main(String[] args) throws IOException {
TcpEchoServer server = new TcpEchoServer(9090);
server.start();
}
}
客户端代码：
public class TcpEchoClient {
private Socket socket = null;
public TcpEchoClient(String serverIp,int serverPort) throws IOException {
socket = new Socket(serverIp,serverPort);
}
public void start(){
System.out.println("客户端启动！");
Scanner scanner = new Scanner(System.in);
try (InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream()){
while (true){
//1.从控制台读取数据
System.out.print("=>:");
String request = scanner.next();
if (request.equals("exit")){
System.out.println("goodBye!");
break;
}
//2.构造请求并发送
PrintWriter printWriter = new PrintWriter(outputStream);
printWriter.println(request);
printWriter.flush();
//3.读取服务器响应
Scanner respScanner = new Scanner(inputStream);
String response = respScanner.next();
//4.回显
System.out.println(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();
}
}总结
在上面代码中，关于有无连接，面向字节流和面向数据报，以及全双工都能在代码中体现。但是，在TCP中的可靠传输是在代码层面感知不到的。从TCP诞生的意义来说，就是为了解决可靠传输的问题的。关于TCP能够保证可靠传输问题 ，后面再来总结。
