网络编程基础

网络资源

网络资源，其实就是在网络中可以获取的各种数据资源。
而所有的网络资源，都是通过网络编程来进行数据传输的。

网络编程

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

• 进程A：编程来获取网络资源
• 进程B：编程来提供网络资源

网络编程中的基本概念

发送端和接收端

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

请求和响应

一般来说，获取一个网络资源，涉及到两次网络数据传输：

• 第一次：请求数据的发送
• 第二次：响应数据的发送。

客户端和服务端

服务端：在常见的网络数据传输场景下，把提供服务的一方进程，称为服务端，可以提供对外服务。
客户端：获取服务的一方进程，称为客户端。

对于服务来说，一般是提供：

• 客户端获取服务资源
• 客户端保存资源在服务端

常见的客户端服务端模型

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

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

Socket套接字

网络编程中的核心就是Socket（套接字） API，这是操作系统给应用程序提供的网络编程API。
socket api是和传输层密切相关的。
传输层里提供了两个最核心的协议。UDP和TCP。

因此，socket api也提供了两种风格UDP TCP

了解UDP和TCP

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

有无连接：

打电话就是有连接的没需要连接建立了才能通信，连接建立需要对方来“接受”。如果连接没建立好，就无法通信。
发短信/发微信就是无连接的，直接发送即可。

可靠不可靠传输：

网络环境是复杂的，不可能保证传输的数据百分百就能到达。
可靠传输：发送发能知道自己的消息是不是发过去了，还是丢了。比如抖音的已读功能。打电话功能。
不可靠传输：发短信/发微信。（QQ或者微信等没有已读功能的）

面向数据报/字节流：

面向字节流：数据传输就和文件读写类似“流式”的。
面向数据报：数据则以一个个的“数据报”为基本单位（一个数据报可能是若干字节）

全/半双工：

全双工：一个通信通道，可以双向传输。（既可以发送也可以接收）
半双工：比如一跟水管，是单向传输的，是半双工。

UDP数据报套接字编程

DatagramSocket API

DatagramSocket使用这个类，表示一个Socket对象，把这个socket对象也是当成一个文件来处理的。相当于是文件描述表上的一项。

普通的文件对应的硬件设备是硬盘。
socket文件，对应的硬件设备是网卡。

DatagramSocket 是UDP Socket，用于发送和接收UDP数据报。
DatagramSocket 构造方法：

方法签名	方法说明
DatagramSocket()	创建一个UDP数据报套接字的Socket，绑定到本机任意一个随机端口（一般用于客户端)
DatagramSocket(intport)	创建一个UDP数据报套接字的Socket，绑定到本机指定的端口（一般用于服务端）

注意：DatagramSocket()中没有指定端口时，系统则会自动分配一个空闲的端口。
DatagramSocket(intport)这个版本是要传入一个端口号，此时就是让当前的socket对象和这个指定的端口之间关联起来.

DatagramSocket 方法：

方法签名	方法说明
void receive(DatagramPacket p)	从此套接字接收数据报（如果没有接收到数据报，该方法会阻塞等待）
void send(DatagramPacketp)	从此套接字发送数据报包（不会阻塞等待，直接发送）
void close()	关闭此数据报套接字

注意：receive(DatagramPacket p)此处传入的相当于是一个空的对象。recive方法内部，会对参数的这个空对象进行内容填充。从而构造出数据结果。参数也是一个“输出型参数”。
close()使用完后释放资源。

DatagramPacket API

DatagramPacket 表示UDP中传输的一个报文，构造这个对象，可以指定一些具体的数据进去。

DatagramPacket 构造方法：

方法签名	方法说明
DatagramPacket(byte[] buf, int length)	构造一个DatagramPacket以用来接收数据报，接收的数据保存在字节数组（第一个参数buf）中，接收指定长度（第二个参数length）
DatagramPacket(byte[] buf, int offset, int length, SocketAddress address)	构造一个DatagramPacket以用来发送数据报，发送的数据为字节数组（第一个参数buf）中，从0到指定长度（第二个参数length）。address指定目的主机的IP和端口

注意：DatagramPacket(byte[] buf, int length)是把buf缓冲区设置进去了
DatagramPacket(byte[] buf, int offset, int length(构造缓冲区+地址), SocketAddress address(使用此类表示IP+port))

DatagramPacket 方法：

