网络编程中的基本概念

发送端和接收端
在一次网络数据传输时：
发送端：数据的发送方进程，称为发送端。发送端主机即网络通信中的源主机。
接收端：数据的接收方进程，称为接收端。接收端主机即网络通信中的目的主机。
收发端：发送端和接收端两端，也简称为收发端。
注意：发送端和接收端只是相对的，只是一次网络数据传输产生数据流向后的概念。
请求和响应
一般来说，获取一个网络资源，涉及到两次网络数据传输：
第一次：请求数据的发送
第二次：响应数据的发送。
客户端和服务端
服务端：在常见的网络数据传输场景下，把提供服务的一方进程，称为服务端，可以提供对外服务。
客户端：获取服务的一方进程，称为客户端。
对于服务来说，一般是提供：

客户端获取服务资源

在这里插入图片描述

客户端保存资源在服务端

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

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

Socket套接字

概念
Socket套接字，是由系统提供用于网络通信的技术，是基于TCP/IP协议的网络通信的基本操作单元。基于Socket套接字的网络程序开发就是网络编程。
分类
Socket套接字主要针对传输层协议划分为如下三类：
流套接字：使用传输层TCP协议
TCP，即Transmission Control Protocol（传输控制协议），传输层协议
以下为TCP的特点（细节后续再学习）：

有连接

可靠传输

面向字节流

有接收缓冲区，也有发送缓冲区

大小不限

对于字节流来说，可以简单的理解为，传输数据是基于IO流，流式数据的特征就是在IO流没有关闭的情况下，是无边界的数据，可以多次发送，也可以分开多次接收。
数据报套接字：使用传输层UDP协议
UDP，即User Datagram Protocol（用户数据报协议），传输层协议。
以下为UDP的特点（细节后续再学习）：

无连接

不可靠传输

面向数据报

有接收缓冲区，无发送缓冲区

大小受限：一次最多传输64k对于数据报来说，可以简单的理解为，传输数据是一块一块的，发送一块数据假如100个字节，必须一
次发送，接收也必须一次接收100个字节，而不能分100次，每次接收1个字节。
原始套接字
原始套接字用于自定义传输层协议，用于读写内核没有处理的IP协议数据。

Java数据报套接字通信

对于UDP协议来说，具有无连接，面向数据报的特征，即每次都是没有建立连接，并且一次发送全部数据报，一次接收全部的数据报。
java中使用UDP协议通信，主要基于 DatagramSocket 类来创建数据报套接字，并使用
DatagramPacket 作为发送或接收的UDP数据报。对于一次发送及接收UDP数据报的流程如下：

以上只是一次发送端的UDP数据报发送，及接收端的数据报接收，并没有返回的数据。也就是只有请求，没有响应。对于一个服务端来说，重要的是提供多个客户端的请求处理及响应，流程如下：

UDP数据报套接字编程

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

DatagramSocket 方法：

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

DatagramPacket 方法：

构造UDP发送的数据报时，需要传入 SocketAddress ，该对象可以使用 InetSocketAddress 来创建。
InetSocketAddress API
InetSocketAddress （ SocketAddress 的子类）构造方法：

建立一个服务器端

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.nio.charset.StandardCharsets;

public class UDPEchoServer {
    
    
    // 定义一个用于服务器端的DatagramSocket
    private DatagramSocket server;

    /**
     * 构造方法，完成服务器的初始化
     * @param port 端口号
     */
    public UDPEchoServer (int port) throws Exception {
    
    
        if (port > 65535 || port < 1024) {
    
    
            throw new Exception("端口号必须在1024 ~ 65535之间");
        }
        // 初始化服务器端的UDP服务
        this.server = new DatagramSocket(port);
    }

    /**
     * 对外提供服务
     */
    public void start () throws IOException {
    
    
        System.out.println("服务器已启动！");
        // 循环接收用户的请求
        while (true) {
    
    
            // 1. 创建一个用于接收请求数据的DatagramPacket
            DatagramPacket requestPacket = new DatagramPacket(new byte[1024], 1024);
            // 2. 接收请求, 把真实的内容填充到requestPacket
            server.receive(requestPacket);
            // 3. 从requestPacket获取数据
            String request = new String(requestPacket.getData(), 0, requestPacket.getLength(), "UTF-8");
            // 4. 根据请求获取响应
            String response = processor (request);
            // 5. 把响应封装到DatagramPacket
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(StandardCharsets.UTF_8),
                    response.getBytes().length, requestPacket.getSocketAddress());
            // 6. 发送数据
            server.send(responsePacket);
            // 7. 打印日志
            System.out.printf("[%s:%d] request: %s, response: %s.\n", requestPacket.getAddress().toString(),
                    requestPacket.getPort(), request, response);
        }

    }

    public String processor(String request) {
    
    
        return request;
    }

    public static void main(String[] args) throws Exception {
    
    
        // 初始化服务器
        UDPEchoServer server = new UDPEchoServer(9999);
        // 启动服务
        server.start();
    }
}

