原文链接：
区块链的应用是基于http服务，这种能力在EOS中是依靠http_plugin插件赋予的。
关键字：通讯模式，add_api，http server，https server，unix server，io_service，socket，connection
通讯模式
EOS中，一个插件的使用要先获取其实例，例如http_plugin获取实例的语句是：
auto& _http_plugin = app().get_plugin ();
其他插件的获取方式与此相同。目前为止，包括前文介绍到的method、channel、信号槽、信号量，跨模块的交互方式可以总结为五种：
- method，插件之间的调用，一个插件A将其函数按key注册到method池中，其他任意数量的插件B、C、D均可通过key去method池中找到该函数并调用。这种通讯模式是一个由调用者主动发起的过程。
- channel，插件之间的调用，一个插件A按key找到频道并向频道publish一个动作，其他任意数量的插件B、C、D，甚至在不同节点上的插件B、C、D，只要是按key订阅了该channel并绑定了他们各自本地的一个notify function，就会被触发执行。这种通讯模式是基于发布订阅模式，或者说是更高级的观察者模式，是由发布者的行为交由channel来触发所有订阅者绑定的本地通知函数的过程。
- 信号槽，插件与controller的交互过程。controller下启基于chainbase的状态数据库，上承信号的管理，通过信号来与外部进行交互，controller会根据链的行为emit一个对应的信号出来，其他插件如果有处理该信号的需求会连接connect该信号并绑定函数实现。有时候一个信号会被多个插件所连接，例如accepted_block_header信号，是承认区块头的信号，会被net_plugin捕捉并处理，同时该信号也会被chain_plugin所捕捉，触发广播。
- 信号量，一般是应用程序与操作系统发生的交互，在EOS中，应用程序的实例是application，它与操作系统发生的交互都是通过信号量来完成，首先声明一个信号，然后通过async_wait触发信号完成与操作系统的交互。
- 实例调用，对比以上四种松散的方式，这种模式是强关联，正如我们刚刚学习编程时喜欢使用new/create而不考虑对象的垃圾处理以及实例管理，后来会采用解耦的松散的统一实例管理框架，或者采用单例而不是每次都要new/create。但这种方式并不是完全不被推荐的，当实例的某个成员直接被需要时，可以直接通过该方式获取到，而不是通过以上四种方式来使用。
目前总结出来的五种跨模块交互方式，前四种更注重通讯，最后一种更注重其他模块的内容。更注重通讯的前四种是基于同一底层通讯机制(socket)，但适用于不同场景的设计实现。
add_api函数
从chain_api_plugin过来，http_plugin的使用方式是：
_http_plugin.add_api({ CHAIN_RO_CALL(get_info, 200l), ... }); 那么，就从add_api入手研究http_plugin。add_api函数声明在http_plugin头文件中，说明该函数的内容很少或很具备通用性。
void add_api(const api_description& api) { for (const auto& call : api) add_handler(call.first, call.second);} 从前面的调用代码可以看出，add_api函数的参数是一个对象集合，它们总体是一个api_description类型的常量引用。
using api_description = std::map ;
api_description根据源码可知是一个map，key为string类型的url路径地址，值为url_handler是具体实现API功能的处理函数。在add_api的调用部分，宏CHAIN_RO_CALL调用了另一个宏CALL，CALL组装了map的这两个数：
#define CALL(api_name, api_handle, api_namespace, call_name) \{std::string("/v1/" #api_name "/" #call_name), \ [api_handle](string, string body, url_response_callback cb) mutable { \ try { \ if (body.empty()) body = "{}"; \ auto result = api_handle.call_name(fc::json::from_string(body).as ()); \ cb(200, fc::json::to_string(result)); \ } catch (...) { \ http_plugin::handle_exception(#api_name, #call_name, body, cb); \ } \ }} CALL宏体包含两个数据，以逗号隔开，前面部分为url路径地址，后面部分为api_handler，此处实际上是一个匿名内部函数。回到add_api函数的声明，遍历整个api，逐一执行add_handler为url和api处理函数添加相互绑定的关系。
add_handler函数
直接进入函数实现的代码：
void http_plugin::add_handler(const string& url, const url_handler& handler) { ilog( "add api url: ${c}", ("c",url) ); // 输出日志 app().get_io_service().post([=](){ my->url_handlers.insert(std::make_pair(url,handler)); });} app()前文讲到了，是用来获取application实例的，其包含一个public权限的成员函数get_io_service：
boost::asio::io_service& get_io_service() { return *io_serv; } 返回的是基于boost::asio::io_service库的共享指针类型，application的私有成员io_serv的指针。
io_service是asio框架中的调度器，用来调度异步事件，application实例要保存一个io_service对象，用于保存当前实例的所有待调度的异步事件。
io_service的两个重要方法：
- post，用于发布一个异步事件，依赖asio库进行自动调度，不需要显式调用函数。
- run，显式调用，同步执行回调函数。
当appbase.exec()执行时，io_service会同步启动，如果一个插件需要IO或其他异步操作，可以通过以下方式进行分发：
app().get_io_service().post( lambda )
那么，这种分发方式，除了在http_plugin的add_handler函数中使用到，EOSIO/eos中在bnet_plugin插件中有大量使用到，缘于bnet_plugin对异步事件发布的需求。回到add_handler函数，post后面跟随的是lambda表达式，[=]代表捕获所有以值访问的局部名字。lambda体是将url和handler作为二元组插入到http_plugin_impl对象的唯一指针my的共有成员url_handlers集合中，数据类型与上面的api_description一致。
url_handlers集合
url_handlers集合的数据源是其他插件通过add_api函数传入组装好的url和handler的对象。该集合作为api的异步处理器集合，在http_plugin中消费该集合数据的是handle_http_request函数。该函数处理外部请求，根据请求url在url_handlers集合中查找数据，找到handler以后，传入外部参数数据并执行handler对应的处理函数。
handle_http_request函数
/** * 处理一个http请求(http_plugin) * @tparam T socket type * @param con 连接对象 */template void handle_http_request(typename websocketpp::server ::connection_ptr con) { try { auto& req = con->get_request(); // 获得请求对象req。 if(!allow_host (req, con))// 检查host地址是否有效 return; // 根据config.ini中http_plugin相关的连接配置项进行设置。 if( !access_control_allow_origin.empty()) { con->append_header( "Access-Control-Allow-Origin", access_control_allow_origin ); } if( !access_control_allow_headers.empty()) { con->append_header( "Access-Control-Allow-Headers", access_control_allow_headers ); } if( !access_control_max_age.empty()) { con->append_header( "Access-Control-Max-Age", access_control_max_age ); } if( access_control_allow_credentials ) { con->append_header( "Access-Control-Allow-Credentials", "true" ); } if(req.get_method() == "OPTIONS") { // HTTP method包含：`GET` `HEAD` `POST` `OPTIONS` `PUT` `DELETE` `TRACE` `CONNECT` con->set_status(websocketpp::http::status_code::ok); return;// OPTIONS不能缓存，未能获取到请求的资源。 } con->append_header( "Content-type", "application/json" );// 增加请求头。 auto body = con->get_request_body(); // 获得请求体(请求参数) auto resource = con->get_uri()->get_resource(); // 获得请求的路径(url) auto handler_itr = url_handlers.find( resource ); // 在url_handlers集合中找到对应的handler if( handler_itr != url_handlers.end()) { con->defer_http_response();// 延时响应 // 调用handler，传入参数、url，回调函数是lambda表达式，用于将接收到的结果code和响应body赋值给连接。 handler_itr->second( resource, body, [con]( auto code, auto&& body ) { con->set_body( std::move( body )); // 接收到的响应body赋值给连接。 con->set_status( websocketpp::http::status_code::value( code )); // 接收到的code赋值给连接。 con->send_http_response();// 发送http响应 } ); } else { dlog( "404 - not found: ${ep}", ("ep", resource)); // 未在url_handlers集合中找到 // 针对失败的情况，设置http的响应对象数据。 error_results results{websocketpp::http::status_code::not_found, "Not Found", error_results::error_info(fc::exception( FC_LOG_MESSAGE( error, "Unknown Endpoint" )), verbose_http_errors )}; con->set_body( fc::json::to_string( results )); con->set_status( websocketpp::http::status_code::not_found ); } } catch( ... ) { handle_exception ( con ); }}
下面来看该函数handle_http_request的使用位置。有两处，均在http_plugin内部：
- create_server_for_endpoint函数，为websocket对象ws设置http处理函数，是一个lambda表达式，lambda体为handle_http_request函数的调用，传入连接对象con，由hdl转换而来。另外，create_server_for_endpoint函数在http_plugin::plugin_startup中也有两处调用。
- http_plugin::plugin_startup，插件的启动阶段，下面将分析该插件的生命周期。
http_plugin的生命周期
正如研究其他的插件一样，学习路线离不开插件的生命周期。
插件一般都是在程序入口(例如nodeos，keosd)进行生命周期的控制的，一般不做区分，由于插件有共同基类，程序入口做统一控制。
下面依次介绍http_plugin的生命周期。
http_plugin::set_defaults
仅属于http_plugin插件的生命周期。设置默认值，默认值仅包含三项：
struct http_plugin_defaults { // 如果不为空，该项的值将在被监听的地址生效。作为不同配置项的前缀。 string address_config_prefix; // 如果为空，unix socket支持将被完全禁用。如果不为空，值为data目录的相对路径，作为默认路径启用unix socket支持。 string default_unix_socket_path; // 如果不是0，HTTP将被启用于默认给出的端口号。如果是0，HTTP将不被默认启用。 uint16_t default_http_port{0};}; nodeos的set_defaults语句为：
http_plugin::set_defaults({ .address_config_prefix = "", .default_unix_socket_path = "", .default_http_port = 8888}); keosd的set_defaults语句为：
http_plugin::set_defaults({ .address_config_prefix = "", // key_store_executable_name = "keosd"; .default_unix_socket_path = keosd::config::key_store_executable_name + ".sock", // 默认unix socket路径为keosd.sock .default_http_port = 0}); http_plugin::set_program_options
设置http_plugin插件的参数，构建属于http_plugin的配置选项，将与其他插件的配置共同组成配置文件config.ini，在此基础上添加--help等参数构建程序(例如nodeos)的CLI命令行参数。同时设置参数被设置以后的处理方案。
/** * 生命周期 http_plugin::set_program_options * @param cfg 命令行和配置文件的手动配置项的并集，交集以命令行配置为准的配置对象。 */void http_plugin::set_program_options(options_description&, options_description& cfg) { // 处理默认set_defaults配置项。 my->mangle_option_names(); if(current_http_plugin_defaults.default_unix_socket_path.length())// 默认unix socket 路径 cfg.add_options() (my->unix_socket_path_option_name.c_str(), bpo::value ()->default_value(current_http_plugin_defaults.default_unix_socket_path), "The filename (relative to data-dir) to create a unix socket for HTTP RPC; set blank to disable."); if(current_http_plugin_defaults.default_http_port)// 设置默认http端口 cfg.add_options() (my->http_server_address_option_name.c_str(), bpo::value ()->default_value("127.0.0.1:" + std::to_string(current_http_plugin_defaults.default_http_port)), "The local IP and port to listen for incoming http connections; set blank to disable."); else cfg.add_options() (my->http_server_address_option_name.c_str(), bpo::value (), "The local IP and port to listen for incoming http connections; leave blank to disable.");// 端口配置为空的话禁用http // 根据手动配置项来设置 cfg.add_options() (my->https_server_address_option_name.c_str(), bpo::value (), "The local IP and port to listen for incoming https connections; leave blank to disable.")// 端口配置为空的话禁用http ("https-certificate-chain-file", bpo::value (),// https的配置，证书链文件 "Filename with the certificate chain to present on https connections. PEM format. Required for https.") ("https-private-key-file", bpo::value (),// https的配置，私钥文件 "Filename with https private key in PEM format. Required for https") ("access-control-allow-origin", bpo::value ()->notifier([this](const string& v) {// 跨域问题，控制访问源 my->access_control_allow_origin = v; ilog("configured http with Access-Control-Allow-Origin: ${o}", ("o", my->access_control_allow_origin)); }), "Specify the Access-Control-Allow-Origin to be returned on each request.") ("access-control-allow-headers", bpo::value ()->notifier([this](const string& v) {// 控制允许访问的http头 my->access_control_allow_headers = v; ilog("configured http with Access-Control-Allow-Headers : ${o}", ("o", my->access_control_allow_headers)); }), "Specify the Access-Control-Allow-Headers to be returned on each request.") ("access-control-max-age", bpo::value ()->notifier([this](const string& v) {// 控制访问的最大缓存age my->access_control_max_age = v; ilog("configured http with Access-Control-Max-Age : ${o}", ("o", my->access_control_max_age)); }), "Specify the Access-Control-Max-Age to be returned on each request.") ("access-control-allow-credentials", bpo::bool_switch()->notifier([this](bool v) { my->access_control_allow_credentials = v; if (v) ilog("configured http with Access-Control-Allow-Credentials: true"); })->default_value(false), // 控制访问允许的证书 "Specify if Access-Control-Allow-Credentials: true should be returned on each request.") // 最大请求体的大小，默认为1MB。 ("max-body-size", bpo::value ()->default_value(1024*1024), "The maximum body size in bytes allowed for incoming RPC requests") // 打印http详细的错误信息到日志，默认为false，不打印。 ("verbose-http-errors", bpo::bool_switch()->default_value(false), "Append the error log to HTTP responses") // 校验host，如果设置为false，任意host均为有效。默认为true，要校验host。 ("http-validate-host", boost::program_options::value ()->default_value(true), "If set to false, then any incoming \"Host\" header is considered valid") // 别名。另外可接受的host头 ("http-alias", bpo::value >()->composing(), "Additionaly acceptable values for the \"Host\" header of incoming HTTP requests, can be specified multiple times. Includes http/s_server_address by default.");} http_plugin::plugin_initialize
插件初始化的操作。读取配置并做出处理。
实际上，在set_option_program阶段也做了对配置值的读取及转储处理。原因是一些默认参数，即用户不经常配置的选项，就不需要读取用户配置的选项，可以在set_option_program阶段做出处理，而那些需要用户来配置的选项则需要在初始化阶段读入并处理。
初始化阶段读入的配置项包含：
http_plugin::plugin_startup
在插件中，启动阶段都是非常重要的生命周期。它往往代码很简单甚至简略，但功能性很强。下面来看http_plugin的启动阶段的内容，g共分为三部分：
- listen_endpoint，本地节点的http监听路径，例如127.0.0.1:8888。
- unix_endpoint，如果为空，unix socket支持将被完全禁用。如果不为空，值为data目录的相对路径，作为默认路径启用unix socket支持。
- https_listen_endpoint，https版本的本地节点http监听路径，一般不设置，对应的是配置中的https_server_address选项。
对于以上三种情况，启动阶段分别做了三种对应的处理，首先来看最标准最常见的情况，就是基于http的本地监听路径listen_endpoint：
if(my->listen_endpoint) { try { my->create_server_for_endpoint(*my->listen_endpoint, my->server); // 创建http服务(上面介绍到的函数)。内部调用了http请求处理函数。 ilog("start listening for http requests"); my->server.listen(*my->listen_endpoint);// 手动监听设置端点。使用设置绑定内部接收器。 my->server.start_accept();// 启动服务器的异步连接，开始监听：无限循环接收器。启动服务器连接无限循环接收器。监听后必须调用。在底层io_service开始运行之前，此方法不会有任何效果。它可以在io_service已经运行之后被调用。有关如何停止此验收循环的说明，请参阅传输策略的文档。 } catch ( const fc::exception& e ){ elog( "http service failed to start: ${e}", ("e",e.to_detail_string())); throw; } catch ( const std::exception& e ){ elog( "http service failed to start: ${e}", ("e",e.what())); throw; } catch (...) { elog("error thrown from http io service"); throw; }} 主要是启动http服务的流程，包括客户端和服务端，endpoint和server_endpoint两个角色的启动。下面来看基于unix socket的情况unix_endpoint：
if(my->unix_endpoint) { try { my->unix_server.clear_access_channels(websocketpp::log::alevel::all);// 清除所有登陆的频道 my->unix_server.init_asio(&app().get_io_service());// 初始化io_service对象，io_service就是上面分析过的application的io_service对象，传入asio初始化函数初始化asio传输策略。在使用asio transport之前必须要init asio。 my->unix_server.set_max_http_body_size(my->max_body_size); // 设置HTTP消息体大小的最大值，该值决定了如果超过这个值的消息体将导致连接断开。 my->unix_server.listen(*my->unix_endpoint); // 手动设置本地socket监听路径。 my->unix_server.set_http_handler([&](connection_hdl hdl) {// 设置http请求处理函数(注意此处不再通过create_server_for_endpoint函数来调用，因为不再需要websocket的包装)。 my->handle_http_request ( my->unix_server.get_con_from_hdl(hdl)); }); my->unix_server.start_accept();// 同上，启动server端的无限循环接收器。 } catch ( const fc::exception& e ){ elog( "unix socket service failed to start: ${e}", ("e",e.to_detail_string())); throw; } catch ( const std::exception& e ){ elog( "unix socket service failed to start: ${e}", ("e",e.what())); throw; } catch (...) { elog("error thrown from unix socket io service"); throw; }} 下面来看基于https的本地监听路径https_listen_endpointd的处理：
if(my->https_listen_endpoint) { try { my->create_server_for_endpoint(*my->https_listen_endpoint, my->https_server); // 同上http的原理，只是参数换为https的值。 // 设置TLS初始化处理器。当请求一个TLS上下文使用时，将调用该TLS初始化处理器。该处理器必须返回一个有效TLS上下文，以支持当前端点能够初始化TLS连接。 // connection_hdl，一个连接的唯一标识。它是实现了一个弱引用智能指针weak_ptr指向连接对象。线程安全。通过函数endpoint::get_con_from_hdl()可以转化为一个完整的共享指针。 my->https_server.set_tls_init_handler([this](websocketpp::connection_hdl hdl) -> ssl_context_ptr{ return my->on_tls_init(hdl); }); ilog("start listening for https requests"); my->https_server.listen(*my->https_listen_endpoint);// 同上http的原理，监听地址。 my->https_server.start_accept();// 同上http的原理，启动服务。 } catch ( const fc::exception& e ){ elog( "https service failed to start: ${e}", ("e",e.to_detail_string())); throw; } catch ( const std::exception& e ){ elog( "https service failed to start: ${e}", ("e",e.what())); throw; } catch (...) { elog("error thrown from https io service"); throw; }} unix server与server的底层实现是一致的，只是外部的包裹处理不同，https_server的类型再加上这个ssl上下文的类型指针ssl_context_ptr。他们的声明分别是：
using websocket_server_type = websocketpp::server >; // http serverusing websocket_local_server_type = websocketpp::server ; // unix serverusing websocket_server_tls_type = websocketpp::server >; // https serverusing ssl_context_ptr = websocketpp::lib::shared_ptr ; // https ssl_context_ptr
HTTPS = HTTP over TLS。TLS的前身是SSL。
从上面的声明可以看出，http和https最大的不同是，前者是basic_socket，后者是tls_socket，socket类型不同，http是基础socket，https是包裹了tls的socket。
http_plugin::plugin_shutdown
关闭是插件的最后一个生命周期，代码很少，主要执行的是资源释放工作。
void http_plugin::plugin_shutdown() { if(my->server.is_listening()) my->server.stop_listening(); if(my->https_server.is_listening()) my->https_server.stop_listening();} 此处没有unix_server的处理。http和https都是socket，需要手动停止监听，启动无限循环接收器。unix server是通过io_service来异步处理，底层实现逻辑相同，也启动了无限循环接收器。
总结
本文首先以外部使用http_plugin的方式：add_api函数为研究入口，逐层深入分析。接着从整体上研究了http_plugin的生命周期，进一步加深了对http_plugin的http/https/unix三种server的认识。