tcp 数据传输实例测试

最新推荐文章于 2024-02-26 15:36:46 发布
原创 最新推荐文章于 2024-02-26 15:36:46 发布 · 置顶 · 813 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#tcp #byte #socket #stream #sockets #string

本文提供了一个使用VC++和Java实现的TCP客户端-服务器通信示例，演示了一次连接后持续发送数据的过程。VC++部分使用Winsock库进行网络编程，而Java部分则利用标准库完成网络交互。
 
  1. #include <Winsock2.h>
  2. #include <stdio.h>
  4. void main()
  5. {
  6.     WORD wVersionRequested;
  7.     WSADATA wsaData;
  8.     int err;
  10.     wVersionRequested = MAKEWORD( 2, 2 );
  12.     err = WSAStartup( wVersionRequested,&wsaData);
  13.     if( err != 0){
  14.         return;
  15.     }
  17.     if( LOBYTE( wsaData.wVersion)!= 2||
  18.         HIBYTE(wsaData.wVersion)!= 2)
  19.     {
  20.         WSACleanup();
  21.         return;
  22.     }
  23.     //SOCKET    sockClient = socket(AF_INET,SOCK_STREAM,0);
  25.     SOCKADDR_IN addrSrv;
  26.     addrSrv.sin_addr.S_un.S_addr = inet_addr("10.150.20.45");
  27.     addrSrv.sin_family = AF_INET;
  28.     addrSrv.sin_port = htons(6000);
  29.     SOCKET  sockClient;
  30.         
  31.                 sockClient = socket(AF_INET,SOCK_STREAM,0);
  32.         connect(sockClient,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));
  33.     for(int i=0;i<30;i++)
  34.     {
  36.         //char recvBuf[100];
  37.         //recv(sockClient,recvBuf,100,0);
  38.         //printf("%s/n",recvBuf);
  39.         try{
  40.             
  41.             send(sockClient,"This",strlen("This"),0);
  42.         }catch(...)
  43.         {
  44.             printf("%s/n","Errors");
  45.             sockClient = socket(AF_INET,SOCK_STREAM,0);
  46.             connect(sockClient,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));
  47.         }
  49.         
  50.         Sleep(500);
  51.     }
  52.     closesocket(sockClient);
  53.     WSACleanup();
  55.     //Sleep(10000);
  56.     return;
  57.     
  58. }

vc++的程序在VS2008运行，还需要增加一个lib  #pragma comment(lib, "ws2_32.lib") 我在在编译器加 或者直接加到代码中，

程序强调，一次连接，持续发送数据，所有对一些细节如多个客户端连接的处理，没有涉及，我还有些疑问就是，发送字节不定长的处理。

  1. #include <Winsock2.h>
  2. #include <stdio.h>
  5. void main()
  6. {
  7.     WORD wVersionRequested;
  8.     WSADATA wsaData;
  9.     int err;
  11.     wVersionRequested = MAKEWORD( 2, 2 );
  13.     err = WSAStartup( wVersionRequested,&wsaData);
  14.     if( err != 0){
  15.         return;
  16.     }
  18.     if( LOBYTE( wsaData.wVersion)!= 2||
  19.         HIBYTE(wsaData.wVersion)!= 2)
  20.     {
  21.         WSACleanup();
  22.         return;
  23.     }
  24.     SOCKET sockSrv = socket(AF_INET,SOCK_STREAM,0);
  26.     SOCKADDR_IN addrSrv;
  27.     addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
  28.     addrSrv.sin_family = AF_INET;
  29.     addrSrv.sin_port= htons(6000);
  31.     bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));
  33.     err = listen(sockSrv,5);
  34.     if(err!=0)
  35.     {
  36.         //getErrors
  37.         err = WSAGetLastError();
  38.     }
  40.     SOCKADDR_IN addrClient;
  41.     int len = sizeof(SOCKADDR);
  42.     SOCKET sockConn =  accept(sockSrv,(SOCKADDR*)&addrClient,&len);
  43.     
  44.     while(1)
  45.     {
  46.         
  47.         //char sendBuf[100];
  48.         //sprintf_s(sendBuf,"Welcome %s to http://www.sunxin.org",
  49.         //  inet_ntoa(addrClient.sin_addr));
  50.         //send(sockConn,sendBuf,strlen(sendBuf)+1,0);
  51.         char recvBuf[4];
  52.         int sign = recv(sockConn,recvBuf,4,0);
  53.         printf("%s/n",recvBuf);
  54.         
  55.         
  56.     }
  57.     closesocket(sockConn);
  58.     return;
  59. }