建立一个客户器端

import java.io.IOException;
import java.net.*;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

public class UDPEchoClient {
    
    
    // 定义一个用于客户端的DatagramSocket
    private DatagramSocket client;
    // 定义服务器的IP地址
    private String serverIp;
    // 定义服务器的端口号
    private int port;
    private SocketAddress address;

    /**
     * 构造方法,指定服务器的Ip地址和端口号
     *
     * @param serverIp 服务器IP
     * @param port 端口号
     */
    public UDPEchoClient (String serverIp, int port) throws SocketException {
    
    
        this.client = new DatagramSocket();
        this.serverIp = serverIp;
        this.port = port;
        this.address = new InetSocketAddress(serverIp, port);
    }

    public void start () throws IOException {
    
    
        System.out.println("客户端已启动.");
        // 循环接收用户的输入
        Scanner scanner = new Scanner(System.in);
        while (true) {
    
    
            System.out.println("->");
            // 接收用户输入
            String request = scanner.next();
         
           // 1. 把请求内容包装成DatagramPacket
           DatagramPacket requestPacket = new DatagramPacket(request.getBytes(StandardCharsets.UTF_8),
                   request.getBytes().length, address);
           // 2. 发送数据
           client.send(requestPacket);
           // 3. 接收响应
           DatagramPacket responsePacket = new DatagramPacket(new byte[1024], 1024);
           // 4. 在receive方法中填充响应数据
           client.receive(responsePacket);
           // 5. 解析响应数据
           String response = new String(responsePacket.getData(), 0, responsePacket.getLength(), "UTF-8");
           // 6. 打印日志
           System.out.printf("request: %s, response: %s.\n", request, response);
        }
    }

    public static void main(String[] args) throws IOException {
    
    
        UDPEchoClient client = new UDPEchoClient("127.0.0.1", 9998);
        // 启动服务
        client.start();
    }
}

Java流套接字通信

TCP流套接字编程

和刚才UDP类似. 实现一个简单的英译汉的功能
ServerSocket API
ServerSocket 是创建TCP服务端Socket的API。
ServerSocket 构造方法：

ServerSocket 方法：

Socket API
Socket 是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
不管是客户端还是服务端Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。
Socket 构造方法：

Socket 方法：

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

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

建立一个服务端

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.net.SocketException;
import java.text.MessageFormat;
import java.util.Scanner;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


public class TCPEchoServer {
    
    
//    声明一个用于服务器的对象
    private ServerSocket server;

    public TCPEchoServer(int port) throws IOException {
    
    
        if(port < 1024 || port > 65535){
    
    
            throw new SocketException("端口号不正确！");
        }
        this.server = new ServerSocket(port);
    }
    public void start() throws IOException {
    
    
        System.out.println("服务端启动成功！");
        //接收连接
        while (true){
    
    
            //没有连接会阻塞，
            Socket clientSocket = server.accept();
            processConnetion(clientSocket);
        }
    }

    //处理数据
    private void processConnetion(Socket clientSocket) throws IOException {
    
    
//        System.out.printf("[%s:%d客户端已经上线\n");
        String clientInfo = MessageFormat.format("[{0},{1}]客户端已经上线\n",clientSocket.getInetAddress(),clientSocket.getPort());
        System.out.println(clientInfo);
        //获取输入输出流
        try(InputStream inputStream = clientSocket.getInputStream();
            OutputStream outputStream = clientSocket.getOutputStream()) {
    
    
            //处理用户请求
            while (true){
    
    
                //读取用户数据
                Scanner requestScanner = new Scanner(inputStream);
                if(!requestScanner.hasNextLine()){
    
    
                    clientInfo = MessageFormat.format("[{0},{1}]客户端已经下线\n",clientSocket.getInetAddress(),clientSocket.getPort());
                    System.out.println(clientInfo);
                    break;
                }
                // 有数据，获取用户真实请求
                String request = requestScanner.nextLine();
//                响应
                String response = process(request);
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(response);
                printWriter.flush();

                clientInfo = MessageFormat.format("[{0},{1}]request:{2},response:{3}\n",
                        clientSocket.getInetAddress(),clientSocket.getPort(),request,response);
                System.out.println(clientInfo);
            }

        } catch (IOException e) {
    
    
            throw new RuntimeException(e);
        }finally {
    
    
            clientSocket.close();
        }
    }

    private String process(String request) {
    
    
        System.out.println("收到新消息：" + request);
        System.out.print("->");
        Scanner scanner = new Scanner(System.in);
        String re = scanner.nextLine();
        return re;
    }

    public static void main(String[] args) throws IOException {
    
    
        TCPEchoServer server = new TCPEchoServer(9999);
//        Scanner scanner = new Scanner(System.in);
//        String s = scanner.nextLine();
        server.start();
    }
}

