• Socket套接字

    Socket的概念

    Socket是由操作系统提供用于网络编程的一组API，是基于TCP/IP协议网络通信的基本操作单元。socket本质上是一个文件描述符，是用来描述文件的，在JAVA中一切都是文件。

    我们在网络编程中要使用到网卡，网卡是一个硬件设备，计算机中通过操作系统来管理网卡，因此网卡就被描述为一个文件，这个文件就是Socket文件。所以说要想网络编程，就需要操作网卡，要想操作网卡，就需要先创建socket文件出来，通过读写这个socket文件来实现网络数据的传输。

    网络编程中需要建立客户端和服务器模型：当我们在网上输入一个请求时，服务器接收到请求并做出相应的处理，然后将处理的结果返回给客户端，客户端这边收到服务器的响应后将结果显示出来。

    Socket的分类  

    流套接字(使用传输层TCP协议)

    JAVA流套接字通信模型 

     

     

    数据报套接字(使用传输层UDP协议) 

    Java数据报套接字通信模型

    java 中使用 UDP 协议通信，主要基于 DatagramSocket 类来创建数据报套接字，并使用
    DatagramPacket 作为发送或接收的 UDP 数据报。对于一次发送及接收 UDP 数据报的流程如下：

     

     

    TCP协议 

    TCP和UDP都属于传输层协议，关于这两个协议会在后面的博客中详细介绍，现在只讨论Socket如何利用这两个协议来实现客户端和服务器之间的传输。

    TCP协议的特点 

    • 有连接
    • 可靠传输
    • 面向字节流
    • 有发送缓冲区和接收缓冲区
    • 全双工
    • 大小不受限制 

    对上面的特点进行分析：有连接就好比我们生活中的打电话，发起打电话的一方只有在另一方接起电话以后才能进行信息交流。

    可靠传输这里先不讲，这里面的东西太多了。

    面向字节流可以想象成生活中的喝水，我们在拿到一瓶水的时候，可以分几次喝完，也可以一次性喝完，水终究只有一瓶 。也就是说我们在传输数据的时候非常灵活，可以一次传输一个数据，也可以一次传输多个数据。

    发送缓冲区和接收缓冲区是对这种数据流专门设置的一个相当于蓄水池的内存空间。

    全双公是指双向通信，同一时间你我可以同时说话，在文件中就是既能读也能写。

    大小不受限制这块主要是为了区别UDP协议。

    TCP流套接字编程 

    服务端

    主要使用的是ServerSocket API来进行编程，下面是ServerSocket的构造方法

    ServerSocket(int port)    功能：创建一个服务端流套接字Socket，并绑定到指定端口

     ServerSocket的主要方法

    1. Socket accept()    开始监听指定端口(创建对象时绑定的窗口)，有客户连接后，返回一个Socket对象，并基于该Socket建立与客户端的连接，否者阻塞等待。
    2. close()            关闭此套接字

    客户端 

    主要使用的是Socket API来进行编程，同时服务端中接收到客户端建立连接(accept方法)的请求后，返回的服务端Socket

    Socket构造方法 

    Socket(String host,int port)    功能：创建一个客户端流套接字，并与对应IP的主机上，对应端口的进程建立连接

    Socket的主要方法 

    1. getInetAddress()    功能：返回流套接字所连接的地址
    2. getInputStream()    功能：返回此流套接字的输入流
    3. getOutputStream()   功能：返回此套接字的输出流

    下面根据一个需求演示一下它们的使用：

    写一个环回网络服务器，所谓环回网络服务器是指客服端发送什么消息，服务器就返回什么消息。

    下面根据网络编程模型来写代码，关于网络编程模型可以看我的上一篇博客网络编程的原理和基础概念_咸鱼吐泡泡的博客-CSDN博客 

    1. //下面是客户端的代码
    2. /**
    3.  * 客户端代码，客户端需要做的事情：
    4.  * 1.客户端构造请求并发送给服务器(在这个过程中要知道服务器的IP和端口号，IP因为是一台主机上面测试，所以就是127.0.0.1)
    5.  * 2.客户端接收服务器返回来的响应并显示
    6.  */
    7. @SuppressWarnings("all")
    8. public class TcpEchoClient {
    9.     private String serverIp;//服务器IP
    10.     private int serverPort;//服务器端口号
    11.     private Socket socket;//套接字
    12.  
    13.     public TcpEchoClient(String serverIp, int serverPort) throws IOException {
    14.         this.serverIp = serverIp;
    15.         this.serverPort = serverPort;
    16.         this.socket = new Socket(serverIp,serverPort);//创建对象的同时就建立连接
    17.     }
    18.  
    19.     public void start(){//启动方法
    20.         //创建一个容器，用来接收用户的输入
    21.         Scanner scanner = new Scanner(System.in);
    22.         try(InputStream inputStream = socket.getInputStream();//socket.getInputStream()返回一个输入流，该方法的作用是将套接字中的字节放入输入流中
    23.             OutputStream outputStream = socket.getOutputStream()) {//socket.getOutputStream()返回一个输出流，该方法的作用是将字节写入套接字中
    24.             while(true){
    25.                 //1.从键盘上读取用户输入的数据
    26.                 System.out.print("->");
    27.                 String request = scanner.next();
    28.                 if (request.equals("exit")){
    29.                     System.out.println("goodbey");
    30.                     break;
    31.                 }
    32.                 //2.将用户输入的数据构造成请求，并发送给服务器
    33.                 PrintWriter printWriter = new PrintWriter(outputStream);
    34.                 printWriter.println(request);
    35.                 printWriter.flush();
    36.  
    37.                 //3.从服务器上面读取响应并解析
    38.                 Scanner respScanner = new Scanner(inputStream);
    39.                 String response = respScanner.next();
    40.  
    41.                 //4.把结果显示在屏幕上
    42.                 String log = String.format("req: %s; res: %s",request,response);
    43.                 System.out.println(log);
    44.             }
    45.         } catch (Exception e) {
    46.             e.printStackTrace();
    47.         }
    48.     }
    49.  
    50.     public static void main(String[] args) throws IOException {
    51.         TcpEchoClient tcpEchoClient = new TcpEchoClient("127.0.0.1", 1234);
    52.         tcpEchoClient.start();
    53.     }
    54. }
    论文研究-基于MFC的网络编程的原理及实现 .pdf
    .pdf 0星 超过10%的资源 195KB
    下载
    1. //下面是服务器程序
    2. public class TcpEchoService {
    3.     private ServerSocket listenSocket = null;
    4.  
    5.     public TcpEchoService(int port) throws IOException {
    6.         this.listenSocket = new ServerSocket(port);
    7.     }
    8.     public void start() throws IOException {
    9.         System.out.println("服务器启动");
    10.         while(true){
    11.             /**
    12.              * UDP的服务器进入主循环，就直接尝试receive读取请求了，但是TCP是有连接的，现需要做的是，建立好连接，当服务器运行的时候
    13.              * 当前是否有客户端来建立连接，不确定。如果客户端没有建立连接，accept就会阻止等待，如果有客户端建立连接，此时accept就会返回一个Socket
    14.              * 对象，进一步的服务器和客户端之间的交互，就交给clientSocket来完成了
    15.              */
    16.             Socket clientSocket = listenSocket.accept();
    17.             Connection(clientSocket);
    18.         }
    19.     }
    20.     public void Connection(Socket clientSocket) throws IOException {
    21.         String log = String.format("[%s: %d] 客户端已上线",clientSocket.getInetAddress().toString(),
    22.                 clientSocket.getPort());
    23.         System.out.println(log);
    24.         try(InputStream inputStream = clientSocket.getInputStream();
    25.             OutputStream outputStream = clientSocket.getOutputStream()){
    26.             while(true){
    27.                 /**
    28.                  * 1.读取请求并解析，可以直接通过inputStream的read把数据读到一个byte[]，然后再转成一个String
    29.                  * 但是比较麻烦，还可以借助Scanner来完成这个任务
    30.                  */
    31.                 Scanner scanner = new Scanner(inputStream);
    32.                 if(!scanner.hasNext()){
    33.                     log = String.format("[%s:%d] 客户端已下线",clientSocket.getInetAddress().toString(),clientSocket.getPort());
    34.                     System.out.println(log);
    35.                     break;
    36.                 }
    37.                 String request = scanner.next();
    38.                 //2.根据请求计算响应
    39.                 String response = process(request);
    40.                 //3.把响应写回到客户端
    41.                 PrintWriter writer = new PrintWriter(outputStream);
    42.                 writer.println(response);
    43.                 writer.flush();
    44.                 //打印日志
    45.                 log = String.format("[%s:%d] req: %s; res: %s",clientSocket.getInetAddress().toString(),
    46.                         clientSocket.getPort(),request,response);
    47.                 System.out.println(log);
    48.             }
    49.         } catch (IOException e) {
    50.             e.printStackTrace();
    51.         } finally{
    52.             clientSocket.close();
    53.         }
    54.     }
    55.     public String process(String request){
    56.         return request;
    57.     }
    58.  
    59.     public static void main(String[] args) throws IOException {
    60.         TcpEchoService tcpEchoService = new TcpEchoService(1234);
    61.         tcpEchoService.start();
    62.     }
    63. }

    结果：

    UDP协议

    User Datagram Protocol（用户数据报协议），是传输层协议

    UDP协议的特点

    • 无连接
    • 不可靠传输
    • 面向数据报
    • 全双工
    • 有接收缓冲区，没有发送缓冲区
    • 大小受到限制，一次最多传输64K

    解释上面每个特点的含义：

    无连接相当于发微信，不管对方在不在线都可以发送，对方什么时候看到消息就可以什么时候回复。不可靠传输是相对于发送方来说的，因为他不知道对方是否在线。

    面向数据报指的是：把一个一个的数据报作为基本单位，发送的时候，一次至少发一个数据报，接收的时候，一次至少接收一个数据报。

    使用UDP协议来传输数据报，接收方要构造一个空的字节数组来存储接收到的数据。

    因为UDP协议首部中有一个16位的最大长度，所以一个UDP所能传输的数据报最大长度是64K。

    UDP数据报套接字编程

    DatagramSocket 

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

    1. DatagramSocket()                功能：创建一个UDP数据报套接字Socket，绑定到本机任意一个随机端口(一般用于客户端)
    2. DatagramSocket(int port)        功能：创建一个UDP数据报套接字Socket，绑定到本机任意一个随机端口(一般用于服务器)

     DatagramSocket的方法：

    socket套接字编程
    rar 0星 超过10%的资源 1.48MB
    下载
    1. receive(DatagramPacket)        功能：以DatagramSocket为单位接收数据报(如果没有接受到数据报，该方法会阻塞等待)
    2. send(DatagramSocket)           功能：以DatagramSocket为单位发送数据包(不会阻塞等待，直接发送)
    3. close()                        功能：关闭此数据报套接字

    DatagramPacket 

    是发送/接收的数据报

    DatagramPacket的构造方法：

    1. DatagramPacket(byte[] buf,int length)                                    功能：构造一个DatagramPacket用来接收数据报，接收的数据存放在buf数组里面，存储数据的长度为length
    2. DatagramPacket(byte[] buf,int offset,int length,SocketAddress address)   功能：构造一个DatagramPacket用来发送数据报，发送的数据在buf里面，发送0~length的长度，address用来指定目的主机的IP和端口号

     DatagramPacket的方法

    1. InetAddress/getAddress()        功能：获取到数据报中的IP地址
    2. getPort()                       功能：获取到数据报中的中端口号
    3. getDate()                       功能：获取数据报中的数据

     

    同样写一个环回网络服务器：

    下面是客户端的代码：

    1. @SuppressWarnings("all")
    2. public class UdpSocket_Client {
    3.     private String ServerIp;
    4.     private int ServerPort;
    5.     private DatagramSocket socket = null;
    6.  
    7.     public UdpSocket_Client(String serverIp, int serverPort) throws SocketException {
    8.         this.ServerIp = serverIp;
    9.         this.ServerPort = serverPort;
    10.         this.socket = new DatagramSocket();
    11.     }
    12.     public void start() throws IOException {
    13.         //让用户输入一个数据
    14.         Scanner scanner = new Scanner(System.in);
    15.         while(true){
    16.             System.out.print("-> ");
    17.             String request = scanner.next();
    18.             if(request.equals("exit")){
    19.                 System.out.println("goodbey");
    20.                 return;
    21.             }
    22.             //1.构造请求————构造一个发送数据报，此数据报中包含要发送的内容，同时还要包含指定目的主机的Ip和端口号
    23.             DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,
    24.                     InetAddress.getByName(ServerIp),ServerPort);
    25.             //2.发送请求
    26.             socket.send(requestPacket);
    27.  
    28.             //3.读取服务器返回来的响应
    29.             DatagramPacket responsePacket = new DatagramPacket(new byte[4096] ,4096);
    30.             socket.receive(responsePacket);
    31.             String response = new String(responsePacket.getData(),0,responsePacket.getLength());
    32.  
    33.             //显示结果
    34.             String log = String.format("req: %s; resp: %s",request,response);
    35.             System.out.println(log);
    36.         }
    37.     }
    38.  
    39.     public static void main(String[] args) throws IOException {
    40.         UdpSocket_Client udpSocket_client = new UdpSocket_Client("127.0.0.1", 333);
    41.         udpSocket_client.start();
    42.     }
    43. }

    下面是服务器的代码：

    1. public class UdpSocket_Server {
    2.     private DatagramSocket socket = null;
    3.     /**
    4.      * port表示端口号，服务器启动的时候需要关联一个端口号。收到数据的时候，就会
    5.      * 根据这个端口号来决定把数据交给那个进程。虽然此处port写的类型是int，但是实际上端口号是一个两个字节的无符号整数
    6.      * 范围在0-65535
    7.      * @param port
    8.      * @throws SocketException
    9.      */
    10.     public UdpSocket_Server(int port) throws SocketException {
    11.         this.socket = new DatagramSocket(port);
    12.     }
    13.     public void start() throws IOException {
    14.         System.out.println("服务器启动");
    15.         while(true){
    16.             /**
    17.              * 读取请求，当前服务器不知道客户端什么时候发来请求，receive方法也会阻塞，如果真的有请求过来，此时
    18.              * receive就会返回，参数DatagramPacket是一个输出型参数,socket中独到的数据会设置到这个参数的对象中，
    19.              * DatagramPacket在构造的时候，需要指定一个缓冲区
    20.              */
    21.             DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
    22.             //接收到请求
    23.             socket.receive(requestPacket);
    24.             //1.读取请求
    25.             String request = new String(requestPacket.getData(),0, requestPacket.getLength());
    26.             //2.根据请求计算出响应
    27.             String response = process(request);
    28.             /**
    29.              * 3.把响应写回到客户端，这时候也要构造一个DatagramPacket,此处给DatagramPacket中设置长度，必须是字节的个数
    30.              * 如果直接response.length()此处得到的是字符串的长度，也就是字符的个数
    31.              */
    32.             DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), requestPacket.getLength(),
    33.                     requestPacket.getSocketAddress());
    34.             socket.send(responsePacket);
    35.  
    36.             //打印日志
    37.             String log = String.format("[%s:%s] req:%s; resp:%s",
    38.                     requestPacket.getAddress().toString(),
    39.                     requestPacket.getPort(),
    40.                     request,
    41.                     response);
    42.             System.out.println(log);
    43.         }
    44.     }
    45.  
    46.     public String process(String request){
    47.         return request;
    48.     }
    49.  
    50.     public static void main(String[] args) throws IOException {
    51.         UdpSocket_Server udpSocket_server = new UdpSocket_Server(333);
    52.         udpSocket_server.start();
    53.     }
    54. }

     

    TCP和UDP的适用场景

    • TCP用于可靠传输的情况，应用于文件传输，重要状态更新等场景；
    • UDP适用于高速传输和实时性要求较高的通信领域；
    • 如果传输单个数据报大于64K使用TCP，如果需要广播，使用UDP；

  • 相关阅读:
    CentOS 7镜像下载 以及 DVD ISO 和 Minimal ISO 等各版本的区别介绍
    关于 JavaScript 中 null 的一切
    html笔记
    2023，8种必备Selenium编写自动化用例的技巧！
    深入理解强化学习——强化学习的目标和数据
    省钱兄短剧短视频小程序是如何运营的？
    相机标定、校正和投影
    【JavaScript】巩固JS开发中十个常用功能/案例（21-30）（牛客题解）
    设计师设计相关图表时，如何运用设计技巧与合理的用户体验？【大屏可视化（PC端、移动端）】
    GDPU 数据结构 天码行空3
  • 原文地址：https://blog.csdn.net/yahid/article/details/126109477