网络编程套接字(Socket)

为什么需要网络编程???    -丰富的网络资源

每天你在b站上刷着喜欢的up主的视频,实质是通过网络,获取到网络上的一个视频资源

与本地打开文件类似,只是视频文件这个资源来源是网络

所谓的网络编程,其实就是从网络上获取各种数据资源

什么是网络编程??

网络编程,指的是网络上的主机,通过不同的进程,以编程的方式实现网络通信(数据传输)

此时的主机也可以发送方和接收方是同一个,只需要保证进程号不同即可

但是一般我们是用于不同主机之间的通信的

Socket 套接字

概念:是由系统提供用于网络通信的技术,是基于TCP/UDP协议的网络通信的基本操作单元

基于Socket套接字的网络程序开发的就是网络编程

下面我们介绍UDP和TCP中是如何实现的

UDP特点: 无连接,面向数据报,不可靠传输,全双工(可双向传输),大小受限(64字节),有接收缓冲区,无发送缓冲区

TCP特点:有连接,面向字节流,可靠传输,全双工,有接收和发送缓冲区,大小不受限

UDP socket api的使用 

主要是两个类 DatagramSocket(用于发送和接受数据报)和DatagramPacket(数据报)

此处的api都是封装了操作系统的api

⽅法签名	方法说明
DatagramSocket()

 

创建⼀个UDP数据报套接字的Socket，绑定到本机任意⼀个随机端（⼀般⽤于客⼾端）
DatagramSocket(intport)	创建⼀个UDP数据报套接字的Socket，绑定到本机指定的端（⼀般⽤于服务端）

DatagramSocket ⽅法：

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

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

注:这里的DatagramPacket是一个输出型参数,传入字节数组后通过引用来修改源数组

⽅法签名	⽅法说明
DatagramPacket(byte[] buf, int length)	构造⼀个DatagramPacket以⽤来接收数据报，接收的数据保存在字节数组（第⼀个参数buf）中，接收指定⻓度（第⼆个参数length）
DatagramPacket(byte[]buf,int offset,int length,SocketAddressaddress)	构造⼀个DatagramPacket以⽤来发送数据报，发送的数据为字节数组（第⼀个参数buf）中，从0到指定⻓度（第⼆个参数length）。address指定⽬的主机的IP 和端⼝号

DatagramPacket  ⽅法：

⽅法签名	⽅法说明
InetAddress getAddress()	从接收的数据报中，获取发送端主机IP地址；或从发 送的数据报中，获取接收端主机IP地址
int getPort()	从接收的数据报中，获取发送端主机的端⼝号；或从 发送的数据报中，获取接收端主机端⼝号

byte[] getData()

获取数据报中的数据

InetSocketAddress
InetSocketAddress （ SocketAddress 的⼦类）构造⽅法：

⽅法签名	⽅法说明
InetSocketAddress(Inet Addressaddr,int port)	创建⼀个Socket地址，包含IP地址和端⼝号

常见的客户端服务端模型

此处的客户端在发送请求的时候作为发送端

在接收返回响应的时候作为接收端

所以我们说发送端和接收端是一个相对的概念

使用UDP协议实现回显服务器

此时我们想基于UDP实现一个回显服务器,所谓的回显服务器就是客户端发送什么内容,接收端就响应什么内容,下面我们开始具体实现

服务器

对于服务器来说,第一步是要创建一个DatagramSocket对象,因为接下来我们是要操作网卡的,操作网卡是通过socket对象来实现的,你可以认为网卡这个硬件设备被抽象成一个类,实际上操作系统内核将它抽象成文件的形式来表示,socket对象是在内存中的,这里我们只需要针对内存操作就可以影响到网卡

通过网卡发送数据,就是写socket文件

通过网卡接收数据,就是读socket文件

UDP面向数据报,每次发送和接收的基本单位就是一个DatagramPacket

注:服务器一定要绑定一个端口号

端口号:区分不同应用程序的依据,一个进程可以绑定多个端口,一个端口只能被一个进程绑定

public class Udp_server {
    private DatagramSocket socket = null;

