网络编程

程序员主要操作应用层和传输层来实现网络编程
也就是自己写一个程序，让这个程序可以使用网络来通信
这个程序属于应用层，实现通讯就需要获取到传输层提供的服务
这就需要使用传输层提供的api
在这里插入图片描述

UDP：无连接，不可靠传输，面向数据报，全双工
TCP:有连接，可靠传输，面向字节流，全双工

连接（Connection）

这里的连接是个抽象的概念
比如两个人领证了才算结婚，这时候就相当于把两个人连接起来了，但是这个连接不是拿绳子拴着，是通过过结婚证那个小本本来把两个人连接起来的（一对一）
客户端和服务器之间，使用这个小本本（内存）保存对应的端口号的信息，双方都保存了这个信息，此时“连接”就出现了
这里最大的区别在于，一个客户可以连接多个服务器，一个服务器也可以多对应多个客户（多对多）（比如一个人可以去多个餐馆买今天的晚饭，一个餐馆也可以接待多个客人）

可靠传输

可靠传输不是说的是 A给B发的消息百分百能到，而是
A尽可能的把消息传给B，并且在传输失败的时候，A能感知到，或者在传输成功的时候，也能知道自己传输成功了
有舍才有得，既然TCP是可靠传输，那么它的传输效率就降低了

有人会问了，既然TCP是可靠传输，UDP是不可靠的，那么TCP是不是比UDP安全呢？
当然不是！！！可靠不等于安全！！！
“网络安全”指的是你传输的数据是否容易被黑客截获，以及如果截获后是否会泄露一些重要信息

面向字节流和面向数据报

TCP是面向字节流，它的字节流和文件操作类似，都是“流”式的（由于这里传输的单位是字节，所以称为字节流）
跟水流一样，假如通过tcp读写100字节的数据，可以一次读写100字节，也可以一次读写50字节，分两次，还可以一次读写10字节，分10次
UDP是面向数据报，UDP读写的基本单位，是一个UDP数据报，这个数据报包含了一系列的数据和属性

全双工和半双工

全双工，一个通道，可以双向通信
半双工，一个通道，只能单向通信
网线就是全双工呢，一根网线包含八根铜缆，44一组，一组里面有的负责这个方向，有的负责那个方向

网络编程基础

为什么需要网络编程？

用户在浏览器中，打开在线视频网站，如优酷看视频，实质是通过网络，获取到网络上的一个视频资源。
与本地打开视频文件类似，只是视频文件这个资源的来源是网络。相比本地资源来说，网络提供了更为丰富的网络资源
所谓的网络资源，其实就是在网络中可以获取的各种数据资源。
而所有的网络资源，都是通过网络编程来进行数据传输的。

什么是网络编程？

网络编程，指网络上的主机，通过不同的进程，以编程的方式实现网络通信（或称为网络数据传输）。
当然，我们只要满足进程不同就行；所以即便是同一个主机，只要是不同进程，基于网络来传输数据，
也属于网络编程。特殊的，对于开发来说，在条件有限的情况下，一般也都是在一个主机中运行多个进程来完成网络编程。
但是，我们一定要明确，我们的目的是提供网络上不同主机，基于网络来传输数据资源：
进程A：编程来获取网络资源
进程B：编程来提供网络资源

网络编程中的基本概念

发送端和接收端

在一次网络数据传输时：
发送端：数据的发送方进程，称为发送端。发送端主机即网络通信中的源主机。
接收端：数据的接收方进程，称为接收端。接收端主机即网络通信中的目的主机。
收发端：发送端和接收端两端，也简称为收发端。
注意：发送端和接收端只是相对的，只是一次网络数据传输产生数据流向后的概念。

请求和响应

一般来说，获取一个网络资源，涉及到两次网络数据传输：
第一次：请求数据的发送
第二次：响应数据的发送。
好比在快餐店点一份炒饭：
先要发起请求：点一份炒饭，有快餐店提供的对应响应：提供一份炒饭

服务端和客户端

服务端：在常见的网络数据传输场景下，把提供服务的一方进程，称为服务端，可以提供对外服务。
客户端：获取服务的一方进程，称为客户端。
好比在银行办事：
银行提供存款服务：用户（客户端）保存资源（现金）在银行（服务端）
银行提供取款服务：用户（客户端）获取服务端资源（银行替用户保管的现金）

常见的客户端服务端模型

最常见的场景，客户端是指给用户使用的程序，服务端是提供用户服务的程序：

客户端先发送请求到服务端
服务端根据请求数据，执行相应的业务处理
服务端返回响应：发送业务处理结果
客户端根据响应数据，展示处理结果（展示获取的资源，或提示保存资源的处理结果）

Socket套接字

概念