方法签名	方法说明
InetAddress()/getAddress()	从接收的数据报中，获取发送端主机IP地址；或从发送的数据报中，获取接收端主机IP地址
int getPort()	从接收的数据报中，获取发送端主机的端口号；或从发送的数据报中，获取接收端主机端口号
byte[] getData()	获取数据报中的数据

InetSocketAddress API

InetSocketAddress （ SocketAddress 的子类 ）构造方法：

方法签名	方法说明
InetSocketAddress(InetAddress addr, int port)	创建一个Socket地址，包含IP地址和端口号

UDP版本的客户端服务器程序

此处的服务器是 回显服务器
一个普通的服务器：收到请求，根据请求计算响应，返回响应
回显服务器echo server:省略了其中还的“根据请求计算响应”，请求是什么，就返回什么。
作为一个真正的服务器，最重要的环节就是“根据请求计算响应”。

接下来我们实现一个UDP 版本的回显服务器

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

//UDP版本的回显服务器
public class UdpEchoServe {
    //网络编程，本质上是操作网卡
    //但是网卡不方便直接操作，在操作系统内核中，使用了一种特殊的叫做“socket”这样的文件来抽象表示网卡。
    //因此进行网络传输中，必须首先要有一个socket对象
    private DatagramSocket socket = null;

    //对于服务器来说，创建socket对象的同时，要让他绑定上一个端口号
    //服务器一定要关联上一个具体的端口号！
    //服务器是网络传输中，被动的一方，如果是操作系统随机分配端口，此时客户端就不知道这个端口时什么了，也就无法进行通信了
    public UdpEchoServe(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);
            //(receive内部会针对参数对象填充数据，填充的数据来自于网卡)
            socket.receive(requestPacket);

            //此时这个DatagramPacket是一个特殊的对象，并不方便直接进行处理，可以把这里包含的数据拿出来，构造成一个字符串。
            String request = new String(requestPacket.getData(),0, requestPacket.getLength());

            //2.根据请求计算响应
            String response = process(request);

            //3.把响应写回到客户端，send的参数也是DatagramPacket，需要把这个Packet对象构造好
            //此处构造的响应对象，不能是用空的字节数组构造了，而是要使用响应数据来构造
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,
                    requestPacket.getSocketAddress());
            socket.send(responsePacket);

            //4.打印当前请求响应的处理中间结果
            System.out.printf("[%s:%d] req: %s;resp %s\n",requestPacket.getAddress().toString(),
                    requestPacket.getPort(),request,response);
        }
    }

    private String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        //端口号的指定，从1024-》65535之间选择一个数字
        UdpEchoServe serve = new UdpEchoServe(1988);
        serve.start();
    }
}

因此，构造字符串，那些用了就构造那些部分。就通过getLength获取到实际的数据报的长度，只是把这个实际的有效部分给构造成字符串即可。

数据到达网卡，经过内核层层分用，最终到达UDP传输层协议。
调用receive相当于是执行到了内核中的相关的udp的代码，就会把这个udp数据报里面的载荷部分取出来，拷贝到用户提供的byte[]数组中。

接下来，编写客户端代码:

import java.io.IOException;
import java.net.*;
import java.util.Scanner;

public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String severIp = null;
    private int serverPort = 0;

    //一次通信，需要有两个ip，两个端口
    //客户端的ip是127.0.0.1已知的
    //客户端的port是系统自动分配的
    //服务器的ip和端口也需要告诉客户端，才能顺利把消息发给服务器
    public UdpEchoClient(String severIp, int serverPort) throws SocketException {
        socket = new DatagramSocket();
        this.severIp = severIp;
        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的时候，需要把serveIp和port都传过来，但是此处IP地址需要的是一个32位的整数形式
            //上述的IP地址是一个字符串，需要使用InetAddress.getByName()来进行一个转换
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,
                    InetAddress.getByName(severIp),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",1988);
        client.start();
    }
}

在一次通信中，涉及到的ip和端口有两组：

• 源ip
• 源端口
• 目的ip
• 目的端口

假设是让客户端给服务器发个数据：
此时源ip就是客户端的ip地址
目的ip就是服务器的ip地址（上述代码中，由于客户端和服务器都在同一主机上，所以ip都是“127.0.0.1”（环回ip））
源端口就是客户端端口（即系统随机分配的空闲的端口）
目的端口就是服务器的端口（在上述程序中指定的是1988）

端口号用来表示/区分一个进程
因此不允许一个端口同时被多个进程使用（前提是在同一主机上。）一个端口通常情况下不能被多个进程使用，但是一个进程可以绑定多个端口。（准确来说，socket和端口号是一对一的，进程和socket是一对多的）