下面是java实现的,源程序

  1. package coldwind.socket.Server;
  3. import java.net.*;
  4. import java.io.*;
  5. import eccl.socket.tools.*;
  7. public class TcpServer{
  8.     
  9.     public static void main(String[] args) throws Exception{
  10.         
  11.         ServerSocket ss = new ServerSocket(6000);
  12.         Socket s = new Socket();
  13.         
  14.         System.out.println ("start");
  15.         s = ss.accept();
  17.         System.out.println("A client has heen connected.");
  18.         DataInputStream r = new DataInputStream(s.getInputStream()); 
  20.         int count=0;
  21.         while(true){
  22.        
  23.             try {
  24.                 
  25.                 //Thread.sleep(10);
  27.                 byte c = 0;
  28.                 byte[] sendType = new byte[128];
  29. //              if(r.read()<=0)
  30. //                  continue;
  31.                 Thread.sleep(100);      
  32.                 for(int i=0;i<4;i++){
  33.                     c = r.readByte();
  34.                     sendType[i]=c;
  35.                 }
  36.                 System.out.println ("count:"+count);
  37.                 count++;
  38.                 System.out.println ("sendType: "+ByteOperator.getStr(sendType,0,4));
  39.                 
  40.             }
  41.             catch(EOFException eof)
  42.             {
  43.                 continue;
  44.             }
  45.             catch (Exception ex) {
  46.                 
  47.                 s.close();
  48.                 System.out.println (ex.toString());
  49.                 continue;
  50.                 
  51.             }
  52.             
  53.                      
  56.         }
  57.         
  58.     }
  59. }

 

 

 

  1. package coldwind.socket.Client;
  3. import java.net.*;
  4. import java.io.*;
  5. import java.sql.Connection;
  6. import java.sql.DriverManager;
  7. import java.sql.Statement;
  8. import eccl.socket.tools.ByteOperator;
  12. /**
  13.  * 发送实时数据包类
  14.  */
  16. public class TcpClient{
  17.     
  18.     public TcpClient(){
  19.         
  20.     }
  22.     private static String ip = "127.0.0.1";
  23.     private static int port = 6000;
  25.     public static Socket socket = null;
  27.     public static BufferedOutputStream bufos = null;
  29.     
  30.     public static boolean isException = false;//是否有异常
  31.     public static String errors = "";
  34. /**
  35.  *  获得与TcpServer的连接
  36.  */
  38.     public static void socketClose(){
  39.         try {
  40.             if(socket!=null){
  41.                 if(!socket.isClosed())
  42.                     socket.close();
  43.             }
  44.         } catch (IOException e) {
  45.             // TODO 自动生成 catch 块
  46.             e.printStackTrace();
  47.         }
  48.     }
  49.     
  51.     //进行连接
  52.     
  53.     public static void getTcpSocket(){
  54.         try {
  56.             SocketAddress socketAddr1 = new InetSocketAddress(ip,port);
  57.             socket = new Socket();
  58.             socket.connect(socketAddr1);
  59.                     
  61.         }
  62.         catch (Exception ex) {
  63.             System.out.println ("Do not Connect the TcpServer!/n"+ex);
  66.         }
  67.     }
  68.     
  70.     public static  void  sendThread(byte[] sendByte){
  71.         int unitNo = 0;
  72.         try{
  73.             
  74.             for(int k=0;k<5;k++)
  75.             {
  76.                 bufos = new BufferedOutputStream(socket.getOutputStream()); 
  77.                 Thread.sleep(2000);
  78.                 bufos.write(sendByte);  
  79.                 
  80.                 System.out.println ("k:"+k);
  81.                 bufos.flush();  
  82.                 
  83.                 //bufos.close();            
  84.             }
  85.             //开始时间戳,4个字节       
  87.             if(isException){
  88.                 isException = false;
  89.             }
  90.         
  91.         }catch(Exception e){
  92.             
  93.             
  94.             System.out.println(e);
  96.             if(!isException){
  98.                 isException = true;
  99.             }
  100.             
  101.             
  102.             System.out.print("RealSend The program can't send the date!/n");
  103.             //设定保存的目录
  106.             
  107.         }
  108.         
  109.         System.out.print("/n");     
  110.         
  111.     }
  112.     
  113.     public static void main(String [] arsg){
  114.         TcpClient tcpClient = new TcpClient();
  116.         getTcpSocket();
  117.         byte[] pp = new byte[4];
  118.         ByteOperator.putStr(pp,0,4,"abcd");
  119.             
  120.         sendThread(pp); 
  122.         socketClose();  
  124.     }
  127. }

 

 

 

    1. package coldwind..socket.tools;
    3. public class ByteOperator{
    4.     
    5.     public ByteOperator(){
    6.         
    7.     }
    8.      
    9.      
    10.     /**   
    11.     *   长整形转化为byte类型  
    12.     */ 
    13.     public static void putLong(byte[] buf,int offset,long value) { 
    14.         buf[offset + 0] = (byte) ((value >> 56) & 0xff); 
    15.         buf[offset + 1] = (byte) ((value >> 48) & 0xff); 
    16.         buf[offset + 2] = (byte) ((value >> 40) & 0xff); 
    17.         buf[offset + 3] = (byte) ((value >> 32) & 0xff); 
    18.         buf[offset + 4] = (byte) ((value >> 24) & 0xff); 
    19.         buf[offset + 5] = (byte) ((value >> 16) & 0xff); 
    20.         buf[offset + 6] = (byte) ((value >> 8) & 0xff); 
    21.         buf[offset + 7] = (byte) ((value >> 0) & 0xff); 
    22.     } 
    23.     
    24.     /**
    25.      *  长整形转化为byte类型
    26.      */
    27.      
    28.     public static void putReverseBytesLong(byte[] buf, int offset, long value) { 
    29.         buf[offset + 7] = (byte) (value >> 56); 
    30.         buf[offset + 6] = (byte) (value >> 48); 
    31.         buf[offset + 5] = (byte) (value >> 40); 
    32.         buf[offset + 4] = (byte) (value >> 32); 
    33.         buf[offset + 3] = (byte) (value >> 24); 
    34.         buf[offset + 2] = (byte) (value >> 16); 
    35.         buf[offset + 1] = (byte) (value >> 8); 
    36.         buf[offset + 0] = (byte) (value >> 0); 
    37.     }     
    38.      
    39.     /**
    40.      * byte 型转化为 Long 类型
    41.      */
    43.     public static long getLong(byte[] bytes, int index) { 
    44.         return ((((long) bytes[index + 0] & 0xff) << 56) 
    45.                 | (((long) bytes[index + 1] & 0xff) << 48) 
    46.                 | (((long) bytes[index + 2] & 0xff) << 40) 
    47.                 | (((long) bytes[index + 3] & 0xff) << 32) 
    48.                 | (((long) bytes[index + 4] & 0xff) << 24) 
    49.                 | (((long) bytes[index + 5] & 0xff) << 16) 
    50.                 | (((long) bytes[index + 6] & 0xff) << 8) | (((long) bytes[index + 7] & 0xff) << 0)); 
    51.     } 
    54.     /**
    55.      * byte 型转换为 Long 类型 高低位
    56.      */
    58.     public static long getReverseBytesLong(byte[] bytes, int index) { 
    59.         return ((((long) bytes[index + 7] & 0xff) << 56) 
    60.                 | (((long) bytes[index + 6] & 0xff) << 48) 
    61.                 | (((long) bytes[index + 5] & 0xff) << 40) 
    62.                 | (((long) bytes[index + 4] & 0xff) << 32) 
    63.                 | (((long) bytes[index + 3] & 0xff) << 24) 
    64.                 | (((long) bytes[index + 2] & 0xff) << 16) 
    65.                 | (((long) bytes[index + 1] & 0xff) << 8) | (((long) bytes[index + 0] & 0xff) << 0)); 
    66.     }
    68.    /**   
    69.     *   整形转化为byte类型  
    70.     */   
    71.     public static void putInt(byte[] buf,int offset,int value)   {   
    72.         buf[offset+0] = (byte)((value  >> 24) & 0xff);   
    73.         buf[offset+1] = (byte)((value  >> 16) & 0xff);   
    74.         buf[offset+2] = (byte)((value  >> 8)  & 0xff);   
    75.         buf[offset+3] = (byte)((value  >> 0)  & 0xff);   
    76.     }
    77.     
    78.     
    79.     /**
    80.      *  整型转化为byte类型 高低位
    81.      */
    82.     
    83.     public static void putReverseBytesInt(byte[] buf,int offset,int value) { 
    84.         buf[offset + 3] = (byte) (value >> 24); 
    85.         buf[offset + 2] = (byte) (value >> 16); 
    86.         buf[offset + 1] = (byte) (value >> 8); 
    87.         buf[offset + 0] = (byte) (value >> 0); 
    88.     }   
    89.     
    90.     
    91.     /**   
    92.     *   整形转化为byte类型  
    93.     */   
    94.     public static void putInt(byte[] buf,int offset,long value)   {   
    95.         buf[offset+0] = (byte)((value  >> 24) & 0xff);   
    96.         buf[offset+1] = (byte)((value  >> 16) & 0xff);   
    97.         buf[offset+2] = (byte)((value  >> 8)  & 0xff);   
    98.         buf[offset+3] = (byte)((value  >> 0)  & 0xff);   
    99.     }
    100.     
    101.     
    102.     /**
    103.      *  整型转化为byte类型 高低位
    104.      */
    105.     
    106.     public static void putReverseBytesInt(byte[] buf,int offset,long value) { 
    107.         buf[offset + 3] = (byte) (value >> 24); 
    108.         buf[offset + 2] = (byte) (value >> 16); 
    109.         buf[offset + 1] = (byte) (value >> 8); 
    110.         buf[offset + 0] = (byte) (value >> 0); 
    111.     }       
    112.     
    113.     
    114.     /**
    115.      *  byte类型转换为int型
    116.      */
    117.     
    118.     public static int getInt(byte[] bytes, int index) { 
    119.         return (int) ((((bytes[index + 0] & 0xff) << 24) | ((bytes[index + 1] & 0xff) << 16) | ((bytes[index + 2] & 0xff) << 8) | ((bytes[index + 3] & 0xff) << 0))); 
    120.     }   
    121.     
    122.     /**
    123.      *  byte类型转换为int 型 高低位
    124.      */
    125.      
    126.     public static int getReverseBytesInt(byte[] bytes, int index) { 
    127.         return (int) ((((bytes[index + 3] & 0xff) << 24) 
    128.                 | ((bytes[index + 2] & 0xff) << 16) 
    129.                 | ((bytes[index + 1] & 0xff) << 8) | ((bytes[index + 0] & 0xff) << 0))); 
    130.     }
    131.     
    132.      
    133.     /**
    134.      *  浮点型转化为byte类型
    135.      */
    136.     
    137.     public static void putFloat(byte[] buf,int offset,float value){
    138.         
    139.         try {
    140.             putInt(buf,offset,Float.floatToIntBits(value));
    141.         }
    142.         catch (Exception ex) {
    143.             System.out.print("convert the float to Byte is error!/n"+ex);
    144.         }
    145.         
    146.     }
    147.     
    148.     /**
    149.      *  浮点型转化为 byte类型 高低位
    150.      */
    151.     
    152.     public static void putReverseBytesFloat(byte[] buf,int offset,float value) { 
    153.     
    154.         try {
    155.             putReverseBytesInt(buf,offset,Float.floatToIntBits(value));
    156.         }
    157.         catch (Exception ex) {
    158.             System.out.print("convert the ReverseBytesFloat to Byte is error!/n");
    159.         }
    160.     }   
    161.     
    162.     
    163.     
    164.     /**
    165.      *  byte类型转换为浮点型
    166.      */
    167.     
    168.      public static float getReverseBytesFloat(byte[] bytes,int index){
    169.         
    170.         int num = ((bytes[index+3]<<24)0xFF000000)|((bytes[index+2]<<16)0xFF0000)|((bytes[index+1]<<8)0xFF00)|(bytes[index]0xFF);
    171.         float f = Float.intBitsToFloat(num);
    172.         return f;
    173.      }
    174.      
    175.     /**
    176.      *  byte类型转换为 浮点型 高低位
    177.      */     
    178.      
    179.      public static float getFloat (byte[] bytes, int index) { 
    180.         int num = ((bytes[index]<<24)0xFF000000)|((bytes[index+1]<<16)0xFF0000)|((bytes[index+2]<<8)0xFF00)|(bytes[index+3]0xFF);
    181.         float f = Float.intBitsToFloat(num);
    182.         return f;
    183.      }
    184.          
    186.    /**   
    187.     *   短整形转化为byte类型  
    188.     */   
    189.     public static void putShort(byte[] buf,int offset,short value)   {   
    190.         buf[offset+0] = (byte)((value  >> 8) & 0xff);   
    191.         buf[offset+1] = (byte)((value  >> 0) & 0xff);
    192.     }   
    193.     
    194.     /**
    195.      *  short 转化为 byte 类型 高低对调
    196.      */
    197.     
    198.     
    199.     public static void putReverseBytesShort(byte[] buf,int offset,short value) { 
    200.         buf[offset] = (byte) (value >> 0); 
    201.         buf[offset + 1] = (byte) (value >> 8); 
    202.     } 
    204.     
    205.     /**
    206.      *  byte 类型转换为 short型
    207.      */
    208.      
    209.     public static short getShort(byte[] bytes, int index) { 
    210.         return (short) (((bytes[index] << 8) | bytes[index + 1] & 0xff)); 
    211.     }   
    212.     
    213.     
    214.     /**
    215.      *  byte 类型转换为 short型 高低位
    216.      */
    217.     
    218.     public static short getReverseBytesShort(byte[] bytes, int index) { 
    219.         return (short) (((bytes[index + 1] << 8) | bytes[index] & 0xff)); 
    220.     }
    221.     
    222.     /**
    223.      * byte型转换为char类型
    224.      */
    225.      
    226.     public static char getChar(byte[] bytes,int index){
    227.         
    228.         return (char)(((bytes[index+1]<<8) | bytes[index] & 0xff));
    229.         
    230.     }   
    231.     
    232.     
    233.     
    234.     
    235.     /**   
    236.     *   字符串转化为byte类型  
    237.     */ 
    238.     public static void putStr(byte[] buf,int offset,int length,String value) {
    239.         try{
    240.             byte[] tmpByte = value.getBytes();
    241.             for(int i=length-1;i>=0;i--){
    242. //              buf[offset+i] = tmpByte[i]; 
    243.                 buf[offset+i] = tmpByte[i]; 
    244.             }
    245.         }catch(Exception e)
    246.         {
    247.             System.out.print("convert the String to Byte is error!/n"+e);
    248.         }
    249.     }   
    250.     
    251.     
    252.     /**
    253.      * byte型转换为字符串型
    254.      */
    255.      
    256.      public static String getStr(byte[] bytes,int index,int length){
    257.         
    258.         byte[] str = new byte[length];
    259.         for(int i=0;i<length;i++){
    260.             str[i] = bytes[index+i];    
    261.         }
    262.         
    263.         return new String(str);
    264.         
    265.      }  
    266.     
    269. }
        
  2. 以上为vc和java写的tcp的服务器端和客户端，是那种一次连接多次发送的测试例子。本人水平有限，辛苦了好久才写成功，为写应用程序做测试。
