使用poco库，实现tcp server例子

最新推荐文章于 2024-08-06 23:01:59 发布
最新推荐文章于 2024-08-06 23:01:59 发布
阅读量1.8k 收藏 8
点赞数 2
分类专栏： 乱点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuu19/article/details/102974232
版权

代码：

//
// UserTcpServer.cpp
//
// This sample demonstrates the SocketReactor and SocketAcceptor classes.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier:    BSL-1.0
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stddef.h>

#include <iostream>

#include "Poco/Net/SocketReactor.h"
#include "Poco/Net/SocketAcceptor.h"
#include "Poco/Net/SocketNotification.h"
#include "Poco/Net/StreamSocket.h"
#include "Poco/Net/ServerSocket.h"
#include "Poco/NObserver.h"
#include "Poco/Exception.h"
#include "Poco/Thread.h"
#include "Poco/FIFOBuffer.h"
#include "Poco/Delegate.h"
#include "Poco/Util/ServerApplication.h"
#include "Poco/Util/Option.h"
#include "Poco/Util/OptionSet.h"
#include "Poco/Util/HelpFormatter.h"

#include "Poco/LocalDateTime.h"
#include "Poco/DateTime.h"
#include "Poco/DateTimeFormat.h"
#include "Poco/DateTimeFormatter.h"
#include "Poco/DateTimeParser.h"


class UserServiceHandler
{
public:
    UserServiceHandler(Poco::Net::StreamSocket& socket, Poco::Net::SocketReactor& reactor):
        socket_(socket), reactor_(reactor)
    {
        Poco::Util::Application& app = Poco::Util::Application::instance();
        app.logger().information("Connection from " + socket.peerAddress().toString());

        recv_buf_ = (uint8_t *)malloc(BUFFER_SIZE);
        send_buf_ = (uint8_t *)malloc(BUFFER_SIZE);

        recv_len_ = 0;
        send_len_ = 0;

        reactor_.addEventHandler(socket_, Poco::NObserver<UserServiceHandler, Poco::Net::ReadableNotification>(*this, &UserServiceHandler::onSocketReadable));
        reactor_.addEventHandler(socket_, Poco::NObserver<UserServiceHandler, Poco::Net::ShutdownNotification>(*this, &UserServiceHandler::onSocketShutdown));

    }
    
    ~UserServiceHandler()
    {
        Poco::Util::Application& app = Poco::Util::Application::instance();
        try
        {
            app.logger().information("Disconnecting " + socket_.peerAddress().toString());
        }
        catch (...)
        {
        }
        reactor_.removeEventHandler(socket_, Poco::NObserver<UserServiceHandler, Poco::Net::ReadableNotification>(*this, &UserServiceHandler::onSocketReadable));
        reactor_.removeEventHandler(socket_, Poco::NObserver<UserServiceHandler, Poco::Net::WritableNotification>(*this, &UserServiceHandler::onSocketWritable));
        reactor_.removeEventHandler(socket_, Poco::NObserver<UserServiceHandler, Poco::Net::ShutdownNotification>(*this, &UserServiceHandler::onSocketShutdown));

        if (recv_buf_)
        {
            free(recv_buf_);
            recv_buf_ = NULL;
        }
        if (send_buf_)
        {
            free(send_buf_);
            send_buf_ = NULL;
        }
    }


    void onSocketReadable(const Poco::AutoPtr<Poco::Net::ReadableNotification>& pNf)
    {
        recv_len_ = socket_.receiveBytes(recv_buf_, BUFFER_SIZE);
        if (recv_len_ > 0)
        {
            // do some user work here
            // do some user work here
            // do some user work here
            // sleep(1); // 不要sleep，不要花时间处理数据，先把数据拷贝到链表里，放其他线程单独处理数据。
            
            // example
            // receive string
            // return server date
            printf("RECV - %s\n\r", recv_buf_);

            Poco::LocalDateTime now;
            std::string time_str =  Poco::DateTimeFormatter::format(now, Poco::DateTimeFormat::ISO8601_FRAC_FORMAT);
            
            //
            send_len_ = sprintf((char *)send_buf_, "%s, SVR - %s\n\r", recv_buf_, time_str.c_str());
            send_buf_[send_len_ ++] = '\0';

            // en send
            reactor_.addEventHandler(socket_, Poco::NObserver<UserServiceHandler, Poco::Net::WritableNotification>(*this, &UserServiceHandler::onSocketWritable));
        }
    }
    
