TCP（面向连接）的socket编程

最新推荐文章于 2022-10-30 17:31:20 发布
最新推荐文章于 2022-10-30 17:31:20 发布
阅读量3.1k 收藏 4
点赞数
分类专栏： 【网络编程】

基于TCP（面向连接）的socket编程，分为客户端和服务器端。

客户端的流程如下：

（1）创建套接字（socket）

（2）向服务器发出连接请求（connect）

（3）和服务器端进行通信（send/recv）

（4）关闭套接字

服务器端的流程如下：

（1）创建套接字（socket）

（2）将套接字绑定到一个本地地址和端口上（bind）

（3）将套接字设为监听模式，准备接收客户端请求（listen）

（4）等待客户请求到来；当请求到来后，接受连接请求，返回一个新的对应于此次连接的套接字（accept）

（5）用返回的套接字和客户端进行通信（send/recv）

（6）返回，等待另一个客户请求。

（7）关闭套接字。

 

下面通过一个具体例子讲解一下具体的过程和相关的函数。

客户端代码，运行于vs2008

[cpp] view plain copy print ?
  1. // ClientTest.cpp : 定义控制台应用程序的入口点。   
  2. //   
  3.   
  4. #include "stdafx.h"   
  5. #include <stdio.h>   
  6. #include <stdlib.h>   
  7. #include <winsock2.h>   
  8.   
  9. #define SERVER_PORT 5208 //侦听端口   
  10.   
  11.   
  12. int _tmain(int argc, _TCHAR* argv[])  
  13. {  
  14.     WORD wVersionRequested;  
  15.     WSADATA wsaData;  
  16.     int ret;  
  17.     SOCKET sClient; //连接套接字   
  18.     struct sockaddr_in saServer; //服务器地址信息   
  19.     char *ptr;  
  20.     BOOL fSuccess = TRUE;  
  21.   
  22.     //WinSock初始化   
  23.     wVersionRequested = MAKEWORD(2, 2); //希望使用的WinSock DLL的版本   
  24.     ret = WSAStartup(wVersionRequested, &wsaData);  //加载套接字库   
  25.     if(ret!=0)  
  26.     {  
  27.         printf("WSAStartup() failed!\n");  
  28.         //return 0;   
  29.     }  
  30.     //确认WinSock DLL支持版本2.2   
  31.     if(LOBYTE(wsaData.wVersion)!=2 || HIBYTE(wsaData.wVersion)!=2)  
  32.     {  
  33.         WSACleanup();   //释放为该程序分配的资源，终止对winsock动态库的使用   
  34.         printf("Invalid WinSock version!\n");  
  35.         //return 0;   
  36.     }  
  37.   
  38.     //创建Socket,使用TCP协议   
  39.     sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);  
  40.     if (sClient == INVALID_SOCKET)  
  41.     {  
  42.         WSACleanup();  
  43.         printf("socket() failed!\n");  
  44.         //return 0;   
  45.     }  
  46.   
  47.     //构建服务器地址信息   
  48.     saServer.sin_family = AF_INET; //地址家族   
  49.     saServer.sin_port = htons(SERVER_PORT); //注意转化为网络节序   
  50.     saServer.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");  
  51.   
  52.     //连接服务器   
  53.     ret = connect(sClient, (struct sockaddr *)&saServer, sizeof(saServer));  
  54.     if (ret == SOCKET_ERROR)  
  55.     {  
  56.         printf("connect() failed!\n");  
  57.         closesocket(sClient); //关闭套接字   
  58.         WSACleanup();  
  59.         //return 0;   
  60.     }  
  61.   
  62.   
  63.     char sendMessage[]="ZhongXingPengYue";   
  64.     ret = send (sClient, (char *)&sendMessage, sizeof(sendMessage), 0);  
  65.     if (ret == SOCKET_ERROR)  
  66.     {  
  67.         printf("send() failed!\n");  
  68.     }  
  69.     else  
  70.         printf("client info has been sent!");  
  71.     char recvBuf[100];  
  72.     recv(sClient,recvBuf,100,0);  
  73.     printf("%s\n",recvBuf);  
  74.     closesocket(sClient); //关闭套接字   
  75.     WSACleanup();  
  76.     getchar();  
  77.     //return 0;   
  78. }  
  79.   
  80. <SPAN style="FONT-SIZE: 16px"></SPAN>  
