Boost beast 使用例子

布满荆棘的人生 2022-01-22 06:15 680阅读 0赞

最近接触到了Boost beast，这里记录一下。

# Introduction #

Beast is a C++ header-only library serving as a foundation for writing interoperable networking libraries by providing **low-level HTTP/1, WebSocket, and networking protocol** vocabulary types and algorithms using the consistent asynchronous model of Boost.Asio.

This library is designed for:

*  **Symmetry:** Algorithms are role-agnostic; build clients, servers, or both.
 *  **Ease of Use:** Boost.Asio users will immediately understand Beast.
 *  **Flexibility:** Users make the important decisions such as buffer or thread management.
 *  **Performance:** Build applications handling thousands of connections or more.
 *  **Basis for Further Abstraction.** Components are well-suited for building upon.

# Requirements #

This library is for programmers familiar with Boost.Asio. Users who wish to use asynchronous interfaces should already know how to create concurrent network programs using callbacks or coroutines.

*  **C++11:** Robust support for most language features.
 *  **Boost:** Boost.Asio and some other parts of Boost.
 *  **OpenSSL:** Required for using TLS/Secure sockets and examples/tests

When using Microsoft Visual C++, Visual Studio 2017 or later is required.

One of these components is required in order to build the tests and examples:

*  Properly configured bjam/b2
 *  CMake 3.5.1 or later (Windows only)

# http client例子： #

#include <boost/beast/core.hpp>
    #include <boost/beast/http.hpp>
    #include <boost/beast/version.hpp>
    #include <boost/asio/connect.hpp>
    #include <boost/asio/ip/tcp.hpp>
    #include <cstdlib>
    #include <iostream>
    #include <string>
    
    namespace beast = boost::beast;     // from <boost/beast.hpp>
    namespace http = beast::http;       // from <boost/beast/http.hpp>
    namespace net = boost::asio;        // from <boost/asio.hpp>
    using tcp = net::ip::tcp;           // from <boost/asio/ip/tcp.hpp>
    
    // Performs an HTTP GET and prints the response
    int main(int argc, char** argv)
    {
        try
        {
            // Check command line arguments.
            if(argc != 4 && argc != 5)
            {
                std::cerr <<
                    "Usage: http-client-sync <host> <port> <target> [<HTTP version: 1.0 or 1.1(default)>]\n" <<
                    "Example:\n" <<
                    "    http-client-sync www.example.com 80 /\n" <<
                    "    http-client-sync www.example.com 80 / 1.0\n";
                return EXIT_FAILURE;
            }
            auto const host = argv[1];
            auto const port = argv[2];
            auto const target = argv[3];
            int version = argc == 5 && !std::strcmp("1.0", argv[4]) ? 10 : 11;
    
            // The io_context is required for all I/O
            net::io_context ioc;
    
            // These objects perform our I/O
            tcp::resolver resolver(ioc);
            beast::tcp_stream stream(ioc);
    
            // Look up the domain name
            auto const results = resolver.resolve(host, port);
    
            // Make the connection on the IP address we get from a lookup
            stream.connect(results);
    
            // Set up an HTTP GET request message
            http::request<http::string_body> req{http::verb::get, target, version};
            req.set(http::field::host, host);
            req.set(http::field::user_agent, BOOST_BEAST_VERSION_STRING);
    
            // Send the HTTP request to the remote host
            http::write(stream, req);
    
            // This buffer is used for reading and must be persisted
            beast::flat_buffer buffer;
    
            // Declare a container to hold the response
            http::response<http::dynamic_body> res;
    
            // Receive the HTTP response
            http::read(stream, buffer, res);
    
            // Write the message to standard out
            std::cout << res << std::endl;
    
            // Gracefully close the socket
            beast::error_code ec;
            stream.socket().shutdown(tcp::socket::shutdown_both, ec);
    
            // not_connected happens sometimes
            // so don't bother reporting it.
            //
            if(ec && ec != beast::errc::not_connected)
                throw beast::system_error{ec};
    
            // If we get here then the connection is closed gracefully
        }
        catch(std::exception const& e)
        {
            std::cerr << "Error: " << e.what() << std::endl;
            return EXIT_FAILURE;
        }
        return EXIT_SUCCESS;
    }

从例子看得出来，用起来还是方便。

[https://www.boost.org/doc/libs/1\_68\_0/libs/beast/doc/html/index.html][https_www.boost.org_doc_libs_1_68_0_libs_beast_doc_html_index.html]

[https://github.com/boostorg/beast][https_github.com_boostorg_beast]

[https_www.boost.org_doc_libs_1_68_0_libs_beast_doc_html_index.html]: https://www.boost.org/doc/libs/1_68_0/libs/beast/doc/html/index.html
[https_github.com_boostorg_beast]: https://github.com/boostorg/beast