本文就来学习一下 网络编程， 既然谈到了网络编程，那么要如何进行呢 ？

 
这里的核心就是 Socket API

 
Socket 就是操作系统，给应用程序，提供的网络编程 API

 
在上篇文章说过，在网络分层内传输层及其以下都是属于操作系统内核实现的，应用层是在应用程序内的，这里 socket api 就相当于 站在传输层的角度 与应用层进行交互的 （ 可以认为 socket api 是和 传输层密切相关的 ）。

 
回忆一下 ： 说过的传输层，是不是说过两个最核心的协议 UDP , TCP .

 
因此针对 传输层 中的 两种 核心的协议 ， socket 推出了两种风格 API , 也就是 UDP 版本的 和 TCP 版本的 。(其实这里还有第三种风格 unix 域套接字， 只不过没人使用了，知道了也没啥用 ，这里就过个眼熟) .

 
这里我们想要学习 UDP 和 TCP 两种风格的API ，那么就需要对 UDP 和 TCP 这两种协议 有个简单的认识 ， 所以下面就先来简单了解一下这两种协议

UDP 和 TCP 区别

 
这里先来看看 UDP 和 TCP 两种协议的 区别

 
UDP :

• 无连接
• 不可靠传输
• 面向数据报
• 全双工

 
TCP :

• 有连接
• 可靠传输
• 面向字节流
• 全双工

1. 有连接 VS 无连接

 
有连接 : 使用TCP 协议 ,需要连接成功才能够建立通信 ，连接建立需要对方来 接收 ，如果连接没建立好 ，通信不了. （简单来说就是 双方 需要数据传输的时候需要先建立联系，没有建立好就无法进行传输）.

 
好比 打电话 ：假设现在我要给女神打电话 ， 拨号口，等待女神接听 ，等听到女神的 喂 ， 就说明此时连接建立成功，可以进行交流了， 如果女神挂掉了，也会有对方正在繁忙的语音提示此时就说明没有连接建立成功，不能进行通话。

 
无连接 ： 双方无需建立建立，直接发送消息 。

 
好比 ： 发微信 发 qq 等 ， 假设我 给女神发送早安 ， 女神可能看到了也可能没看到，或者看到了但是不想回我们 。此时我们并不能知道了 女神 看没看到消息 ，这种情况就是 无连接 ，

 
总的来说 ：TCP 就是要求双发先建立连接，连接好了，才能进行传数据。 而 UDP，直接传输数据，不需要双方建立连接。

2. 可靠传输 VS 不可靠传输

 
可靠传输 ： 发送方知道 接收方 有没有接收到数据

 
注意 ： 网络环境天然是复杂的 ， 不可能保证传输的数据 100% 就能到达 ， 比如说 拔网线 ，即便我们厉害 也不顶用。

 
所以可靠传输 ， 传输的数据并不是百分百就能够成功的， 关键是看这里是否能 **感知 **到 传输的数据是否成功到达。

 
这里打电话就是可靠传输 ： 比如说我们打电话，对方接听了， 我们说了一大堆事情，对方是否听到了我们是可以知道的，比如对方一直没有回应，我们就可以问一句，你听到了吗， 对方回应，此时我们就能够知道对方听到了 。

 
不可靠传输 ： 发送方不知道接收方有没有接收到数据

 
这里的不可靠传输，同样于发微信或发qq消息 一样

 
还是发消息给女神，想要邀请女神来吃麻辣烫 ，假设将消息发送出去，
 
对方可以能不在线，此时无法看到消息，
 
对方可能太忙 (毕竟是女神吗，咋可能就一条舔狗呢) 。
 
对方看见了 但是不回你 (你都是舔狗 ，那不就是可有可无的吗 ，人家不会挺正常)
 