// ClientTest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>

#define SERVER_PORT 5208 //侦听端口


int _tmain(int argc, _TCHAR* argv[])
{
	WORD wVersionRequested;
	WSADATA wsaData;
	int ret;
	SOCKET sClient; //连接套接字
	struct sockaddr_in saServer; //服务器地址信息
	char *ptr;
	BOOL fSuccess = TRUE;

	//WinSock初始化
	wVersionRequested = MAKEWORD(2, 2); //希望使用的WinSock DLL的版本
	ret = WSAStartup(wVersionRequested, &wsaData);	//加载套接字库
	if(ret!=0)
	{
		printf("WSAStartup() failed!\n");
		//return 0;
	}
	//确认WinSock DLL支持版本2.2
	if(LOBYTE(wsaData.wVersion)!=2 || HIBYTE(wsaData.wVersion)!=2)
	{
		WSACleanup();	//释放为该程序分配的资源，终止对winsock动态库的使用
		printf("Invalid WinSock version!\n");
		//return 0;
	}

	//创建Socket,使用TCP协议
	sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (sClient == INVALID_SOCKET)
	{
		WSACleanup();
		printf("socket() failed!\n");
		//return 0;
	}

	//构建服务器地址信息
	saServer.sin_family = AF_INET; //地址家族
	saServer.sin_port = htons(SERVER_PORT); //注意转化为网络节序
	saServer.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");

	//连接服务器
	ret = connect(sClient, (struct sockaddr *)&saServer, sizeof(saServer));
	if (ret == SOCKET_ERROR)
	{
		printf("connect() failed!\n");
		closesocket(sClient); //关闭套接字
		WSACleanup();
		//return 0;
	}


	char sendMessage[]="ZhongXingPengYue"; 
	ret = send (sClient, (char *)&sendMessage, sizeof(sendMessage), 0);
	if (ret == SOCKET_ERROR)
	{
		printf("send() failed!\n");
	}
	else
		printf("client info has been sent!");
	char recvBuf[100];
	recv(sClient,recvBuf,100,0);
	printf("%s\n",recvBuf);
	closesocket(sClient); //关闭套接字
	WSACleanup();
	getchar();
	//return 0;
}
[cpp] view plain copy print ?
  1. <SPAN style="FONT-SIZE: 16px"></SPAN>   
 

        第一步，加载套接字。使用WSAStartup 函数，如：ret = WSAStartup(wVersionRequested, &wsaData)。WSAStartup函数的原型为

[cpp] view plain copy print ?
  1. int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData)  
int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData)

第一参数wVersionRequested，用来指定准备加载的winsock库的版本。利用MAKEWORD(x,y)宏来赋值。x是高位字节，表示副版本号；y是低位字节，表示主版本号。MAKEWORD(2, 2)表示版本号为2.2。

第二个参数是指向WSADATA结构的指针，是一个返回值，保存了库版本的有关信息。

 

       第二步，创建套接字。使用socket函数，如：sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)。socket函数的原型为:

[cpp] view plain copy print ?
  1. SOCKET socket(int af, int type, int protocol );  
SOCKET socket(int af, int type, int protocol );

第一个参数，指定地址族，对于TCP/IP协议的套接字，只能为AF_INET；

第二个参数，指定socket类型，SOCK_STREAM指产生流式套接字，SOCK_DGRAM指产生数据报套接字，TCP/IP协议使用SOCK_STREAM。

第三个参数，与特定的地址家族相关的协议，TCP协议一般为IPPROTO_TCP。也可以写0，那么系统会根据地址格式和套接字类别，自动选择一个适合的协议。

