回显服务端/client

时间 2019-12-11

标签服务 client 繁體版

原文原文链接

回显服务端/client

在这一章。咱们将会实现一个小的client/服务端应用。这可能会是你写过的最简单的client/服务端应用。回显应用就是一个把client发过来的不论什么内容回显给其自己，而后关闭链接的的服务端。这个服务端可以处理不论什么数量的client。每个client链接以后发送一个消息，服务端接收到完毕消息后把它发送回去。在那以后。服务端关闭链接。css

所以。每个回显client链接到服务端，发送一个消息，而后读取服务端返回的结果。确保这是它发送给服务端的消息就结束和服务端的会话。缓存

咱们首先实现一个同步应用。而后实现一个异步应用，以便你可以很easy对照他们：ruby

为了节省空间，如下的代码有一些被裁剪掉了。你可以在附加在这本书的代码中看到所有的代码。markdown

TCP回显服务端/client

对于TCP而言。咱们需要一个额外的保证；每个消息以换行符结束(‘\n’)。编写一个同步回显服务端/client很简单。异步

咱们会展现编码内容，比方同步client，同步服务端。异步client和异步服务端。socket

TCP同步client

在大多数有价值的样例中。client一般比服务端编码要简单（因为服务端需要处理多个client请求）。async

如下的代码展现了不符合这条规则的一个例外：tcp

