#IQRV #comment [Restful] 将引用变为指针

Other/libRestfulFunc/CMakeLists.txt

@@ -8,6 +8,7 @@ set(${MODULE_PREFIX}_SRCS
     PingImpl.cpp
     JsonConvertHelper.hpp
     SocketConnectImpl.cpp
+    RestfulUtilty.hpp
 )
 
 add_library(${MODULE_NAME} SHARED ${${MODULE_PREFIX}_SRCS})

Other/libRestfulFunc/RestfulFunc.h

@@ -20,6 +20,7 @@
 #endif
 #endif
 
+#include <iostream>
 #include <string>
 #include <map>
 #include <vector>
@@ -82,6 +83,21 @@ enum HttpStatusCode : int
     ServiceUnavailable = 503
 };
 
+
+struct HttpClientResponseResult
+{
+    int statusCode;
+    std::string content;
+
+    HttpClientResponseResult() :statusCode(HttpStatusCode::NotFound), content("") {}
+
+    /**  子类继承实现 */
+    virtual bool ConsiderAsSucc() const
+    {
+        return (statusCode == HttpStatusCode::OK);
+    }
+};
+
 struct HttpClientRequestConfig
 {
     /*!
@@ -92,19 +108,23 @@ struct HttpClientRequestConfig
      */
     HttpClientRequestConfig(const std::string& uri) 
         :mMethod(HttpRequestMethod::GET), mUri(uri), mToValidCert(false)
-        , mBodyContent(""), mContentType(""), mTimeoutSecs(0)
+        , mBodyContent(""), mContentType(""), mHeaderAcceptType("application/json"), mTimeoutSecs(0)
     {
     }
     HttpClientRequestConfig(HttpRequestMethod method)
-        : mMethod(method), mToValidCert(false), mBodyContent(""), mContentType(""), mTimeoutSecs(0)
+        : mMethod(method), mToValidCert(false), mBodyContent(""), mHeaderAcceptType("application/json")
+        , mContentType(""), mTimeoutSecs(0)
     {
     }
     HttpClientRequestConfig(HttpRequestMethod method, const std::string& uri) 
-        :mMethod(method), mUri(uri), mToValidCert(false), mBodyContent(""), mContentType(""), mTimeoutSecs(0)
+        :mMethod(method), mUri(uri), mToValidCert(false), mBodyContent("")
+        , mContentType(""), mHeaderAcceptType("application/json"), mTimeoutSecs(0)
     {
     }
 
     void SetRequestType(HttpRequestMethod method) { mMethod = method; }
+    HttpRequestMethod GetRequestType() const { return mMethod; }
+
     // uri: 必须以 "http://" 或 "https://" 开头
     void SetUri(const std::string& uri) { mUri = uri; }
     void SetChildUri(const std::string& subUri) { mSubUri = subUri; }
@@ -119,21 +139,10 @@ struct HttpClientRequestConfig
     void ResetQuery() { mQueryPairs.clear(); }
     const std::map<std::string, std::string>& GetQueryPairs() const { return mQueryPairs; }
 
-    void ClearPararm() { mParams.clear(); }
-    void AddParams(const std::string& name, const std::string& value) {
-        mParams.push_back(std::move(std::pair<std::string, std::string>(name, value)));
-    }
-    void SetDefaultParam(const std::string& value) {
-        AddParams("params", value);
-    }
-
-    void ClearFiles() { mFiles.clear(); }
-    void AddFiles(const std::string& filePath) {
-        mFiles.push_back(std::move(std::pair<std::string, std::string>("file_content", filePath)));
+    std::string GetAcceptType() const { return mHeaderAcceptType; }
+    void SetAcceptType(const std::string& value) {
+        mHeaderAcceptType = value;
     }
-    std::pair<std::string, std::string> BuildBodyContent() const;
-
-    HttpRequestMethod GetType() const { return mMethod; }
 
     bool NeedValidCert() const { return mToValidCert; }
 
@@ -145,13 +154,15 @@ struct HttpClientRequestConfig
         mBodyContent = value;
         mContentType = type;
     }
-
     virtual std::string GetBodyContent() const { return mBodyContent; }
     virtual std::string GetContentType() const { return mContentType; }
 
     void SetTimeout(uint32_t timeoutSecs) { mTimeoutSecs = timeoutSecs; }
     uint32_t GetTimeout() const { return mTimeoutSecs; }
 
+    virtual void PreDo() {}
+    virtual void PostDo() {}
+
 private:
 
     HttpRequestMethod mMethod;
@@ -159,34 +170,62 @@ private:
     std::string mSubUri;
     std::string mBodyContent;
     std::string mContentType;
+    std::string mHeaderAcceptType;
 
     std::map<std::string, std::string> mQueryPairs;
-    std::vector<std::pair<std::string, std::string> > mParams;
-    std::vector<std::pair<std::string, std::string> > mFiles;
 
     bool mToValidCert;
     uint32_t mTimeoutSecs;
 };
 