如果socket创建成功，则返回一个新的SOCKET数据类型的套接字描述符；若失败，则返回INVALID_SOCKET，由此可以判断是否创建成功。

 

        第三步，连接服务器。使用connect函数，如：ret = connect(sClient, (struct sockaddr *)&saServer, sizeof(saServer))。connect函数函数原型为

[csharp] view plain copy print ?
  1. int connect(SOCKET s, const struct sockaddr FAR* name, int namelen);  
int connect(SOCKET s, const struct sockaddr FAR* name, int namelen);

第一个参数是将在上面建立连接的那个套接字的描述符，即之前创建socket的返回值sClient。

第二个参数是要连接的服务器端的地址信息。它是一个结构体类型struct sockaddr_in ，需要在调用connect函数之前构建服务器地址信息。sockaddr_in的定义如下：

[cpp] view plain copy print ?
  1. struct sockaddr_in{  
  2.   
  3. short sin_family;  
  4.   
  5. unsigned short sin_port;  
  6.   
  7. struct in_addr sin_addr;  
  8.   
  9. char sin_zero[8]  
  10.   
  11. };  
struct sockaddr_in{

short sin_family;

unsigned short sin_port;

struct in_addr sin_addr;

char sin_zero[8]

};


设置服务器端口时，用到htons函数，该函数把一个u_short类型的值从主机字节顺序转换为TCP/IP网络字节顺序，因为不同的计算机存放多字节的顺序不同（基于Intel CPU是高字节存放在低地址，低字节存放在高地址），所以网络中不同主机间通信时，要统一采用网络字节顺序。设置服务器IP地址时，使用到inet_addr函数，它是将点分十进制的IP地址的字符串转换成unsigned long型。inet_ntoa函数做相反的转换。

第三个参数是服务器端地址结构体的大小。

 

        第四步，发送。使用send函数向服务器发送数据，如：ret = send (sClient, (char *)&sendMessage, sizeof(sendMessage), 0)。send函数的原型为

[cpp] view plain copy print ?
  1. int send(SOCKET s, const char FAR* buf, int len, int flags);  
int send(SOCKET s, const char FAR* buf, int len, int flags);

第一个参数，是一个与服务器已经建立连接的套接字。

第二个参数，指向包含要发送的数据的缓冲区的指针。

第三个参数，是所指向的缓冲区的长度。准确的说，应该是所要发送的数据的长度，因为不是缓冲区的所有数据都要同时发送。

第四个参数，它设定的值将影响函数的行为，一般将其设置为0即可。

如果发送失败，send会返回SOCKET_ERROR，由此可以判断发送是否成功。

 

        第五步，接收。使用recv函数接收服务器发过来的数据，如recv(sClient,recvBuf,100,0)。recv函数的原型为

[cpp] view plain copy print ?
  1. int recv(SOCKET s, const char FAR* buf, int len, int flags);  
int recv(SOCKET s, const char FAR* buf, int len, int flags);

recv函数的参数的含义和send函数参数含义差不多，只是第二个参数是指向用来保存接收数据的缓冲区的指针。recv函数的返回值应该是所接收的数据的长度，如果返回SOCKET_ERROR表示接收失败；返回0表示服务器端关闭连接。

 

       第六步，关闭socket，释放资源。使用closesocket函数关闭套接字，如closesocket(sClient)；使用WSACleanup函数释放为该程序分配的资源，终止对winsock动态库的使用，如WSACleanup();
 

服务器端代码，运行于vs2008

