简单的TCP网络程序·单进程(后端服务器)

news/2024/7/3 17:19:13

目录

文件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网络程序·多进程、多线程(后端服务器）_


http://lihuaxi.xjx100.cn/news/1247066.html

相关文章

Python基础教程(一)：Python简介

Python基础教程(一)：Python简介

Python基础教程(一)&#xff1a;Python简介 1、什么是Python Python 是一门流行的编程语言。它由 Guido van Rossum 创建&#xff0c;于 1991 年发布。 它用于&#xff1a; Web开发&#xff08;服务器端&#xff09;软件开发数学系统脚本 2、Python可以做什么 可以在服务器…
阅读更多...
SpringBoot的基础配置 - yaml文件的格式以及数据读取

SpringBoot的基础配置 - yaml文件的格式以及数据读取

文章目录 SpringBoot基础配置配置文件格式yaml文件格式yaml数据读取 SpringBoot基础配置 配置文件格式 我们用修改服务器端口号来举例, 演示配置的格式 目前我们SpringBoot入门程序已经可以启动, 但是端口是使用的默认的8080 http://localhost:8080/books/1修改服务器的端口号…
阅读更多...
Android+Rxjava3入门小例子--读取图片并显示

Android+Rxjava3入门小例子--读取图片并显示

第三次学习Rxjava了&#xff0c;这次一定要学会&#xff0c;至少入门吧。。。 为什么要学习这个东东呢&#xff1f; 经常碰到与安卓系统交互的外部设备是应答式的&#xff0c;就是你一步步的问它&#xff0c;它一步步的回答&#xff0c;例如某厂商的指纹仪进行指纹比对操作&am…
阅读更多...
【CompareAndSwap底层原理】

【CompareAndSwap底层原理】

文章目录 CompareAndSwap底层原理小故事 CompareAndSwap底层原理 CompareAndSwap&#xff08;CAS&#xff09;是一种并发编程中的操作&#xff0c;它可以判断一个变量的当前值是否与预期值相同&#xff0c;如果相同&#xff0c;就将该变量的值设置为新值。CAS操作通常用于多线…
阅读更多...
Mini LED电视大热，“智能化”渐行渐远？

Mini LED电视大热，“智能化”渐行渐远？

在中国&#xff0c;电视机几乎是每个家庭必备的家用电器。相较于手机、平板、电脑、学习机等产品而言&#xff0c;由于电视机的屏幕足够大&#xff0c;所以其带给用户的视觉体验会相对更好一些&#xff0c;而影响用户视觉体验的除了屏幕大小以外&#xff0c;还有显示技术。 前…
阅读更多...
微信小程序实现选择地区demo，记录最近访问的地区

微信小程序实现选择地区demo，记录最近访问的地区

最终效果图&#xff1a; index.wxml <view class"container"><view class"search_contaniner"><view class"search_box"><input type"text" placeholder"省/市级/区县级" value"{{search_con…
阅读更多...
1.5 掌握Scala内建控制结构（一）

1.5 掌握Scala内建控制结构（一）

一、条件表达式 &#xff08;一&#xff09;语法格式 if (条件) 值1 else 值2 &#xff08;二&#xff09;执行情况 条件为真&#xff0c;结果是值1&#xff1b;条件为假&#xff0c;结果是值2。如果if和else的返回结果同为某种类型&#xff0c;那么条件表达式结果也是那种…
阅读更多...
10 个杀手级的Python自动化脚本，解放你的双手

10 个杀手级的Python自动化脚本，解放你的双手

重复性任务总是耗时且无聊&#xff0c;想一想你想要一张一张地裁剪 100 张照片或 Fetch API、纠正拼写和语法等工作&#xff0c;所有这些任务都很耗时&#xff0c;为什么不自动化它们呢&#xff1f;在今天的文章中&#xff0c;我将与你分享 10 个 Python [自动化脚本]。 所以&a…
阅读更多...
最新文章

Copyright @ 2022~2023