-
 struct HttpClientPostTypeRequest : public HttpClientRequestConfig
 {
-    HttpClientPostTypeRequest(const std::string& uri) :HttpClientRequestConfig(HttpRequestMethod::POST, uri) {}
+    HttpClientPostTypeRequest(const std::string& uri)
+        :HttpClientRequestConfig(HttpRequestMethod::POST, uri) {}
 };
 
-struct HttpClientDownloadRequest : public HttpClientRequestConfig
+struct HttpClientUploadRequest : public HttpClientRequestConfig
 {
-    HttpClientDownloadRequest(const std::string& uri) :HttpClientRequestConfig(HttpRequestMethod::POST, uri) {}
+    HttpClientUploadRequest(const std::string& uri)
+        :HttpClientRequestConfig(HttpRequestMethod::DOWNLOAD, uri)
+    {
+    }
+
+    void ClearPararm() { mParams.clear(); }
+    void AddParams(const std::string& name, const std::string& value)
+    {
+        mParams.push_back(std::move(std::pair<std::string, std::string>(name, value)));
+    }
+    void SetDefaultParam(const std::string& value)
+    {
+        AddParams("params", value);
+    }
+
+    void ClearFiles() { mFiles.clear(); }
+    void AddFiles(const std::string& filePath)
+    {
+        mFiles.push_back(std::move(std::pair<std::string, std::string>("file_content", filePath)));
+    }
 
+    virtual void PreDo() 
+    {
+        auto p = BuildBodyContent();
+        std::cout << p.second << std::endl;
+        SetBodyContent(p.second, std::string("multipart/form-data; boundary=") + p.first);
+    }
+
+    std::pair<std::string, std::string> BuildBodyContent() const;
+
+private:
+    std::vector<std::pair<std::string, std::string> > mParams;
+    std::vector<std::pair<std::string, std::string> > mFiles;
 };
 
-struct HttpClientResponseResult
+struct HttpClientDownloadRequest : public HttpClientRequestConfig
 {
-    int statusCode;
-    std::string content;
-    /**  子类继承实现 */
-    virtual bool ConsiderAsSucc() const {
-        return (statusCode == HttpStatusCode::OK);
+    HttpClientDownloadRequest(const std::string& uri) 
+        :HttpClientRequestConfig(HttpRequestMethod::DOWNLOAD, uri) {
+        SetAcceptType("*/*");
     }
 };
 
@@ -198,7 +237,7 @@ public:
     static RestfulClient& getInstance(); // Singleton
     ~RestfulClient();
 
-    void Do(const HttpClientRequestConfig& requestConfig, HttpClientResponseResult& result);
+    void Do(const HttpClientRequestConfig* const pRequestConfig, HttpClientResponseResult* pResponse) const;
 
 private:
     RestfulClient();

Other/libRestfulFunc/RestfulFuncImpl.cpp

@@ -88,74 +88,93 @@ namespace
     }
 }
 