[cpp] view plain copy print ?
  1. // ServerTest.cpp : 定义控制台应用程序的入口点。   
  2. //   
  3.   
  4. #include "stdafx.h"   
  5. #include <stdio.h>   
  6. #include <winsock2.h>   
  7.   
  8. #define SERVER_PORT 5208 //侦听端口   
  9.   
  10. int _tmain(int argc, _TCHAR* argv[])  
  11. {  
  12.     WORD wVersionRequested;  
  13.     WSADATA wsaData;  
  14.     int ret, nLeft, length;  
  15.     SOCKET sListen, sServer; //侦听套接字，连接套接字   
  16.     struct sockaddr_in saServer, saClient; //地址信息      
  17.     char *ptr;//用于遍历信息的指针      
  18.     //WinSock初始化   
  19.     wVersionRequested=MAKEWORD(2, 2); //希望使用的WinSock DLL 的版本   
  20.     ret=WSAStartup(wVersionRequested, &wsaData);  
  21.     if(ret!=0)  
  22.     {  
  23.         printf("WSAStartup() failed!\n");  
  24.         //return 0;   
  25.     }  
  26.     //创建Socket,使用TCP协议   
  27.     sListen=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);  
  28.     if (sListen == INVALID_SOCKET)  
  29.     {  
  30.         WSACleanup();  
  31.         printf("socket() faild!\n");  
  32.         //return 0;   
  33.     }  
  34.     //构建本地地址信息   
  35.     saServer.sin_family = AF_INET; //地址家族   
  36.     saServer.sin_port = htons(SERVER_PORT); //注意转化为网络字节序   
  37.     saServer.sin_addr.S_un.S_addr = htonl(INADDR_ANY); //使用INADDR_ANY 指示任意地址   
  38.     
  39.     //绑定   
  40.     ret = bind(sListen, (struct sockaddr *)&saServer, sizeof(saServer));  
  41.     if (ret == SOCKET_ERROR)  
  42.     {  
  43.         printf("bind() faild! code:%d\n", WSAGetLastError());  
  44.         closesocket(sListen); //关闭套接字   
  45.         WSACleanup();  
  46.         //return 0;   
  47.     }  
  48.     
  49.     //侦听连接请求   
  50.     ret = listen(sListen, 5);  
  51.     if (ret == SOCKET_ERROR)  
  52.     {  
  53.         printf("listen() faild! code:%d\n", WSAGetLastError());  
  54.         closesocket(sListen); //关闭套接字   
  55.         //return 0;   
  56.     }  
  57.     
  58.     printf("Waiting for client connecting!\n");  
  59.     printf("Tips: Ctrl+c to quit!\n");  
  60.     //阻塞等待接受客户端连接   
  61.     while(1)//循环监听客户端，永远不停止，所以，在本项目中，我们没有心跳包。   
  62.     {  
  63.         length = sizeof(saClient);  
  64.         sServer = accept(sListen, (struct sockaddr *)&saClient, &length);  
  65.         if (sServer == INVALID_SOCKET)  
  66.         {  
  67.             printf("accept() faild! code:%d\n", WSAGetLastError());  
  68.             closesocket(sListen); //关闭套接字   
  69.             WSACleanup();  
  70.             return 0;  
  71.         }    
  72.   
  73.         char sendMessage[]="hello client";  //发送信息给客户端   
  74.         send(sServer,sendMessage,strlen(sendMessage)+1,0);  
  75.   
  76.         char receiveMessage[5000];  
  77.         nLeft = sizeof(receiveMessage);  
  78.         ptr = (char *)&receiveMessage;  
  79.         while(nLeft>0)  
  80.         {  
  81.             //接收数据   
  82.             ret = recv(sServer, ptr, 5000, 0);  
  83.             if (ret == SOCKET_ERROR)  
  84.             {  
  85.                 printf("recv() failed!\n");  
  86.                 return 0;  
  87.             }  
  88.             if (ret == 0) //客户端已经关闭连接   
  89.             {  
  90.                 printf("Client has closed the connection\n");  
  91.                 break;  
  92.             }  
  93.             nLeft -= ret;  
  94.             ptr += ret;  
  95.         }    
  96.         printf("receive message:%s\n", receiveMessage);//打印我们接收到的消息。   
  97.           
  98.   
  99.     }   
  100.   //  closesocket(sListen);   
  101.   //  closesocket(sServer);   
  102.   //  WSACleanup();   
  103.     return 0;  
  104. }  