Socket套接字，是由系统提供用于网络通信的技术，是基于TCP/IP协议的网络通信的基本操作单元。基于Socket套接字的网络程序开发就是网络编程

分类

Socket套接字主要针对传输层协议划分为如下三类
流套接字：使用传输层TCP协议TCP，即Transmission Control Protocol（传输控制协议），传输层协议
数据报套接字：使用传输层UDP协议UDP，即User Datagram Protocol（用户数据报协议），传输层协议
原始套接字：原始套接字用于自定义传输层协议，用于读写内核没有处理的IP协议数据。
我们不学习原始套接字，简单了解即可。

UDP数据报套接字编程

DatagramSocket API

这个类是一个Socket对象
操作系统使用文件这样的概念来管理一些软硬件资源，同样的操作系统也是用文件的方式来管理网卡的，表示网卡这类的文件称为Socket文件。（假如你把键盘插入到电脑上，操作系统也认为是一个键盘文件）
java中Socket对象来表示系统的Socket文件，系统的Socket文件来表示网卡，最终还是要落到网卡身上，毕竟进行网络通信，绕不开网卡这样的设备
因此要想进行网络通信，必须要有Socket对象，Socket对象关联Socket文件，Socket文件关联网卡，最终通过网卡来使我们实现网络通讯，来实现发送数据和接收数据
在这里插入图片描述

客户端使用系统分配的端口号原因可能是客户端像发送程序2的请求，但是如果你想手动指定一个18号端口，可能这个端口会被程序1占着呢
对于服务器来说，手动设定一个固定窗口，方便其他客户找到
举个例子
我在学校食堂的18号档口开了一家小吃店
18号端口，这个18号端口就相当于服务器的端口号
这时候同学们看到我的传单，来我这里吃饭了，我给同学们做好了一份饭，他们都会去找一个位置，这个位置就相当于客户端的端口号，而第二次来的时候，这个位置可能就不会再坐了，可能就被别人站着了，这个时候只能再随机坐一个位置，同学们需要根据实际情况，找一个空闲的位置，因此客户端的端口号就不能是固定值
一个客户端的主机，上面运行的程序很多，谁知道你手动指定的端口是不是被别的程序占用了，让系统自动分配一个端口是更明智的选择
而服务器是完全在程序员手里控制的，程序员可以把服务器上的多个程序安排好，让他们使用不同的端口

在这里插入图片描述
receive相当于读，send相当于写

DatagramPacket API

这个类表示了一个UDP数据报，代表了系统中设定的UDP数据报的二进制结构
在这里插入图片描述

构造UDP发送的数据报时，需要传入SocketAddress ，该对象可以使用 InetSocketAddress 来创建。

在这里插入图片描述

回显服务器（echo server）

回显服务器是一个最简单的服务器，也就是客户端发啥，服务器返回啥

服务器代码

// UDP 的 回显服务器.
// 客户端发的请求是啥, 服务器返回的响应就是啥.
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;// UDP 的 回显服务器.
// 客户端发的请求是啥, 服务器返回的响应就是啥.
public class UdpEchoServer
{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以用来接收数据报，接收的数据保存在字节数组中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. 把响应写回给客户端//    此时需要告知网卡, 要发的内容是啥, 要发给谁.DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), response.getBytes().length,requestPacket.getSocketAddress());//response.getBytes().length单位是字节，而response.length单位是字符，因此不能用response.lengthsocket.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 server = new UdpEchoServer(1800);server.start();}
}

在这里插入图片描述

客户端代码

import java.io.IOException;
import java.net.*;
import java.util.Scanner;public class UdpEchoClient 
{private DatagramSocket socket = null;private String serverIp;private int serverPort;// 服务器的 ip 和 服务器的端口.public UdpEchoClient(String ip, int port) throws SocketException {serverIp = ip;serverPort = port;// 这个 new 操作, 就不再指定端口了. 让系统自动分配一个空闲端口.socket = new DatagramSocket();}// 让这个客户端反复的从控制台读取用户输入的内容. 把这个内容构造成 UDP 请求, 发给服务器. 再读取服务器返回的 UDP 响应// 最终再显示在客户端的屏幕上.public void start() throws IOException {Scanner scanner = new Scanner(System.in);System.out.println("客户端启动!");while (true) {// 1. 从控制台读取用户输入的内容System.out.print("-> "); // 命令提示符, 提示用户要输入字符串.String request = scanner.next();// 2. 构造请求对象, 并发给服务器.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);String response = new String(responsePacket.getData(), 0, responsePacket.getLength());// 4. 显示到屏幕上.System.out.println(response);}}public static void main(String[] args) throws IOException {//发送到127.0.0.1的数据或者从127.0.0.1返回的数据只会在本机进行传输, 而不进行外部网络传输UdpEchoClient client = new UdpEchoClient("127.0.0.1", 9090);client.start();}
}

