TCP/IP 协议：网络世界的基石（2/10）

   import java.io.FileOutputStream;
   import java.io.IOException;
   import java.io.InputStream;
   import java.net.ServerSocket;
   import java.net.Socket;

   public class TCPServer {
       public static void main(String[] args) throws IOException {
           // 获取 ServerSocket 对象，提供 TCP 连接服务
           ServerSocket serverSocket = new ServerSocket(8888);
           // 等待接收客户端的 TCP 连接申请
           Socket socket = serverSocket.accept();
           // 保存客户端发送的文件
           // 获取 TCP 连接提供的字节输入流
           InputStream is = socket.getInputStream();
           // 把数据存入指定文件
           FileOutputStream fos = new FileOutputStream(new File("D://receivedFile.txt"));
           byte[] b = new byte[1024];
           int len;
           // 读取数据，保存数据
           while ((len = is.read(b))!= -1) {
               fos.write(b, 0, len);
           }
           // 关闭资源
           fos.close();
           is.close();
           socket.close();
           serverSocket.close();
       }
   }

   import java.io.FileInputStream;
   import java.io.IOException;
   import java.io.OutputStream;
   import java.net.InetAddress;
   import java.net.Socket;

   public class TCPClient {
       public static void main(String[] args) throws IOException {
           // 创建了一个匿名的 InetAddress 独享，创建了一个 socket,进行连接
           Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 8888);
           // 创建输出流，用来发送字节流
           OutputStream os = socket.getOutputStream();
           // 本身我需要获取到本地的一个文件，所以我需要 input
           FileInputStream fis = new FileInputStream(new File("D://originalFile.txt"));
           // 具体读和写的过程
           byte[] buffer = new byte[1024];
           int len;
           while ((len = fis.read(buffer))!= -1) {
               // 再次提醒这样是为了防止读取到重复数据
               os.write(buffer, 0, len);
           }
           // 关闭资源
           fis.close();
           os.close();
           socket.close();
       }
   }

import socket

import threading

# 创建一个 socket 对象

serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 获取本地主机名

host = socket.gethostname()

# 设置端口号

port = 9999

# 绑定端口号

serversocket.bind((host, port))

# 设置最大连接数，超过后排队

serversocket.listen(5)

client_list = []

# 用于存储所有连接的客户端 socket

def handle_client(clientsocket):

data = clientsocket.recv(1024).decode()

print(f"收到数据：{data}")

clientsocket.send("已收到您的消息".encode())

clientsocket.close()

client_list.remove(clientsocket)

while True:

# 建立客户端连接

clientsocket, addr = serversocket.accept()

print(f"连接地址：{str(addr)}")

client_list.append(clientsocket)

# 为每个新连接创建一个线程来处理

threading.Thread(target=handle_client, args=(clientsocket,)).start()

import socket

# 创建一个 socket 对象

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 获取本地主机名

host = socket.gethostname()

# 设置端口号

port = 9999

# 连接服务，指定主机和端口

s.connect((host, port))

# 发送数据

s.send("Hello, server".encode())

# 接收响应数据

response = s.recv(1024).decode()

print(f"收到响应：{response}")

# 关闭连接

s.close()

def broadcast_message(message):

for client in client_list:

client.send(message.encode())

   // MyServer.cpp : 定义控制台应用程序的入口点。
   #include "stdafx.h"
   #include <iostream>
   #include <stdlib.h>
   #include <winsock2.h>
   // 引用头文件
   #pragma comment(lib,"ws2_32.lib")
   // 最大连接数
   #define g_MaxConnect 20
   int g_Connect = 0;
   struct sock_params {
       SOCKET hsock;
       int nSockIndex;
   };
   // 线程实现函数
   DWORD WINAPI threadpro(LPVOID pParam) {
       sock_params* sockPam = (sock_params*)pParam;
       SOCKET hsock = sockPam->hsock;
       int nSockIndex = sockPam->nSockIndex;
       char aIndex[4];
       _itoa_s(nSockIndex, aIndex, 10);
       char buffer[1024];
       char sendBuffer[1024];
       if (hsock!= INVALID_SOCKET) {
           std::cout << "客户端 " << nSockIndex << " 加入服务器!" << std::endl;
       }
       while (1) {
           // 循环接收发送的内容
           int num = recv(hsock, buffer, 1024, 0);
           // 阻塞函数，等待接收内容
           if (num > 0) {
               std::cout << "客户端 " << nSockIndex << ": " << buffer << std::endl;
               memset(sendBuffer, 0, 1024);
               char strValue[30] = "服务器 ";
               strcat_s(strValue, aIndex);
               strcpy_s(sendBuffer, strValue);
               char strSpace[30] = " 收到数据如下: ";
               strcat_s(sendBuffer, strSpace);
               strcat_s(sendBuffer, buffer);
               int ires = send(hsock, sendBuffer, sizeof(sendBuffer), 0);
               // 回送消息
               // cout << "Send to Client: " << sendBuffer << endl;
           }
           else {
               std::cout << "客户端 " << nSockIndex << " 关闭！" << std::endl;
               // cout << "Server Process " << nSockIndex << " Closed" << endl;
               return 0;
           }
       }
       return 0;
   }
   // 主函数
   void main() {
       WSADATA wsd;
       // 定义 WSADATA 对象
       WSAStartup(MAKEWORD(2, 2), &wsd);
       SOCKET m_SockServer;
       sockaddr_in serveraddr;
       sockaddr_in serveraddrfrom;
       SOCKET m_Server[g_MaxConnect];
       serveraddr.sin_family = AF_INET;
       // 设置服务器地址
       serveraddr.sin_port = htons(4600);
       // 设置端口号
       serveraddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
       m_SockServer = socket(AF_INET, SOCK_STREAM, 0);
       int nStatus = bind(m_SockServer, (sockaddr*)&serveraddr, sizeof(serveraddr));
       if (nStatus == 0) {
           std::cout << "服务端启动成功!" << std::endl;
       }
       else {
           std::cout << "服务端启动失败!" << std::endl;
           return;
       }
       int iLisRet = 0;
       int len = sizeof(sockaddr);
       while (1) {
           iLisRet = listen(m_SockServer, 0);
           // 进行监听
           m_Server[g_Connect] = accept(m_SockServer, (sockaddr*)&serveraddrfrom, &len);
           // 同意连接
           if (m_Server[g_Connect]!= INVALID_SOCKET) {
               if (g_Connect > g_MaxConnect - 1) {
                   char WarnBuf[50] = "客户端连接个数:超限!";
                   int ires = send(m_Server[g_Connect], WarnBuf, sizeof(WarnBuf), 0);
               }
               else {
                   char cIndex[4];
                   _itoa_s(g_Connect, cIndex, 10);
                   char buf[50] = "你的服务端 ID: ";
                   strcat_s(buf, cIndex);
                   int ires = send(m_Server[g_Connect], buf, sizeof(buf), 0);
                   // 发送字符过去
                   // cout << buf << endl;
                   HANDLE m_Handel;
                   // 线程句柄
                   DWORD nThreadId = 0;
                   // 线程 ID
                   sock_params sockPam;
                   sockPam.hsock = m_Server[g_Connect];
                   sockPam.nSockIndex = g_Connect;
                   m_Handel = (HANDLE)::CreateThread(NULL, 0, threadpro, &sockPam, 0, &nThreadId);
                   CloseHandle(m_Handel);
               }
               ++g_Connect;
           }
       }
       WSACleanup();
   }

   // MyClient.cpp : 定义控制台应用程序的入口点。
   #include "stdafx.h"
   #include <iostream>
   #include <stdlib.h>
   #include <stdio.h>
   #include "winsock2.h"
   #include <time.h>
   #pragma comment(lib,"ws2_32.lib")
   void main() {
       WSADATA wsd;
       // 定义 WSADATA 对象
       WSAStartup(MAKEWORD(2, 2), &wsd);
       SOCKET m_SockClient;
       sockaddr_in clientaddr;
       clientaddr.sin_family = AF_INET;
       // 设置服务器地址
       clientaddr.sin_port = htons(4600);
       // 设置服务器端口号
       clientaddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
       m_SockClient = socket(AF_INET, SOCK_STREAM, 0);
       if (m_SockClient == INVALID_SOCKET) {
           printf("Sock 初始化失败: %d\n", WSAGetLastError());
           WSACleanup();
           return;
       }
       // 获取发送缓冲区和接送缓冲区大小
       {
           int optlen = 0;
           int optval = 0;
           optlen = sizeof(optval);
           getsockopt(m_SockClient, SOL_SOCKET, SO_SNDBUF, (char*)&optval, &optlen);
           printf("send buf len is %d\n", optval);
           // 64 位 默认发送缓冲区 64k
           getsockopt(m_SockClient, SOL_SOCKET, SO_RCVBUF, (char*)&optval, &optlen);
           printf("Recv buf len is %d\n", optval);
           // 64 位 默认接收缓冲区 64k
       }
       // 设定发送缓冲区大小
       // optval = 1024 * 2;  // setsockopt(ConnectSocket, SOL_SOCKET, SO_SNDBUF, (char*)&optval, optlen);
       int nSuccess = connect(m_SockClient, (sockaddr*)&clientaddr, sizeof(clientaddr));
       // 连接超时
       if (nSuccess == 0) {
           std::cout << "连接服务器成功!" << std::endl;
       }
       else {
           std::cout << "连接服务器失败!" << std::endl;
           return;
       }
       char buffer[1024];
       char inBuf[1024];
       int num = 0;
       num = recv(m_SockClient, buffer, 1024, 0);
       // 阻塞
       if (num > 0) {
           std::cout << buffer << std::endl;
           char* pResult = strstr(buffer, "超限");
           if (pResult!= NULL) {
               std::cout << "服务器连接个数超限，不可用！" << std::endl;
               system("pause");
               return;
           }
           while (1) {
               std::cout << "请输入要发送的消息：" << std::endl;
               std::cin >> inBuf;
               if (strcmp(inBuf, "exit") == 0) {
                   send(m_SockClient, inBuf, sizeof(inBuf), 0);
                   // 发送退出指令
                   return;
               }
               int send_len = send(m_SockClient, inBuf, sizeof(inBuf), 0);
               if (send_len < 0) {
                   std::cout << "发送失败！请检查服务器是否开启！" << std::endl;
                   system("pause");
                   return;
               }
               int recv_len = recv(m_SockClient, buffer, 1024, 0);
               // 接收客户端发送过来的数据
               if (recv_len >= 0) {
                   std::cout << buffer << std::endl;
               }
           }
       }
   }