// ServerTest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <stdio.h>
#include <winsock2.h>

#define SERVER_PORT 5208 //侦听端口

int _tmain(int argc, _TCHAR* argv[])
{
	WORD wVersionRequested;
    WSADATA wsaData;
    int ret, nLeft, length;
    SOCKET sListen, sServer; //侦听套接字，连接套接字
    struct sockaddr_in saServer, saClient; //地址信息   
    char *ptr;//用于遍历信息的指针   
    //WinSock初始化
    wVersionRequested=MAKEWORD(2, 2); //希望使用的WinSock DLL 的版本
    ret=WSAStartup(wVersionRequested, &wsaData);
    if(ret!=0)
    {
        printf("WSAStartup() failed!\n");
        //return 0;
    }
    //创建Socket,使用TCP协议
    sListen=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sListen == INVALID_SOCKET)
    {
        WSACleanup();
        printf("socket() faild!\n");
        //return 0;
    }
    //构建本地地址信息
    saServer.sin_family = AF_INET; //地址家族
    saServer.sin_port = htons(SERVER_PORT); //注意转化为网络字节序
    saServer.sin_addr.S_un.S_addr = htonl(INADDR_ANY); //使用INADDR_ANY 指示任意地址
  
    //绑定
    ret = bind(sListen, (struct sockaddr *)&saServer, sizeof(saServer));
    if (ret == SOCKET_ERROR)
    {
        printf("bind() faild! code:%d\n", WSAGetLastError());
        closesocket(sListen); //关闭套接字
        WSACleanup();
        //return 0;
    }
  
    //侦听连接请求
    ret = listen(sListen, 5);
    if (ret == SOCKET_ERROR)
    {
        printf("listen() faild! code:%d\n", WSAGetLastError());
        closesocket(sListen); //关闭套接字
        //return 0;
    }
  
    printf("Waiting for client connecting!\n");
    printf("Tips: Ctrl+c to quit!\n");
    //阻塞等待接受客户端连接
	while(1)//循环监听客户端，永远不停止，所以，在本项目中，我们没有心跳包。
	{
		length = sizeof(saClient);
		sServer = accept(sListen, (struct sockaddr *)&saClient, &length);
		if (sServer == INVALID_SOCKET)
		{
			printf("accept() faild! code:%d\n", WSAGetLastError());
			closesocket(sListen); //关闭套接字
			WSACleanup();
			return 0;
		}  

		char sendMessage[]="hello client";  //发送信息给客户端
		send(sServer,sendMessage,strlen(sendMessage)+1,0);

		char receiveMessage[5000];
		nLeft = sizeof(receiveMessage);
		ptr = (char *)&receiveMessage;
		while(nLeft>0)
		{
			//接收数据
			ret = recv(sServer, ptr, 5000, 0);
			if (ret == SOCKET_ERROR)
			{
				printf("recv() failed!\n");
				return 0;
			}
			if (ret == 0) //客户端已经关闭连接
			{
				printf("Client has closed the connection\n");
				break;
			}
			nLeft -= ret;
			ptr += ret;
		}  
		printf("receive message:%s\n", receiveMessage);//打印我们接收到的消息。
		

	} 
  //  closesocket(sListen);
  //  closesocket(sServer);
  //  WSACleanup();
	return 0;
}


 

        第一步，加载套接字库，和客户端得加载套接字一样。

 

        第二步，创建监听套接字，sListen=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);仍然使用的是socket函数。

 

        第三步，绑定。使用bind函数，该函数的作用是将一个创建好的套接字绑定到本地的某个地址和端口上，该函数的原型为：

[cpp] view plain copy print ?
  1. int bind(SOCKET s, const struct sockaddr FAR* name, int namelen);  
int bind(SOCKET s, const struct sockaddr FAR* name, int namelen);

第一个参数，指定要绑定的套接字；