建立一个客户端

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.SocketException;
import java.util.Scanner;

public class TCPEchoClient {
    
    
    private Socket client;
    public TCPEchoClient(String serverIp,int port) throws IOException {
    
    
        if(port < 1024 || port > 65535){
    
    
            throw new SocketException("端口号不正确！");
        }
        this.client = new Socket(serverIp,port);
    }
    public void start() throws IOException {
    
    
        System.out.println("客户端已启动！");
        try(InputStream inputStream = client.getInputStream();
            OutputStream outputStream = client.getOutputStream()) {
    
    
            while (true){
    
    
                System.out.print("->");
                Scanner scanner = new Scanner(System.in);
                String request = scanner.nextLine();
//                发送请求
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(request);
                printWriter.flush();
                //接收服务器的响应
                Scanner responseScaner = new Scanner(inputStream);
                String response = responseScaner.nextLine();

                System.out.println("接收到服务器的响应" + response);
            }

        } catch (IOException e) {
    
    
            throw new RuntimeException(e);
        }finally {
    
    
            client.close();
        }
    }

    public static void main(String[] args) throws IOException {
    
    
        //本机，连接服务端端口
        TCPEchoClient client = new TCPEchoClient("127.0.0.1",9999);
        client.start();
    }
}

上面的的服务端只能服务于一个客户端，为了实现服务器可以处理多个客户端连接
那么就可以为每一个客户端创建一个新的线程，那请求的处理在单独子线程中去执行
但是如果有1万个连接那么就要创建1万个线程，如果有1万个连接那么就要创建1万个线程，1万个线程会消耗掉非常大的系统资源，C10K现象；为了解决线程大量创建，那么可以使用线程池的方式进一步做优化。

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.text.MessageFormat;
import java.util.Scanner;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TCPEchoServerThreadPool {
    
    
    // 声明一个用于服务端的Socket对象
    private ServerSocket server;

    /**
     * 通过指定端口号实例化服务
     *
     * @param port 端口号
     * @throws IOException
     */
    public TCPEchoServerThreadPool(int port) throws IOException {
    
    
        if (port < 1025 || port > 65535) {
    
    
            throw new RuntimeException("端口号要在 1025 ~ 65535之间.");
        }
        // 实例化ServerSocket并指定端口号
        this.server = new ServerSocket(port);
    }

    public void start() throws IOException {
    
    
        System.out.println("服务器启动成功...");
        // 创建一个线程池
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(3, 10, 1, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(10));
        // 循环接收客户端的连接
        while (true) {
    
    
            Socket clientSocket = server.accept();
            // 每接收到一个新连接请求，就创建一个新的子线程
//            Thread thread = new Thread(() -> {
    
    
//                // 处理Socket中的数据
//                try {
    
    
//                    processConnections(clientSocket);
//                } catch (IOException e) {
    
    
//                    e.printStackTrace();
//                }
//            });
//            // 启动线程
//            thread.start();

            // 提交任务到线程池中
            poolExecutor.submit(() -> {
    
    
                try {
    
    
                    processConnections(clientSocket);
                } catch (IOException e) {
    
    
                    e.printStackTrace();
                }
            });

        }
    }

    // 处理数据
    private void processConnections(Socket clientSocket) throws IOException {
    
    
        // 打印日志
        String clientInfo = MessageFormat.format("[{0}:{1}] 客户端已上线", clientSocket.getInetAddress(),
                clientSocket.getPort());
        System.out.println(clientInfo);
        // 处理数据之前要获取一下输入输出流
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
    
    
            // 循环处理用户的请求
            while (true) {
    
    
                // 通过Scanner读取用户请求中的数据
                Scanner requestScanner = new Scanner(inputStream);
                if (!requestScanner.hasNextLine()) {
    
    
                    // 日志
                    clientInfo = MessageFormat.format("[{0}:{1}] 客户端已下线.", clientSocket.getInetAddress(),
                            clientSocket.getPort());
                    System.out.println(clientInfo);
                    break;
                }
                // 获取真实的用户请求数据
                String request = requestScanner.nextLine();
                // 根据请求计算响应
                String response = process(request);
                // 把响应写回客户端
                PrintWriter printWriter = new PrintWriter(outputStream);
                // 写入输出流
                printWriter.println(response);
                // 强制刷新缓冲区
                printWriter.flush();
                // 打印日志
                clientInfo = MessageFormat.format("[{0}:{1}], request: {2}, response: {3}",
                        clientSocket.getInetAddress(), clientSocket.getPort(), request, response);
                System.out.println(clientInfo);

            }


        } catch (IOException e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            clientSocket.close();
        }

    }

    private String process(String request) {
    
    
        System.out.println("收到新消息："  + request);
        Scanner scanner = new Scanner(System.in);
        String response = scanner.nextLine();
        return response;
    }

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

【JavaEE】网络编程