zoukankan      html  css  js  c++  java

  • 网络Socket编程及实例

    1 TCP和UDP介绍

    在介绍TCP和UDP之前，有必要先介绍下网络体系结构的各个层次。

    1.1  网络体系结构

    协议：控制网络中信息的发送和接收。定义了通信实体之间交换报文的格式和次序，以及在报文传输或接收或其他事件所采取的动作。

    一般把网络的层次结构和每层所使用协议的集合称为网络体系结构(NetworkArchitecture)。

    由国际标准化组织ISO 在1981年提出的网络分层结构，简称为OSI参考模型。(Open Systems Interconnection Reference Model)。

    各层协议如下，可以看出TCP和UDP协议在传输层。

    各层功能

    1）链路层

    链路层的功能：是把接收到的网络层数据报（也 称IP数据报）通过该层的物理接口发送到传输介质上，或从物理网络上接收数据帧，抽出IP数据报并交给IP层。

    链路层通常包括操作系统中的设备驱动程序和计算机中对应的网络接口卡。

    2）网络层

    主要功能：是可以把源主机上的分组发送到互联网中的任何一台目标主机上。

    3）传输层

    为运行在不同主机上的应用进程提供逻辑通信功能（主机好像是直接相连的）。

    进程之间使用逻辑通信功能彼此发送报文，无需考虑具体物理链路。

    传输层主要包括种协议：传输控制协议（TCP），用户数据报协议（UDP）。

    4）应用层

    应用层向使用网络的用户提供特定的、常用的应用程序。

    表示层：通信用户之间数据格式的转换、数据压缩及加解密等。

    会话层：对数据传输进行管理，包括数据交换的定界、同步，建立检查点等。

    1.2 套接字

    套接字是从网络向进程传递数据，或从进程向网络传递数据的门户。传输层和应用层的进程通过套接字来传递数据。

    主机上的套接字可以有多个，每个套接字都有惟一的标识符（格式取决于UDP或TCP）。

    当报文段到达主机时，运输层检查报文段中的目的端口号，将其定向到相应的套接字。

    1.3  用户数据报协议UDP

    用户数据报协议UDP（User Datagram Protocol）：提供用户之间的不可靠、无连接的报文传输服。使用UDP协议的原因

    1）无连接创建（减少时延）

    2）简单：无连接（在UDP发送方和接收方之间无握手）

    3）段首部小

    4）无拥塞控制: UDP能够尽可能快地传输

    经UDP的可靠传输 : 在应用层增加可靠性，实现特定的差错恢复！

    1.4 传输控制协议TCP

    传输控制协议TCP（Transmission Control Protocol）：提供用户之间可靠的、面向连接的报文传输服务。

    面向连接、可靠的服务是指在进行数据交换前，初始化发送方与接收方状态，进行握手（交换控制信息）。

    建立一个TCP 连接的作用：让发送方和接收方都做好准备，准备好之后就要开始进行数据传输了。三次握手建立TCP连接

    三次握手的目的主要在于同步连接双方发送数据的初始序列号。

    TCP 连接是一种全双工的连接，即一个TCP 连接的两个端点之间可以同时发送和接收数据，而不是每一个时刻只能有一个端点发送数据。

    1.5 TCP与UDP的比较

    TCP与UDP特点比较

    TCP 是一种面向连接的协议，而UDP 是无连接的协议。
    TCP 提供的是可靠的传输服务，而UDP 协议提供的是不可靠的服务。
    TCP 提供的是面向字节流的服务。
    UDP 协议的传输单位是数据块，一个数据块只能封装在一个UDP 数据包中。

    解释：

    1）可靠、连接

    UDP不可靠、无连接：在UDP发送方和接收方之间无握手（交换控制信息）。

    面向连接举例：两个人之间通过电话进行通信;

    面向无连接举例：邮政服务，用户把信函放在邮件中期待邮政处理流程来传递邮政包裹。显然，不可达代表不可靠。

    2）TCP面向字节流和UDP面向数据块（面向报文）

    面向报文的传输方式是应用层交给UDP多长的报文，UDP就照样发送，即一次发送一个报文。因此，应用程序必须选择合适大小的报文。若报文太长，则IP层需要分片，降低效率。若太短，会使IP太小。UDP对应用层交下来的报文，既不合并，也不拆分，而是保留这些报文的边界。这也就是说，应用层交给UDP多长的报文，UDP就照样发送，即一次发送一个报文。
           面向字节流的话，虽然应用程序和TCP的交互是一次一个数据块（大小不等），但TCP把应用程序看成是一连串的无结构的字节流。TCP有一个缓冲，当应用程序传送的数据块太长，TCP就可以把它划分短一些再传送。如果应用程序一次只发送一个字节，TCP也可以等待积累有足够多的字节后再构成报文段发送出去。

    TCP 协议与UDP协议应用的比较

    TCP 协议对于有大量数据需要进行可靠传输的应用是很适合的。比如可用于文件传输协议（FTP ）。
    对于虽然数据量少但需要时间较长且可靠性要求高的应用TCP 也是比较适合的。 Telnet 就是这种应用的一个例子。
    实时应用适合使用UDP 协议。
    对于多个实体间的多播式应用无法使用TCP 进行通信 。

    从程序实现的角度，TCP与UDP的过程如下

    从上图也能清晰的看出，TCP通信需要服务器端侦听listen、接收客户端连接请求accept，等待客户端connect建立连接后才能进行数据包的收发（recv/send）工作。而UDP则服务器和客户端的概念不明显，服务器端即接收端需要绑定端口，等待客户端的数据的到来。后续便可以进行数据的收发（recvfrom/sendto）工作。

    2 JAVA代码

    在JAVA中TCP套接字由Socket类实现，UDP套接字由DatagramSocket类实现。

    2.1 TCP的JAVA代码大致如下

    TCP网络编程步骤
    1）创建Socket
    2）打开连接到socket的输入、输出流
    3）按照一定的协议对socket进行读、写操作（接收消息-处理数据-发送消息）
    4）关闭socket
    服务端代码
    [java] view plain copy
     
    1. <span style="font-size:14px;">  public static start(){  
    2.         ServerSocket serverSocket=null;  
    3.         try {         
    4.             int i=1;  
    5.               
    6.             //1、创建TCP套接字  
    7.             int maxConnection="10";   //最大连接数  
    8.             serverSocket = new java.net.ServerSocket(8189,maxConnection);         
    9.               
    10.             //等待连接  
    11.             Socket sct=serverSocket.accept();  
    12.               
    13.             //输入输出流  
    14.             InputStream inStream = clientSocket.getInputStream();  
    15.             BufferedReader in = new BufferedReader(new InputStreamReader(inStream));  
    16.           
    17.             OutputStream outStream = clientSocket.getOutputStream();  
    18.             BufferedWriter out = new BufferedWriter(new OutputStreamWriter(outStream));  
    19.               
    20.             //接收消息-处理数据-发送消息  
    21.             //接收客户端消息  
    22.             String response="",lineStr = in.readLine();  
    23.             while(lineStr!=null){  
    24.               response += lineStr;  
    25.               lineStr = in.readLine();  
    26.            }//end while  
    27.              
    28.            //TODO 处理消息等及其动作  
    29.           
    30.           //向客户端发送信息（output-write）  
    31.           out.wirte("TODO");   
    32.         }   
    33.         catch (Exception e)  
    34.         {  
    35.             e.printStackTrace();  
    36.         }  
    37.         finally{  
    38.             if(serverSocket!=null)   //关闭套接字  
    39.               serverSocket.close();  
    40.         }  
    41.     }//end start()</span>  
    客户端代码与服务端代码类似，只不过服务端对客户端的请求是accept，而客户端需要连接服务端，所以使用connect方法，如下
    [java] view plain copy
     
    1. <span style="font-size:14px;">  public static start(){  
    2.         ServerSocket serverSocket=null;  
    3.         try {         
    4.             int i=1;  
    5.               
    6.             ////打开套接字  
    7.            Socket clientSocket = new Socket(String serverMachineIp, int port);  
    8.            int timeout=1000;               
    9.            clientSocket.connect(sa, timeout);     
    10.               
    11.             //输入输出流  
    12.             InputStream inStream = clientSocket.getInputStream();  
    13.             BufferedReader in = new BufferedReader(new InputStreamReader(inStream));  
    14.           
    15.             OutputStream outStream = clientSocket.getOutputStream();  
    16.             BufferedWriter out = new BufferedWriter(new OutputStreamWriter(outStream));  
    17.               
    18.             //接收消息-处理数据-发送消息  
    19.             /向客户端发送信息（output-write）  
    20.             out.wirte("TODO");   
    21.               
    22.             //TODO 处理消息等及其动作  
    23.               
    24.             //返回服务端的消息  
    25.             String response="",lineStr = in.readLine();  
    26.             while(lineStr!=null){  
    27.               response += lineStr;  
    28.               lineStr = in.readLine();  
    29.            }//end while   
    30.         }   
    31.         catch (Exception e)  
    32.         {  
    33.             e.printStackTrace();  
    34.         }  
    35.         finally{  
    36.             if(serverSocket!=null)   //关闭套接字  
    37.               serverSocket.close();  
    38.         }  
    39.     }//end start()</span>  

    2.1 UDP的JAVA代码大致如下

    服务端代码
    [java] view plain copy
     
    1. <span style="font-size:14px;">public class ServerDatagramSocket   
    2. {  
    3.       
    4.     public static void main(String[] args)   
    5.     {  
    6.         try  
    7.         {  
    8.             //1创建套接字，监听某个端口  
    9.             DatagramSocket ds = new DatagramSocket(10010);  
    10.               
    11.             //2接收数据  
    12.             //构造缓冲数组,用于存放接收到的数据(要求该长度必须大于或等于接收到的数据长度)  
    13.             byte[] data=new byte[1024];  
    14.             //构造数据包对象  
    15.             DatagramPacket receiveDp=new DatagramPacket(data, data.length);  
    16.             //接收数据  
    17.             ds.receive(receiveDp);   
    18.             //输出接收到的数据内容  
    19.             byte[] receiveByte=receiveDp.getData();  
    20.             String receiveContent=new String(receiveByte,0,receiveByte.length);  
    21.               
    22.             //3发送数据  
    23.             //准备数据  
    24.             //获得客户端的IP  
    25.             InetAddress clientIp=receiveDp.getAddress();  
    26.             //获得客户端的端口号  
    27.             int port=receiveDp.getPort();  
    28.             String sendContent="hello back";  
    29.             byte[] sendByte=sendContent.getBytes();  
    30.               
    31.             DatagramPacket sendDp=new DatagramPacket(sendByte, sendByte.length, clientIp, port);  
    32.               
    33.             ds.send(sendDp);              
    34.         }   
    35.         catch (Exception e) {  
    36.             // TODO: handle exception  
    37.         }  
    38.         finally{  
    39.             //4关闭连接  
    40.             ds.close();  
    41.         }     
    42.     }   
    43. }</span>  
    客户端代码
    [java] view plain copy
     
    1. <span style="font-size:14px;">public static void main(String[] args) {  
    2.           
    3.         try   
    4.         {  
    5.             //1创建连接  
    6.             DatagramSocket ds=new DatagramSocket();  
    7.               
    8.             //2发送数据  
    9.             //数据准备（数据内容+地址+端口号）  
    10.             String sendContent="hello";  
    11.             String host="127.0.0.1";  
    12.             int port=10001;  
    13.             //将发送的内容转换为字节数组  
    14.             byte[] sendByte=sendContent.getBytes();  
    15.             //将服务器IP转换为InetAddress对象  
    16.             InetAddress server=InetAddress.getByName(host);  
    17.             //构造发送的数据包对象  
    18.             DatagramPacket sendDp=new DatagramPacket(sendByte, sendByte.length, server, port);  
    19.               
    20.             //发送数据  
    21.             ds.send(sendDp);  
    22.                       
    23.             //3接收数据  
    24.             //构造缓冲数组,用于存放接收到的数据(要求该长度必须大于或等于接收到的数据长度)  
    25.             byte[] data=new byte[1024];  
    26.             //构造数据包对象  
    27.             DatagramPacket receiveDp=new DatagramPacket(data, data.length);  
    28.             //接收数据  
    29.             ds.receive(receiveDp);  
    30.             //输出数据内容  
    31.             byte[] receiveByte=receiveDp.getData();   //获得缓冲数组  
    32.             int len=receiveDp.getLength();   //获得有效数据长度  
    33.             String receiveContent=new String(receiveByte, 0, len);  
    34.             System.out.println(receiveContent);   
    35.         }   
    36.         catch (Exception e)   
    37.         {  
    38.             // TODO: handle exception  
    39.         }  
    40.         finally{  
    41.             //4关闭连接  
    42.             ds.close();  
    43.         }  
    44.     }  
    45. }</span>  

    3 应用（TCP和多线程的应用）

    在工作中遇到如下问题：一个算法执行程序可以部署到多台机器上，一台机器上可以部署多个算法执行程序，即算法程序和机器是多对多的关系。现在要求用户只需要输入提供算法的名称和相关算法参数（如数据路径），然后返回数据处理结果。
    解决方案：
    服务端为多台部署算法程序的机器。客户端响应用户算法的请求，并从服务端多台机器中选择最优机器执行用户的算法处理。由于一台服务端机器可能会同时处理多个用户算法请求，而每个算法处理数据的过程（数据下载，数据处理，处理结果上传）是个比较长的时间，所以服务端程序采用多线程并行执行多个算法的请求。这个用一个共享FTP来在服务端和客户端共享处理的数据和上传处理后的数据。服务端和客户端通过TCP协议保证可靠的、面向连接的通信服务。整个系统架构如下图
    实现代码的关键部分如下
    服务端代码
    [java] view plain copy
     
    1. /* 
    2. 服务器端模块功能： 
    3. 运行在多台服务端机器上面，监听和接收客户端机器发送的多个算法请求； 
    4. 业务逻辑： 
    5. 根据接收到的算法请求参数，启动一个新的线程，运行算法处理程序，完成最终的数据处理任务 
    6.  */  
    7. public class ServerSocketApplication {  
    8.   
    9.     /** 
    10.      * @param args 
    11.      */  
    12.     public static void main(String[] args) {  
    13.         start();  
    14.     }//end main()  
    15.       
    16.     public static start(){  
    17.         ServerSocket serverSocket=null;  
    18.         ExecutorService threadPool=null; //用线程池管理线程  
    19.         try {         
    20.             //1、创建TCP套接字  
    21.             int maxConnection="10";   //最大连接数  
    22.             serverSocket = new ServerSocket(8189,maxConnection);          
    23.               
    24.             while(true)  {  //while循环,不停等待算法任务的请求.服务端每接到一个算法处理请求，就开启一个线程处理该请求  
    25.                 //等待连接  
    26.                 Socket sct=serverSocket.accept();  
    27.                 //Create a work thread to deal with a socket request  
    28.                //创建一个线程池  
    29.                //获得可用的处理器个数Runtime.getRuntime().availableProcessors()  
    30.                // int threadPoolSize=Runtime.getRuntime().availableProcessors() +1;   
    31.               //  ExecutorService threadPool= Executors.newFixedThreadPool(threadPoolSize);  
    32.                threadPool= Executors.newCachedThreadPool();  
    33.                //将线程放入线程池中  
    34.                LogicThread logicThread = new LogicThread( sct );   
    35.                Thread thd = new Thread( logicThread );  
    36.                threadPool.execute(thd);  
    37.             }   //end while   
    38.         }   
    39.         catch (Exception e)  
    40.         {  
    41.             e.printStackTrace();  
    42.         }  
    43.         finally{  
    44.             if(threadPool!=null)  
    45.               threadPool.shutdown(); //关闭线程池  
    46.             if(serverSocket!=null)   //关闭套接字  
    47.               serverSocket.close();  
    48.         }  
    49.     }//end start()  
    50. }//end class ServerSocketApplication  
    [java] view plain copy
     
    1. //-----------------------------------  
    2. //LogicThread的任务是具体负责一次算法执行任务的处理，流程：  
    3. //1.解析客户端发送的算法请求参数 2. 根据请求参数中的算法名称和类型，调用具体某个算法  
    4. public class LogicThread implements Runnable {  
    5.     private Socket  clientSocket = null;  
    6.       
    7.     public LogicThread( ){  
    8.     }  
    9.     /** 
    10.      * Constructor 
    11.      * @param sck 
    12.      */  
    13.     public LogicThread( Socket clientSocket){  
    14.         this.clientSocket = clientSocket;  
    15.     }  
    16.       
    17.     public void run(){  
    18.           clientContentHandle();  
    19.     }//end run()  
    20.       
    21.     /** 
    22.      * 接收客户端消息，处理客户端消息，发送消息到客户端 
    23.      * @param clientContent 发送的消息 
    24.      * @param serverMachineIp 目标服务器地址 
    25.      * @param port 目标服务器监听端口 
    26.      * @return   返回的消息 
    27.      */  
    28.     private static void clientContentHandle() throws Exception{                           
    29.         InputStream inStream = clientSocket.getInputStream();  
    30.         BufferedReader in = new BufferedReader(new InputStreamReader(inStream));  
    31.           
    32.         OutputStream outStream = clientSocket.getOutputStream();  
    33.         BufferedWriter out = new BufferedWriter(new OutputStreamWriter(outStream));  
    34.           
    35.         try{  
    36.           //接收客户端消息  
    37.           String response="",lineStr = in.readLine();  
    38.           while(lineStr!=null){  
    39.               response += lineStr;  
    40.               lineStr = in.readLine();  
    41.           }//end while  
    42.             
    43.           //TODO 处理消息  
    44.           //如根据客户端发送的算法请求及其参数，调用对应的算法开始处理数据，并将处理结果上传到FTP  
    45.           
    46.           //向服务端发送信息（output-write）  
    47.           out.wirte("successfull"); //处理完通知客户端  
    48.         }  
    49.         catch (Exception e)   
    50.          {  
    51.             e.printStackTrace();  
    52.         }  
    53.         finally{  
    54.             //关闭输入输出流  
    55.             out.close();  
    56.             in.close();  
    57.             //关闭套接字  
    58.             s.close();  
    59.         }  
    60.           
    61.         //处理服务端返回消息（这里直接返回）  
    62.         return response;  
    63.     }//end clientContentHandle()  
    64. }//end class LogicThread  
    客户端代码
    [java] view plain copy
     
    1. /* 
    2. 客户端模块功能：选择算法程序所在的最优的服务端机器，向该服务器端机器发送算法调用请求； 
    3. */  
    4. public class ClientSocketApplication {  
    5.   
    6.     public static void main(String[] args)  
    7.     {         
    8.         //处理服务端返回消息       
    9.         String response=sendMsg("10.3.11.33",9090);       
    10.         if(response==null)  
    11.            System.out.println("Socket服务器连接失败：请检查安装的Socket服务器是否正常工作!");  
    12.              
    13.         processData("send algorithem name and its parameters");//此处省略掉算法的名称和其参数  
    14.     }//end main()  
    15.       
    16.       
    17.     /** 
    18.      * 向指定的服务器发送信息，并接收返回结果 
    19.      * @param sendContent 发送的消息 
    20.      * @param serverMachineIp 目标服务器地址 
    21.      * @param port 目标服务器监听端口 
    22.      * @return   返回的消息 
    23.      */  
    24.     public static String sendMsg(String sendContent, String serverMachineIp, int port) throws Exception{  
    25.         //服务端消息返回结果  
    26.         String response=null;  
    27.           
    28.         //打开套接字  
    29.         Socket clientSocket = new Socket(String serverMachineIp, int port);  
    30.         int timeout=1000;              
    31.         clientSocket.connect(sa, timeout);    
    32.           
    33.         OutputStream outStream = clientSocket.getOutputStream();  
    34.         BufferedWriter out = new BufferedWriter(new OutputStreamWriter(outStream));  
    35.           
    36.         InputStream inStream = clientSocket.getInputStream();  
    37.         BufferedReader in = new BufferedReader(new InputStreamReader(inStream));  
    38.           
    39.         try{  
    40.           //向服务端发送信息（output-write）  
    41.           out.wirte(sendContent);  
    42.           
    43.           //接收服务端返回消息  
    44.           String lineStr = in.readLine();  
    45.           while(lineStr!=null){  
    46.               response += lineStr;  
    47.               lineStr = in.readLine();  
    48.           }//end while  
    49.         }  
    50.         catch (Exception e)   
    51.          {  
    52.             e.printStackTrace();  
    53.         }  
    54.         finally{  
    55.             //关闭输入输出流  
    56.             out.close();  
    57.             in.close();  
    58.             //关闭套接字  
    59.             s.close();  
    60.         }  
    61.           
    62.         //处理服务端返回消息（这里直接返回）  
    63.         return response;  
    64.     }//end sendMsg()  
    65.       
    66.     /*  
    67.     */  
    68.       
    69.      /** 监听服务端处理数据过程 
    70.     客户端选择最优的服务端处理机器 
    71.     客户端将算法名称及其参数（如要处理数据的地址）发送给服务端 
    72.     客户端监听服务端发回的消息，判断数据是否处理完成，如果完成打包下载处理结果（服务端数据处理完会上传处理结果和日志文件log.xml到共享FTP上，供客户端下载） 
    73.      * @param algName 
    74.      *            请求算法资源名称 
    75.      * @param reqValues 
    76.      *            请求参数 
    77.      * @return 算法返回结果，无结果返回<code>null</code> 
    78.      */  
    79.     public static void processData(String algName, Map<String, String> reqValues) throws ManagerException  
    80.     {  
    81.         //一个算法可以部署到不同的机器上，这里随机选择一台部署该算法的机器(在具体开发中应该根据资源占用情况选择等因素，采用高响应比调度算法分配资源)  
    82.         CMachine optCMachine=getOptCMachine(algName);    
    83.         String sendRequest=createReqStr(algName, reqValues);  // 生成算法资源请求文件  
    84.           
    85.         // 发送Socket连接，并等待返回结果  
    86.         try {  
    87.             String response = sendMsg(reqStr, optCMachine.getIp(),optCMachine.getPort());  
    88.             if ( !response.eques("processing") || !response.eques("successfull")) {  //如果服务端返回的消息是正在处理数据或处理成功，则正常，否则服务端出现异常  
    89.                    throw new ManagerException("向服务器发送计算请求失败: " + response);  
    90.             }   
    91.               
    92.             // 开始循环监视工作目录，是否已经完成处理，标识为有log.xml文件  
    93.             String monitDir = FileTool.getNodeManagerShareDir() + "/" + jobID + "/" + algName + "/output";  
    94.             File logFile = new File(monitDir + "/log.xml");  
    95.             for (;;) {  
    96.                 if (logFile.exists()) {  
    97.                     logger.info("Log文件已经上传，算法处理完成; 开始打包文件");  
    98.                     ZipTool.zipFiles(monitDir); //打包文件  
    99.                     break;  
    100.                 } else {  
    101.                     Thread.sleep(30000);  
    102.                     logger.info("请求正在处理中...: " + algName);  
    103.                 }  
    104.             }  
    105.         } catch (Exception e) {  
    106.             throw new ManagerException("算法服务器处理请求时出错，请与节点管理员联系查看原因");  
    107.         }     
    108.     }//end processData()  
    109. }//end ClientSocket  
  • 相关阅读:
    免费下载 80多种的微软推出入门级 .NET视频
    和付费网盘说再见，自己搭建个人网盘（Java 开源项目）
    JS惰性删除和定时删除可过期的localStorage缓存，或sessionStorage缓存
    docker——系列文章
    Bash 脚本教程
    Sublime text3里 修改TAB键为缩进为四个空格
    百度网盘不限速，直接获取直链
    技术党适合做浏览器首页的网站
    常用电脑软件
    有哪些开源的 Python 库让你相见恨晚？
  • 原文地址：https://www.cnblogs.com/klb561/p/9011615.html
Copyright © 2011-2022 走看看