目录

文件1：tcpServer.cc

文件2：tcpServer.hpp

1.提出日志概念 -- 在后续完善

日志格式 -- 暂定简单的打印功能

2.创建套接字

SOCK_STREAM -- socket参数

3.bind自己的套接字

4.设置socket 为监听状态 *

新接口1：listen

函数1：initServer()

新接口2：accept *

接口1：read

接口2：write

文件描述符本质是数组下标 -- 有限

ulimit -- 查看本机可以开多少个文件描述符

函数2：serviceIO()

至此基本的功能完成 -- 测试1

准备工作

文件3：tcpClient.cc

文件4：tcpClient.hpp

函数3：initClient()

新接口3：connect *

函数4：start()

至此TCP通信的功能完成 -- 测试2

全部代码

log.hpp

makefile

tcpClient.cc

tcpClient.hpp

tcpServer.cc

tcpServer.hpp

---

直接代码开整

文件1：tcpServer.cc

准备阶段 -- 目前和UDP是一样的

#include "tcpServer.hpp"
#include <memory>

using namespace std;
using namespace server;

static void Usage(string proc)
{
    cout << "Usage:\n\t" << proc << " local_port\n\n"; // 命令提示符
}

// tcp服务器，启动和 udp server 一模一样
// ./tcpserver lock_port
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        Usage(argv[0]);
        exit(USAGE_ERR);
    }
    uint16_t port = atoi(argv[1]);

    unique_ptr<TcpServer> tsvr(new TcpServer());
    tsvr->initServer();
    tsvr->start();
     
    return 0;
}

文件2：tcpServer.hpp

1.提出日志概念 -- 在后续完善

日志格式 -- 暂定简单的打印功能

这个日志在后序完善TCP之后再进行修改，现在只实现简单的打印功能

2.创建套接字

SOCK_STREAM -- socket参数

3.bind自己的套接字

        这里有个细节，我们会发现当我们接受数据的时候是不需要主机转网路序列的，因为关于IO类的接口，内部都帮我们实现了这一功能，这里不帮我们做是因为我们传入的是一个结构体，系统做不到

4.设置socket 为监听状态 *

新接口1：listen

底层链接的长度+1，先不管他，在后序讲原理再讲述

函数1：initServer()

        void initServer()
        {
            // 1. 创建socket文件套接字对象 -- 流式套接字
            _sock = socket(AF_INET, SOCK_STREAM, 0); // 第三个参数默认 0
            if (_sock < 0)
            {
                logMessage(FATAL, "create socket error");
                exit(SOCKET_ERR);
            }
            logMessage(NORMAL, "create socket success");

            // 2.bind绑定自己的网路信息 -- 注意包含头文件
            struct sockaddr_in local;
            memset(&local, 0, sizeof(local));
            local.sin_family = AF_INET;
            local.sin_port = htons(_port);      // 这里有个细节，我们会发现当我们接受数据的时候是不需要主机转网路序列的，因为关于IO类的接口，内部都帮我们实现了这一功能，这里不帮我们做是因为我们传入的是一个结构体，系统做不到
            local.sin_addr.s_addr = INADDR_ANY; // 接受任意ip地址
            if (bind(_sock, (struct sockaddr *)&local, sizeof(local)) < 0)
            {
                logMessage(FATAL, "bind socket error");
                exit(BIND_ERR);
            }
            logMessage(NORMAL, "bind socket success");

            // 3. 设置socket 为监听状态 -- TCP与UDP不同，它先要建立链接之后，TCP是面向链接的，后面还会有“握手”过程
            if (listen(_sock, gbacklog) < 0) // 第二个参数backlog后面再填这个坑
            {
                logMessage(FATAL, "listen socket error");
                exit(LISTEN_ERR);
            }
            logMessage(FATAL, "listen socket success");
        }

注意这里是起始版本，在认识下面的一个接口的时候，需要整改

新接口2：accept *

        一个比喻：就像一家饭店的门口招呼人的张三，当张三从外边招呼人进来的时候，就向饭店里面喊人，让李四去服务客人，但是张三不会进来，又返回去在门口拉客

        因为随着客户端的不断增多，TCP服务器上可能存在多个套接字，就像饭店里面会有多个客人有多个服务员