    void onSocketWritable(const Poco::AutoPtr<Poco::Net::WritableNotification>& pNf)
    {
        if (send_len_ > 0)
        {
            socket_.sendBytes(send_buf_, send_len_);

        }
        //
        reactor_.removeEventHandler(socket_, Poco::NObserver<UserServiceHandler, Poco::Net::WritableNotification>(*this, &UserServiceHandler::onSocketWritable));
    }

    void onSocketShutdown(const Poco::AutoPtr<Poco::Net::ShutdownNotification>& pNf)
    {
        delete this;
    }
    
private:
    enum
    {
        BUFFER_SIZE = 1024
    };
    
    Poco::Net::StreamSocket   socket_;
    Poco::Net::SocketReactor& reactor_;

    uint8_t    *recv_buf_;        // 接收缓存区
    uint8_t    *send_buf_;        // 发送缓存区

    int    recv_len_;
    int send_len_;
};

class UserTcpServer: public Poco::Util::ServerApplication
{
public:
    UserTcpServer(Poco::Net::SocketAddress &socket_addr)
    {
        socket_addr_ = &socket_addr;
    }
    
    ~UserTcpServer()
    {
    }

protected:
    void initialize(Application& self)
    {
        Poco::Util::ServerApplication::initialize(self);
    }
        
    void uninitialize()
    {
        Poco::Util::ServerApplication::uninitialize();
    }

    int main(const std::vector<std::string>& args)
    {
        // set-up a server socket
        Poco::Net::ServerSocket svs(*socket_addr_);
        // set-up a SocketReactor...
        Poco::Net::SocketReactor reactor;
        // ... and a SocketAcceptor
        Poco::Net::SocketAcceptor<UserServiceHandler> acceptor(svs, reactor);
        // run the reactor in its own thread so that we can wait for 
        // a termination request
        Poco::Thread thread;
        thread.start(reactor);
        // wait for CTRL-C or kill
        Poco::Util::ServerApplication::waitForTerminationRequest();
        // Stop the SocketReactor
        reactor.stop();
        thread.join();

        return Poco::Util::Application::EXIT_OK;
    }
    
private:
    Poco::Net::SocketAddress *socket_addr_;
};

int main(int argc, char** argv)
{
    int server_port = 8089;
    std::string server_ip("localhost");
    Poco::Net::SocketAddress socket_addr(server_ip.c_str(), server_port);


    UserTcpServer app(socket_addr);
    return app.run(argc, argv);
}

makefile：

export TOP_DIR = $(PWD)

# 包含参数配置文件
#include ./Makefile.param

# 目标文件名称、编译后文件位置
PWD := $(shell pwd)
INSTALLDIR = .

TARGET = tcp_server_test
DBGTARGET = $(INSTALLDIR)/$(TARGET)d
RLSTARGET = $(INSTALLDIR)/$(TARGET)

# 配置编译器
CC = $(CROSS_COMPILE)gcc
CXX = $(CROSS_COMPILE)g++
LD_CXX = $(CROSS_COMPILE)g++
STRIP = $(CROSS_COMPILE)strip
RM = rm



# 配置依赖头文件、库文件路径
INCPATH += -I. -I$(REL_INC) -I/usr/local/include 
LIBPATH += -L. -L$(REL_LIB) -L/usr/local/lib 

# 配置编译参数
FLAGS_C += $(MACRO_DEFINE) $(INCPATH) $(CFLAGS) -Wall 
FLAGS_CXX += $(MACRO_DEFINE) $(INCPATH) $(CFLAGS) -Wall 
LDFLAGS += $(CFLAGS) $(LIBPATH) $(LIBS_CFLAGS) -pie -fPIE 
LIBS += -lPocoFoundation -lPocoUtil -lPocoNet -lpthread -lm -lc -lgcc -lgcc_s -ldl 

