网络编程：写一个应用程序,让这个程序可以使用网络通信。这里就需要调用传输层提供的 api。

Socket套接字

传输层提供协议，主要是两个: UDP和TCP
提供了两套不同的 api，这api也叫做socket api。

UDP和 TCP 特点对比：

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

有连接,无连接：客户端和服务器之间，彼此之间使用内存空间保存对端的信息，双方都保存这个信息此时“连接”就出现了。

可靠传输，不可靠传输：不是说,A 给 B 发的消息 100% 能到(这个要求太难了)。A 尽可能的把消息传给 B.并且在传输失败的时候,A 能感知到，**或者在传输成功的时候,也能知道自己传输成了。**可靠传输效率低，不可靠传输效率高。

面向字节流，面向数据报：

1. TCP 和 文件操作类似,都是“流”式的(由于这里传输的单位是字节,称为字节流)
2. UDP 是面向数据报,读写的基本单位是一个 UDP 数据报(包含了一系列的数据/属性)

全双工，半双工：

1. 全双工：一个通道,可以双向通信
2. 半双工：一个通道,只能单向通信

UDP数据报套接字编程

DatagramSocket API

DatagramSocket API 是一个 Socket 对象。操作系统，使用文件这样的概念,来管理一些软硬件资源，操作系统也是使用文件的方式来管理网卡的。表示网卡的这类文件,称为 Socket 文件。Java 中的 socket 对象，就对应这系统里的 socket 文件。

构造方法：

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

客户端使用哪个端口,系统自动分配。但是服务器使用哪个端口,是手动指定的。对于服务器来说，需要有一个固定的端口号,方便其他客户端找到。一个客户端的主机，上面运行的程序很多,天知道你手动指定的端口是不是被别的程序占用了。让系统自动分配一个端口是更明智的选择。服务器是完全在程序猿手里控制的。程序猿可以把服务器上的多个程序安排好，让他们使用不同的端口。

普通方法：

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

DatagramPacket API

表示了一个 UDP 数据报，代表了系统中设定的 UDP 数据报的二进制结构。

构造方法：

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

普通方法：

方法签名	方法说明
SocketAddress getSocketAddress()	SocketAddress对象包含了IP地址和端口号
InetAddress getAddress()	从接收的数据报中，获取发送端主机IP地址；或从发送的数据报中，获取 接收端主机IP地址
int getPort()	从接收的数据报中，获取发送端主机的端口号；或从发送的数据报中，获取接收端主机端口号
byte[] getData()	获取数据报中的数据。udp 数据报载荷部分(完整的应用层数据报)

示例一：回显服务器(echo server).

回显服务器(echo server):客户端发啥,服务器返回啥.

// 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 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());
            socket.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(9090);
        server.start();
    }
}

客户端代码：

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 {
        UdpEchoClient client = new UdpEchoClient("127.0.0.1", 9090);
        client.start();
    }
}

可以启动多个客户端，服务器也是可以应对的。IDEA 上启动多个程序,需要稍微设置一下：

其他人的电脑不能访问我这个程序。原因是：网络环境的现状，NAT 机制是主流。NAT 机制下，就把 IP 地址分成了外网 IP 和内网 IP.(内网IP 不能直接访问)。

示例二：翻译服务器

翻译服务器：请求是一些英文单词，响应则是对应的中文翻译。代码很多和回显服务器相同，所以继承UdpEchoServer 来实现代码的复用。

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("hello", "你好");
        // 可以在这里继续添加千千万万个单词. 使每个单词都有一个对应的翻译.
    }

    // 是要复用之前的代码, 但是又要做出调整.
    @Override
    public 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 分量要比 UDP 更重用的，用的更多的协议。

TCP 提供的 api 也是主要有两个类

• ServerSoeket：给服务器使用的 socket
• Socket： 既会给服务器使用,也会给客户端使用

字节流,一个字节一个字节进行传输的。一个 tcp 数据报,就是一个 字节数组 byte[]。

ServerSocket API

ServerSocket 构造方法：

方法签名	方法说明
ServerSocket(int port)	创建一个服务端流套接字Socket，并绑定到指定端口

ServerSocket 方法：

方法签 名	方法说明
Socket accept()	开始监听指定端口（创建时绑定的端口），有客户端连接后，返回一个服务端Socket 对象，并基于该Socket建立与客户端的连接，否则阻塞等待
void close()	关闭此套接字

Socket API

Socket 构造方法：

方法签名	方法说明
Socket(String host, int port)	创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的 进程建立连接

Socket 方法：

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

ServerSocket的accept()方法负责产生连接，产生连接的类型是Socket。Socket负责后续的连接后的通信。 ServerSocket的accept()是在服务器中使用，当服务器执行到 accept 的时候, 此时客户端可能还没来呢。accept 就会阻塞到有客户端连接成功为止。

