San Airteagal seo labhróidh mé faoi conas a chruthaigh mé teimpléad (fianán) agus mar a bhunaigh mé timpeallacht chun seirbhís REST API a scríobh i C ++ ag baint úsáide as docker/docker-compose agus an bainisteoir pacáiste conan.
Le linn an chéad hackathon eile, inar ghlac mé páirt mar fhorbróir backend, d'éirigh an cheist faoi cad ba cheart a úsáid chun an chéad mhicrosheirbhís eile a scríobh. Gach rud atá scríofa go dtí seo a scríobh mé féin agus mo i Python, ós rud é go raibh mo chomhghleacaí ina shaineolaí sa réimse seo agus go ndearna sé backends forbartha go gairmiúil, agus mé i gcoitinne i mo fhorbróir córais leabaithe agus ag scríobh sa C++ iontach agus uafásach, agus d'fhoghlaim mé Python díreach tar éis dom san ollscoil.
Mar sin, bhí orainn seirbhís ard-ualach a scríobh, arbh é an príomhthasc a bhí ann ná na sonraí a bhí ag teacht chuige a réamhphróiseáil agus é a scríobh chuig an mbunachar sonraí. Agus tar éis briseadh deataigh eile, mhol cara domsa, mar fhorbróir C++, an tseirbhís seo a scríobh ag baint úsáide as na buntáistí. Is é an argóint seo ná go mbeidh sé níos tapúla, níos táirgiúla, agus go ginearálta, beidh an giúiré thar a bheith sásta leis an gcaoi a bhfuil a fhios againn conas acmhainní na foirne a bhainistiú. D'fhreagair mé nach raibh a leithéid de rudaí déanta agam riamh in C++ agus go bhféadfainn an 20+ uair an chloig eile a chaitheamh go héasca ar leabharlanna oiriúnacha a chuardach, a thiomsú agus a nascadh. Níl ort ach a chur, chicked mé amach. Sin a shocraigh muid agus chuireamar gach rud i gcrích go socair i Python.
Anois, le linn an fhéin-aonraithe éigeantaigh, chinn mé a dhéanamh amach conas seirbhísí a scríobh i C++. Ba é an chéad rud a bhí le déanamh ná cinneadh a dhéanamh ar leabharlann oiriúnach. Thit mo rogha ar , toisc go raibh sé scríofa i stíl atá dírithe ar oibiachtaí agus go raibh gnáthcháipéisíocht ann freisin. Chomh maith leis sin, tháinig an cheist maidir le roghnú córas tionóil. Go dtí seo níor oibrigh mé ach le Visual Studio, IAR agus le makefiles lom. Agus níor chuir aon cheann de na córais seo achomharc orm, ós rud é go raibh sé beartaithe agam an tseirbhís iomlán a reáchtáil i gcoimeádán duga. Ansin chinn mé iarracht a dhéanamh cmake agus bainisteoir pacáiste suimiúil a dhéanamh amach . Thug an bainisteoir pacáiste seo deis duit gach spleáchas a chlárú in aon chomhad amháin
conanfile.txt
[éilíonn]poco/1.9.3
libpq/11.5
agus le hordú simplí "conan install ." na leabharlanna riachtanacha a shuiteáil. Ar ndóigh, bhí sé riachtanach freisin athruithe a dhéanamh ar
CMakeLists.txt
include(build/conanbuildinfo.cmake)
conan_basic_setup()
target_link_libraries(<target_name> ${CONAN_LIBS})
Ina dhiaidh sin, thosaigh mé ag lorg leabharlann chun oibriú le PostgreSQL, ós rud é gurb é an ceann a raibh beagán taithí agam ag obair leis, agus ba é an ceann a ndearna ár seirbhísí Python idirghníomhú leis freisin. Agus an bhfuil a fhios agat cad a d'fhoghlaim mé? Tá sé i POCO! Ach níl a fhios ag Conan go bhfuil sé in POCO agus níl a fhios aige conas é a thógáil; tá comhad cumraíochta as dáta sa stór ( scríobh mé faoin earráid seo chuig cruthaitheoirí POCO cheana féin). Ciallaíonn sé seo go mbeidh ort leabharlann eile a chuardach.
Agus ansin thit mo rogha ar leabharlann nach raibh chomh coitianta . Agus bhí an t-ádh orm, bhí sé i gConán cheana féin agus bhí sé á chur le chéile agus á chur le chéile fiú.
Ba é an chéad chéim eile ná teimpléad seirbhíse a scríobh a fhéadfaidh iarratais a phróiseáil.
Ní mór dúinn ár n-aicme TemplateServerApp a oidhreacht le hoidhreacht ó Poco ::Util::ServerAppplication agus an príomh-mhodh a shárú.
Teimpléad ServerApp
#pragma once
#include <string>
#include <vector>
#include <Poco/Util/ServerApplication.h>
class TemplateServerApp : public Poco::Util::ServerApplication
{
protected:
int main(const std::vector<std::string> &);
};int TemplateServerApp::main(const vector<string> &)
{
HTTPServerParams* pParams = new HTTPServerParams;
pParams->setMaxQueued(100);
pParams->setMaxThreads(16);
HTTPServer s(new TemplateRequestHandlerFactory, ServerSocket(8000), pParams);
s.start();
cerr << "Server started" << endl;
waitForTerminationRequest(); // wait for CTRL-C or kill
cerr << "Shutting down..." << endl;
s.stop();
return Application::EXIT_OK;
}Sa phríomh-mhodh ní mór dúinn na paraiméadair a shocrú: calafort, líon na snáitheanna agus méid scuaine. Agus is tábhachtaí fós, ní mór duit láimhseálaí a shonrú le haghaidh iarratais isteach. Déantar é seo trí mhonarcha a chruthú
TemplateRequestHandlerFactory
class TemplateRequestHandlerFactory : public HTTPRequestHandlerFactory
{
public:
virtual HTTPRequestHandler* createRequestHandler(const HTTPServerRequest & request)
{
return new TemplateServerAppHandler;
}
};I mo chás, cruthaíonn sé an láimhseálaí céanna gach uair - TemplateServerAppHandler. Seo an áit ar féidir linn ár loighic ghnó a chur.
TemplateServerAppHandler
class TemplateServerAppHandler : public HTTPRequestHandler
{
public:
void handleRequest(HTTPServerRequest &req, HTTPServerResponse &resp)
{
URI uri(req.getURI());
string method = req.getMethod();
cerr << "URI: " << uri.toString() << endl;
cerr << "Method: " << req.getMethod() << endl;
StringTokenizer tokenizer(uri.getPath(), "/", StringTokenizer::TOK_TRIM);
HTMLForm form(req,req.stream());
if(!method.compare("POST"))
{
cerr << "POST" << endl;
}
else if(!method.compare("PUT"))
{
cerr << "PUT" << endl;
}
else if(!method.compare("DELETE"))
{
cerr << "DELETE" << endl;
}
resp.setStatus(HTTPResponse::HTTP_OK);
resp.setContentType("application/json");
ostream& out = resp.send();
out << "{"hello":"heh"}" << endl;
out.flush();
}
};Chruthaigh mé teimpléad ranga freisin chun oibriú le PostgreSQL. Chun SQL simplí a dhéanamh, mar shampla tábla a chruthú, tá modh ann RithSQL(). Le haghaidh ceisteanna níos casta nó aisghabháil sonraí, beidh ort nasc a fháil trí GetConnection() agus an API libpg a úsáid. (B’fhéidir ina dhiaidh sin ceartóidh mé an éagóir seo).
Bunachar
#pragma once
#include <memory>
#include <mutex>
#include <libpq-fe.h>
class Database
{
public:
Database();
std::shared_ptr<PGconn> GetConnection() const;
bool ExecuteSQL(const std::string& sql);
private:
void establish_connection();
void LoadEnvVariables();
std::string m_dbhost;
int m_dbport;
std::string m_dbname;
std::string m_dbuser;
std::string m_dbpass;
std::shared_ptr<PGconn> m_connection;
};Tógtar na paraiméadair go léir chun nascadh leis an mbunachar sonraí ón timpeallacht, mar sin ní mór duit an comhad .env a chruthú agus a chumrú freisin
.a V
DATABASE_NAME=template
DATABASE_USER=user
DATABASE_PASSWORD=password
DATABASE_HOST=postgres
DATABASE_PORT=5432Is féidir leat an cód ar fad a fheiceáil ag
Agus anois tagann an chéim dheireanach de scríobh an dockerfile agus docker-compose.yml. Le bheith ionraic, thóg sé seo an chuid is mó den am, agus ní hamháin toisc gur noob mé, toisc go raibh sé riachtanach na leabharlanna a atógáil gach uair, ach mar gheall ar na deacrachtaí a bhaineann le conán. Mar shampla, chun go bhféadfaidh Conan na spleáchais riachtanacha a íoslódáil, a shuiteáil agus a thógáil, ní leor dó “conan install .” a íoslódáil, caithfidh sé pas a fháil sa pharaiméadar -s compiler.libcxx=libstdc++11, ar shlí eile tá an baol ann go bhfaighidh tú a lán earráidí ag an gcéim nasctha d’iarratas. Tá mé i bhfostú leis an earráid seo le roinnt uaireanta an chloig agus tá súil agam go gcabhróidh an t-alt seo le daoine eile an fhadhb seo a réiteach i níos lú ama.
Ansin, tar éis dom docker-compose.yml a scríobh, ar chomhairle mo chara, chuir mé tacaíocht leis agus anois is féidir leat teimpléad iomlán a fháil duit féin do sheirbhís REST API in C++, le timpeallacht shaincheaptha, agus PostgreSQL suiteáilte, go simplí trí “fianán” a chur isteach sa chonsól " Agus ansin “dugadóir-cumadh suas — tógáil”.
Tá súil agam go gcabhróidh an teimpléad seo le tosaitheoirí ar a gcosán deacair maidir le feidhmchláir REST API a fhorbairt sa teanga iontach agus chumhachtach, ach atá chomh clumsy mar C ++.
Chomh maith leis sin, molaim go mór léamh anseo alt. Míníonn sé go mion conas oibriú le POCO agus do sheirbhís REST API féin a scríobh.
Foinse: will.com