精华内容
下载资源
问答
  • 2014-12-12 20:03:03
    
    
    
    
    服务端代码:
    
    
    // 负责处理每个线程通信的线程类
    public class ServerThread implements Runnable
    {
    	// 定义当前线程所处理的Socket
    	Socket s = null;
    	// 该线程所处理的Socket所对应的输入流
    	BufferedReader br = null;
    	public ServerThread(Socket s)
    		throws IOException
    	{
    		this.s = s;
    		// 初始化该Socket对应的输入流
    		br = new BufferedReader(new InputStreamReader(
    			s.getInputStream() , "utf-8"));   //②
    	}
    	public void run()
    	{
    		try
    		{
    			String content = null;
    			// 采用循环不断从Socket中读取客户端发送过来的数据
    			while ((content = readFromClient()) != null)
    			{
    				// 遍历socketList中的每个Socket,
    				// 将读到的内容向每个Socket发送一次
    				for (Socket s : MyServer.socketList)
    				{
    					OutputStream os = s.getOutputStream();
    					os.write((content + "\n").getBytes("utf-8"));
    				}
    			}
    		}
    		catch (IOException e)
    		{
    			e.printStackTrace();
    		}
    	}
    	// 定义读取客户端数据的方法
    	private String readFromClient()
    	{
    		try
    		{
    			return br.readLine();
    		}
    		// 如果捕捉到异常,表明该Socket对应的客户端已经关闭
    		catch (IOException e)
    		{
    			// 删除该Socket。
    			MyServer.socketList.remove(s);    //①
    		}
    		return null;
    	}
    }


    public class MyServer
    {
    	// 定义保存所有Socket的ArrayList
    	public static ArrayList<Socket> socketList
    		= new ArrayList<Socket>();
        public static void main(String[] args)
    		throws IOException
        {
    		ServerSocket ss = new ServerSocket(30000);
    		while(true)
    		{
    			// 此行代码会阻塞,将一直等待别人的连接
    			Socket s = ss.accept();
    			socketList.add(s);
    			// 每当客户端连接后启动一条ServerThread线程为该客户端服务
    			new Thread(new ServerThread(s)).start();
    		}
        }
    }


    客户端代码:

    public class ClientThread implements Runnable
    {
    	private Socket s;
    	// 定义向UI线程发送消息的Handler对象
    	private Handler handler;
    	// 定义接收UI线程的消息的Handler对象
    	public Handler revHandler;
    	// 该线程所处理的Socket所对应的输入流
    	BufferedReader br = null;
    	OutputStream os = null;
    
    	public ClientThread(Handler handler)
    	{
    		this.handler = handler;
    	}
    
    	public void run()
    	{
    		try
    		{
    			s = new Socket("192.168.1.88", 30000);
    			br = new BufferedReader(new InputStreamReader(
    				s.getInputStream()));
    			os = s.getOutputStream();
    			// 启动一条子线程来读取服务器响应的数据
    			new Thread()
    			{
    				@Override
    				public void run()
    				{
    					String content = null;
    					// 不断读取Socket输入流中的内容。
    					try
    					{
    						while ((content = br.readLine()) != null)
    						{
    							// 每当读到来自服务器的数据之后,发送消息通知程序界面显示该数据
    							Message msg = new Message();
    							msg.what = 0x123;
    							msg.obj = content;
    							handler.sendMessage(msg);
    						}
    					}
    					catch (IOException e)
    					{
    						e.printStackTrace();
    					}
    				}
    			}.start();
    			// 为当前线程初始化Looper
    			Looper.prepare();
    			// 创建revHandler对象
    			revHandler = new Handler()
    			{
    				@Override
    				public void handleMessage(Message msg)
    				{
    					// 接收到UI线程中用户输入的数据
    					if (msg.what == 0x345)
    					{
    						// 将用户在文本框内输入的内容写入网络
    						try
    						{
    							os.write((msg.obj.toString() + "\r\n")
    								.getBytes("utf-8"));
    						}
    						catch (Exception e)
    						{
    							e.printStackTrace();
    						}
    					}
    				}
    			};
    			// 启动Looper
    			Looper.loop();
    		}
    		catch (SocketTimeoutException e1)
    		{
    			System.out.println("网络连接超时!!");
    		}
    		catch (Exception e)
    		{
    			e.printStackTrace();
    		}
    	}
    }
    


    public class MultiThreadClient extends Activity
    {
    	// 定义界面上的两个文本框
    	EditText input;
    	TextView show;
    	// 定义界面上的一个按钮
    	Button send;
    	Handler handler;
    	// 定义与服务器通信的子线程
    	ClientThread clientThread;
    	@Override
    	public void onCreate(Bundle savedInstanceState)
    	{
    		super.onCreate(savedInstanceState);
    		setContentView(R.layout.main);
    		input = (EditText) findViewById(R.id.input);
    		send = (Button) findViewById(R.id.send);
    		show = (TextView) findViewById(R.id.show);
    		handler = new Handler() //①
    		{
    			@Override
    			public void handleMessage(Message msg)
    			{
    				// 如果消息来自于子线程
    				if (msg.what == 0x123)
    				{
    					// 将读取的内容追加显示在文本框中
    					show.append("\n" + msg.obj.toString());
    				}
    			}
    		};
    		clientThread = new ClientThread(handler);
    		// 客户端启动ClientThread线程创建网络连接、读取来自服务器的数据
    		new Thread(clientThread).start(); //①
    		send.setOnClickListener(new OnClickListener()
    		{
    			@Override
    			public void onClick(View v)
    			{
    				try
    				{
    					// 当用户按下发送按钮后,将用户输入的数据封装成Message,
    					// 然后发送给子线程的Handler
    					Message msg = new Message();
    					msg.what = 0x345;
    					msg.obj = input.getText().toString();
    					clientThread.revHandler.sendMessage(msg);
    					// 清空input文本框
    					input.setText("");
    				}
    				catch (Exception e)
    				{
    					e.printStackTrace();
    				}
    			}
    		});
    	}
    }



    更多相关内容
  • Socket编程-服务器向客户端发送数据

    千次阅读 2018-12-28 13:38:28
    最近想学习一下底层的socket编程的东西,了解一下具体的原理,而不...服务器向客户端发送数据:Hello World! 运行结果: 客户端: 源代码: 服务器端: #include &lt;stdio.h&gt; #include &l...

    最近想学习一下底层的socket编程的东西,了解一下具体的原理,而不只是使用封装好的类库。从C语言中文网教程上学习的,记录一下吧。

    使用vs2010为开发环境,可能由于缺少库的原因?codeblocks没法使用.

    服务器向客户端发送数据:Hello World!

    运行结果:

    客户端:

    源代码:

    服务器端:

    #include <stdio.h>
    #include <WinSock2.h>
    
    #pragma comment(lib, "ws2_32.lib")        //加载 ws2_32.dll
    
    int main()
    {
    	//初始化DLL
    	WSADATA wsaData;
    	WSAStartup(MAKEWORD(2,2), &wsaData);
    
    	//创建套接字
    	SOCKET servSock = socket(AF_INET, SOCK_STREAM, 0);
    
    	//绑定套接字
    	sockaddr_in servAddr;
    	//每个字节都用0填充
    	memset(&servAddr, 0, sizeof(servAddr));
    	//使用IPv4地址
    	servAddr.sin_family = AF_INET;
    	//具体的IP地址
    	servAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    	//端口
    	servAddr.sin_port = htons(1234);
    
    	bind(servSock, (sockaddr *)&servAddr, sizeof(servAddr));
    
    	//进入监听状态
    	listen(servSock, 20);
    
    	//接收客户端请求
    	sockaddr clntAddr;
    	int nSize = sizeof(clntAddr);
    	SOCKET clntSock = accept(servSock, &clntAddr, &nSize);  
    
    	//向客户端发送数据
    	char *str = "Hello World!";
    	send(clntSock, str, strlen(str) + sizeof(char), NULL);
    
    	//关闭套接字
    	closesocket(clntSock);
    	closesocket(servSock);
    
    	//终止DLL的使用
    	WSACleanup();
    
    	return 0;
    }

    客户端:

    #include <stdio.h>
    #include <WinSock2.h>
    
    #pragma comment(lib, "ws2_32.lib")   //加载 ws2_32.dll
    
    int main()
    {
    	//初始化DLL
    	WSADATA wsaData;
    	WSAStartup(MAKEWORD(2,2), &wsaData);
    
    	//创建套接字
    	SOCKET clntSock = socket(AF_INET, SOCK_STREAM, 0);
    
    	//向服务器发起请求
    	sockaddr_in clntAddr;
    	//每个字节都用0填充
    	memset(&clntAddr, 0, sizeof(clntAddr));
    	clntAddr.sin_family = AF_INET;
    	clntAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    	clntAddr.sin_port = htons(1234);
    	connect(clntSock, (sockaddr *)&clntAddr, sizeof(clntAddr));
    
    	//接收服务器传回的数据
    	char szBuffer[MAXBYTE] = {0};
    	recv(clntSock, szBuffer, MAXBYTE, NULL);
    
    	//输出接收到的数据
    	printf("Message form server: %s\n", szBuffer);
    
    	//关闭套接字
    	closesocket(clntSock);
    
    	//终止使用 DLL
    	WSACleanup();
    
    	system("pause");
    	return 0;
    }

     

    展开全文
  • 服务端 #define _WINSOCK_DEPRECATED_NO_WARNINGS #define _CRT_SECURE_NO_WARNINGS #include #include #pragma comment(lib,"ws2_32.lib") #include #include #...= 0) printf("客户端发送数据%dbyte\n", ret); } }

     服务端

    #define  _WINSOCK_DEPRECATED_NO_WARNINGS 
    #define _CRT_SECURE_NO_WARNINGS
    #include <WinSock2.h>
    #include <WS2tcpip.h>
    #pragma comment(lib,"ws2_32.lib")
    #include <stdio.h>
    #include <Windows.h>
    #include <conio.h>
    #include <map>
    #include <algorithm>
    #include <string>
    #include <vector>
    #include <iostream>
    using std::string;
    using std::map;
    using std::vector;
    map<USHORT, SOCKET> socketMap;
    
    //发送数据
    void WINAPI SendMsg()
    {
    	while (1)
    	{
    		//		'+' 43
    		//		'/'	47
    		//		'*' 42
    		int key = _getch();
    		if (key == 43)		//发送消息
    		{
    			printf("【*】群发【/】单发\n");
    			key = _getch();
    			printf("发送内容:");
    			char sendStr[100] = {};
    			gets_s(sendStr, sizeof(sendStr));
    			//scanf("%s",sendStr);
    			int sendRet = 0;
    
    			if(key == 42 )	//群发
    			{
    				for (auto inter = socketMap.begin(); inter != socketMap.end(); ++inter)
    				{
    					SOCKET clientSocket = inter->second;
    					sendRet = send(clientSocket, sendStr, strlen(sendStr), 0);
    				}
    			}
    			else if(key == 47)		//单发
    			{
    				printf("客户端端口号:");
    				int hostPort = 0;
    				//scanf("%d",&port);
    				char temp[100] = {};
    				gets_s((char*)&temp, sizeof(temp));
    				sscanf(temp, "%d", &hostPort);
    				if (socketMap.find(hostPort) != socketMap.end())
    				{
    					SOCKET clientSocket = socketMap.at(hostPort);
    					sendRet = send(clientSocket, sendStr, strlen(sendStr), 0);
    				}
    				else
    				{
    					printf("输入端口号有误\n");
    					continue;
    				}
    			}
    
    			if(sendRet != 0)
    				printf("已发送\n");
    			else
    				printf("发送失败\n");
    		}
    	}
    }
    
    //接收客户端数据
    DWORD WINAPI  RecvMsg(SOCKET* clientSocket)
    {
    	//int threadId = GetCurrentThreadId();
    	//int n = 5;
    	while (1)
    	{
    		char recvStr[10000] = {};
    		int recvRet = recv(*clientSocket, recvStr, sizeof(recvStr), 0);
    		if (recvRet != -1 && recvRet != 0)
    			printf("thread【%d】:%s\n=========\n", (int)GetCurrentThreadId(), recvStr);
    		else
    		{
    			auto retVal = std::find_if(socketMap.begin(), socketMap.end(), [clientSocket](map<USHORT, SOCKET>::value_type val)
    			{
    				return val.second == *clientSocket;
    			});
    			if (retVal != socketMap.end())
    			{
    				printf("客户端%d已断开\n", retVal->first);
    				closesocket(retVal->second);
    				socketMap.erase(retVal);
    				break;
    			}
    			else
    			{
    				printf("没有该客户端\n");
    			}
    		}
    	}
    	return 0;
    }
    
    int main()
    {	
    	CreateThread(0, 0, (LPTHREAD_START_ROUTINE)SendMsg, 0, 0, 0);
    	WSADATA wsaData = { 0 };
    	WSAStartup(MAKEWORD(2,2),&wsaData);
    	SOCKET serverSocket = socket(AF_INET,SOCK_STREAM,0);
    	sockaddr_in sockaddr;
    	sockaddr.sin_family = AF_INET;
    	sockaddr.sin_addr.S_un.S_addr =  INADDR_ANY; 	//监听本机任意IP地址的8888端口
    	//sockaddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    	sockaddr.sin_port = htons(8888);
    	int  bindRet = bind(serverSocket, (SOCKADDR*)&sockaddr, sizeof(sockaddr));
    	if (bindRet == SOCKET_ERROR)
    	{
    		printf("绑定失败\n");
    		closesocket(serverSocket);
    		WSACleanup();
    		getchar();
    		exit(0);
    	}
    	int listenRet = listen(serverSocket, 3);  
    	if (listenRet == -1)
    	{
    		printf("监听失败\n");
    		closesocket(serverSocket);
    		WSACleanup();
    		system("pause");
    		return 0;
    	}
    	printf("监听中...\n");
    	
    
    	while (1)
    	{
    		SOCKADDR_IN clientSockAddr_in = {};
    		int len = sizeof(clientSockAddr_in);
    		SOCKET clientSocket = accept(serverSocket, (SOCKADDR*)&clientSockAddr_in, &len);
    		printf("有客户端连接\n");
    		printf("ip=%s,port=%d\n", inet_ntoa(clientSockAddr_in.sin_addr), ntohs(clientSockAddr_in.sin_port));
    		socketMap[ntohs(clientSockAddr_in.sin_port)] = clientSocket;
    		CreateThread(0, 0, (LPTHREAD_START_ROUTINE)RecvMsg, &socketMap[ntohs(clientSockAddr_in.sin_port)], 0, 0);
    	}
    }

    客户端

    #define  _WINSOCK_DEPRECATED_NO_WARNINGS 
    #define _CRT_SECURE_NO_WARNINGS
    
    #include <WinSock2.h>
    #include <WS2tcpip.h>
    #pragma comment(lib,"ws2_32.lib")
    #include <stdio.h>
    #include <iostream>
    
    DWORD WINAPI RecvMsg(const SOCKET* clientSocket)
    {
    	while (1)
    	{
    		char recvStr[100] = {};
    		int recvRet = recv(*clientSocket, recvStr, sizeof(recvStr), 0);
    		if (recvRet != -1)
    			printf("服务器说:%s\n", recvStr);
    		else
    		{
    			printf("服务器已断开\n");
    			closesocket(*clientSocket);
    			WSACleanup();
    			system("pause");
    			closesocket(*clientSocket);
    			WSACleanup();
    			exit(0);
    		}
    	}
    	return 0;
    }
    
    int main()
    {
    
    	WSADATA wsaData = { 0 };
    	WSAStartup(MAKEWORD(2, 2), &wsaData);
    	SOCKET clientSocket = socket(AF_INET, SOCK_STREAM, 0);
    	//******bind自定义端口号测试*********/
    	SOCKADDR_IN clientSockAddr_in = { 0 };
    	clientSockAddr_in.sin_family = AF_INET;
    	clientSockAddr_in.sin_addr.S_un.S_addr = INADDR_ANY;	//本机IP
    	clientSockAddr_in.sin_port = htons(2222);
    	if(bind(clientSocket, (SOCKADDR*)&clientSockAddr_in, sizeof(clientSockAddr_in)) == SOCKET_ERROR)
    	{
    		std::cout << "绑定套接字失败\n";
    		closesocket(clientSocket);
    		WSACleanup();
    		system("pause");
    		return 0;
    	}
    	/***************************************/
    
    	SOCKADDR_IN sockaddr_in;
    	sockaddr_in.sin_family = AF_INET;
    	sockaddr_in.sin_addr.S_un.S_addr =  inet_addr("172.16.20.203");		//inet_addr("192.168.18.173");		//服务端ip地址
    	//sockaddr_in.sin_addr.S_un.S_addr = inet_addr("192.168.74.128");
    	sockaddr_in.sin_port = htons(8888);														//服务端监听的端口
    	int conRet = connect(clientSocket,(SOCKADDR*)&sockaddr_in, sizeof(sockaddr_in));
    	if (conRet != SOCKET_ERROR)
    	{
    		printf("连接成功\n");
    		CreateThread(0, 0, (LPTHREAD_START_ROUTINE)RecvMsg, &clientSocket, 0, 0);
    	}
    		
    	else
    	{
    		printf("连接失败,返回%d\n", conRet);
    		closesocket(clientSocket);
    		WSACleanup();
    	}
    		
    	while (1)
    	{
    		printf("输入内容\n");
    		char sendStr[10000] = {};
    		//scanf("%s", sendStr);	//遇到空格会截断后面内容
    		gets_s(sendStr, sizeof(sendStr));
    
    		int ret = send(clientSocket, sendStr, strlen(sendStr), 0);
    		if (ret != 0)
    			printf("客户端发送数据%dbyte\n", ret);
    	}
    }

    展开全文
  • 一、TCP概述 TCP(Transmission Control Protocol传输控制协议)是一种面向连接的、可靠的、基于字节流的传输层通信协议。...3)可靠、出错重传、且每收到一个数据都要给出相应的确认,保证数据传输的可靠性 ...

    一、TCP概述

    TCP(Transmission Control Protocol 传输控制协议)是一种面向连接的、可靠的、基于字节流的传输层通信协议。

    TCP 具有以下特点:
    1)电话系统服务模式的抽象
    2)每一次完整的数据传输都要经过建立连接、使用连接、终止连接的过程
    3)可靠、出错重传、且每收到一个数据都要给出相应的确认,保证数据传输的可靠性

                                        

    二、TCP 编程的 C/S 架构

    基于 TCP 的网络编程开发分为服务器端客户端两部分,常见的核心步骤和流程如下:

                                           

    三、TCP 客户端编程

    对于 TCP 客户端编程流程,有点类似于打电话过程:

    1.找个可以通话的手机(socket() )

    2.拨通对方号码并确定对方是自己要找的人( connect() )

    3.主动聊天( send() 或 write() )

    4.或者,接收对方的回话( recv() 或read() )

    5.通信结束后,双方说再见挂电话(close() )

    所需头文件:#include <sys/socket.h>

    int socket(int family,int type,int protocol);

    功能:

    创建一个用于网络通信的 socket 套接字(描述符), 详细用法,请看《套接 的介绍》

    参数:

    family:本示例写 AF_INET,代表 IPv4

    type:本示例写 SOCK_STREAM,代表 TCP 数据流

    protocol:这里写 0,设为 0 表示使用默认协议

    返回值:

    成功:套接字

    失败 < 0 

    int connect( int sockfd, const struct sockaddr *addr, socklen_t len );

    功能:

    主动跟服务器建立连接,有点类似于,我们给别人电话,主动拨对方的电话号码,具体是怎么一个过程,请《connect()、listen()和accept()三者之间的关系

    参数:

    sockfdsocket()返回的套接字

    addr:连接的服务器地址结构

    len:地址结构体长度

    返回值:

    成功:0    

    失败:-1

    connect() 函数相当于拨号码,只有拨通号码并且确定对方是自己要找的人(三次握手)才能进行下一步的通信。

    ssize_t send(int sockfd, const void* buf, size_t nbytes, int flags);

    功能:

    发送数据,最后一个参数为 0 时,可以用 write() 替代( send 等同于 write )。注意:不能用 TCP 协议发送 0 长度的数据包。假如,数据没有发送成功,内核会自动重发。

    参数:

    sockfd: 已建立连接的套接字

    buf: 发送数据的地址

    nbytes: 发送缓数据的大小(以字节为单位)

    flags: 套接字标志(常为 0)

    返回值:

    成功:成功发送的字节数

    失败 < 0

     

    3.1-实例1:tcp 客户端发送数据:

    #include <stdio.h>  
    #include <unistd.h>  
    #include <string.h>  
    #include <stdlib.h>  
    #include <arpa/inet.h>  
    #include <sys/socket.h>  
    #include <netinet/in.h>  
    int main(int argc,  char *argv[])  
    {  
        unsigned short port = 8080;             // 服务器的端口号  
        char *server_ip = "192.168.1.7";       // 服务器ip地址  
          
        if( argc > 1 )       //函数传参,可以更改服务器的ip地址                                   
        {         
            server_ip = argv[1];  
        }     
        if( argc > 2 )      //函数传参,可以更改服务器的端口号                                     
        {  
            port = atoi(argv[2]);  
        }  
      
        int sockfd;  
        sockfd = socket(AF_INET, SOCK_STREAM, 0);// 创建通信端点:套接字  
        if(sockfd < 0)  
        {  
            perror("socket");  
            exit(-1);  
        }  
          
        // 设置服务器地址结构体  
        struct sockaddr_in server_addr;  
        bzero(&server_addr,sizeof(server_addr)); // 初始化服务器地址  
        server_addr.sin_family = AF_INET;   // IPv4  
        server_addr.sin_port = htons(port); // 端口  
        inet_pton(AF_INET, server_ip, &server_addr.sin_addr.s_addr);    // ip  
          
         // 主动连接服务器  
        int err_log = connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));       
        if(err_log != 0)  
        {  
            perror("connect");  
            close(sockfd);  
            exit(-1);  
        }  
          
        char send_buf[512] = {'a','n'};  
        printf("send data to %s:%d\n",server_ip,port);  
        while(1)  
        {  
            printf("send:");  
            fgets(send_buf,sizeof(send_buf),stdin); // 输入内容  
            send_buf[strlen(send_buf)-1]='\0';  
            send(sockfd, send_buf, strlen(send_buf), 0);   // 向服务器发送信息  
        }  
      
        close(sockfd);  
          
        return 0;  
    }  
    运行结果:

    3.2  tcp客户端接收数据,接收来自服务器回显的数据

    tcp接收数据会用到recv()

    ssize_t recv(int sockfd, void *buf,  size_t nbytes, int flags);

    功能:

    接收网络数据,默认的情况下,如果没有接收到数据,这个函数会阻塞,直到有数据到来。

    参数:

    sockfd套接字

    buf:接收网络数据的缓冲区的地址

    nbytes:接收缓冲区的大小(以字节为单位)

    flags:套接字标志(常为 0 )

    返回值:

    成功:成功接收的字节数

    失败 < 0

    测试代码如下:

    #include <stdio.h>  
    #include <unistd.h>  
    #include <string.h>  
    #include <stdlib.h>  
    #include <arpa/inet.h>  
    #include <sys/socket.h>  
    #include <netinet/in.h>  
    int main(int argc, char *argv[])  
    {  
        unsigned short port = 8080;             // 服务器的端口号  
        char *server_ip = "192.168.1.7";       // 服务器ip地址  
          
        if( argc > 1 )       //函数传参,可以更改服务器的ip地址                                   
        {         
            server_ip = argv[1];  
        }     
        if( argc > 2 )      //函数传参,可以更改服务器的端口号                                     
        {  
            port = atoi(argv[2]);  
        }  
      
        int sockfd;  
        sockfd = socket(AF_INET, SOCK_STREAM, 0);// 创建通信端点:套接字  
        if(sockfd < 0)  
        {  
            perror("socket");  
            exit(-1);  
        }  
          
        // 设置服务器地址结构体  
        struct sockaddr_in server_addr;  
        bzero(&server_addr,sizeof(server_addr)); // 初始化服务器地址  
        server_addr.sin_family = AF_INET;   // IPv4  
        server_addr.sin_port = htons(port); // 端口  
        //inet_pton(AF_INET, server_ip, &server_addr.sin_addr); // ip  
        server_addr.sin_addr.s_addr = inet_addr(server_ip);//与inet_pton等价  
          
         // 主动连接服务器  
        int err_log = connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));       
        if(err_log != 0)  
        {  
            perror("connect");  
            close(sockfd);  
            exit(-1);  
        }  
          
          
        printf("send data to %s:%d\n",server_ip,port);  
          
        char send_buf[512] = "this is send data";  
        printf("send data \"%s \" to %s:%d\n",send_buf,server_ip,port);  
        send(sockfd, send_buf, strlen(send_buf), 0);   // 向服务器发送信息  
          
        char recv_buf[512] = {0};  
        recv(sockfd, recv_buf, sizeof(send_buf), 0); // 接收数据  
        printf("%s\n", recv_buf);  
      
        close(sockfd);  
          
        return 0;  
    }  
    

    ​​​​​​

    运行结果:

    展开全文
  • 服务端主动发送数据给客户端端,本代码在NioServer类中维护了map集合用来存储连接的客户端;map的key为客户端发送过来报文中的id(这里你也可以使用ctx.channel().id()相关业务自己实现); 1.netty版本4.1.25 <...
  • 通过服务器向指定客户端发送消息

    千次阅读 2015-08-07 10:32:32
    1HashMap的遍历每一socket发送数据public HashMap, Socket> sockets = new HashMap(); try { Set<String>set=sockets.keySet(); Iterator<String>it=set.iterator(); while(it.hasNe
  • linux下socket编程实现一个服务器连接多个客户端

    万次阅读 多人点赞 2020-07-30 22:58:14
    2)客户端:socker()建立套接字,连接(connect)服务器,连接上后使用send()和recv(),在套接字上写读数据,直至数据交换完毕,close()关闭套接字。 在Linux中,我们可以使用select函数实现I/O
  • linux下用C语言实现TCP/IP服务器客户端互相发送数据的socket编程 server.c #include <sys/stat.h> #include <fcntl.h> #include <errno.h> #include <netdb.h> #include <...
  • 通过Socket,服务端向客户端发送数据时,客户端一直接收不到 服务端发送代码: ClientWriteHandler.this.printStream.print(msg); 原因: 在socket代码中使用print方法时,要想将数据发送出去,必须在发送的...
  • 一、短轮询方式,客户端定时向服务器请求,服务器收到请求后立即返回 @Controller public class ShowTimeController { private static Logger logger = LoggerFactory.getLogger(ShowTimeController.class); @...
  • 目前移植uip,发现UDP 服务器模式下,必须指定本地端口以及客户端端口,否则只能讲客户端端口设置为0,才能接收任意端口的数据,但是无法发送数据,因为此时客户端端口设置为0了,我通过将原始数据包中的客户端端口保存下来...
  • 客户端向服务器发送数据并接收返回数据。 示例代码:
  • (2)服务器功能:添加新员工--接受客户端发送来的新员工结构体数据,追加到数据文件 emp.db 中;员工列表-- 把emp.db 每员工结构体数据读出发回客户端; (3)客户端功能:添加新员工--键盘读取新员工信息并构造...
  • 当我们多客户端连接同一服务端,这时服务端只能给最后一连接的客户端发送消息,这是因为,在创建连接成功时,覆盖了前一创建的socket!那怎样解决呢,我们知道每一客户端的ip和port是固定的,我们可以创建...
  • (可按目录按需阅读,我一般会整理的比较细) 前置知识 java IO Socket 什么是socket?...在设计模式中,Socket其实就是一门面模式,它把复杂的TCP/IP协议族隐藏在Socket接口后面,对用户来说,一组简单的
  • 如果不是聊天室功能而是要传递数据服务器同时为了以后更多功能的拓展性,还是应该用network manager来实现。 无论是哪种方式,unet里的的一特点就是:服务器端是会包括客户端的。换言之客户端服务器是在同...
  • C++实现TCP服务器同时和多个客户端通信(多线程)

    千次阅读 多人点赞 2021-05-12 15:25:26
    接着客户端发送消息,服务器端接收消息,实现交互发送消息。 服务器同时可以和多客户端建立连接,进行交互; 在某次交互中,服务器端或某客户端有一方发送"end"即终止服务器与其的通信;服务器还可以继续接收其他...
  • 这次是一个服务器与一个客户端可以多次连接,与上次有所不同的是让客户端可以持续发送数据服务器端连接,不仅仅是之连接一次,下面我们直接给出代码,然后分析结果 //服务器端 #include&lt;stdio.h&gt; ...
  • 服务器客户端的简单实现

    千次阅读 2022-04-02 15:44:30
    0基础学习客户端、网络端编程
  • 简单的使用Python来搭建服务器,并搭建一个客户端发送服务器 下面代码是创建一客户端 import socket target_host = "0.0.0.0" target_port = 9998 client = socket.socket(socket.AF_INET,socket.SOCK_STREAM) ...
  • UDP服务器客户端编程流程

    千次阅读 2021-12-05 15:44:53
    UPD的特点与服务端客户端编程流程,UDP直接数据传输的方法
  • //ser.c #include #include #include ...但udp模式不像tcp先进行链接,所以必须客户端先发起通讯,让服务器得到客户端的地址,才能进行通讯,而且限制每次发送的次数(客户端一句,服务器一句)还需要改进
  • 关于模块的信息我在这里简单的介绍...最后还有一EN引脚接到3.3V置高。 串口初始波特率为115200(可修改)。最后上电连接电脑串口终端如下图 串口设置如上图,看到乱码不要慌,属正常现象,这里重点说一下一定要...
  • python 实现TCP socket通信和 HTTP服务器服务器客户端通信实例 socket是什么? 由下图可理解:Socket是应用层与TCP/IP协议族通信的中间软件抽象层。 复杂的TCP/IP协议族隐藏在Socket接口后面,对用户来说,一组...
  • 目标是:实现多个客户端与一服务端通信,客户端会间断发送信息(例如每隔0.2s一发送),服务器可以同时接受多个客户端信息,并处理其中一个客户端的信息将处理后的信息分发送给其余客户端 ### 我自己做了一小的...
  • Qt实现客户端服务器消息发送与文件传输

    万次阅读 多人点赞 2018-05-01 13:06:53
    客户端服务器之间的数据传送在很多案例场景里都会有应用。这里Jungle用Qt来简单设计实现一场景,即: ①两端:服务器QtServer和客户端QtClient ②功能:服务端连接客户端,两者能够互相发送消息,传送文件,...
  • TCP服务器连接多客户端(C语言实现)

    千次阅读 多人点赞 2021-05-13 20:39:34
    目录 思路: 逻辑设计: ...每次连接都会开启一线程用于和客户端的通信(也是使用 for 循环进行数据的接收、处理、发送),数据接收使用阻塞等待。 通信的具体实现,在开发板上部署运行下方..
  • 引言 因为我确实不懂TCP通信这一块儿,最近项目中要实现客户端接收服务器发送过来的数据(这个数据是int型的,范围是0~360,而且服务器端用C语言写的,每一秒发送一次,客户端只需要不断接收就好了),很开心的用...
  • 设计程序,分别构建通信的两端:服务器端和客户端应用程序,套接字类型为面向连接的Socket,自己构建双方的应答模式,实现双方的数据发送和接收(S发给C,C发给S)。 服务端程序能响应单个或任意多个客户端连接...
  • 举一基本的例子来说明服务器端和客户端之间的数据交互,采用TCP协议实现。 题目: 客户端能够接收用户输入的两数并发送到服务器服务器端能够接收到这两数并将其相加并将结果返回给客户端客户端接收到...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 285,315
精华内容 114,126
关键字:

服务器向n个客户端同时发送数据