-void RestfulClient::Do(const HttpClientRequestConfig& requestConfig, HttpClientResponseResult& result)
+void RestfulClient::Do(const HttpClientRequestConfig* const pRequestConfig, HttpClientResponseResult* pResponse) const
 {
     http_client_config config;
-    config.set_validate_certificates(requestConfig.NeedValidCert());
-    const uint32_t timeoutVal = requestConfig.GetTimeout();
+    config.set_validate_certificates(pRequestConfig->NeedValidCert());
+    const uint32_t timeoutVal = pRequestConfig->GetTimeout();
     if (timeoutVal != 0) {
         config.set_timeout(utility::seconds(timeoutVal));
     }
 
-    web::http::client::http_client client(requestConfig.GetBaseUri(), config);
+    web::http::client::http_client client(pRequestConfig->GetBaseUri(), config);
+    http_request request(MappingHttpRequestMethod(pRequestConfig->GetRequestType()));
+    uri_builder urib(pRequestConfig->GetSubUri());
 
-    http_request request(MappingHttpRequestMethod(requestConfig.GetType()));
-    uri_builder urib(requestConfig.GetSubUri());
-    if (requestConfig.GetQueryPairs().size() > 0) {
-        const auto& queries = requestConfig.GetQueryPairs();
+    if (pRequestConfig->GetQueryPairs().size() > 0) {
+        const auto& queries = pRequestConfig->GetQueryPairs();
         for (auto it = queries.cbegin(); it != queries.cend(); ++it) {
             urib.append_query(it->first, it->second);
         }
     }
     request.set_request_uri(urib.to_string());
+    request.headers().add(header_names::accept, pRequestConfig->GetAcceptType());
+    request.set_body(pRequestConfig->GetBodyContent(), pRequestConfig->GetContentType());
+
+    if (pRequestConfig->GetRequestType() == HttpRequestMethod::DOWNLOAD) {
+        pplx::task<void> requestTask = client.request(request)
+            .then([pResponse](http_response response) ->pplx::task<std::string> {
+            pResponse->statusCode = response.status_code();
+            if (pResponse->ConsiderAsSucc()) {
+                return response.extract_string();
+            } else {
+                std::cout << "response status result: " << response.status_code() << std::endl;
+                return pplx::task_from_result(std::string());
+            }
+                  })
+            .then([pResponse](pplx::task<std::string> vt) {
+                      try {
+                          pResponse->content = vt.get();
+                      } catch (const http_exception& ex) {
+                          pResponse->statusCode = -1;
+                          pResponse->content = ex.what();
+                      }
+                  });
+
+                  try {
+                      requestTask.wait();
+                  } catch (const std::exception& ex) {
+                      pResponse->statusCode = -1;
+                      pResponse->content = ex.what();
+                  }
 
-    request.headers().add(header_names::accept, "application/json");
-
-    if (requestConfig.GetType() == HttpRequestMethod::UPLOAD) {
-        auto p = requestConfig.BuildBodyContent();
-        std::cout << p.second << std::endl;
-        request.set_body(p.second, std::string("multipart/form-data; boundary=") + p.first);
     } else {
-        request.set_body(requestConfig.GetBodyContent(), requestConfig.GetBodyContent());
-    }
-
-    pplx::task<void> requestTask = client.request(request)
-     .then([&result](http_response response) ->pplx::task<json::value> {
-        result.statusCode = response.status_code();
-        if (result.ConsiderAsSucc()) {
-            return response.extract_json();
-        } else {
-            std::cout << "response status rsult: " << response.status_code() << std::endl;
-            return pplx::task_from_result(json::value());
-        }
-     })
-    .then([&result](pplx::task<json::value> vt) {
-        try {
 
-            json::value const& v = vt.get();
-            result.content = v.to_string();
-
-        } catch (const http_exception& ex) {
-            result.statusCode = -1;
-            result.content = ex.what();
-        }
-    });
-
-     try
-     {
-         requestTask.wait();
-     }
-     catch (const std::exception& ex)
-     {
-         result.statusCode = -1;
-         result.content = ex.what();
-     }
+        request.set_body(pRequestConfig->GetBodyContent(), pRequestConfig->GetBodyContent());
+        pplx::task<void> requestTask = client.request(request)
+            .then([pResponse](http_response response) ->pplx::task<json::value> {
+            pResponse->statusCode = response.status_code();
+            if (pResponse->ConsiderAsSucc()) {
+                return response.extract_json();
+            } else {
+                std::cout << "response status result: " << response.status_code() << std::endl;
+                return pplx::task_from_result(json::value());
+            }
+                  })
+            .then([pResponse](pplx::task<json::value> vt) {
+                      try {
+
+                          json::value const& v = vt.get();
+                          pResponse->content = v.to_string();
+
+                      } catch (const http_exception& ex) {
+                          pResponse->statusCode = -1;
+                          pResponse->content = ex.what();
+                      }
+                  });
+
+                  try {
+                      requestTask.wait();
+                  } catch (const std::exception& ex) {
+                      pResponse->statusCode = -1;
+                      pResponse->content = ex.what();
+                  }
+    }
 }
 
 
-std::pair<std::string, std::string> HttpClientRequestConfig::BuildBodyContent() const
+std::pair<std::string, std::string> HttpClientUploadRequest::BuildBodyContent() const
 {
-
     std::stringstream data;
 
     std::string boundary{};

Other/libRestfulFunc/test/testNormlReqAns.cpp

@@ -8,7 +8,7 @@ TEST_CASE("test api manage", "[restful]")
     HttpClientResponseResult result;
     config.SetChildUri("/api/manage/regist/7555980103");
     RestfulClient client = RestfulClient::getInstance();
-    client.Do(config, result);
+    client.Do(&config, &result);
     std::cout << result.content << std::endl;
     REQUIRE(!result.content.empty());
 }
@@ -20,7 +20,7 @@ TEST_CASE("test  api stage get api", "[restful]")
     config.SetChildUri("/api/stage");
     config.AppendQuery("terminalNo", "7555980001");
     RestfulClient client = RestfulClient::getInstance();
-    client.Do(config, result);
+    client.Do(&config, &result);
     std::cout << result.content << std::endl;
     REQUIRE(!result.content.empty());
 }