    public Udp_server(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 方便后续的逻辑处理.
            String request = new String(requestPacket.getData(), 0, requestPacket.getLength());
            // 2. 根据请求计算响应 (对于 回显服务器来说, 这一步啥都不用做)
            String response = process(request);
            // 3. 把响应返回到客户端.
            //    构造一个 DatagramPacket 作为响应对象
            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 {
        Udp_server server = new Udp_server(9090);
        server.start();
    }
}

客户端

相对来说,这里客户端和服务器的代码就很像了,有一点不同,就是客户端不需要手动指定端口号,这里就是系统自动分配一个空闲的端口号,而服务器的端口往往是固定不变的,服务器用空闲的端口即可.

客户端构造的时候需要指定服务器的端口和ip

注:服务器实在程序员手里的,是可控的,而客户端是在用户手里的,假设你固定端口为8080,但是此时用户的8080端口被其他的应用程序所占用了,这时候程序就g了呀

public class UDP_Client {
    private DatagramSocket socket = null;
    private String serverIp;
    private int serverPort;


    // 此处 ip 使用的字符串, 点分十进制风格. "192.168.2.100"
    public UDP_Client(String serverIp, int serverPort) throws SocketException {
        this.serverIp = serverIp;
        this.serverPort = serverPort;
        socket = new DatagramSocket();
    }

    public void start() throws IOException {
        System.out.println("客户端启动");
        Scanner scanner = new Scanner(System.in);
        while (true) {
            // 要做四个事情
            System.out.print("-> "); // 表示提示用户接下来要输入内容.
            // 2. 从控制台读取要发送的请求数据.
            if (!scanner.hasNext()) {
                break;
            }
            String request = scanner.next();
            // 3. 构造请求并发送.
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(), request.getBytes().length,
                    InetAddress.getByName(serverIp), serverPort);
            socket.send(requestPacket);
            // 4. 读取服务器的响应.
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096], 4096);
            socket.receive(responsePacket);
            // 5. 把响应显示到控制台上.
            String response = new String(responsePacket.getData(), 0, responsePacket.getLength());
            System.out.println(response);
        }
    }

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

流程梳理

1.服务器启动,启动之后进入while循环,执行到receive进入阻塞状态,此时客户端还没发来任何请求

2.客户端启动,启动之后进入while循环,执行到hasNext,进入阻塞,此时用户没有输入内容

3.用户输入字符串,按下回车,此时next返回内容,构造一个DatagramPacket进行发送send

send执行完毕之后,继续执行到receive阶段,等待服务器的响应数据

4.服务器接收到请求后从receive的阻塞中返回

返回之后根据读到的DatagramPacket,通过process方法构造返回的字符串,再根据返回的字符串构造响应对象DatagramPacket,再进行发送给客户端

在此过程中,客户端也是在阻塞等待的

5.客户端从receive中执行返回,就能得到对应的响应,打印到控制台上,此时再次等待用户输入请求

使用TCP方式实现一个回显服务器

TCP是有链接的,就和打电话一样,需要客户端拨号,服务器来接听

ServerSocket类只能给服务器进行使用,同样抽象成网卡

Socket类对应到网卡,既可以给服务器来使用,也可以给客户端来使用

当服务器这里调用了ServerSocket的accept()方法,,服务器的内核就会配合客户端的工作,来完成连接的建立,这个建立的过程就类似于电话拨号,电话响铃,一直到另一方接通,才能进行后续的通信.在没有客户端来连接的时候,accept方法会进行阻塞,当有多个客户端来连接的时候,accept方法就会执行多次

注:TCP是有连接的,TCP socket就会保存对端的信息

所以这里客户端也无需保存对端的信息了

长短连接

长连接:一次连接服务器与客户端进行多次交互

短连接:一次服务器和客户端连接只进行一次交互

客户端程序

public class TCPEchoClient {

    private Socket socket= null;