DBG_FLAGS = -g -D__DEBUG
RLS_FLAGS = -O2 -fno-strict-aliasing


# 源文件包含
SRCS_C  = $(wildcard *.c)
SRCS_CXX  = $(wildcard *.cpp)
SRCS_H  = $(wildcard *.h*)


# obj文件包含
OBJ_DBG_DIR = 0-obj/$(CROSS_COMPILE)dbg
OBJ_RLS_DIR = 0-obj/$(CROSS_COMPILE)rls

OBJS_C_DBG = $(addprefix $(OBJ_DBG_DIR)/,$(SRCS_C:%.c=%.o))
OBJS_CXX_DBG = $(addprefix $(OBJ_DBG_DIR)/,$(SRCS_CXX:%.cpp=%.o))
OBJS_C_RLS = $(addprefix $(OBJ_RLS_DIR)/,$(SRCS_C:%.c=%.o))
OBJS_CXX_RLS = $(addprefix $(OBJ_RLS_DIR)/,$(SRCS_CXX:%.cpp=%.o))

# 编译动作
COMPILE_C = $(CC) $(FLAGS_C) -c
COMPILE_CXX = $(CXX) $(FLAGS_CXX) -c
LINK_CXX = $(LD_CXX) $(LDFLAGS) 



.PHONY: clean debug release install

all:	release

install:
	install -d $(EXEC_DIR)
	install $(RLSTARGET) $(EXEC_DIR)
	install -m 444 $(TARGET).txt $(EXEC_DIR)

release: $(RLSTARGET)
	$(STRIP) $(RLSTARGET)

debug: $(DBGTARGET)
	@echo $(TARGET)_debug_done

$(RLSTARGET):	$(OBJS_C_RLS) $(OBJS_CXX_RLS)
	@mkdir -p $(INSTALLDIR)
	$(LINK_CXX) -o $@ $^ $(LIBS) 

$(DBGTARGET):	$(OBJS_C_DBG) $(OBJS_CXX_DBG)
	@mkdir -p $(INSTALLDIR)
	$(LINK_CXX) -o $@ $^ $(LIBS) 


$(OBJS_CXX_RLS):	$(OBJ_RLS_DIR)/%.o: %.cpp $(SRCS_H)
	@mkdir -p $(OBJ_RLS_DIR)
	$(COMPILE_CXX) $(RLS_FLAGS) -o $@ $<
	
$(OBJS_C_RLS):		$(OBJ_RLS_DIR)/%.o: %.c $(SRCS_H)
	@mkdir -p $(OBJ_RLS_DIR)
	$(COMPILE_C) $(RLS_FLAGS) -o $@ $<	

$(OBJS_CXX_DBG):	$(OBJ_DBG_DIR)/%.o: %.cpp $(SRCS_H)
	@mkdir -p $(OBJ_DBG_DIR)
	$(COMPILE_CXX) $(DBG_FLAGS) -o $@ $<

$(OBJS_C_DBG):		$(OBJ_DBG_DIR)/%.o: %.c $(SRCS_H)
	@mkdir -p $(OBJ_DBG_DIR)
	$(COMPILE_C) $(DBG_FLAGS) -o $@ $<

clean:
	-$(RM) -rf  *~ *.d .dep 0-obj
