boost寫的異步客戶端樣例代碼修改為支持斷開重連的代碼

考慮到boost的工業級強度，因此就直接用了，代碼的官方示例地址：https://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/examples/cpp11_examples.html

用起來還是挺方便的，代碼量少，穩定性高，速度快。

后來實際過程中希望能支持斷開生連的功能，比如客戶端先啟動，服務器后啟動，希望服務器起來后，客戶端立即連上去。網絡波動的情況下，客戶端有可能斷開，斷開后立即再連接上去。

原有的示例代碼不能實現以上兩個功能，經過研究發現異步連接時，如果成功才進行do_read_header(),那不成功時再進行do_connect即可

然后在類中設置一個連接標識is_connected_, 當發生斷開時，將連接標識置為false,外部不斷檢測此標識，發現標識為false，則重新啟動整個客戶端即可

修改的完整代碼， 需要服務器測試請到剛開始給的網址去下載：

//
// chat_client.cpp
// ~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2013 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// https://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/examples/cpp11_examples.html

#include <cstdlib>
#include <deque>
#include <iostream>
#include <thread>
#include <boost/asio.hpp>
#include "chat_message.hpp"

using boost::asio::ip::tcp;

typedef std::deque<chat_message> chat_message_queue;

class chat_client
{
public:
    chat_client(boost::asio::io_service& io_service,
        tcp::resolver::iterator endpoint_iterator)
        : io_service_(io_service),
        socket_(io_service)
    {
        is_connected_ = false;
        do_connect(endpoint_iterator);
    }

    void write(const chat_message& msg)
    {
        io_service_.post(
            [this, msg]()
        {
            bool write_in_progress = !write_msgs_.empty();
            write_msgs_.push_back(msg);
            if (!write_in_progress)
            {
                do_write();
            }
        });
    }

    void close()
    {
        io_service_.post([this]() { close_socket(); });
    }

    bool get_connected() const {
        return is_connected_;
    }

private:
    void do_connect(tcp::resolver::iterator endpoint_iterator)
    {
        boost::asio::async_connect(socket_, endpoint_iterator,
            [this, endpoint_iterator](boost::system::error_code ec, tcp::resolver::iterator)
        {
            if (!ec)
            {
                is_connected_ = true;
                do_read_header();
            }
            else {
                do_connect(endpoint_iterator);
            }
        });
    }

    void do_read_header()
    {
        boost::asio::async_read(socket_,
            boost::asio::buffer(read_msg_.data(), chat_message::header_length),
            [this](boost::system::error_code ec, std::size_t /*length*/)
        {
            if (!ec && read_msg_.decode_header())
            {
                do_read_body();
            }
            else
            {
                close_socket();
            }
        });
    }

    void close_socket()
    {
        socket_.close();
        is_connected_ = false;
    }

    void do_read_body()
    {
        boost::asio::async_read(socket_,
            boost::asio::buffer(read_msg_.body(), read_msg_.body_length()),
            [this](boost::system::error_code ec, std::size_t /*length*/)
        {
            if (!ec)
            {
                std::cout.write(read_msg_.body(), read_msg_.body_length());
                std::cout << "\n";
                do_read_header();
            }
            else
            {
                close_socket();
            }
        });
    }

    void do_write()
    {
        boost::asio::async_write(socket_,
            boost::asio::buffer(write_msgs_.front().data(),
                write_msgs_.front().length()),
            [this](boost::system::error_code ec, std::size_t /*length*/)
        {
            if (!ec)
            {
                write_msgs_.pop_front();
                if (!write_msgs_.empty())
                {
                    do_write();
                }
            }
            else
            {
                close_socket();
            }
        });
    }

private:
    bool is_connected_;
    boost::asio::io_service& io_service_;
    tcp::socket socket_;
    chat_message read_msg_;
    chat_message_queue write_msgs_;
};

int main(int argc, char* argv[])
{

    if (argc != 3)
    {
        std::cerr << "Usage: chat_client <host> <port>\n";
        return 1;
    }
    while (true)
    {
        try
        {
            boost::asio::io_service io_service;

            tcp::resolver resolver(io_service);
            auto endpoint_iterator = resolver.resolve({ argv[1], argv[2] });
            chat_client c(io_service, endpoint_iterator);

            std::thread t([&io_service]() { io_service.run(); });

            //         char line[chat_message::max_body_length + 1];
            //         while (std::cin.getline(line, chat_message::max_body_length + 1))
            //         {
            //             chat_message msg;
            //             msg.body_length(std::strlen(line));
            //             std::memcpy(msg.body(), line, msg.body_length());
            //             msg.encode_header();
            //             c.write(msg);
            //         }
            while (c.get_connected())
            {
                std::this_thread::sleep_for(std::chrono::milliseconds(1));
            }

            c.close();
            t.join();
        }
        catch (std::exception& e)
        {
            std::cerr << "Exception: " << e.what() << "\n";
        }
    }


    return 0;
}