至此我们需要把之前的_sock 修改为 _listensock

至此我们获取的sock就是一个文件操作符，可以使用文件操作类的函数进行处理，例如read之类的

接口1：read

从一个文件描述符中读取

接口2：write

文件描述符本质是数组下标 -- 有限

ulimit -- 查看本机可以开多少个文件描述符

函数2：serviceIO()

        void serviceIO(int sock)
        {
            // 先用最简单的，读取再写回去
            char buffer[1024];
            while (true)
            {
                ssize_t n = read(sock, buffer, sizeof(buffer) - 1);
                if (n > 0)
                {
                    // 截至目前，我们把读到的数据当作字符串
                    buffer[n] = 0;
                    std::cout << "recv message: " << buffer << std::endl;

                    std::string outbuffer = buffer;
                    outbuffer += "server[echo]";

                    write(sock, outbuffer.c_str(), outbuffer.size()); // 在多路转接的时候再详谈write的返回值
                }
                else if(n == 0)
                {
                    // 代表client退出 -- 把它想象成一个建立好的管道，客户端不写了，并且把它的文件描述符关了，读端就会像管道一样读到 0 TCP同理
                    logMessage(NORMAL, "client quit, me too!");
                }
            }
        }

至此基本的功能完成 -- 测试1

准备工作

文件3：tcpClient.cc

调用逻辑 

#include "tcpClient.hpp"
#include <memory>

using namespace std;

static void Usage(string proc)
{
    cout << "Usage:\n\t" << proc << " serverip serverport\n\n"; // 命令提示符
}

// ./tcpclient serverip serverport  调用逻辑
int main(int argc, char *argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }
    string serverip = argv[1];
    uint16_t serverport = atoi(argv[2]);

    unique_ptr<TcpClient> tcli(new TcpClient(serverip, serverport));
    tcli->initClient();
    tcli->start();

    return 0;
}

文件4：tcpClient.hpp

函数3：initClient()

    void initClient()
    {
        // 1. 创建socket
        _sock = socket(AF_INET, SOCK_STREAM, 0);
        if (_sock < 0)
        {
            // 客户端也可以有日志，不过这里就不再实现了，直接打印错误
            std::cout << "socket create error" << std::endl;
            exit(2);
        }

        // 2. tcp的客户端要不要bind？ 要的！ 但是不需要显示bind，这里的client port要让OS自定！
        // 3. 要不要listen？ -- 不需要！客户端不需要建立链接
        // 4. 要不要accept？ -- 不要！
        // 5. 要什么？ 要发起链接！
    }

新接口3：connect *

函数4：start()

 void start()
    {
        struct sockaddr_in server;
        memset(&server, 0, sizeof(server));
        server.sin_family = AF_INET;
        server.sin_port = htons(_serverport);
        server.sin_addr.s_addr = inet_addr(_serverip.c_str());

        if (connect(_sock, (struct sockaddr *)&server, sizeof(server)) != 0)
        {
            std::cerr << "socket connect error" << std::endl;
        }
        else
        {
            std::string msg;
            while (true)
            {
                std::cout << "Enter# ";
                std::getline(std::cin, msg);
                write(_sock, msg.c_str(), msg.size());

                char buffer[NUM];
                int n = read(_sock, buffer, sizeof(buffer) - 1);
                if (n > 0)
                {
                    // 目前我们把读到的数据当成字符串， 截至目前
                    buffer[n] = 0;
                    std::cout << "Server回显# " << buffer << std::endl;
                }
                else
                {
                    break;
                }
            }
        }
    }

至此TCP通信的功能完成 -- 测试2

        但是至此，我们所写的不过是一个单进程版的，所以会出现下面的情况，后续需要进一步修改成为多进程形式的

全部代码

log.hpp

#pragma once

#include <iostream>
#include <string>

// 定义五种不同的信息
#define DEBUG 0
#define NORMAL 1
#define WARNING 2
#define ERROR 3     //一种不影响服务器的错误
#define FATAL 4     //致命错误

