网络编程--UDP/TCP_servers = servers || new udpserver(that.socketport-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_72536301/article/details/132900202

一. 网络编程基础

1.1 什么网络编程

网络编程，指网络上的主机，通过 不同的进程 ，以编程的方式实现 网络通信（或称为网络数据传输） 。

只要满足进程 不同就行；所以即便是同一个主机，只要是不同进程，基于网络来传输数据，也属于网络编程 (比如在同一部手机上登陆的两个微信号相互发送消息)。

特殊的，对于开发来说，在条件有限的情况下，一般也都是在一个主机中运行多个进程来完成网络编程.

1.2 网络编程中的基本概念

1. 发送端和接收端

发送端 ：数据的 发送方进程 ，称为发送端。发送端主机即网络通信中的源主机。

接收端 ：数据的 接收方进程 ，称为接收端。接收端主机即网络通信中的目的主机。

收发端 ：发送端和接收端两端，也简称为收发端。

发送端和接收端只是相对地,是一次网络数据传输产生数据流向的概念.一台主机可以成为发送端,也可以成为接收端.

2. 请求和响应

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

第一次：请求数据的发送

第二次：响应数据的发送。

3. 客户端和服务器

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

客户端 ： 获取服务 的一方进程，称为客户端。

一般来说,是由客户端主动发起请求,服务器传回响应.

二. Socket套接字

Socket是操作系统给应用程序提供的网络编程API,与传输层密切相关. 最常使用的Socket有两个: UDP,TCP. 下面我们来逐一讲解>>

1. 流套接字:传输层使用TCP协议

TCP ，即 Transmission Control Protocol （传输控制协议），传输层协议之一.特点如下:

有连接
可靠传输
面向字节流
全双工

2. 数据报套接字: 传输层使用UDP协议

UDP，即User Datagram Protocol（用户数据报协议），传输层协议之一. 特点如下:

无连接
不可靠传输
面向数据报
全双工

3.原始套接字(简单了解)

用于自定义传输层协议,读写内核中没有处理的IP协议数据

肯定有童鞋会问,上面的那些特点是啥意思?下面来详细解释下.

1> 有无连接

TCP协议要求在双方建立连接后才能进行网络通信,UDP则不需要.

就好像打电话,必须等到对方接受之后才可以建立连接进行通信;发微信就不需要连接了.

2> 可靠/不可靠传输

因为网络消息不能保证百分百送达,所以发送端在发送出去数据后,需要知道自己的消息是否被接收,这就是可靠性传输;如果发送端不知道自己发出去的数据是到达了还是丢了,就是不可靠传输.

下图中的快递员不知道自己扔出去的包裹是否被下一个人接收,就是不可靠传输→_→

3> 面向字节流: 以字节为单位进行传输

4> 面向数据报: 以数据报(带有一定格式的若干字节组成)为单位进行传输

5> 全双工/半双工

全双工是指一个主机能同时发送/接收数据;半双工是指一台主机可以发送消息,也可以接收消息,但是这两种行为不能同时进行.

就像下面这一根水管,水流既可以从A口流向B口,也可以从B口流向A口,但是不能同时进行,它就是半双工.

普及一个博主刚学的小知识,我们使用的传输介质双绞线(光缆)能够支持全双工的原因是因为收发数据使用的介质不是同一个.

三. UDP套接字编程

3.1 DatagramSocket API

DatagramSocket 是Java封装的UDP Socket,用于接收和发送UDP数据报.

构造方法

方法签名	说明
DatagramSocket()	创建一个UDP数据报套接字,随机绑定本机的一个空闲端口(一般用于客户端)
DatagramSocket(int port)	创建一个UDP数据报套接字,绑定到本机的port端口(一般用于服务器)

DatagramSocket方法

方法签名	说明
void receive(DatagramPacket p)	接收数据报(DatagramPacket),如果没有数据报传输过来,该方法会阻塞
void send(DatagramPacket p)	发送数据报,立即发送
void close()	关闭套接字

3.2 DatagramPacket API

Java同样对UDP数据报进行了封装--DatagramPacket是UDP套接字用来发送和接收的单位.

构造方法

方法签名	说明
DatagramPacket(byte[] buf,int length)	构造一个数据报用于接收,接收的信息保存在字节数组(buf)中,接收指定长度为length个字节(如果接收的数据长度超过length,后面的数据会被截断)
DatagramPacket(byte[] buf,int offset,int length,SocketAddress address)	构造一个数据报用于发送,发送的数据为字节数组(buf),从下标offset开始发送length个长度的字节,指定接收方地址为address.

DatagramPacket方法

方法签名	说明
InetAddress getAddress()	从接收的数据报中,得到发送方的地址
int getPort()	从接收的数据报中,得到发送方的端口号
byte[] getData()	获取数据报中的数据(数据报载荷部分)

3.3 UDP回显服务器的实现

先来解释一下什么是回显服务器---服务器接收到数据后,不做任何处理,将该数据重新发给客户端.

下面来实现一下,请带着代码注释理解~

public class UDPServer {
    private DatagramSocket socket=null;

    public UDPServer(int port) throws SocketException {
        socket=new DatagramSocket(port);//程序猿自己指定服务器端口
    }

    private void start() throws IOException {
        while(true){//服务器一般是24*7工作制,需要一直运行,判断是否有客户的响应
            DatagramPacket requestPac=new DatagramPacket(new byte[1024],1024);//构造一个用来接收请求的数据报
            socket.receive(requestPac);//request数据报接收到信息
            String request=new String(requestPac.getData(),0, requestPac.getLength());//将接收的信息转化成字符串
            String response=process(request);//服务器进行业务处理
            DatagramPacket responsePac=new DatagramPacket(response.getBytes(),0,response.getBytes().length,requestPac.getSocketAddress());//构造响应数据报,第三个参数不能写response.length(),否则返回的是字符长度,而不是字节数
            socket.send(requestPac);//将响应数据报返回给客户端
            System.out.println(requestPac.getSocketAddress()+":"+request+"    "+">>"+response);//打印日志,客户端与服务器的交互记录
        }
    }

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

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

3.4 UDP客户端的实现

public class UDPClient {
    private DatagramSocket socket=null;

    public UDPClient() throws SocketException {
        socket=new DatagramSocket();//由系统随机分配一个空闲端口
    }

    private void start(String serverIp,int serverPort) throws IOException {
        Scanner scanner=new Scanner(System.in);
        while(true){
            System.out.println("请输入你的请求>>");
            String request=scanner.next();//用户输入请求
            if(request.equals("exit")){
                System.out.println("已断开连接,欢迎下次使用!");
                break;
            }
            DatagramPacket requestPac=new DatagramPacket(request.getBytes(),0,request.getBytes().length, InetAddress.getByName(serverIp),serverPort);//根据用户请求构造数据报
            socket.send(requestPac);//将用户的request数据报发给服务器
            DatagramPacket responsePac=new DatagramPacket(new byte[1024],1024);//构造数据报用来接收服务器的响应
            socket.receive(responsePac);//用构造的response数据报接收服务器的响应
            String response=new String(responsePac.getData(),0,responsePac.getLength());//将服务器响应转化成字符串
            System.out.println("me:"+request+"       "+"server>>"+response);//输出日志:用户请求+服务器响应
        }

    }

    public static void main(String[] args) throws IOException {
        UDPClient client=new UDPClient();
        client.start("127.0.0.1",9999);//127.0.0.1是环回路线,是本机的IP地址,9999是服务器的端口号
    }
}

上面的代码中有几个问题需要强调:

1. 服务器的端口号必须是固定的,所以需要手动指定.

想象一下,如果你开了一家餐馆,在朝阳大道109号,朝阳大道就对应了IP地址,109号就是你的端口号,有位顾客第一次在这里就餐,觉得你做的锅包肉炒鸡好吃;第二次想来的时候,你的餐馆换了个端口号!这不就流失顾客了嘛.

2. 客户端的端口号必须由系统自动分配.

如果我们让客户自己指定端口号,他指定的端口恰好被计算机上的另一个进程占用了,就会抛出下面的异常.遇到这种情况,客户能自己解决嘛!

3. 指定服务器端口号前可使用netstat -ano | findstr +端口号,查看该端口是否已被占用,否则也会抛出下图异常.

4. 如果打印的日志有乱码,可以使用String(byte bytes[], Charset charset)方法构造字符串进行打印,charset为字符编码方式

四. TCP套接字编程

4.1 ServerSocket API

ServerSocket 是Java封装的TCP服务端的API.

构造方法

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

ServerSocket方法

方法签名	说明
Socket accept()	开始监听端口,有客户端连接后,返回一个服务器端Socket对象,基于该对象传送数据
void close()	关闭ServerSocket套接字

4.2 Socket API

Socket是客户端Socket,或者服务器中接收到客户端建立连接的请求后,返回的服务端Socket.

Socket对象是通信双方建立连接后,用来保存对端信息以及交换数据的介质.

构造方法

方法签名	说明
Socket(String host,int port)	创建一个客户端套接字Socket,并与服务器端建立连接

Socket方法

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

4.3 TCP回显服务器的实现

程序猿的尽头是代码~一起来康康吧

public class TCPServer {
    private ServerSocket serverSocket=null;
    public TCPServer(int port) throws IOException {
        serverSocket=new ServerSocket(port);//指定服务器端绑定的端口,创建服务器套接字
    }

    private void start() throws IOException {
        while(true){
            Socket respSocket=serverSocket.accept();//客户端与服务器连接成功后,服务器端会接收到一个Socket对象
            System.out.println("已与"+respSocket.getRemoteSocketAddress()+"建立连接");
            process(respSocket);//基于这个Socket对象与客户端进行通信
        }
    }

    private void process(Socket respSocket) throws IOException {
        try(InputStream inputStream= respSocket.getInputStream();//获取Socket端的流输入对象
            OutputStream outputStream= respSocket.getOutputStream();//获取Socket端的流输出对象
            Scanner scanner=new Scanner(inputStream);//分别用Scanner和PrintWriter类封装流对象
            PrintWriter writer=new PrintWriter(outputStream)){

            while(scanner.hasNext()){
                String request=scanner.next();//默认空白符,换行,回车等为客户端的数据结束符号
                String resp=getResp(request);
                writer.println(resp);//必须使用println()方法,作为响应的结束符号
                writer.flush();//printerWriter有自己的缓冲区,需要进行及时刷新,否则数据可能会残留在缓冲区里,没有被发送
                System.out.println(respSocket.getRemoteSocketAddress()+">>"+request+"      "+"resp>>"+resp);//打印日志

            }
            System.out.println("已与"+respSocket.getRemoteSocketAddress()+"断开连接");

        }catch (IOException e) {
            e.printStackTrace();
        }finally {
            respSocket.close();//关闭Socket对象,释放服务器这边的资源
        }
    }

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

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

4.4 TCP客户端的实现

public class TCPClient {
    Socket socket=null;
    public TCPClient(String serverIP,int port) throws IOException {
        socket=new Socket(serverIP,port);//构造这个Socket对象,代表想和服务器建立连接
    }
    private void start() throws IOException {
        try(Scanner scanner=new Scanner(socket.getInputStream());//用Scanner,PrintWriter封装Socket的输入输出流
            PrintWriter writer=new PrintWriter(socket.getOutputStream())) {
            Scanner console=new Scanner(System.in);//构建Console用于获取控制台用户的输入
            while(true){
                System.out.println("请输入你的请求>>");
                String request=console.next();
                if(request.equals("exit")){
                    System.out.println("客户端下线");
                    break;
                }
                writer.println(request);//必须使用println()方法,作为请求的结束字符
                writer.flush();//刷新缓冲区
                String response=scanner.next();//获取服务器端的响应
                System.out.println("server>>"+response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            socket.close();
        }

    }

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

该注意的点都在注释上啦!但是服务器端的代码还是有点问题~

来看下面的情况--假设有两个客户端同时上线,服务器只会与其中一个建立连接,只有处理完上一个客户端的请求,才能服务下一个客户端.

聪明的你一定想到了多线程,我们不如送佛送到西,创建一个线程池,避免线程频繁的创建/销毁

下面是更改后的服务器端代码~只是给服务器对象添加了一个线程池,修改了部分start()方法的代码

public class TCPServer {
    private ExecutorService pool= Executors.newCachedThreadPool();
    

    private void start() throws IOException {
        while(true){
            Socket respSocket=serverSocket.accept();//客户端与服务器连接成功后,服务器端会接收到一个Socket对象
            System.out.println("已与"+respSocket.getRemoteSocketAddress()+"建立连接");
            pool.submit(()->{
                try {
                    process(respSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });//基于这个Socket对象与客户端进行通信
        }
    }

}

这样就可以实现一个服务器同时与多个客户端进行交互了.