    public TCPEchoClient(String serverIP, int port) throws IOException {
        socket = new Socket(serverIP,port);
        //由于TCP是有连接的,所以IP和端口会保存好
        //因此TCPEchoClient就不必保存

    }
    public void start() {
        System.out.println("客户端启动");
        //和UDP类似
        //1.从控制台读取
        try(InputStream inputStream = socket.getInputStream();
            OutputStream outputStream = socket.getOutputStream()) {
            Scanner scannerConsole = new Scanner(System.in);
            Scanner scannerNetwork = new Scanner(inputStream);
            PrintWriter writer = new PrintWriter(outputStream);
            while(true) {
                System.out.print("->");
                if(!scannerConsole.hasNext()) {
                    break;
                }

                String request = scannerConsole.next();
                writer.println(request);
                //2.请求发给服务器
                //确保这里发送出去了
                writer.flush();
                //3.读取响应
                String response = scannerNetwork.next();
                //4.把响应显示出来
                System.out.println(response);

            }
        } catch (IOException e) {

        }

    }

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

服务器程序

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("服务器启动");
        ExecutorService pool = Executors.newCachedThreadPool();
        while(true) {
            //通过accept来接听电话,才能通信(置业顾问)
            Socket clientSocket = serverSocket.accept();
//            Thread t = new Thread(()->{
//                processConnection(clientSocket);
//            });
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    processConnection(clientSocket);
                }
            });

        }
    }
    private void processConnection(Socket clientSocket) {
        System.out.printf("[%s:%d]客户端上线\n",clientSocket.getInetAddress(),clientSocket.getPort());
        //循环读取客户端的请求并返client
        try(InputStream inputStream = clientSocket.getInputStream();
                OutputStream OutputStream = clientSocket.getOutputStream()){
            //使用Scanner就不使用read了
            Scanner scanner = new Scanner(inputStream);
            while(true) {
                //使用inputStream
                if(!scanner.hasNext()) {
                    //读取完毕,比如客户端断开连接就算读取完毕
                    System.out.printf("[%s:%d] 客户端下线\n",clientSocket.getInetAddress(),clientSocket.getPort());
                    break;
                }
                //读取请求并解析,这里注意隐藏的约定,客户端发来的请求必须带有空白符作为结尾
                String request = scanner.next();

                //计算请求
                String response = process(request);
                //返回给客户端
                //这种方式可以写会但不方便给返回的响应添加换行
//                OutputStream.write(response.getBytes(StandardCharsets.UTF_8),0,response.getBytes().length);
                //也可以给OutputStream套上一层
                //将输出流包装一下,这里的操作也就是将字节流转换为字符流
                PrintWriter printWriter = new PrintWriter(OutputStream);
                printWriter.println(response);
                printWriter.flush();
                System.out.printf("[%s:%d] req %s,resp : %s\n",clientSocket.getInetAddress(),clientSocket.getPort(),
                        request,response);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally{
            try {
                clientSocket.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }


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

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

    }

}

此时客户端的用户态应用程序调用一定的api和服务器尝试建立连接,客户端就会发起建立连接的流程,服务器就会配合这里客户端的工作来完成连接的建立

这里内核中的连接并不是决定性的,还需要用户程序进行接听accept操作,才能进行后续的操作

流程梳理

1.服务器启动,阻塞在accept,等待客户端发送数据

2.客户端new socket的操作就是建立了连接

3.服务器从accept返回,进入到processConnection方法中,执行到hasNext之后,等待客户端传输数据,

4.客户端执行到hasNext阶段,等待用户从控制台输入数据

5.用户输入完了数据之后,进行发送

6.服务器读取到数据之后进行处理,然后包装成响应发送给客户端

7.客户端读取到响应并且打印在控制台上

服务器细节补充

这里我们注意到,每接收到一个客户端都会创建一个socket对象,这就会消耗我们的文件描述符表,所以一定要在结束后关闭,要写在finally里面,不然给文件描述符表给占满了程序就崩溃了

serverSocket不能关闭的原因是这个对象的生命周期跟随程序始终,而且只有一个,最后会随着程序的关闭自动销毁.

注:这里的两层while循环会导致服务器一次只能处理一个客户端的请求,这里我们可以采用IO复用,协程,线程池等方案修改即可

IO多路复用:基本在于虽然有多个socket,但是同一时刻活跃的socket只是少数,大部分socket是在等待,就造成了一个线程等待多个socket 的现象 效率相对不低的同时系统开销也不高

不像多线程,虽然效率很高,但是也大大增加了系统开销