第二个参数，指定该套接字的地址信息，这里即服务器的地址信息，它仍是指向struct sockaddr_in类型的结构体的指针。这个结构体和客户端调用connect函数之前构建服务器地址信息的一样。其中INADDR_ANY 是指示任意地址，因为服务器含有可能多个网卡，可能有多个IP地址，这边指选择一个任意可用的地址。

第三个参数，地址的信息的长度。

 

        第四步，监听连接。使用listen函数，该函数是将指定的套接字设置为监听模式，如ret = listen(sListen, 5)。函数原型为

[cpp] view plain copy print ?
  1. int listen(SOCKET s, int backlog);  
int listen(SOCKET s, int backlog);


第一个参数，是要设置为监听的套接字描述符。

第二个参数，是等待连接队列的最大的长度。注意了，设置这个值是为了设置等待连接队列的最大长度，而不是在一个端口上可以连接的最大数目。例如，设置为5，当有6个连接请求同时到达，前面5个连接请求会被放到等待请求连接队列中，然后服务器依次处理这些请求服务，但是第6个连接请求会被拒绝。

 

       第五步，接受客户端的连接请求。使用accept函数接受客户端发送的连接请求，如sServer = accept(sListen, (struct sockaddr *)&saClient, &length);该函数的原型为

[cpp] view plain copy print ?
  1. SOCKET accept(SOCKET s, struct sockaddr FAR* addr, int FAR* addrlen);  
SOCKET accept(SOCKET s, struct sockaddr FAR* addr, int FAR* addrlen);


第一个参数，是一个已设为监听模式的socket的描述符。

第二个参数，是一个返回值，它指向一个struct sockaddr类型的结构体的变量，保存了发起连接的客户端得IP地址信息和端口信息。

第三个参数，也是一个返回值，指向整型的变量，保存了返回的地址信息的长度。

accept函数返回值是一个客户端和服务器连接的SOCKET类型的描述符，在服务器端标识着这个客户端。

      

       第六、七步是发送和接收，分别使用send和recv函数，这里和客户端的一样，不再重复。

       accept函数是放在一个死循环中的，一直监听客户的请求。当服务器关闭时要关闭所有的套接字，和释放资源。

Ailoverer
关注
专栏目录
基于TCP的Socket编程
qq_41141896的博客
06-06 6619
     TCP/IP(Transmission Control Protocol/Internet Protocol) 即传输控制协议/网间协议，是一种面向连接（连接导向）的、可靠的、基于字节流的运输层（Transport layer）通信协议。在使用TCP协议传输数据，接收端收到的是一个和发送端完全一样的数据流。发送端和接收端必须建立联系，以便在TCP协议基础上进行通讯，其端口之间建立连接，一...