accept()把内核中的连接获取到应用程序中了，这个过程类似于，"生产者消费者模型”。

TCP版本的回显服务器

客户端代码,要做的事情:

1. 读取请求并解析.
2. 根据请求计算响应
3. 把响应写回给客户端.

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){
            Socket clientSocket = serverSocket.accept();
            processConnection(clientSocket);
        }
    }
    // 通过这个方法来处理一个连接的逻辑.
    private void processConnection(Socket clientSocket) throws IOException {
        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 sc = new Scanner(inputStream);
                if(!sc.hasNext()){
                    //读取完毕，客户端下线
                    System.out.printf("[%s:%d]客户端下线\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
                    break;
                }
                // 这个代码暗含一个约定, 客户端发过来的请求, 得是文本数据, 同时, 还得带有空白符作为分割. (比如换行这种)
                String request = sc.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 {
            clientSocket.close();
        }

    }

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

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

客户端代码,要做的事情:
1.从控制台读取用户的输入
2.把输入的内容构造成请求并发送给服务器
3.从服务器读取响应
4.把响应显示到控制台上

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();
    }
}

多线程版本的会先服务器

当前代码还存在一个很大的问题。多个客户端访问会出现bug。当第一个客户端连接好了之后，第二个客户端,不能正确被处理服务器。看不到客户端上线，同时客户端发来的请求也无法被处理。当第一个客户端退出之后，之前第二个客户端发的请求，就能正确响应了。

上面的单线程代码中，serverSocket.accept()，建立一个连接，但是在进入processConnection()后，连接不断开，下一个连接就没办法连接上。主线程一个线程，又要建立连接，又要进行通信，只有通信结束连接断开之后，才会有下一个连接。要想解决这个问题我们就需要用多线程来解决，主线程负责建立连接，新建立的线程负责连接后的通信，各司其职就能解决这个问题。

public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }
    // 启动服务器
    public void start() throws IOException {
        System.out.println("服务器启动");
        while (true){
            Socket clientSocket = serverSocket.accept();
            Thread t = new Thread(()->{
                processConnection(clientSocket);
            });
        }
    }

经过上述改进，只要服务器系统资源足够，有几个客户端都是可以的了。

TCP 程序的时候,涉及到两种写法

1. 一个连接中只传输一次请求和响应.短连接

2. 一个连接中,可以传输多次请求和响应.长连接

上面代码属于长连接。其实如果我们刚才的代码,不写成这个样子。比如要求每个客户端只能发一次请求，发完就断开。上述情况能得到一定的缓解，但是还是有类似的问题的。处理多个消息,自然就会延长 processConnection 的执行时间，后续的连接也得等到上个连接断开后才能继续连接。

现在是有一个连接,就有一个新的线程。如果很多客户端，频繁的来连接/断开，服务器就涉及到频繁创建/释放线程了。我们使用线程池会比较好的解决这个问题。

    // 此处不应该创建固定线程数目的线程池.
    private ExecutorService service = Executors.newCachedThreadPool();
        // 启动服务器
    public void start() throws IOException {
        System.out.println("服务器启动");
        while (true){
            Socket clientSocket = serverSocket.accept();
            // 使用线程池, 来解决上述问题
            service.submit(new Runnable() {
                @Override
                public void run() {
                    processConnection(clientSocket);
                }
            });
        }
    }

虽然使用线程池，避免了频繁创建销毁线程。但是毕竟是每个客户端对应一个线程。如果服务器对应的客户端很多,服务器就需要创建出大量的线程.对于服务器的开销是很大的。当客户端进一步增加，线程数目进一步增加系统的负担就越来越重，响应速度也会大打折扣。

< C10K问题：同一时刻,有 10k 个客户端(1w 个客户端)，通过前面的一些技术手段,硬件设备,是可以处理好.(线程池之类的)
随着互联网的发展,客户端越来越多,请求也越来越多，进而引发了C10M问题。
C10M： 同一时刻,有 1kw 的客户端并发请求。引入了很多技术手段.其中一个非常 有效/必要 的手段,IO 多路复用/IO 多路转接.
IO 多路复用：一个线程完成多个IO操作。 不是说使用了这一个方法就能解决C10M问题，但是解决 高并发(C10M) 重要手之一。

解决高并发,就是四个字：

1. 开源: 引入更多的硬件资源 (多核CPU)
2. 节流: 提高单位硬件资源能够处理的请求数。同样的请求数，消耗的硬件资源更少。

IO 多路复用,就是节流的方式。同样的请求,消耗的硬件资源更少了。本质上就是减少线程的数量。操作系统提供的另一组网络编程的 API 可以和 tcp udp api 配合使用的。可以去搜索 Java NIO 一些关键词来学习IO多路复用。