函数
size_t read_complete(char * buf, const error_code & err, size_t bytes)
{
    if ( err) return 0;
    bool found = std::find(buf, buf + bytes, '\n') < buf + bytes;
    // 咱们一个一个读取直到读到回车，不缓存
    return found ?0 : 1; } void sync_echo(std::string msg) { msg += "\n”; ip::tcp::socket sock(service); sock.connect(ep); sock.write_some(buffer(msg)); char buf[1024]; int bytes = read(sock, buffer(buf), boost::bind(read_complete,buf,_1,_2)); std::string copy(buf, bytes - 1); msg = msg.substr(0, msg.size() - 1); std::cout << "server echoed our " << msg << ": "<< (copy == msg ? "OK" : "FAIL") << std::endl; sock.close(); } int main(int argc, char* argv[]) { char* messages[] = { "John says hi", "so does James", "Lucy just got home", "Boost.Asio is Fun!", 0 }; boost::thread_group threads; for ( char ** message = messages; *message; ++message) { threads.create_thread( boost::bind(sync_echo, *message)); boost::this_thread::sleep( boost::posix_time::millisec(100)); } threads.join_all(); }

核心功能sync_echo。工具

它包括了链接到服务端。发送信息而后等待回显的所有逻辑。

你会发现，在读取时，我使用了自由函数read()，因为我想要读’\n’以前的所有内容。sock.read_some()方法知足不了这个要求，因为它仅仅会读可用的，而不是所有的消息。

read()方法的第三个參数是完毕处理句柄。当读取到完整消息时，它返回0。不然，它会返回我下一步（直到读取结束）能都到的最大的缓冲区大小。

在咱们的样例中。返回结果始终是1，因为我永远不想读的消息比咱们需要的不少其它。

在main()中，咱们建立了几个线程；每个线程负责把消息发送到client，而后等待操做结束。

假设你执行这个程序，你会看到如下的输出：

server echoed our John says hi: OK
server echoed our so does James: OK
server echoed our Lucy just got home: OK
server echoed our Boost.Asio is Fun!: OK

注意：因为咱们是同步的，因此不需要调用service.run()。

TCP同步服务端

回显同步服务端的编写很easy。參考例如如下的代码片断：

io_service service;
size_t read_complete(char * buff, const error_code & err, size_t bytes) {
    if ( err) return 0;
    bool found = std::find(buff, buff + bytes, '\n') < buff + bytes;
    // 咱们一个一个读取直到读到回车，不缓存
    return found ? 0 : 1;
}
void handle_connections() {
    ip::tcp::acceptor acceptor(service, ip::tcp::endpoint(ip::tcp::v4(),8001));
    char buff[1024];
    while ( true) {
        ip::tcp::socket sock(service);
        acceptor.accept(sock);
        int bytes = read(sock, buffer(buff), boost::bind(read_complete,buff,_1,_2));
        std::string msg(buff, bytes);
        sock.write_some(buffer(msg));
        sock.close();
    }
}
int main(int argc, char* argv[]) {
    handle_connections();
}

服务端的逻辑主要在handle_connections()。因为是单线程。咱们接受一个client请求。读取它发送给咱们的消息，而后回显。而后等待下一个链接。可以肯定。当两个client同一时候链接时，第二个client需要等待服务端处理完第一个client的请求。

仍是要注意因为咱们是同步的，因此不需要调用service.run()。

TCP异步client

当咱们開始异步时。编码会变得略微有点复杂。

咱们会构建在第二章保持活动中展现的connection类。

观察这个章节中接下来的代码，你会发现每个异步操做启动了新的异步操做。以保持service.run()一直工做。

首先，核心功能例如如下：

#define MEM_FN(x)       boost::bind(&self_type::x, shared_from_this())
#define MEM_FN1(x,y)    boost::bind(&self_type::x, shared_from_this(),y)
#define MEM_FN2(x,y,z)  boost::bind(&self_type::x, shared_from_this(),y,z)
class talk_to_svr : public boost::enable_shared_from_this<talk_to_svr> , boost::noncopyable {
    typedef talk_to_svr self_type;
    talk_to_svr(const std::string & message) : sock_(service), started_(true), message_(message) {}
    void start(ip::tcp::endpoint ep) {
        sock_.async_connect(ep, MEM_FN1(on_connect,_1));
    }
public:
    typedef boost::system::error_code error_code;
    typedef boost::shared_ptr<talk_to_svr> ptr;
    static ptr start(ip::tcp::endpoint ep, const std::string &message) {
        ptr new_(new talk_to_svr(message));
        new_->start(ep);
        return new_;
    }
    void stop() {
        if ( !started_) return;
        started_ = false;
        sock_.close();
    }
    bool started() { return started_; }
    ...
private:
    ip::tcp::socket sock_;
    enum { max_msg = 1024 };
    char read_buffer_[max_msg]; char write_buffer_[max_msg]; bool started_; std::string message_; };

咱们需要一直使用指向talk_to_svr的智能指针。这种话当在tack_to_svr的实例上有异步操做时，那个实例是一直活动的。

为了不错误。比方在栈上构建一个talk_to_svr对象的实例时，我把构造方法设置成了私有而且不一样意拷贝构造（继承自boost::noncopyable）。

咱们有了核心方法，比方start(),stop()和started()，它们所作的事情也正如它们名字表达的同样。假设需要创建链接，调用talk_to_svr::start(endpoint, message)就能够。咱们同一时候另外一个read缓冲区和一个write缓冲区。（read_buufer_和write_buffer_）。

MEM_FN 是一个方便使用的宏，它们经过*shared_ptr_from_this()方法强制使用一个指向* this 的智能指针。

如下的几行代码和以前的解释很不一样：

//等同于 "sock_.async_connect(ep, MEM_FN1(on_connect,_1));"
sock_.async_connect(ep,boost::bind(&talk_to_svr::on_connect,shared_ptr_from_this(),_1));
sock_.async_connect(ep, boost::bind(&talk_to_svr::on_connect,this,_1));

在上述样例中。咱们正确的建立了async_connect的完毕处理句柄；在调用完毕处理句柄以前它会保留一个指向talk_to_server实例的智能指针，从而保证当其发生时talk_to_server实例仍是保持活动的。

在接下来的样例中，咱们错误地建立了完毕处理句柄。当它被调用时。talk_to_server实例极可能已经被释放了。

从socket读取或写入时，你使用例如如下的代码片断：

void do_read() {
    async_read(sock_, buffer(read_buffer_), MEM_FN2(read_complete,_1,_2), MEM_FN2(on_read,_1,_2));
}
void do_write(const std::string & msg) {
    if ( !started() ) return;
    std::copy(msg.begin(), msg.end(), write_buffer_);
    sock_.async_write_some( buffer(write_buffer_, msg.size()), MEM_FN2(on_write,_1,_2));
}
size_t read_complete(const boost::system::error_code & err, size_t bytes) {
    // 和TCPclient中的类似
}

do_read()方法会保证当on_read()被调用的时候，咱们从服务端读取一行。do_write()方法会先把信息复制到缓冲区（考虑到当async_write发生时msg可能已经超出范围被释放），而后保证明际的写入操做发生时on_write()被调用。

而后是最重要的方法，这种方法包括了类的主要逻辑：

void on_connect(const error_code & err) {
    if ( !err)      do_write(message_ + "\n");
    else            stop();
}
void on_read(const error_code & err, size_t bytes) {
    if ( !err) {
        std::string copy(read_buffer_, bytes - 1);
        std::cout << "server echoed our " << message_ << ": " << (copy == message_ ? "OK" : "FAIL") << std::endl; 
    }
    stop(); 
}
void on_write(const error_code & err, size_t bytes) {
    do_read();
}

当链接成功以后。咱们发送消息到服务端,do_write()。当write操做结束时，on_write()被调用，它初始化了一个do_read()方法。当do_read()完毕时。on_read()被调用；这里，咱们简单的检查一下返回的信息是不是服务端的回显。而后退出服务。

咱们会发送三个消息到服务端让它变得更有趣一点：

int main(int argc, char* argv[]) {
    ip::tcp::endpoint ep( ip::address::from_string("127.0.0.1"), 8001);
    char* messages[] = { "John says hi", "so does James", "Lucy got home", 0 };
    for ( char ** message = messages; *message; ++message) {
        talk_to_svr::start( ep, *message);
        boost::this_thread::sleep( boost::posix_time::millisec(100));
    }
    service.run();
}

上述的代码会生成例如如下的输出：

server echoed our John says hi: OK
server echoed our so does James: OK
server echoed our Lucy just got home: OK

TCP异步服务端

核心功能和同步服务端的功能类似，例如如下：

class talk_to_client : public boost::enable_shared_from_this<talk_to_
   client>, boost::noncopyable {
    typedef talk_to_client self_type;
    talk_to_client() : sock_(service), started_(false) {}
public:
    typedef boost::system::error_code error_code;
    typedef boost::shared_ptr<talk_to_client> ptr;
    void start() {
        started_ = true;
        do_read(); 
    }

    static ptr new_() {
        ptr new_(new talk_to_client);
        return new_;
    }
    void stop() {
        if ( !started_) return;
        started_ = false;
        sock_.close();
    }
    ip::tcp::socket & sock() { return sock_;}
    ...
private:
    ip::tcp::socket sock_;
    enum { max_msg = 1024 };
    char read_buffer_[max_msg]; char write_buffer_[max_msg]; bool started_; };

因为咱们是很简单的回显服务，这里不需要is_started()方法。对每个client。仅仅读取它的消息，回显，而后关闭它。

do_read()，do_write()和read_complete()方法和TCP同步服务端的全然一致。

基本的逻辑相同是在on_read()和on_write()方法中：

void on_read(const error_code & err, size_t bytes) {
    if ( !err) {
        std::string msg(read_buffer_, bytes);
        do_write(msg + "\n");
    }
    stop(); 
}
void on_write(const error_code & err, size_t bytes) {
    do_read();
}

对client的处理例如如下：

ip::tcp::acceptor acceptor(service, ip::tcp::endpoint(ip::tcp::v4(),8001));
void handle_accept(talk_to_client::ptr client, const error_code & err)
{
    client->start();
    talk_to_client::ptr new_client = talk_to_client::new_();
    acceptor.async_accept(new_client->sock(), boost::bind(handle_accept,new_client,_1));
}
int main(int argc, char* argv[]) { talk_to_client::ptr client = talk_to_client::new_(); acceptor.async_accept(client->sock(), boost::bind(handle_accept,client,_1)); service.run(); }

每一次client链接到服务时，handle_accept被调用，它会异步地从client读取。而后相同异步地等待一个新的client。

代码

你会在这本书对应的代码中获得所有4个应用（TCP回显同步client，TCP回显同步服务端，TCP回显异步client，TCP回显异步服务端）。

当測试时。你可以使用随意client/服务端组合（比方，一个异步client和一个同步服务端）。

UDP回显服务端/client

因为UDP不能保证所有信息都抵达接收者。咱们不能保证“信息以回车结尾”。

没收到消息，咱们仅仅是回显，但是没有socket去关闭（在服务端）。因为咱们是UDP。

UDP同步回显client

UDP回显client比TCP回显client要简单：


ip::udp::endpoint ep( ip::address::from_string("127.0.0.1"), 8001);
void sync_echo(std::string msg) {
    ip::udp::socket sock(service, ip::udp::endpoint(ip::udp::v4(), 0));
    sock.send_to(buffer(msg), ep);
    char buff[1024];
    ip::udp::endpoint sender_ep;
    int bytes = sock.receive_from(buffer(buff), sender_ep);
    std::string copy(buff, bytes);
    std::cout << "server echoed our " << msg << ": " << (copy == msg ?
"OK" : "FAIL") << std::endl; sock.close(); } int main(int argc, char* argv[]) { char* messages[] = { "John says hi", "so does James", "Lucy got home", 0 }; boost::thread_group threads; for ( char ** message = messages; *message; ++message) { threads.create_thread( boost::bind(sync_echo, *message)); boost::this_thread::sleep( boost::posix_time::millisec(100)); } threads.join_all(); }

所有的逻辑都在synch_echo()中。链接到服务端。发送消息，接收服务端的回显，而后关闭链接。

UDP同步回显服务端

UDP回显服务端会是你写过的最简单的服务端：

io_service service;
void handle_connections() {
    char buff[1024];
    ip::udp::socket sock(service, ip::udp::endpoint(ip::udp::v4(), 8001));
    while ( true) {
        ip::udp::endpoint sender_ep;
        int bytes = sock.receive_from(buffer(buff), sender_ep);
        std::string msg(buff, bytes);
        sock.send_to(buffer(msg), sender_ep);
    } 
}
int main(int argc, char* argv[]) {
    handle_connections();
}

它很简单。而且能很好的自释。

我把异步UDPclient和服务端留给读者看成一个练习。

总结

咱们已经写了完整的应用。终于让Boost.Asio得以工做。

回显应用是開始学习一个库时很好的工具。你可以经常学习和执行这个章节所展现的代码，这样你就可以很easy地记住这个库的基础。

在下一章。咱们会创建更复杂的client/服务端应用，咱们要确保避免低级错误，比方内存泄漏，死锁等等。