在这里插入图片描述

翻译服务器

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.put("cat", "小猫");dict.put("dog", "小狗");dict.put("fuck", "卧槽");// 可以在这里继续添加千千万万个单词. 使每个单词都有一个对应的翻译.}// 是要复用之前的代码, 但是又要做出调整.@Overridepublic String process(String request){// 把请求对应单词的翻译, 给返回回去.return dict.getOrDefault(request, "该词没有查询到!");}public static void main(String[] args) throws IOException{UdpDictServer server = new UdpDictServer(9090);// start 不需要重新再写一遍了. 直接就复用了之前的 start !server.start();}
}

TCP流套接字编程

tcp是面向字节流的，是一个字节一个字节进行传输的，一个tcp数据报，就是一个字节数组（byte[]），因此并不像udp一样，需要一个特定的类来代表tcp字节流

ServerSocket API

给服务器用的
ServerSocket 是创建TCP服务端Socket的API。
构造方法
在这里插入图片描述
方法

Socket API

服务器和客户端都可以用
Socket 是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
不管是客户端还是服务端Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。
在这里插入图片描述

回调服务器

服务器代码

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;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class TcpEchoServer 
{private ServerSocket serverSocket = null;// 此处不应该创建固定线程数目的线程池.private ExecutorService service = Executors.newCachedThreadPool();// 这个操作就会绑定端口号public TcpEchoServer(int port) throws IOException {serverSocket = new ServerSocket(port);}// 启动服务器public void start() throws IOException {System.out.println("服务器启动!");while (true) {//执行到accept就已经在操作系统内核中建立好连接了// 这个写法, 是能自动关闭, 也行. 实现 Closeable 接口就可以这么写.// 这么写会有其他问题. (结合后面讲第二个问题, 再说这个事)Socket clientSocket = serverSocket.accept();// 单个线程, 不太方便完成这里的一边拉客, 一边介绍. 就需要多搞线程. 主线程专门负责拉客. 每次有一个客户端, 都创建一个新的线程去服务
//            Thread t = new Thread(() -> {
//                processConnection(clientSocket);
//            });
//            t.start();// 使用线程池, 来解决上述问题service.submit(new Runnable() {@Overridepublic void run() {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 scanner = new Scanner(inputStream);if (!scanner.hasNext()) {// 读取完毕, 客户端下线.System.out.printf("[%s:%d] 客户端下线!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());break;}// 这个代码暗含一个约定, 客户端发过来的请求, 得是文本数据, 同时, 还得带有空白符作为分割. (比如换行这种)String request = scanner.next();// 2. 根据请求计算响应String response = process(request);// 3. 把响应写回给客户端. 把 OutputStream 使用 PrinterWriter 包裹一下, 方便进行发数据.PrintWriter writer = new PrintWriter(outputStream);//    使用 PrintWriter 的 println 方法, 把响应返回给客户端.//    此处用 println, 而不是 print 就是为了在结尾加上 \n . 方便客户端读取响应, 使用 scanner.next 读取.writer.println(response);//    这里还需要加一个 "刷新缓冲区" 操作.writer.flush();// 日志, 打印当前的请求详情.System.out.printf("[%s:%d] req: %s, resp: %s\n", clientSocket.getInetAddress().toString(), clientSocket.getPort(),request, response);}} catch (IOException e) {e.printStackTrace();} finally {// 在 finally 中加上 close 操作, 确保当前 socket 被及时关闭!!try {clientSocket.close();} catch (IOException e) {e.printStackTrace();}}}public String process(String request) {return request;}public static void main(String[] args) throws IOException {TcpEchoServer server = new TcpEchoServer(9090);server.start();}
}

在这里插入图片描述

客户端代码

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 {// 这个 new 操作完成之后, 就完成了 tcp 连接的建立.socket = new Socket(serverIp, serverPort);}public void start() {System.out.println("客户端启动");Scanner scannerConsole = new Scanner(System.in);try (InputStream inputStream = socket.getInputStream();OutputStream outputStream = socket.getOutputStream()) {while (true) {// 1. 从控制台输入字符串.System.out.print("-> ");String request = scannerConsole.next();// 2. 把请求发送给服务器PrintWriter printWriter = new PrintWriter(outputStream);//    使用 println 带上换行. 后续服务器读取请求, 就可以使用 scanner.next 来获取了printWriter.println(request);//    不要忘记 flush, 确保数据是真的发送出去了!!printWriter.flush();// 3. 从服务器读取响应.Scanner scannerNetwork = new Scanner(inputStream);String response = scannerNetwork.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();}
}