对方看见了 ， 并接收了你的邀请消息没有发送成功 等

 
此时不管是那种情况，我们都无法知道 ，此时就相当于不可靠传输.

 
另外 : 有些软件，比如抖音 ，聊天有已读功能，此时发送消息，是能够知道对方是否接收到了 (看到了显示已读 ) 这种已读功能的就相当于可靠传输， QQ 微信 就没有这种已读功能， 就可以认为是不可靠传输 。

 
注意 ： 可不可靠，和有没有连接没有任何关系

 
总的来说 ： 你发送的消息 ， 对方是否看的到 自己是知道的 心里有底对方看到了 ，那么就是 可靠的， 心里没底 , 不知道对方是否收到 那么就是不可靠的

3. 面向字节流 VS 面向数据报

 
面向字节流 ： 数据传输就和 文件读写二 类似 “流式” 的

 
还记得 文件 IO 那片 吗， 这里的流 其实就是一种比喻的 说法，我们的数据可以 分多次发送

比如 ： 发送 100 个字节的数据

可以采用 一次 传 100个字节， 一次 传 10 个字节 分 10次 ，一次传1个字节 分 100次 … 这里是不是就像水流一样。

 
面向数据报 ： 数据传输 以 一个一个的 数据报 为基本单位 (一个数据报可能是诺干个字节，带有一定的格式 )

4. 全双工

 
全双工 ： 一个通信通道，可以双向传输 (既可以发送，也可以接收)

 
图示 ： 半双工 （了解即可）

 
简单了解完，UDP 和 TCP 的区别之后，下面 就来学习一下 ，两种风格的 Socket API 的使用 。

 
这里更详细的 UDP 和 TCP 协议 ，在后面的文章种会说到 ，不急 ，本主要还是对于 Socket 的使用.

UDP 数据报套接字编程

 
这里我们就基于 UDP 来编写一个简单的客户端服务器的网络通信程序

 
想要实现这个， 先来学习一下两个类 .

 
图示 ：

 
1.DatagramSocket

 
DatagramSocket 是 UDP Socket，用于发送和接收UDP数据报。

 
DatagramSocket 构造方法：

 
DatagramSocket 方法：

 
2.DatagramPacket

 
DatagramPacket 是 UDP Socket 发送和接收的数据报。
 
DatagramPacket 构造方法：

 
DatagramPacket 方法：

 
有了对这些方法的认识，就可以 写一个最简单的 UDP 版本的 客户端服务器程序 回显服务器 echo server 。

 
一个普通的服务器 ： 收到请求， 更具请求计算响应 ， 返回响应。

 
这里 就好比 去小馆子里 吃个炒粉， 我们向店长说来份炒粉，店长听到了 ，就将这个请求告诉了厨师 ，厨师接收到了请求，就去炒粉(更具请求计算出响应) ,然后将炒出来的粉 交给我们 (返回响应) .

 
这里我们的回显服务器 (echo server) 会省略其中的 “根据计算计算响应” 这个步骤， 相当于 请求是啥，就返回啥 （当前这个代码没有实际的业务， 这个代码也没啥太大作用 和意义 ，只是展示了 socket api 基础用法）.作为一个真正的服务器， 一定是"根据请求计算响应 " 这个环节是最最重要的 ， 这里的 根据请求计算响应 其实就相当于业务逻辑。

 
下面就来编写代码 ：

 
图一 ：

 
图二 ：

 
图三 ：

 
图四 ：补充一点小细节

 
到此 UDP 服务器 就写完了

 
附上 ： UDP 服务器代码 ，注意这里最后加了一个启动服务器的 main 方法

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;// UDP 版本的回显服务器
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 requestPacket = new DatagramPacket(new byte[4096], 4096);socket.receive(requestPacket);// 此时这个 DatagramPacket 是一个特殊的对象，并不方便直接进行处理，可以把这里包含的数据拿出来， 构造成一个字符串String request = new String(requestPacket.getData(), 0, requestPacket.getLength());// 2. 根据请求计算响应 , 由于此时是一个回显服务器, 响应和请求相同String response = process(request);// 3.把响应写回到客户端  , send 的参数也是 DatagramPacket ，需要把这个 Packet 对象构造好// 此处构造的响应对象,不能是用空的字节数组构造了,而是要使用响应数据 (response字符)DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), response.getBytes().length,requestPacket.getSocketAddress());// 将 计算出来的响应发送给客户端socket.send(responsePacket);// 4. 打印一下 ,当前这次请求响应的处理中间结果System.out.printf("[%s : %d] request : %s; response: %s\n" ,requestPacket.getAddress().toString(),requestPacket.getPort(),request,response);}}// 这个方法就表示 "根据请求计算响应"public String process(String request) {return request;}public static void main(String[] args) throws IOException {// 端口号的在指定,可以随便指定// 1024 -> 65535 这个范围内 随便挑一个数组即可  , 后面会说为啥 在这个范围内UdpEchoServer server = new UdpEchoServer(9090);server.start();}}

 
其实上面这个服务器的代码并不太复杂核心代码也就那么几行 ， 这里我们的主要任务 就是 理解服务器的工作流程。
 
