{"id":270,"date":"2018-07-26T14:59:19","date_gmt":"2018-07-26T12:59:19","guid":{"rendered":"http:\/\/www.kompikownia.pl\/?p=270"},"modified":"2019-03-08T00:08:23","modified_gmt":"2019-03-07T23:08:23","slug":"rest-api-w-c-biblioteka-casablanca-cpprest","status":"publish","type":"post","link":"https:\/\/www.kompikownia.pl\/index.php\/2018\/07\/26\/rest-api-w-c-biblioteka-casablanca-cpprest\/","title":{"rendered":"REST API w C++ – biblioteka Casablanca cpprest"},"content":{"rendered":"Czas czytania:<\/span> 5<\/span> minut<\/span><\/span>\n

Przed lektur\u0105<\/strong>
Aby\u015b zrozumia\u0142 tre\u015b\u0107 tego wpisu by\u0142oby dobrze, aby\u015b wiedzia\u0142 co to jest REST API oraz do czego ono s\u0142u\u017cy. W tre\u015bci tego wpisu nie b\u0119d\u0119 si\u0119 rozwodzi\u0142 nad tym co to dok\u0142adnie jest REST API oraz do czego ono s\u0142u\u017cy. Skupi\u0119 si\u0119 jedynie nad tym, jak wykona\u0107 prost\u0105 implementacj\u0119.<\/p>\n\n\n\n

\n\n\n\n
\n\n\n\n

Ostatnimi czasy tworz\u0119 do\u015b\u0107 du\u017cy projekt. Jego wielko\u015b\u0107 wymaga\u0142a podzia\u0142u na dwie cz\u0119\u015bci: backend i frontend. Backend to wszystko, co dzieje si\u0119 pod spodem (komunikacja z baz\u0105 danych, wykonywanie oblicze\u0144 itp.) Natomiast Frontend zajmuje si\u0119 g\u0142\u00f3wnie interfejsem aplikacji, czyli sposobem \u201ekomunikacji\u201d z u\u017cytkownikiem. Aplikacja powstawa\u0142a w C++ i mia\u0142em spory problem z wyprowadzeniem przetwarzanych danych do aplikacji tworzonej w React\u2019ie. Pr\u00f3bowa\u0142em r\u00f3\u017cnych sposob\u00f3w \u2013 np.: komunikacji za pomoc\u0105 socket\u00f3w. Pewnego razu na uczelni us\u0142ysza\u0142em o czym\u015b takim jak REST API \u2013 kt\u00f3re wykorzystuje m.in. format JSON oraz r\u00f3\u017cne typy zapyta\u0144 HTTP do udost\u0119pnienia frontendowi r\u00f3\u017cnych informacji. W wykonaniu REST API w j\u0119zyku C++ mo\u017ce nam pom\u00f3c biblioteka firmy Microsoft o nazwie Casablanca (cpprest). Za chwil\u0119 zobaczymy, jak j\u0105 zainstalowa\u0107 oraz jak zrobi\u0107 proste API.<\/p>\n\n\n\n

Instalacja Cablanca cpprest<\/h1>\n\n\n\n

Instalacja biblioteki cpprest zosta\u0142a dobrze opisana na jej stronie w Githubie<\/a>. W Linuksie mo\u017cemy j\u0105 bezproblemowo zainstalowa\u0107 za pomoc\u0105 polecenia:<\/p>\n\n\n\n

sudo apt-get install libcpprest-dev\n<\/pre>\n\n\n\n
Nasz projekt nie b\u0119dzie mia\u0142 jakiego\u015b ogromnego rozmiaru. Tote\u017c u\u017cyjemy prostego \u015brodowiska Code::Blocks. Utw\u00f3rz nowy projekt konsolowy w j\u0119zyku C++. Gdy to zrobisz, kliknij PPM na nazwie projektu\u2192Build Options\u2192na li\u015bcie po lewej stronie zaznacz nazw\u0119 swojego projektu. Po prawej stronie przejd\u017a na zak\u0142adk\u0119 Linker Settings. Musimy doda\u0107 nast\u0119puj\u0105ce opcje:<\/p>\n\n\n\n
-lcpprest\n-lpthread\n-lboost_system\n-lssl\n-lcrypto\n<\/pre>\n\n\n\n
Poni\u017cej znajduje si\u0119 screen prezentuj\u0105cy jak to powinno wygl\u0105da\u0107:<\/p>\n\n\n\n
\"\"<\/figure><\/div>\n\n\n\n

To tyle. Biblioteka zosta\u0142a do\u0142\u0105czona a projekt zosta\u0142 skonfigurowany. Pora na napisanie prostego kodu.<\/p>\n\n\n\n
Piszemy proste Rest API w C++<\/h1>\n\n\n\n
Nasz projekt b\u0119dzie sk\u0142ada\u0142 si\u0119 z kilku klas. Utworzymy sobie klas\u0119 BasicController, kt\u00f3ra b\u0119dzie ustawia\u0142a wszystkie podstawowe parametry serwera. Nast\u0119pnie utworzymy sobie klas\u0119 us\u0142ugi, kt\u00f3ra b\u0119dzie implementowa\u0142a metody GET\/PUT\/POST i inne.<\/p>\n\n\n\n
BasicController<\/h2>\n\n\n\n
Zaczynamy od klasy BasicController. Dodajemy do projektu nowy plik o nazwie BasicController.h. Wewn\u0105trz znajduje si\u0119 nast\u0119puj\u0105cy kod:<\/p>\n\n\n\n
Om\u00f3wimy go linijka po linijce.<\/p>\n\n\n\n\n
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<\/div><\/td>
#ifndef BASICCONTROLLER_H_INCLUDED<\/span>
\n#define BASICCONTROLLER_H_INCLUDED<\/span>
\n#include <cpprest\/http_listener.h><\/span>
\n#include <pplx\/pplxtasks.h><\/span>
\n#include <string><\/span>
\n#include <cpprest\/http_msg.h><\/span>
\nusing<\/span> namespace<\/span> web;<\/span>
\nusing<\/span> namespace<\/span> http;<\/span>
\nusing<\/span> namespace<\/span> http::<\/span>experimental<\/span>::<\/span>listener<\/span>;<\/span>
\n
\nclass<\/span> BasicController {<\/span>
\n    public<\/span>:<\/span>
\n    BasicController(<\/span>const<\/span> std::<\/span>string<\/span>&<\/span> address,const<\/span> std::<\/span>string<\/span>&<\/span> port)<\/span>;<\/span>
\n    ~BasicController(<\/span>)<\/span>;<\/span>
\n    void<\/span> setEndpoint(<\/span>const<\/span> std::<\/span>string<\/span>&<\/span> mount_point)<\/span>;<\/span>
\n    std::<\/span>string<\/span> endpoint(<\/span>)<\/span> const<\/span>;<\/span>
\n    pplx::<\/span>task<\/span><<\/span>void<\/span>><\/span> accept(<\/span>)<\/span>;<\/span>
\n    pplx::<\/span>task<\/span><<\/span>void<\/span>><\/span> shutdown(<\/span>)<\/span>;<\/span>
\n
\n    virtual<\/span> void<\/span> initRestOpHandlers(<\/span>)<\/span> =<\/span> 0<\/span>;<\/span>
\n
\n    std::<\/span>vector<\/span><<\/span>utility::<\/span>string_t<\/span>><\/span> requestPath(<\/span>const<\/span> http_request &<\/span> message)<\/span>;<\/span>
\n    protected<\/span>:<\/span>
\n    http_listener _listener;<\/span>
\n    private<\/span>:<\/span>
\n    uri_builder endpointBuilder;<\/span>
\n}<\/span>;<\/span>
\n
\n#endif \/\/ BASICCONTROLLER_H_INCLUDED<\/span><\/div><\/td><\/tr><\/tbody><\/table><\/div>\n\n\n\n\n
#include\u2019y \u2013 to jest to, co musi si\u0119 pojawi\u0107. Aby program prawid\u0142owo si\u0119 skompilowa\u0142, musimy do\u0142\u0105czy\u0107 pliki nag\u0142\u00f3wkowe zawieraj\u0105ce funkcje z nowo dodanej biblioteki, z kt\u00f3rej b\u0119dziemy korzystali.<\/p>\n\n\n\n
Konstruktor naszej klasy przyjmuje dwa parametry: adres oraz port pod kt\u00f3rym nasz serwer b\u0119dzie nas\u0142uchiwa\u0142. Jako adres przeka\u017cemy adres IP naszej karty sieciowej. W przysz\u0142o\u015bci mo\u017cemy sami odczytywa\u0107 ten adres, ale pomin\u0105\u0142em ten fragment dla uproszczenia przyk\u0142adu.<\/p>\n\n\n\n
Destruktor jest, ale nic nie robi.<\/p>\n\n\n\n
setEndpoint<\/strong> \u2013 funkcja ta przyjmuje tylko jeden argument. mount_point, czyli \u201efragment adresu\u201d pod jakim b\u0119dzie widoczna nasza us\u0142uga. np.: Skonstruujmy kontroler, przekazuj\u0105c mu jako adres IP i port 192.168.1.1 i port 8080. setEndpoint uruchommy z argumentem \u201e\/api\/calculator\u201d. Wtedy nasze API b\u0119dzie widoczne pod adresem http:\/\/192.168.1.1:8080\/api\/calculator<\/a>. Proste, nie?<\/p>\n\n\n\n
Kolejne dwie funkcje \u2013 accept<\/strong> i shutdown<\/strong> \u2013 s\u0142u\u017c\u0105 do rozpocz\u0119cia i zako\u0144czenia pracy serwera. Czysto wirtualn\u0105 metod\u0105 initRestOpHandlers<\/strong> zajmiemy si\u0119 p\u00f3\u017aniej.<\/p>\n\n\n\n
requestPath<\/strong> wyci\u0105ga nam z zapytania cz\u0119\u015b\u0107 adresu, kt\u00f3r\u0105 dopisa\u0142 u\u017cytkownik. Wr\u00f3\u0107my do poprzedniego przyk\u0142adu. Za\u0142\u00f3\u017cmy, \u017ce u\u017cytkownik wys\u0142a\u0142 zapytanie pod adres:<\/p>\n\n\n\n
http:\/\/192.168.1.1:8080\/api\/calculator\/adder<\/a>. Wtedy requestPath zwr\u00f3ci tablic\u0119, kt\u00f3rej pierwszym elementem b\u0119dzie s\u0142owo \u201eadder\u201d.<\/p>\n\n\n\n
http_listener _listener<\/strong> \u2013 jest to zmienna, kt\u00f3ra s\u0142u\u017cy\u0107 nam b\u0119dzie po pod\u0142\u0105czenia odpowiednich funkcji do danych zapyta\u0144. Szczeg\u00f3\u0142owo zajmiemy si\u0119 ni\u0105 p\u00f3\u017aniej.<\/p>\n\n\n\n
uri_builder endpointBuilder<\/strong> \u2013 s\u0142u\u017cy do zbudowania adresu, pod kt\u00f3rym b\u0119dzie widoczna nasza us\u0142uga. Zauwa\u017cysz i zrozumiesz jej zastosowanie, kiedy b\u0119dziemy patrzyli na implementacj\u0119 powy\u017cszych metod.<\/p>\n\n\n\n
No dobra. Pierwsze koty za p\u0142oty. Przechodzimy do implementacji klasy BasicController.<\/p>\n\n\n
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<\/div><\/td>
#include "BasicController.h"<\/span>
\n
\nBasicController::<\/span>BasicController<\/span>(<\/span>const<\/span> std::<\/span>string<\/span>&<\/span> naddress,const<\/span> std::<\/span>string<\/span>&<\/span> nport)<\/span> {<\/span>
\n   this-<\/span>><\/span>endpointBuilder.set_host<\/span>(<\/span>naddress)<\/span>;<\/span>
\n   this-<\/span>><\/span>endpointBuilder.set_port<\/span>(<\/span>nport)<\/span>;<\/span>
\n   this-<\/span>><\/span>endpointBuilder.set_scheme<\/span>(<\/span>"http"<\/span>)<\/span>;<\/span>
\n}<\/span>
\nBasicController::<\/span>~BasicController(<\/span>)<\/span> {<\/span>
\n}<\/span>
\nvoid<\/span> BasicController::<\/span>setEndpoint<\/span>(<\/span>const<\/span> std::<\/span>string<\/span>&<\/span> mount_point)<\/span>
\n{<\/span>
\n    endpointBuilder.set_path<\/span>(<\/span>mount_point)<\/span>;<\/span>
\n    _listener =<\/span> http_listener(<\/span>endpointBuilder.to_uri<\/span>(<\/span>)<\/span>)<\/span>;<\/span>
\n}<\/span><\/div><\/td><\/tr><\/tbody><\/table><\/div>\n\n\n\n
W konstruktorze za pomoc\u0105 endpointBuildera ustawiamy adres, port oraz protok\u00f3\u0142, pod kt\u00f3rym b\u0119dziemy nas\u0142uchiwa\u0107. W setEndpoint do endPointBuildera dodajemy \u015bcie\u017ck\u0119 i to wszystko przekazujemy jako wynik do _listenera, kt\u00f3ry od tego momentu wie, pod jakim adresem ma nas\u0142uchiwa\u0107 przychodz\u0105cych zapyta\u0144.<\/p>\n\n\n\n\n
20
21
22
23
24
25
26
<\/div><\/td>
pplx::<\/span>task<\/span><<\/span>void<\/span>><\/span> BasicController::<\/span>accept<\/span>(<\/span>)<\/span> {<\/span>
\n    initRestOpHandlers(<\/span>)<\/span>;<\/span>
\n    return<\/span> _listener.open<\/span>(<\/span>)<\/span>;<\/span>
\n}<\/span>
\npplx::<\/span>task<\/span><<\/span>void<\/span>><\/span> BasicController::<\/span>shutdown<\/span>(<\/span>)<\/span> {<\/span>
\n    return<\/span> _listener.close<\/span>(<\/span>)<\/span>;<\/span>
\n}<\/span><\/div><\/td><\/tr><\/tbody><\/table><\/div>\n\n\n\n\n
W metodzie accept wywo\u0142ujemy metod\u0119 initRestOpHandlers(), kt\u00f3r\u0105 nied\u0142ugo nadpiszemy w klasie pochodnej. Poza tym, otwieramy _listenera. Od momentu wywo\u0142ania tej funkcji nasz serwer zaczyna pracowa\u0107. Implementacja metody shutdown jest analogiczna.<\/p>\n\n\n\n\n
27
28
29
30
31
<\/div><\/td>
std::<\/span>vector<\/span><<\/span>utility::<\/span>string_t<\/span>><\/span> BasicController::<\/span>requestPath<\/span>(<\/span>const<\/span> http_request&<\/span> message)<\/span>
\n{<\/span>
\n    auto<\/span> relativePath =<\/span> uri::<\/span>decode<\/span>(<\/span>message.relative_uri<\/span>(<\/span>)<\/span>.path<\/span>(<\/span>)<\/span>)<\/span>;<\/span>
\n    return<\/span> uri::<\/span>split_path<\/span>(<\/span>relativePath)<\/span>;<\/span>
\n}<\/span><\/div><\/td><\/tr><\/tbody><\/table><\/div>\n\n\n\n\n
Jak dzia\u0142a metoda requestPath? Jako argument przyjmujemy zapytanie http. Dekodujemy je za pomoc\u0105 specjalnej metody uri::decode. Korzystamy ze specjalnego typu zmiennej auto, kt\u00f3rej typ, wzorem Javascriptu i innych nowoczesnych j\u0119zyk\u00f3w, automatycznie dopasowuje si\u0119 do danej sytuacji. Metoda split_path dzieli \u015bcie\u017ck\u0119 na kawa\u0142ki i ka\u017cdy z tych kawa\u0142k\u00f3w wk\u0142ada do oddzielnego elementu klasy vector. To wszystko zwracamy za pomoc\u0105 s\u0142owa kluczowego return.<\/p>\n\n\n\n
Service<\/h2>\n\n\n\n
Klasa Service dziedziczy po BasicController. Umie\u015b\u0107 j\u0105 w oddzielnych plikach: Service.cpp oraz Service.h.<\/p>\n\n\n\n
Nasza us\u0142uga b\u0119dzie pe\u0142ni\u0142a bardzo prost\u0105 rol\u0119. Zapytanie GET b\u0119dzie zwraca\u0142o nam zawarto\u015b\u0107 kontenera vector przechowuj\u0105cego liczby int. Je\u015bli przy zapytaniu GET adres URI b\u0119dzie ko\u0144czy\u0142 si\u0119 s\u0142\u00f3wkiem sum, to dostaniemy sum\u0119 liczb, a je\u015bli s\u0142\u00f3wkiem avg to \u015bredni\u0105. Zapytanie PUT b\u0119dzie natomiast dodawa\u0142o kolejne liczby do tego kontenera. To wystarczy, aby pokaza\u0107 ci og\u00f3ln\u0105 wizj\u0119 pos\u0142ugiwania si\u0119 bibliotek\u0105 cpprest. Pozosta\u0142e zapytania dasz rad\u0119 zaimplementowa\u0107 we w\u0142asnym zakresie.<\/p>\n\n\n\n
Service.h<\/strong><\/p>\n\n\n\n\n
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<\/div><\/td>
#ifndef SERVICE_H_INCLUDED<\/span>
\n#define SERVICE_H_INCLUDED<\/span>
\n#include "BasicController.h"<\/span>
\n#include <vector><\/span>
\nusing<\/span> std::<\/span>vector<\/span>;<\/span>
\n
\nclass<\/span> Service :<\/span> public<\/span> BasicController {<\/span>
\n    public<\/span>:<\/span>
\n    Service(<\/span>const<\/span> std::<\/span>string<\/span>&<\/span> address,const<\/span> std::<\/span>string<\/span>&<\/span> port)<\/span> :<\/span> BasicController(<\/span>address,port)<\/span> {<\/span>}<\/span>
\n    ~Service(<\/span>)<\/span> {<\/span>}<\/span>
\n    void<\/span> handleGet(<\/span>http_request message)<\/span>;<\/span>
\n    void<\/span> handlePut(<\/span>http_request message)<\/span>;<\/span>
\n    void<\/span> initRestOpHandlers(<\/span>)<\/span> override<\/span>;<\/span>
\n    private<\/span>:<\/span>
\n    vector<<\/span>int<\/span>><\/span> numbers;<\/span>
\n    float<\/span> calculateSum(<\/span>)<\/span>;<\/span>
\n}<\/span>;<\/span>
\n#endif \/\/ SERVICE_H_INCLUDED<\/span><\/div><\/td><\/tr><\/tbody><\/table><\/div>\n\n\n\n\n
Oto nasz plik Service.h. Zdefiniowali\u015bmy w nim klas\u0119 Service. To ona b\u0119dzie zajmowa\u0142a si\u0119 analiz\u0105 zapyta\u0144 i wys\u0142aniem odpowiedniej odpowiedzi do u\u017cytkownika. Prywatnie zdefiniowali\u015bmy sobie vector liczb typu int. To tam b\u0119dziemy przechowywali liczby dodane przez u\u017cytkownika za pomoc\u0105 zapytania PUT. Zdefiniowali\u015bmy sobie tak\u017ce pomocnicz\u0105 funkcj\u0119 calculateSum() (w linijce 16). Funkcja calculateSum b\u0119dzie liczy\u0142a sum\u0119 wszystkich element\u00f3w znajduj\u0105cej si\u0119 w kontenerze numbers.<\/p>\n\n\n\n
A co zdefiniowali\u015bmy jako publiczne elementy? Konstruktor, kt\u00f3ry przyjmuje takie same parametry jak konstruktor klasy, po kt\u00f3rej dziedziczymy (BasicController). Poza tym konstruktor nic nie musi robi\u0107. Dalej mamy definicj\u0119 metod, z kt\u00f3rych b\u0119dziemy korzystali: handleGet i handlePut. Obydwie jako argument przyjmuj\u0105 zmienn\u0105 typu http_request. http_request<\/strong> zawiera wszystkie informacje o zapytaniu HTTP, jakie zosta\u0142o wys\u0142ane przez u\u017cytkownika. InitrRestOpHandlers() jest metod\u0105 odziedziczon\u0105 po BasicController, kt\u00f3r\u0105 w tym miejscu zaimplementujemy.<\/p>\n\n\n\n
Service.cpp<\/strong>
Plik Service.cpp jest dosy\u0107 d\u0142ugi. Aby\u015b wszystko dobrze zrozumia\u0142, b\u0119d\u0119 omawia\u0142 po kolei poszczeg\u00f3lne metody tego pliku.<\/p>\n\n\n\n\n
9
10
11
12
13
14
15
<\/div><\/td>
#include "Service.h"<\/span>
\n#include <string><\/span>
\nusing<\/span> std::<\/span>string<\/span>;<\/span>
\nvoid<\/span> Service::<\/span>initRestOpHandlers<\/span>(<\/span>)<\/span> {<\/span>
\n    _listener.support<\/span>(<\/span>methods::<\/span>GET<\/span>,std::<\/span>bind<\/span>(<\/span>&<\/span>Service::<\/span>handleGet<\/span>,this<\/span>,std::<\/span>placeholders<\/span>::<\/span>_1)<\/span>)<\/span>;<\/span>
\n    _listener.support<\/span>(<\/span>methods::<\/span>PUT<\/span>,std::<\/span>bind<\/span>(<\/span>&<\/span>Service::<\/span>handlePut<\/span>,this<\/span>,std::<\/span>placeholders<\/span>::<\/span>_1)<\/span>)<\/span>;<\/span>
\n}<\/span><\/div><\/td><\/tr><\/tbody><\/table><\/div>\n\n\n\n\n
Zaczynamy od funkcji initRestOpHandlers. Domy\u015blasz si\u0119 pewnie, jakie ona ma zadanie :). M\u00f3wimy serwerowi, jakie metody obs\u0142uguje nasze API. Pierwszy argument to odpowiednia metoda. Drugi argument wygl\u0105da nieco bardziej tajemniczo. Za pomoc\u0105 std::bind \u201em\u00f3wimy\u201d listenerowi, \u017ceby u\u017cy\u0142 danej metody obs\u0142ugi je\u015bli serwer otrzyma dane zapytanie. Np.: w linijce pi\u0105tej m\u00f3wimy, \u017ce do obs\u0142ugi zapytania GET powinna zosta\u0107 u\u017cyta metoda handleGet. Natomiast w kolejnej linijce u\u015bwiadamiamy serwerowi, \u017ceby u\u017cy\u0142 metody handlePut do obs\u0142ugi zapytania PUT. Analogicznie post\u0119powaliby\u015bmy z innymi zapytaniami HTTP, kt\u00f3re chcieliby\u015bmy obs\u0142u\u017cy\u0107 a nie ma ich w tym przyk\u0142adzie.<\/p>\n\n\n\n\n
9
10
11
12
13
14
15
<\/div><\/td>
float<\/span> Service::<\/span>calculateSum<\/span>(<\/span>)<\/span> {<\/span>
\n    float<\/span> sum =<\/span> 0<\/span>;<\/span>
\n    for<\/span>(<\/span>unsigned<\/span> int<\/span> i =<\/span> 0<\/span>;<\/span>i<<\/span>numbers.size<\/span>(<\/span>)<\/span>;<\/span>i++<\/span>)<\/span> {<\/span>
\n        sum+<\/span>=<\/span>numbers[<\/span>i]<\/span>;<\/span>
\n    }<\/span>
\n    return<\/span> sum;<\/span>
\n}<\/span><\/div><\/td><\/tr><\/tbody><\/table><\/div>\n\n\n\n\n
Implementacja metody CalculateSum nie pozostawia \u017cadnych w\u0105tpliwo\u015bci. Po prostu w p\u0119tli for sumujemy wszystkie elementy kontenera numbers i sum\u0119 t\u0119 przechowujemy w zmiennej typu float o nazwie sum. Na samym ko\u0144cu, gdy p\u0119tla sko\u0144czy swoj\u0105 prac\u0119, zwracamy zmienn\u0105 sum jako rezultat wykonania tej metody. Nie ma tu nic niezwyk\u0142ego, nad czym warto by\u0142oby d\u0142u\u017cej si\u0119 rozwodzi\u0107.<\/p>\n\n\n\n\n
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
<\/div><\/td>
void<\/span> Service::<\/span>handleGet<\/span>(<\/span>http_request message)<\/span> {<\/span>
\n    vector<<\/span>string><\/span> path =<\/span> requestPath(<\/span>message)<\/span>;<\/span>
\n    if<\/span>(<\/span>path.empty<\/span>(<\/span>)<\/span>)<\/span> {<\/span>
\n        vector <<\/span>json::<\/span>value<\/span>><\/span> jsonNumbers;<\/span>
\n        for<\/span>(<\/span>unsigned<\/span> int<\/span> i =<\/span> 0<\/span>;<\/span>i<<\/span>numbers.size<\/span>(<\/span>)<\/span>;<\/span>i++<\/span>)<\/span> {<\/span>
\n            json::<\/span>value<\/span> number;<\/span>
\n            number[<\/span>"number"<\/span>]<\/span> =<\/span> json::<\/span>value<\/span>::<\/span>number<\/span>(<\/span>numbers[<\/span>i]<\/span>)<\/span>;<\/span>
\n            jsonNumbers.push_back<\/span>(<\/span>number)<\/span>;<\/span>
\n        }<\/span>
\n        json::<\/span>value<\/span> generatedNumberList;<\/span>
\n        generatedNumberList[<\/span>"numbers"<\/span>]<\/span> =<\/span> json::<\/span>value<\/span>::<\/span>array<\/span>(<\/span>jsonNumbers)<\/span>;<\/span>
\n        message.reply<\/span>(<\/span>status_codes::<\/span>OK<\/span>,generatedNumberList)<\/span>;<\/span>
\n    }<\/span>
\n    else<\/span> {<\/span>
\n        if<\/span>(<\/span>path[<\/span>0<\/span>]<\/span>==<\/span>"avg"<\/span>)<\/span> {<\/span>
\n            float<\/span> avg =<\/span> calculateSum(<\/span>)<\/span>\/<\/span>numbers.size<\/span>(<\/span>)<\/span>;<\/span>
\n            json::<\/span>value<\/span> number;<\/span>
\n            number[<\/span>"avg"<\/span>]<\/span> =<\/span> json::<\/span>value<\/span>::<\/span>number<\/span>(<\/span>avg)<\/span>;<\/span>
\n            message.reply<\/span>(<\/span>status_codes::<\/span>OK<\/span>,number)<\/span>;<\/span>
\n        }<\/span>
\n        else<\/span> if<\/span>(<\/span>path[<\/span>0<\/span>]<\/span>==<\/span>"sum"<\/span>)<\/span> {<\/span>
\n            float<\/span> sum =<\/span> calculateSum(<\/span>)<\/span>;<\/span>
\n            json::<\/span>value<\/span> number;<\/span>
\n            number[<\/span>"sum"<\/span>]<\/span> =<\/span> json::<\/span>value<\/span>::<\/span>number<\/span>(<\/span>sum)<\/span>;<\/span>
\n            message.reply<\/span>(<\/span>status_codes::<\/span>OK<\/span>,number)<\/span>;<\/span>
\n        }<\/span>
\n        else<\/span> {<\/span>
\n            message.reply<\/span>(<\/span>status_codes::<\/span>BadRequest<\/span>)<\/span>;<\/span>
\n        }<\/span>
\n    }<\/span>
\n}<\/span><\/div><\/td><\/tr><\/tbody><\/table><\/div>\n\n\n\n\n
Ciekawe rzeczy zaczynaj\u0105 si\u0119 od metody handleGet, kt\u00f3ra ma obs\u0142u\u017cy\u0107 \u017c\u0105danie GET do naszego API. Przyj\u0119li\u015bmy, \u017ce wys\u0142anie zapytania GET pod adres bez \u017cadnych argument\u00f3w zwr\u00f3ci nam list\u0119 liczb zapisanych w kontenerze numbers. Je\u015bli dodamy do adresu avg, to zostanie zwr\u00f3cona \u015brednia, a je\u015bli sum \u2013 to suma. Aby rozpozna\u0107 ka\u017cd\u0105 z tych sytuacji, wykorzystujemy metod\u0119 requestPath, kt\u00f3rej implementacj\u0119 omawia\u0142em wcze\u015bniej. W kolejnej linijce sprawdzamy, jak\u0105 wersj\u0119 zapytania wybra\u0142 u\u017cytkownik. Je\u015bli nic nie dopisa\u0142 do adresu naszego API, to znaczy \u017ce powinni\u015bmy mu zwr\u00f3ci\u0107 liczby zapisane w kontenerze.<\/p>\n\n\n\n
REST API zwykle zwraca wyniki swojej pracy w formie JSON. Musimy takiego JSON\u2019a stworzy\u0107. Kreujemy sobie kontener przechowuj\u0105cy jakie\u015b warto\u015bci (json::value) o nazwie jsonNumbers. Potem w p\u0119tli przechodzimy przez wszystkie elementy kontenera przechowuj\u0105cego nasze liczby, konstruujemy zawarto\u015b\u0107 \u201ewn\u0119trza\u201d tablicy, w kt\u00f3rej znajduje si\u0119 tylko liczba z danego obiegu p\u0119tli. Powsta\u0142y obiekt json::value dopisujemy do wcze\u015bniej utworzonej kolekcji number.<\/p>\n\n\n\n
Gdy p\u0119tla sko\u0144czy swoj\u0105 prac\u0119, musimy jeszcze konwertowa\u0107 kontener vector na tablic\u0119 JSON. Robi\u0105 to linijki 26 i 27. W linijce 28 wysy\u0142amy odpowied\u017a do u\u017cytkownika.<\/p>\n\n\n\n
A co, je\u015bli u\u017cytkownik chcia\u0142by pozna\u0107 \u015bredni\u0105 przechowywanych przez serwer liczb? Ten przypadek jest o wiele prostszy. Zwracamy tylko jedn\u0105 warto\u015b\u0107, wi\u0119c nie musimy bawi\u0107 si\u0119 w \u017cadne p\u0119tle czy tablice. Po prostu obliczamy \u015bredni\u0105. Tworzymy obiekt json::value number, kt\u00f3ry b\u0119dzie przechowywa\u0142 liczb\u0119, kt\u00f3r\u0105 zwr\u00f3cimy. Pod nazw\u0105 avg zapisujemy w nim obliczon\u0105 \u015bredni\u0105. Ostatecznie zwracamy wynik naszych dzia\u0142a\u0144 za pomoc\u0105 message.reply. Analogicznie wygl\u0105da obs\u0142uga sumy.<\/p>\n\n\n\n
Co, je\u015bli u\u017cytkownik rozszerzy zapytanie o co\u015b innego ni\u017c avg czy sum? Odpowiadamy mu, \u017ce zrobi\u0142 co\u015b \u017ale \u2013 linijka 43.<\/p>\n\n\n\n\n
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
<\/div><\/td>
void<\/span> Service::<\/span>handlePut<\/span>(<\/span>http_request message)<\/span> {<\/span>
\n    message.extract_json<\/span>(<\/span>)<\/span>.then<\/span>(<\/span>[<\/span>=<\/span>]<\/span>(<\/span>pplx::<\/span>task<\/span><<\/span>json::<\/span>value<\/span>><\/span> task)<\/span>
\n    {<\/span>
\n        try<\/span>
\n        {<\/span>
\n            json::<\/span>value<\/span> val =<\/span> task.get<\/span>(<\/span>)<\/span>;<\/span>
\n            int<\/span> number =<\/span> val[<\/span>U(<\/span>"number"<\/span>)<\/span>]<\/span>.as_number<\/span>(<\/span>)<\/span>.to_int32<\/span>(<\/span>)<\/span>;<\/span>
\n            numbers.push_back<\/span>(<\/span>number)<\/span>;<\/span>
\n            message.reply<\/span>(<\/span>status_codes::<\/span>OK<\/span>)<\/span>;<\/span>
\n        }<\/span>
\n        catch<\/span>(<\/span>std::<\/span>exception<\/span>&<\/span> e)<\/span> {<\/span>
\n            message.reply<\/span>(<\/span>status_codes::<\/span>BadRequest<\/span>)<\/span>;<\/span>
\n        }<\/span>
\n    }<\/span>)<\/span>;<\/span>
\n}<\/span><\/div><\/td><\/tr><\/tbody><\/table><\/div>\n\n\n\n\n
Zajmijmy si\u0119 teraz dodawaniem nowych liczb \u2013 metoda handlePut. W linijce 45 widzimy tajemniczy zapis: message.extract_json().then([=](pplx::task<json::value> task)<\/strong>. Korzystamy tu z mechanizmu \u201easynchroniczno\u015bci\u201d wprowadzonego w jednym z najnowszych standard\u00f3w C++. To, co znajduje si\u0119 poni\u017cej w nawiasach klamrowych jest wykonywane \u201etak jakby\u201d w oddzielnym w\u0105tku.<\/p>\n\n\n\n
Widzisz blok try,catch. Do czego on mo\u017ce s\u0142u\u017cy\u0107? Oczywi\u015bcie, do obs\u0142ugi sytuacji wyj\u0105tkowych. Nie mogli\u015bmy go pomin\u0105\u0107, gdy\u017c u\u017cytkownik mo\u017ce w ciele zapytania wpisa\u0107 jakie\u015b nieprawid\u0142owe dane. Mo\u017ce si\u0119 te\u017c zwyczajnie pomyli\u0107. Mimo przyj\u0119cia nieprawid\u0142owego zapytania, nasz serwer powinien kontynuowa\u0107 prac\u0119. W\u0142a\u015bnie dlatego zastosowali\u015bmy obs\u0142ug\u0119 wyj\u0105tk\u00f3w. Je\u015bli cia\u0142o zapytania b\u0119dzie posiada\u0142o b\u0142\u0119dy, rzucimy u\u017cytkownikowi BadRequestem. Z pewno\u015bci\u0105 to mu u\u015bwiadomi, \u017ce zrobi\u0142 co\u015b \u017ale.<\/p>\n\n\n\n
Je\u015bli wszystkie dane zosta\u0142y prawid\u0142owo wprowadzone, obs\u0142ugujemy zapytanie. Nie mamy wiele roboty. Odczytujemy zmienn\u0105 number z otrzymanego \u201ecia\u0142a\u201d JSON i zapisujemy j\u0105 do zmiennej number w naszym programie. T\u0119 liczb\u0119 dodajemy do kontenera i odpowiadamy u\u017cytkownikowi, \u017ce operacja si\u0119 powiod\u0142a.<\/p>\n\n\n\n
Main.cpp<\/h2>\n\n\n\n
Om\u00f3wili\u015bmy ju\u017c budow\u0119 ca\u0142ego serwera, a jeszcze nie powiedzieli\u015bmy nic o najwa\u017cniejszej rzeczy – jak go uruchomi\u0107. No c\u00f3\u017c, zostawi\u0142em ten element na sam koniec gdy\u017c nie ma tu specjalnej filozofii. Sp\u00f3jrz na poni\u017cszy kawa\u0142ek kodu.<\/p>\n\n\n\n\n
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<\/div><\/td>
#include <iostream><\/span>
\n#include "Service.h"<\/span>
\nusing<\/span> namespace<\/span> std;<\/span>
\n
\nint<\/span> main(<\/span>)<\/span>
\n{<\/span>
\n    Service serv(<\/span>"127.0.0.1"<\/span>,"8080"<\/span>)<\/span>;<\/span>
\n    serv.setEndpoint<\/span>(<\/span>"\/api"<\/span>)<\/span>;<\/span>
\n    serv.accept<\/span>(<\/span>)<\/span>.wait<\/span>(<\/span>)<\/span>;<\/span>
\n    while<\/span>(<\/span>1<\/span>==<\/span>1<\/span>)<\/span>
\n    {<\/span>
\n        sleep(<\/span>1000<\/span>)<\/span>;<\/span>
\n    }<\/span>
\n    return<\/span> 0<\/span>;<\/span>
\n}<\/span><\/div><\/td><\/tr><\/tbody><\/table><\/div>\n\n\n\n\n
Dos\u0142ownie kilka linijek. Includujemy sobie plik „Service.h” kt\u00f3ry zawiera kod naszej us\u0142ugi. Tworzymy sobie obiekt tej klasy, podaj\u0105c mu jako argument adres i port. Ustawiamy nast\u0119pnie za pomoc\u0105 omawianej wcze\u015bniej funkcji setEndpoint pod jakim adresem ma by\u0107 widoczna ta us\u0142uga. W ko\u0144cu uruchamiamy serwer za pomoc\u0105 metody accept().
Jedynym elementem, kt\u00f3ry m\u00f3g\u0142by wzbudzi\u0107 w\u0105tpliwo\u015bci jest ta p\u0119tla, kt\u00f3ra znajduje si\u0119 na samym ko\u0144cu. Po co ona? serv.accept().wait() jest wywo\u0142aniem nieblokuj\u0105cym. Oznacza to, \u017ce program dalej kontynuowa\u0142by swoje dzia\u0142anie, gdy\u017c serwer uruchamia si\u0119 w oddzielnym w\u0105tku. Gdyby p\u0119tli nie by\u0142o, program natychmiast zako\u0144czy\u0142by swoje dzia\u0142anie. Aby nie marnowa\u0107 czasu procesora, umie\u015bci\u0142em w p\u0119tli wywo\u0142anie funkcji sleep na dosy\u0107 d\u0142ugi okres czasu.<\/p>\n\n\n\n
Nasze API dzia\u0142a!<\/h1>\n\n\n\n
To tyle. Nasze API jest funkcjonalne i prawid\u0142owo reaguje na pro\u015bby u\u017cytkownika. Nie zawiesi si\u0119 te\u017c, gdy wprowadzone zostan\u0105 nieprawid\u0142owe dane.<\/p>\n\n\n\n
\"\"
Dodawanie nowych liczb<\/figcaption><\/figure><\/div>\n\n\n\n
\"\"
Pobieranie sumy<\/figcaption><\/figure><\/div>\n\n\n\n
Z pewno\u015bci\u0105 chcia\u0142by\u015b przetestowa\u0107, jak ono pracuje. S\u0142u\u017cy do tego specjalna aplikacja Postman, kt\u00f3r\u0105 mo\u017cesz pobra\u0107 ze sklepu z aplikacjami dla Google Chrome. Obs\u0142uga jest intuicyjna. Niemniej, w niedalekiej przysz\u0142o\u015bci zajm\u0119 si\u0119 dok\u0142adniejszym opisaniem tego wspania\u0142ego programu.<\/p>\n\n\n\n
W swoim zakresie spr\u00f3buj rozszerzy\u0107 powy\u017cszy program o obs\u0142ug\u0119 usuwania liczb. Mo\u017cesz to zrobi\u0107 na dwa sposoby: albo odczytywa\u0107 z liczb\u0119\/indeks liczby do usuni\u0119cia z cia\u0142a metody JSON, albo przekazywa\u0107 \u017c\u0105danie przez URL.<\/p>\n\n\n\n
Kod omawiany w tym artykule znajduje si\u0119 w moim repozytorium na Githubie. (o w\u0142a\u015bnie tutaj!) <\/a><\/p>\n\n\n\n
Na dzisiaj to tyle. Do zobaczenia \ud83d\ude42 Zapraszam do czytania moich kolejnych artyku\u0142\u00f3w.<\/p>\n","protected":false},"excerpt":{"rendered":"
Czas czytania:<\/span> 5<\/span> minut<\/span><\/span> Przed lektur\u0105Aby\u015b zrozumia\u0142 tre\u015b\u0107 tego wpisu by\u0142oby dobrze, aby\u015b wiedzia\u0142 co to jest REST API oraz do czego ono s\u0142u\u017cy. W tre\u015bci tego wpisu nie b\u0119d\u0119 si\u0119 rozwodzi\u0142 nad tym …<\/p>\n","protected":false},"author":1,"featured_media":298,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"footnotes":""},"categories":[31],"tags":[],"_links":{"self":[{"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/posts\/270"}],"collection":[{"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/comments?post=270"}],"version-history":[{"count":37,"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/posts\/270\/revisions"}],"predecessor-version":[{"id":1205,"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/posts\/270\/revisions\/1205"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/media\/298"}],"wp:attachment":[{"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/media?parent=270"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/categories?post=270"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/tags?post=270"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}