@@ -33,21 +33,21 @@ TEST_CASE("test  api stage post api", "[restful]")
     config.SetJsonBody("{\"terminalNo\":\"7555980001\", \"errEntityList\":\"566666\"}");
     RestfulClient client = RestfulClient::getInstance();
     HttpClientResponseResult result;
-    client.Do(config, result);
+    client.Do(&config, &result);
     std::cout << result.content << std::endl;
     REQUIRE(!result.content.empty());
 }
 
 TEST_CASE("test  api stage upload api", "[restful]")
 {
-    HttpClientRequestConfig config("http://55.6.78.29:8080");
-    config.SetRequestType(HttpRequestMethod::UPLOAD);
+    HttpClientUploadRequest config("http://55.6.78.29:8080");
     config.SetChildUri("/api/upload/file");
     config.SetDefaultParam("{\"branch_no\":\"755\",\"file_head_custom\":\"\",\"file_name\":\"20220301.log\",\"file_path\":\"/home/rvc/dbg/mod_initiativetransfer/20220301.log\",\"file_type\":\"O\",\"first_file_length\":\"105116\",\"last_file_length\":\"\",\"plan_id\":\"dbg\",\"system_type\":\"L\",\"terminal_no\":\"7555980012\",\"upload_length\":\"0\"}");
     config.AddFiles("/home/rvc/dbg/mod_initiativetransfer/20220301.log");
     RestfulClient client = RestfulClient::getInstance();
     HttpClientResponseResult result;
-    client.Do(config, result);
+    config.PreDo();
+    client.Do(&config, &result);
     std::cout << result.content << std::endl;
     REQUIRE(!result.content.empty());
 }