void logMessage(int level, const std::string message)
{
    // 格式如下
    // [日志等级] [时间戳/时间] [pid] [message]
    // [FATAL0] [2023-06-11 16:46:07] [123] [创建套接字失败]

    // 暂定
    std::cout << message << std::endl;
}

makefile

cc=g++
.PHONY:all
all:tcpserver tcpclient

tcpclient:tcpClient.cc
	$(cc) -o $@ $^ -std=c++11

tcpserver:tcpServer.cc
	$(cc) -o $@ $^ -std=c++11
 
.PHONY:clean
clean:
	rm -f tcpserver tcpclient

tcpClient.cc

#include "tcpClient.hpp"
#include <memory>

using namespace std;

static void Usage(string proc)
{
    cout << "Usage:\n\t" << proc << " serverip serverport\n\n"; // 命令提示符
}

// ./tcpclient serverip serverport  调用逻辑
int main(int argc, char *argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }
    string serverip = argv[1];
    uint16_t serverport = atoi(argv[2]);

    unique_ptr<TcpClient> tcli(new TcpClient(serverip, serverport));
    tcli->initClient();
    tcli->start();

    return 0;
}

tcpClient.hpp

#pragma once

#include <iostream>
#include <string>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

#define NUM 1024

class TcpClient
{
public:
    TcpClient(const std::string &serverip, const uint16_t &port)
        : _sock(1), _serverip(serverip), _serverport(port)
    {
    }
    void initClient()
    {
        // 1. 创建socket
        _sock = socket(AF_INET, SOCK_STREAM, 0);
        if (_sock < 0)
        {
            // 客户端也可以有日志，不过这里就不再实现了，直接打印错误
            std::cout << "socket create error" << std::endl;
            exit(2);
        }

        // 2. tcp的客户端要不要bind？ 要的！ 但是不需要显示bind，这里的client port要让OS自定！
        // 3. 要不要listen？ -- 不需要！客户端不需要建立链接
        // 4. 要不要accept？ -- 不要！
        // 5. 要什么？ 要发起链接！
    }

    void start()
    {
        struct sockaddr_in server;
        memset(&server, 0, sizeof(server));
        server.sin_family = AF_INET;
        server.sin_port = htons(_serverport);
        server.sin_addr.s_addr = inet_addr(_serverip.c_str());

        if (connect(_sock, (struct sockaddr *)&server, sizeof(server)) != 0)
        {
            std::cerr << "socket connect error" << std::endl;
        }
        else
        {
            std::string msg;
            while (true)
            {
                std::cout << "Enter# ";
                std::getline(std::cin, msg);
                write(_sock, msg.c_str(), msg.size());

                char buffer[NUM];
                int n = read(_sock, buffer, sizeof(buffer) - 1);
                if (n > 0)
                {
                    // 目前我们把读到的数据当成字符串， 截至目前
                    buffer[n] = 0;
                    std::cout << "Server回显# " << buffer << std::endl;
                }
                else
                {
                    break;
                }
            }
        }
    }
    ~TcpClient()
    {
        if(_sock >= 0) close(_sock);    //不写也行，因为文件描述符的生命周期随进程，所以进程退了，自然也就会自动回收了
    }

private:
    int _sock;
    std::string _serverip;
    uint16_t _serverport;
};

tcpServer.cc

#include "tcpServer.hpp"
#include <memory>

using namespace server;
using namespace std;

static void Usage(string proc)
{
    cout << "Usage:\n\t" << proc << " local_port\n\n"; // 命令提示符
}

// tcp服务器，启动上和udp server一模一样
// ./tcpserver local_port
int main(int argc, char *argv[])
{ 
    if (argc != 2)
    {
        Usage(argv[0]);
        exit(USAGE_ERR);
    }
    uint16_t port = atoi(argv[1]);

    unique_ptr<TcpServer> tsvr(new TcpServer(port));
    tsvr->initServer();
    tsvr->start();

    return 0;
}

tcpServer.hpp

#pragma once

#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include "log.hpp"

namespace server
{
    enum
    {
        USAGE_ERR = 1,
        SOCKET_ERR,
        BIND_ERR,
        LISTEN_ERR

    };

    static const uint16_t gport = 8080;
    static const int gbacklog = 5; // 10、20、50都可以，但是不要太大比如5千，5万