对于服务器来说，端口号必须是确定好的，对于客户端来说，端口可以使系统随机分配的。

客户端是否可以自己手动指定端口？
一般来说是不可以的，客户端如果显示指定端口，可能就和客户端电脑上的其他程序的端口冲突了，这一冲突就可能导致程序无法正确通信了。（比如客户端想要8888这个端口，结果，客户端另外一个程序已经使用8888，此时程序就无法正常正确运行：运行就会抛异常提示绑定端口失败。）
但是对于服务器这里的端口是程序员可控的，我们可以自己安排使用哪个端口。

DatagramSocket这个类的receive能阻塞，是因为操作系统原生提供的。
API（receive）就是阻塞的函数。

稍微调整后可以开启多个客户端。

TCP流套接字编程

TCP提供的API主要是两个类：
ServerSocket：专门给服务器使用的Socket对象
Socket：既是会给客户端使用，也会给服务器使用
注意：TCP不需要一个类来表示“TCP数据报”
TCP不是以数据报为单位进行传输的，是以字节的方式，流式传输。

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的主机上，对应端口的进程建立连接

Socket 方法：

方法签名	方法说明
InetAddress getInetAddress()	返回套接字所连接的地址
InputStream getInputStream()	返回此套接字的输入流
OutputStream getOutputStream()	返回此套接字的输出流

TCP版本的客户端服务器程序

服务器端代码：

package nettwork;

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 TcpEchoSever {
    private ServerSocket serverSocket = null;

    public TcpEchoSever(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.返回响应结果
                //    OutputSrteam 没有  writr String 这样的功能，可以把String 里字节数组拿出来进行写入，
                //    也可以用字符流来转化一下
                PrintWriter printWriter = new PrintWriter(outputStream);
                //此处使用println 来写入，让结果中带有一个\n换行，方便对端来接受解析
                printWriter.println(response);
                //flush刷新缓冲区，保证当前写入的数据被发送出去了。
                printWriter.flush();

                System.out.printf("[%s:%d] req: %s resp: %s \n",clientSocket.getInetAddress().toString(),clientSocket.getPort(),
                        request,response);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            try {
                clientSocket.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

    private String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        TcpEchoSever server = new TcpEchoSever(1988);
        server.start();
    }
}

此代码中，用到了一个clientSocket,此时任意一个客户端连上来吗，都会返回/创建一个Socket对象（Socket就是文件），每次创建一个clientSocket对象，就会占用一个文件描述符表的位置
因此在使用完毕之后，就需要进行“释放”。
前面的socket都没有释放，是因为前面的socket生命周期长。但是此处的clientSocket数量多，每个客户端都有一个，生命周期也更短。

注意：此处使用println来进行发送数据，是因为println会在发送的数据后面自动带上\n换行。如果不使用println，就无法正常运行。因为TCP协议，是面向字节流的协议。（字节流的特性是：一次读多少字节都行。而结束是\n）此处的代码中，隐式约定了使用\n来作为当前代码的请求/响应分割约定。

客户端代码：

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 severIp,int serverPort) throws IOException {
        //Socket构造方法，能够识别点分十进制格式的IP地址，比DatagramPacket更加方便
        //new 这个对象的同时，就会进行TCP连接操作
        socket = new Socket(severIp,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.println(">");
                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) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) throws IOException {
        TcpEchoClient client = new TcpEchoClient("127.0.0.1",1988);
        client.start();
    }
}

运行结果：
多线程模式下的运行结果：

TCP中的长短连接

TCP发送数据时，需要先建立连接，什么时候关闭连接就决定是短连接还是长连接：
短连接：每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数据。
长连接：不关闭连接，一直保持连接状态，双方不停的收发数据，即是长连接。也就是说，长连接可以多次收发数据。

1. 对比以上长短连接，两者区别如下： 建立连接、关闭连接的耗时：短连接每次请求、响应都需要建立连接，关闭连接；而长连接只需要第一次建立连接，之后的请求、响应都可以直接传输。相对来说建立连接，关闭连接也是要耗时 的，长连接效率更高。
2. 主动发送请求不同：短连接一般是客户端主动向服务端发送请求；而长连接可以是客户端主动发送 请求，也可以是服务端主动发。
3. 两者的使用场景有不同：短连接适用于客户端请求频率不高的场景，如浏览网页等。长连接适用于 客户端与服务端通信频繁的场景，如聊天室，实时游戏等。