1.读取请求并解析
 
2.根据请求计算响应
 
3.构造响应并写回给客户端 .

 
下面就来写 客户端代码

 
图一 ：

 
图二 ：

 
图三 ：

 
附上客户端代码 ：

import java.io.IOException;
import java.net.*;
import java.util.Scanner;// UDP 版本的 回显客户端
public class UdpEchoClient {// 同样需要先创建一个 socket对象 , 来操作网卡private DatagramSocket socket = null;// 服务器 的 IP 地址private String serverIp;// 服务器 的 端口号private Integer serverPort;// 一次通信 ，需要由两个 ip ， 两个端口// 客户端的 ip 是 127.0.0.1 已知.// 客户端的 port 是系统自动分配的// 服务器 ip 和 端口 也需要告诉客户端 , 才能顺利把消息发给服务器.public UdpEchoClient(String serverIp, Integer serverPort) throws SocketException {socket = new DatagramSocket();//这里需要 给 服务器的 ip 地址 和 端口号 ，相当于 买家了商品 ，需要提供 地址和电话 , 如果没有卖家咋发货呢?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.println("-> ");String request = scanner.next();if (request.equals("exit")) {System.out.println("goodbye");break;}//        2. 构造成 UDP 请求，并发送.// 构造这个 Packet 的时候 ,需要把 serverIp 和 port 都传入过来， 但是此处 IP 地址需要填写一个 32位的整数形式// 上述的 IP 地址是一个字符串 ， 需要使用 InetAddress.getByName 来进行一个转换 .DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,InetAddress.getByName(serverIp), serverPort);// 构造好了请求发送socket.send(requestPacket);//        3. 读取服务器的 UDP 响应，并解析.DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);socket.receive(responsePacket);String response = new String(responsePacket.getData(), 0, responsePacket.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();}}

 
下面来执行一下 看看下效果 ：

 
可以看到我们的客户端和服务器程序 ，是在我们自己的电脑上运行的， 而实际上，网络存在的意义，是跨主机通信.

 
那么我们的层序是否可以做到 跨主机通信的呢？

 
这里是可以的， 只不过需要外网 IP ，这里可以将服务器的代码 上传到 云服务器上，让后修改 客户端的 ServerIp 改为云服务器的， 就能够进行跨主机通信的。

 
这里就不演示了 ，比较麻烦 . 后面我们学习了 Linux ， 购买了云服务器可以自己尝试一下.

 
下面继续 ， 这里我们写的是回显服务器，缺少业务逻辑，这里就可以在上述代码的基础上稍作调正，实现一个 “查词典” 的服务器. （根据英文单词 ， 翻译成中文解释）

 
附上代码 ： 因为大部分代码是一样的 ，这里就可以通过继承来 ，重写 process 方法 ， 来书写逻辑即可 .

// 对于 DictServer 来说 和 EchoServer 相比，大部分的东西都是一样的// 主要是 "根据请求计算响应" 这个步骤不太一样 .import java.io.IOException;
import java.net.SocketException;
import java.util.HashMap;
import java.util.Map;public class UdpDictServer extends UdpEchoServer {private Map<String, String> dict = new HashMap<>();public UdpDictServer(int port) throws SocketException {super(port);// 给这个 dict 设置内容dict.put("cat", "小猫");dict.put("dog", "小狗");dict.put("error", "错误");// 当然，这里可以无限多的设置键值对. .}@Overridepublic String process(String request) {// 重写我们的 process 方法， 添加逻辑即可// 查词典的过程return dict.getOrDefault(request, "当前单词没有查询到结果!");}public static void main(String[] args) throws IOException {UdpDictServer server = new UdpDictServer(9090);server.start();}
}

 
这里关于上面这个程序还有一个小知识点 这里来补充一下 ,

针对上述的层序，来看看端口冲突 是啥效果 .

这里一个端口只能被一个进程使用 ，如果由多个使用，就不行。
 
这里具体来看一下咋样个不行法 。

 
这里 UDP socket api 使用就到这里 ，下满来 看看 TCP 的 socket api 的使用 .

TCP 数据报套接字编程

 
关于 TCP socket api 的这个 API ， 难易程度 ，可以取决于你之前学习 IO 章节的掌握程度， 如果比较熟悉那么就容易， 如果不太熟悉或没学过，那么就可能有点困难.

 
这里就不多说了，下面就来愉快的学习一下 TCP 的 socket api 。

 
同样的这里 与 UDP 一样涉及到两个类

 
图示 ：

 
ServerSocket API

 
ServerSocket 是创建TCP服务端Socket的API

ServerSocket 构造方法

 
ServerSocket 方法

 
Socket API

Socket 是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端 Socket。

不管是客户端还是服务端Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。

 
Socket 构造方法

 
Socket 方法

 
看完这些 类和方法， 下面通过 写一个 TCP 版本的 回显服务器来 熟悉他们.

 
图一 ：

 
图二 ：

 
附上代码 ：

package T_J4.T_1_23;import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;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("启动服务器");while (true) {// TCP 是有连接的， 因此不能一上来就读取数据, 需要先建立连接// 使用这个 clientSocket 和 具体的客户端进行交流 (建立连接).Socket clientSocket = serverSocket.accept();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. 返回响应结果
//                outputStream 没有 write String 这样的功能 , 可以把 String 里的字节数组拿出来,进行 写入 .// 也可以用字符流来转换一下PrintWriter printWriter = new PrintWriter(outputStream);printWriter.println(response); // 此处使用println 让结果中带有 \n 换行. 方便 对端来接受解析printWriter.flush(); // flush 用来刷新缓冲区 , 保证当前写入的数据, 确实是发送出去了System.out.printf("[%s : %d] request : %s , response %s \n", clientSocket.getInetAddress().toString(), clientSocket.getPort(),request, response);}} catch (IOException e) {e.printStackTrace();} finally {// finally 中的代码一定会被执行，所以 close 放在这里更加合适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();}
}

 
这里 TCP版本的服务器写完了，下面来写 TCP 版本的客户端.

 
图一 ：

 
图二 ：

 
最后加上 main 方法 来启动 客户端 。

 
附上代码 ：

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;public class TcpEchoClient {private Socket socket = null;public TcpEchoClient(String serverIp, int serverPort) throws IOException {// Socket 构造方法 , 能够识别 点分十进制格式的 IP 地址 . 比 DatagramPacket 更方便 .// new 这个对象的同时 ， 就会 进入 TCP 的连接操作.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.printf("> ");String request = scanner.next();if (request.equals("exit")) {System.out.println("goodbye");break;}// 2. 把读到的内容构造成请求,发送给服务器PrintWriter printWriter = new PrintWriter(outputStream);printWriter.println(request);// 此处加上一个 flush 保证数据确实发送出去了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 的短链接 和 长连接

 
另外 ： 这里虽然使用了线程池，但是还不够

 
如果 客户端非常多，而且客户端连接迟迟不肯断开，就会导致我们的机器上有很多线程 . （我们使用的线程池是自增的，觉得需要线程了就会自己创建） .

 
按照上面这种迟迟不肯断开的情况下 ， 如果一个服务器 有几千个客户端，就的是几千个线程，如果是几万个客户端 , 就会有几万个线程 。

 
此时这种情况就会对我们的机器产生很大的负担 。

 
那么如何确解决这个问题呢 ？

 
方法一 ： 采用多开服务器 ，但是多开服务器意味着成本的增加 ， 得多加钱，明显是不好的选择 。

 
方法二　： 使用 IO 多路复用 (IO 多路转接)

 
关于这里的问题 ，其实就是 单机(单个服务器)如何支持更大量客户端的问题 , 这个问题 也可以称为 C 10M 问题.

 
C 10k 问题 ： 单机处理 1w个客户端 , 这里 1w 个 ，我们通过 一些方法 ，还是能够解决的 。

C 10M 问题 ： 但其处理 1Kw个 客户端 ，这里 不是说单机真的能处理 1kw 个 客户端，只是表达说 客户端比 C 10k 这里多很多 。

 
出现 C 10M 问题 的本质 就是 机器 承担不了 这么线程的开销 (每个线程处理一个客户端) ,

 
好比 你开了一家公司 ， 你的公司 需要服务很多客户 ，然而你给每个客户都有一个专属的客服 ， 因为你雇佣了很多客服 ，导致 月底了 你发不出工资 ，此时 你的公司自然就宣布 破产了。 。

 
这里解决办法很容易 ，不用雇佣那么多客服，而每名客服对接多名用户即可 ，这样就大大的减少了 客服人员 。

 
放在我们这里也是同理 ，我们想要一个线程处理多个客户端 连接，就可以采取 IO 多路复用 (IO 多路转接) , 别觉得这个东西很高大上，其实再生活中都接触过 。

 
比如说 ： 买饭 ， 假设 你 想吃 杂粮煎饼 ， 你的弟弟想吃 牛肉面 ， 你的 妹妹 想吃 肉夹馍 。

 
此时就有两种做法 ：
 
1.采用单线程的方式 ， 你作为老大 ，一个人去买 ，先去买你吃的 杂粮煎饼 ，然后去帮妹妹买 肉夹馍，最后卖牛肉面 .
 
2.采用多线程的方式 , 你说 要吃自己去买 ，然后就各买各的 。
 
3.还是采用单线程的方式 ， 还是你去买饭 ，但是这次不同了，你来到 卖杂粮煎饼的摊子前 ，说老板给我来份杂粮煎饼 ，等会做好了我来那，然后你就跑到肉夹馍的摊子 如法炮制， 最后来到了 牛肉面的摊子 ，点了份牛肉面，此时那个好了就去拿那个 。

 
这三种方式 ， 明显是第三种更好 ，我们的IO 复用就是这种操作 ， 虽然是单线程 ，但是充分的利用了等待时间，再等待的过程中做其他事情。

 
这里我们IO 过程中 ，并不会一直持续的 ，IO过程也会有等待， 所以 IO 多路复用就抓住了这一点， 将这个等待时间充分利用起来， 做别的事情 .

 
知道了 IO 复用是啥 ，那么来处理 C 10M问题 。

 
思路 ： 这里就可以 给线程安排个集合 ，这个集合就放了一堆连接 ，线程就负责监听这个集合，那个连接有数据来了 ， 线程就来处理那个连接 … 这个其实就应用了一个事实 ， 虽然连接很多 ，但是这些连接的请求并非严格意义上的同时，总还是有先有后的 。

 
解决 ：多路复用 在操作系统里 ，提供了一些原生 API select , poll , epoll , 在 java 提供了一组 NIO 类 就封装了上述多路复用的 API ， 我们就可以使用这个 类来解决问题

 
这里 思路 大于 API 的使用 ， 这里就不继续下去了 ，如果感兴趣 可以自己去看看这个 NIO 类 .

 
到此 本文结束 ， 下文预告 网络原理 。