    class TcpServer
    {
    public:
        TcpServer(const uint16_t &port = gport) : _listensock(-1), _port(port)
        {
        }
        void initServer()
        {
            // 1. 创建socket文件套接字对象 -- 流式套接字
            _listensock = socket(AF_INET, SOCK_STREAM, 0); // 第三个参数默认 0
            if (_listensock < 0)
            {
                logMessage(FATAL, "create socket error");
                exit(SOCKET_ERR);
            }
            logMessage(NORMAL, "create socket success");

            // 2.bind绑定自己的网路信息 -- 注意包含头文件
            struct sockaddr_in local;
            memset(&local, 0, sizeof(local));
            local.sin_family = AF_INET;
            local.sin_port = htons(_port);      // 这里有个细节，我们会发现当我们接受数据的时候是不需要主机转网路序列的，因为关于IO类的接口，内部都帮我们实现了这一功能，这里不帮我们做是因为我们传入的是一个结构体，系统做不到
            local.sin_addr.s_addr = INADDR_ANY; // 接受任意ip地址
            if (bind(_listensock, (struct sockaddr *)&local, sizeof(local)) < 0)
            {
                logMessage(FATAL, "bind socket error");
                exit(BIND_ERR);
            }
            logMessage(NORMAL, "bind socket success");

            // 3. 设置socket 为监听状态 -- TCP与UDP不同，它先要建立链接之后，TCP是面向链接的，后面还会有“握手”过程
            if (listen(_listensock, gbacklog) < 0) // 第二个参数backlog后面再填这个坑
            {
                logMessage(FATAL, "listen socket error");
                exit(LISTEN_ERR);
            }
            logMessage(NORMAL, "listen socket success");
        }

        void start()
        {
            for (;;) // 一个死循环
            {
                // 4. server 获取新链接
                // sock 和client 进行通信的fd
                struct sockaddr_in peer;
                socklen_t len = sizeof(peer);
                int sock = accept(_listensock, (struct sockaddr *)&peer, &len);
                if (sock < 0)
                {
                    logMessage(ERROR, "accept error, next"); // 这个不影响服务器的运行，用ERROR，就像张三不会因为没有把人招呼进来就不干了
                    continue;
                }
                logMessage(NORMAL, "accept a new link success");
                std::cout << "sock: " << sock << std::endl;

                // 5. 这里就是一个sock， 未来通信我们就用这个sock， 面向字节流的，后续全部都是文件操作！
                // 我们就可以直接使用read之类的面向字节流的操作都行
                // version 1
                serviceIO(sock);
                close(sock); // 走到这里就说明客户端已经关闭
                             // 对一个已经使用完毕的sock，我们要关闭这个sock，要不然会导致，文件描述符会越来越少，因为文件描述符本质就是一个数组下标
                             // 只要是数组下标就会有尽头，提供服务的上限 就等于文件描述符的上限
                             // 对一个已经使用完毕的sock，我们要关闭这个sock，要不然会导致，文件描述符泄漏
            }
        }

        void serviceIO(int sock)
        {
            // 先用最简单的，读取再写回去
            char buffer[1024];
            while (true)
            {
                ssize_t n = read(sock, buffer, sizeof(buffer) - 1);
                if (n > 0)
                {
                    // 截至目前，我们把读到的数据当作字符串
                    buffer[n] = 0;
                    std::cout << "recv message: " << buffer << std::endl;

                    std::string outbuffer = buffer;
                    outbuffer += "server[echo]";

                    write(sock, outbuffer.c_str(), outbuffer.size()); // 在多路转接的时候再详谈write的返回值
                }
                else if (n == 0)
                {
                    // 代表client退出 -- 把它想象成一个建立好的管道，客户端不写了，并且把它的文件描述符关了，读端就会像管道一样读到 0 TCP同理
                    logMessage(NORMAL, "client quit, me too!");
                    break;
                }
            }
        }

        ~TcpServer() {}

    private:
        int _listensock; // 修改二：改为listensock 不是用来进行数据通信的，它是用来监听链接到来，获取新链接的！
        uint16_t _port;
    };

} // namespace server

转下文：简单的TCP网络程序·多进程、多线程(后端服务器）_