基于TCP的Socket 编程
热门推荐
chocolate的专栏
07-22 9万+
基于TCP（面向连接）的socket编程，分为客户端和服务器端。客户端的流程如下：（1）创建套接字（socket）（2）向服务器发出连接请求（connect）（3）和服务器端进行通信（send/recv）（4）关闭套接字服务器端的流程如下：（1）创建套接字（socket）（2）将
基于TCP的Socket网络编程
weixin_47604497的博客
10-30 3153
基于TCP的Socket网络编程
计算机网络实验——基于TCP协议的socket编程
m0_67402588的博客
08-30 1807
不同主机的应用层之间经常需要可靠的、像管道一样的连接，但是IP层不提供这样的流机制，而是提供不可靠的包交换。结合多人聊天的场景，这里的服务器实际上起到消息中转的作用，将客户端发给它的消息转发给与之相连的所有客户端，以间接实现客户端之间的通信。服务器先创建一个套接字，然后将该套接字和特定端口绑定，然后服务器开始在此套接字上监听，直到收到一个客户端的连接请求，然后服务器与客户端建立连接，连接成功后和该客户端进行通信（相互接收和发送数据），最后，服务器和客户端断开连接，继续在端口上监听。...
TCP面向连接Socket编程实验：Java实现客户端-服务器交互
"这篇实验报告主要探讨了基于TCP面向连接的Socket网络编程，涉及TCP/IP协议，使用Java作为编程语言，并介绍了如何运用Ethereal抓包工具进行协议分析，特别是理解TCP的三次握手过程。实验内容包括编写客户端和服务器...
基于TCP面向连接的 Socket网络编程实验
05-23
基于TCP面向连接的Socket网络编程实验 本实验旨在掌握基于TCP面向连接的Socket网络编程的知识和技能，通过编写客户端和服务器端的程序，实现数据的可靠传输和交互。同时，使用Etheral抓包工具对TCP协议进行协议分析...
Java+TCP／IP+Socket编程++原书第2版.pdf
05-15
总的来说，《Java + TCP/IP + Socket编程++ 原书第2版》可能会涵盖这些主题：TCP/IP协议基础，Java Socket API的使用，异常处理，多线程编程，以及网络编程的最佳实践。这本书将帮助开发者深入理解如何在Java环境中...
Java TCP_IP Socket编程源代码书籍以及附带源码
12-08
Java TCP/IP Socket编程是网络通信领域中的核心技术，广泛应用于服务器端和客户端之间的数据传输。本资源包含一本关于Java TCP/IP Socket编程的书籍及其配套源代码，对于深入理解Socket编程至关重要。 书籍《Java ...
Java TCP/IP Socket编程
06-04
Java TCP/IP Socket编程是Java网络编程中的重要组成部分，它提供了在网络间进行数据传输的基础机制。TCP（Transmission Control Protocol）和IP（Internet Protocol）是互联网上最基础的通信协议，而Socket则是TCP/...
基于tcp的socket编程
12-03
基于tcp连接的socket编程，简单实现基于tcp的server端和client端的连接。
基于TCP协议的Socket编程
qq_57165108的博客
10-08 620
【代码】基于TCP协议的Socket编程。
基于TCP协议之——socket编程
weixin_34185320的博客
05-20 160
一. 套接字（socket） socket英文为插座的意思，也就是为用户提供了一个接入某个链路的接口。而在计算机网络中，一个IP地址标识唯一一台主机，而一个端口号标识着主机中唯一一个应用进程，因此“IP+端口号”就可以称之为socket。 两个主机的进程之间要通信，就可以各自建立一个socket，其实可以看做各自提供出来一个“插座”，然后通过连接上“插座”的两头也...
基于TCP的socket编程
BerMaker
09-19 722
基于TCP的socket编程的服务器程序流程如下： 1、创建套接字(socket); 2、将套接字绑定到一个本地地址和端口上(bind); 3、将套接字设为监听模式，准备接收客户请求(listen); 4、等待客户请求到来，当请求到来后，接受连接请求，返回一个新的对应于此次连接的套接字(accept); 5、用返回的套接字和客户端进行通信(send/recv); 6、返回，等待另一客户
基于TCP（面向连接）的socket编程
顾清欢的博客
11-14 888
基于TCP的socket编程是采用的流式套接字(SOCK_STREAM) 服务器端编程的步骤: 1:加载套接字库,创建套接字(WSAStartup()/socket()); 2:绑定套接字到一个IP地址和一个端口上(bind()); 3:将套接字设置为监听模式等待连接请求(listen()); 4:请求到来后,接受连接请求,返回一个新的对应于此次连接的套接字(accept()); 5:用返回的套接...
Socket网络编程学习笔记（2）：面向连接的Socket
weixin_30369087的博客
10-26 160
在上一篇中，我列了一些常用的方法，可以说这些方法是一些辅助性的方法，对于分析网络中的主机属性非常有用。在这篇中，我将会介绍一下面向连接（TCP）socket编程，其中辅以实例，代码可供下载。对于TCP的Socket编程，主要分二部分：一、服务端Socket侦听：服务端Socket侦听主要分以下几个步骤，按照以下几个步骤我们可以很方便的建立起一个Sock...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值