wuu19
关注
专栏目录
POCO::NET::TCPServer框架学习以及使用
SaySomething
08-27 3947
POCO::NET::TCPServer框架学习以及使用 一、预备知识： 1、POCO ​ POCO C++ Libraries是一套第三方库，去年的这个时候才进入公司实习，前辈让我接触这个库很难受官网全是英文:https://pocoproject.org/，GitHub：https://github.com/pocoproject/poco ，库方法查找：https://pocoprojec...
POCO-TCPServer使用简单Demo
雪球的博客
06-23 5244
1、梗概 Demo涉及三个类：CustomTCPServer、CustomTCPConnection、CustomTCPConnectionFactory 作用：CustomTCPServer继承自ServerApplication作为一个服务器的主体 CustomTCPConnection继承自TCPServerConnection相当于客户端的socket CustomTCPConnec
手把手教你使用Poco框架开发服务器应用
最新发布
jiexijihe945的博客
08-06 627
最近接触一个服务器项目，想来想去还是用C++来开发，C++应该来说没有像Spring那么顶顶大名的的框架，但是好的框架还是有的，要不然纯手写服务器要开发到什么时候。今天选的Poco就是相当不错的一个框架，不说多丰富吧，至少开发服务器用到的东西都有了。接下来从0开始教你使用Poco开发服务器应用1、Poco很强大我演示的只是冰山一角，后面我还会演示Poco的其它功能，今天的Demo只能说很简单。
Poco::TCPServer框架解析
zhangxinrun的专栏
09-29 4727
Poco::TCPServer框架解析<br />POCO C++ Libraries提供一套 C++ 的类库用以开发基于网络的可移植的应用程序，功能涉及线程、文件、流，网络协议包括：HTTP、FTP、SMTP 等，还提供 XML 的解析和 SQL 数据库的访问接口。不仅给我的工作带来极大的便利，而且设计巧妙，代码易读，注释丰富，也是非常好的学习材料，我个人非常喜欢。POCO的创始人在这个开源项目的基础上做了一些收费产品，也成立了自己的公司，"I am in the lucky position to wo
手把手教你如何使用Poco TCPServer框架
大鹏的blog
03-11 2990
1 TCPServer 框架概述 POCO 库提供TCPServer框架，用以搭建自定义的 TCP 服务器。TCPServer维护一个连接队列、一个连接线程池。连接线程用于处理连接，连接线程只要一空闲就不断地从连接队列中取连接并进行处理。一旦连接线程从连接队列中取到一个连接，就会创建一个TCPServerConnection连接对象，并且调用该对象的start()方法，直到start()方法返回...
POCO库中文编程参考指南（10）如何使用TCPServer框架？
麦克船长的技术笔记
04-21 517
POCO库中文编程参考指南（10）如何使用TCPServer框架？ Author: 柳大·Poechant（钟超） Email: zhongchao.ustc@gmail.com Blog:Blog.CSDN.net/Poechant Date: April 21th, 2012 1 TCPServer 框架概述 POCO 库提供TCPServer框架，用以搭建自定义的 TCP 服务器。TC...
Poco:TCPServer框架
08-27
poco的TCPServer框架，里面包含服务端和客户端代码，编译环境：VS2013 poco动态库：1.7.4完整版
poco tcp client 完整的例子
05-31
以下是一个Poco TCP客户端的完整示例代码。它连接到指定的IP地址和端口，并向服务器发送一条消息，然后等待并接收回复消息。需要注意的是，该示例使用了Poco的AutoPtr来管理对象的内存，确保资源在不再需要时被正确...
c++ tcpserver
06-09
这个例子使用了Boost.Asio库中的io_context、tcp::acceptor和tcp::socket等类。其中，io_context是Boost.Asio库中的核心类，负责管理所有的异步IO操作，tcp::acceptor用于监听客户端连接请求，tcp::socket用于处理...
websocket++库的使用：基于websocket模块收发RTSP 消息，作为一个RTSP测试工具
qq_36973999的博客
09-08 2095
一般来说，*.h里面只有声明，没有实现，而*.hpp里声明实现都可以有，后者可以减少.cpp的数量。.h放声明，.cpp放实现，.hpp就是声明与实现在一起，比如模块类。 hpp，其实质就是将.cpp的实现代码混入.h头文件当中，定义与实现都包含在同一文件，则该类的调用者只需要include该hpp文件即可，无需再 将cpp加入到project中进行编译。而实现代码将直接编译到调用者的obj...
Poco TcpServer 介绍
yuhaiyang457288的专栏
07-13 4484
TcpServer 使用简介 简介 1) Poco 的　TcpServer 是一个多线程的　Tcp 服务器。 服务器使用　ServerSocket(Poco 的一个用于初始化服务器的socket的类) 来接收链接。ServerSocket 在被传给　TcpServer 之前必须是处于监听状态。 2) TcpServer 为到来的链接维护一个队列。队列是多大呢?默认情况下队列的大小是和线程池
TcpServerDemo
08-16
博客地址：http://blog.csdn.net/zy19940906/article/details/77187400
轻量级C++网络库poco文档
10-10
C++网络库POCO的文档。POCO是轻量级的网络库，适用于网络开发，如HTTP等
使用poco库，实现tcp client例子
学习记录
11-09 2970
poco tcp client
基于 POCO 框架的 TCP 连接分流程序
热门推荐
A Fork of Stuffs
11-25 1万+
下面的程序实现了对 TCP 连接的分流，即将一个 TCP 连接的流量分布到多个 TCP 连接上进行传输。 本程序的主要作用是在特定网络环境下提升通过 TCP 连接的 OpenVPN 服务的速率，使之充分利用带宽。 程序的主要复杂之处在于单生产者—多消费者、多生产者—单消费者两种同步方式的实现。 在测试中：客户端网络环境为 CERNET ，服务器是位于达拉斯的 BurstNET VPS ，连接方式是 TCP/IPv6 。 直接连接， OpenVPN 速率为 341 KB/s 。使用 5 个连接进行分流， Op
poco库学习笔记(1) Poco::Net::TCPServerConnection
linyanwen99的专栏
09-26 2892
一.概述 TCPServerConnection继承Poco::Runnable类，是所有被TCPServer创建的TCP server connections的抽象基类，其派生类必须重写Poco::Runnable的run()方法，且TCPServerConnection的子类必须提供TCPServerConnection的工厂模式TCPServerConnectionFactory，TCPS
（C++）利用TCP协议服务器（epoll），实现reactor（二）--------------------附直接实现代码
weixin_43961989的博客
04-07 2679
#include <errno.h> #include <netinet/in.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/socket.h> #include <sys/types.h> #include <unistd.h> #include <sys/poll.h> #include &.
poco mysql 库_poco网络库
weixin_39901571的博客
01-28 271
poco vs BoostWooce Yang收集整理POCO的优点：1) 比boost更好的线程库，特别是一个活动的方法的实现，并且还可设置线程的优先级。2) 比 boost:asio更全面的网络库。但是boost:asio也是一个非常好的网络库。3) 包含了一些Boost所不包含的功能，像XML，数据库接口等。...文章double2li2013-11-28846浏览量c++网络库调研...
Poco::TCPServer框架解析【转】
06-09
好的，我会回答你关于Poco::TCPServer框架的问题。Poco::TCPServer是Poco C++库中的一个网络编程框架，用于实现TCP服务器。它提供了一个基于事件驱动的架构，可以方便地实现高性能、高可靠性的TCP服务器。 具体来说，Poco::TCPServer框架包含了以下组件： 1. TCPServer：这是整个框架的核心组件，负责接受客户端连接请求，并将请求转发给相应的处理器。TCPServer提供了一些基本的事件回调函数，可以让开发者自定义处理客户端请求的逻辑。 2. TCPServerParams：这是一个参数类，可以用来配置TCPServer的各种属性，比如最大连接数、超时时间等。 3. TCPServerConnectionFactory：这是一个工厂类，用于创建TCPServer处理请求的处理器。开发者需要继承这个类并实现其中的createConnection()函数，以便创建自己的处理器。 4. TCPServerConnection：这是一个抽象类，是所有处理器的基类。开发者需要继承这个类并实现其中的handleRequest()函数，以便处理客户端请求。 总的来说，Poco::TCPServer框架提供了一个非常灵活的架构，可以让开发者轻松地实现自己的TCP服务器。同时，它还提供了很多高级功能，比如SSL支持、多线程处理等，可以大大提高服务器的性能和安全性。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值