tcp数据传输效率测试
09-26
客户端和服务端互传数据，测试传输效率，1、使用tcp传输，服务端比较复杂用到了epoll，客户端用select
window tcp测试发送数据
10-13
用于模拟tcp发送数据，支持tcp，udp，发送16进制，字符串数据
一个简单的tcp例子
04-20
一个简单的tcp例子，socket的发与接的例子
Java网络编程系列--------TCP的数据传输测试
SmilingCobra
08-01 1024
现在我来讲述一下关于TCP的Socket网络编程。与UDP不同，TCP需要三次握手建立连接。我们可以利用C/S模型进行解释 首先我们需要Socket和ServerSocket两个对象(可以类比DatagramSocket)，实现两个IP地址的通信。 关于Socket Socket是我们在客户端需要使用的套接字。 我们知道实际上两个程序的通信是通过端口号进行标识并进行传输数据的。可以说T...
android测试例子 TCP长连接
12-18
android 客户端 后台启动服务 保持 TCP 长连接例子。
XILINX FPGA以太网协议栈IP：实现高速TCP数据传输及软硬件定制解决方案
最新发布
08-18
文中涵盖了硬件层面的卓越实现（如千兆和万兆TCP数据传输）、软件层面的巧妙设计（如配套的上位机QT软件界面）以及算法模块与逻辑接口的精细打造。此外，还提供了FPGA软硬件定制服务，以满足用户的特殊需求。最后，...
python中用调用tcp传输的实例.rar
05-20
1. 面向连接：在数据传输之前，客户端和服务器需要先建立连接。 2. 可靠性：通过序列号、确认应答、重传机制等确保数据的准确无误传输。 3. 字节流：TCP将数据看作一个无结构的字节流，不保留消息边界。 首先，我们...
精选资源
QT测试tcp通讯SOCKET实例程序
06-01
在实际应用中，通常还需要处理各种异常情况，例如连接失败、网络中断、数据传输错误等。QT提供了一系列的错误检查和处理机制，比如socket的状态检查、错误信息获取等。 此外，QT还提供了异步编程模型，可以使用信号...
LabVIEW实现TCP数据传输的双机通信实例分析
在LabVIEW中，TCP数据传输涉及的VI操作如下： - **打开TCP连接**：创建TCP客户端或服务器连接。 - **读取TCP数据**：从TCP连接中读取数据，返回数据字节或字符串。 - **写入TCP数据**：向TCP连接写入数据。 - **...
精选资源
Android TCP Socket通信实例Demo源码Apk下载
03-13
以及对接硬件的项目数据在十六进制&&byte&&int的转换处理。 要注意BufferedReader的readLine()方法的阻塞问题： 读取socket输入流的时候很多代码都会这么写，一般也不会有什么问题，但是readLine()方法读取不到换行...
精心整理的TCP、UDP数据收发例子
03-26
精心整理的TCP、UDP包括组播和单播协议，客户端和服务端数据收发完整案例，用C#实现的，费了好几天时间调试和完善，吐血推荐。
TCP测试小工具
05-08
类似于Telnet，可以发送数据到服务端进行测试哦，后面自己会写一个兼容性更强的！
TCP报文发送接收测试工具
06-04
TCP报文接收发送测试工具，可模拟客户端，也可模拟服务器端，可自动发送报文，对用来调试TCP报文传输调试是个非常好的测试工具。
TCP连接测试工具_强烈推荐！
08-24
软件名字叫“TCPUDPDbg”，是一个TCP和UDP协议的网络连接测试工具，支持服务器模式和客户端模式，支持多连接，可同时对多路网络连接进行操作，支持发送汉字，支持十六进制发送和接收方式。非常好用，强烈推荐！
TCPTool好用的TCP通信测试工具
07-28
TCP测试工具，调试TCP程序比较好用。 有十六进制和文本两种显示方式。
如何测试两台计算机的TCP通信
VN520的博客
02-26 1553
测量到远程主机的网络延迟的一种常用方法是使用ping应用程序。该ping工具依赖ICMP ECHO请求和回复数据包来测量远程主机的往返延迟。但是，在某些情况下，ICMP流量可能会被防火墙阻止，这使得该ping应用程序对于受限制的防火墙后面的主机毫无用处。在这种情况下，你将需要依赖使用TCP/UDP数据包的第3层测量工具，因为这些第3层数据包更有可能绕过常见的防火墙规则。一种这样的第3层测量工具是Tcpping。为了测量延迟，Tcpping利用所谓的半开放连接技术，基于TCP三路握手。
TCP通信测试
weixin_40933653的博客
09-11 938
在连接建立成功后,可以进行数据收发的测试：当鼠标点中每个Socket时, 软件都会在右方提供操作该Socket的面板。UDP Server刚创建成功时,其对方IP及对方端口都是空的. 必须要收到UDP Client先发送的数据包后, UDP Server才确定对方IP及对方端口，并进行数据包的发送．。UDP Client则在创建的时候及指定了对方IP及对方端口号, 因此,两个UDP Client之间也是可以通信的. 而UDP Server则必须与UDP Client才行进行通信．。
TCP带外数据测试
VHeroin的博客
12-01 666
原文地址: http://blog.youkuaiyun.com/hishentan/article/details/38351871 带外数据的应用情况 如果发送客户端程序由于一些原因需要取消已经写入服务器的请求，那么他就需要向服务器紧急发送一个标识取消的请求。 使用带外数据的实际程序例子就是telnet,rlogin,ftp命令。 前两个程序（telnet和rlogin
RPC接口测试技术-Tcp 协议的接口测试
hogwarts_beibei的博客
04-26 1256
首先明确 Tcp 的概念，针对 Tcp 协议进行接口测试，是指基于 Tcp 协议的上层协议比如 Http ，串口，网口， Socket 等。这些协议与 Http 测试方法类似（具体查看接口自动化测试章节），但在测试过程中需要做些调整。 Socket Socket 又称套接字，进程可通过套接字进行网络通信，使多个设备具有交互能力。Socket 适合对传输速度和安全性有严格要求的应用，比如手机内核与外界进行测试数据的传输。支持 Socket 设备不止计算机，还会有移动端，如果测试 Socket 协议，需要有
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值