{"id":5481,"date":"2020-03-13T17:55:16","date_gmt":"2020-03-13T16:55:16","guid":{"rendered":"https:\/\/infoshareacademy.com\/?p=5481"},"modified":"2021-01-12T08:59:53","modified_gmt":"2021-01-12T07:59:53","slug":"klient-http-i-obsluga-api-czesc-i","status":"publish","type":"post","link":"https:\/\/infoshareacademy.com\/blog\/klient-http-i-obsluga-api-czesc-i\/","title":{"rendered":"Klient HTTP i obs\u0142uga API – cz\u0119\u015b\u0107 I"},"content":{"rendered":"

Jako programista Javy pr\u0119dzej czy p\u00f3\u017aniej b\u0119dziesz musia\u0142 zacz\u0105\u0107 komunikowa\u0107 si\u0119 ze \u015bwiatem zewn\u0119trznym. Spokojnie, spokojnie. Chodzi mi tylko o Twoj\u0105 aplikacj\u0119.<\/strong><\/p>\n

\"mem<\/figure>\n

W dobie wszechobecnego internetu, kiedy Twoja kom\u00f3rka bez sieci jest praktycznie bezu\u017cyteczna, kiedy \u201ctaks\u00f3wkarz\u201d gubi si\u0119 bez Google Maps, kiedy hulajnogi zatrzymuj\u0105 si\u0119 po utracie sygna\u0142u, kiedy wkr\u00f3tce Twoja pralka b\u0119dzie rozmawia\u0107 z Twoj\u0105 lod\u00f3wk\u0105, Twoja aplikacja r\u00f3wnie\u017c pr\u0119dzej czy p\u00f3\u017aniej b\u0119dzie musia\u0142a wysy\u0142a\u0107 zapytania do innych.<\/p>\n

Ten artyku\u0142 jest pierwszym z serii, kt\u00f3ry ma na celu pokaza\u0107 Ci, w jaki spos\u00f3b korzysta\u0107 z API przy pomocy klienta HTTP z Javy 11. Zaczniemy od bardzo prostego zapytania, kt\u00f3re zwr\u00f3ci nam prosty tekst, kt\u00f3ry wy\u015bwietlimy w konsoli. Stara\u0142em si\u0119 opisa\u0107 wszystkie kroki bardzo szczeg\u00f3\u0142owo, kolejne cz\u0119\u015bci b\u0119d\u0105 stopniowo trudniejsze z racji zar\u00f3wno bardziej skomplikowanych zapyta\u0144, jak i mniejszej ilo\u015bci wyja\u015bnie\u0144. Niezrozumia\u0142e fragmenty zawsze jednak z ch\u0119ci\u0105 wyja\u015bni\u0119 w komentarzu.<\/p>\n

API – czym w\u0142a\u015bciwie jest?<\/h2>\n

Nie b\u0119d\u0119 si\u0119 tutaj sili\u0142 na jak najbardziej precyzyjn\u0105 definicj\u0119 API, bo to wymaga\u0142oby oddzielnego artyku\u0142u, kt\u00f3ry by\u0142by do\u015b\u0107 suchy i niezbyt ciekawy. Interesuj\u0105ce, czym jest API, kiedy m\u00f3wi o nim programista backendowy w \u015brodowisku webowym.<\/p>\n

Tak w uproszczeniu i telegraficznym skr\u00f3cie – jest to cz\u0119\u015b\u0107 serwera, pod kt\u00f3ry mo\u017cemy wys\u0142a\u0107 nasze zapytanie (request) i dostaniemy odpowied\u017a (response) w postaci czystych danych, bez zb\u0119dnej otoczki. Czyli bez szaty graficznej, bez HTML itd. Z regu\u0142y to nie my – ludzie – jeste\u015bmy odbiorc\u0105 tych danych, ale nasza aplikacja, kt\u00f3ra te dane odpowiednio przetwarza i wy\u015bwietla w formie nam przyst\u0119pnej. Co wi\u0119cej, celem naszego zapytania mo\u017ce by\u0107 nie tylko otrzymanie danych, ale r\u00f3wnie\u017c ich wys\u0142anie.<\/p>\n

Wiele firm wystawia takie API. Google do t\u0142umacze\u0144<\/a>, gdzie mo\u017cesz wys\u0142a\u0107 tekst w jednym j\u0119zyku i otrzyma\u0107 w drugim. Aplikacje pogodynek<\/a> korzystaj\u0105 z API, aby otrzyma\u0107 czyste dane dotycz\u0105ce pogody i wy\u015bwietli\u0107 je w postaci s\u0142oneczek i chmurek. Samochody Tesli<\/a> wystawiaj\u0105 API, dzi\u0119ki kt\u00f3remu mo\u017cliwe jest sterowanie cz\u0119\u015bci\u0105 funkcji samochodu – cho\u0107 dokumentacja jest nieoficjalna. Wiele z nich jest p\u0142atne i wymaga autoryzacji, kt\u00f3ra mo\u017ce si\u0119 na pocz\u0105tek wydawa\u0107 skomplikowana. Ca\u0142e szcz\u0119\u015bcie jest te\u017c wiele darmowych, kt\u00f3re zosta\u0142y zebrane i skategoryzowane na tej li\u015bcie<\/a>.<\/p>\n

My\u015blisz o rozpocz\u0119ciu nauki?<\/span><\/span><\/p>\n

Sprawd\u017a zdalny kurs Junior Java Developer z trenerem na \u017bYWO<\/a><\/p>\n<\/div>\n

API nie musi wcale by\u0107 wystawiane \u201cna zewn\u0105trz\u201d. Dzisiejsze aplikacje internetowe s\u0105 tak du\u017ce, \u017ce cz\u0119sto dzielone s\u0105 na tak zwane mikroserwisy, kt\u00f3re porozumiewaj\u0105 si\u0119 mi\u0119dzy sob\u0105 za pomoc\u0105 swoich API w obr\u0119bie serwera. Je\u017celi planujesz zacz\u0105\u0107 komercyjn\u0105 prac\u0119 w wi\u0119kszym projekcie, to nie obejdziesz si\u0119 bez umiej\u0119tno\u015bci obs\u0142ugi tego typu zapyta\u0144.<\/p>\n

Http Client<\/h2>\n

Podstawow\u0105 klas\u0105, z kt\u00f3rej b\u0119dziemy korzysta\u0107 w tym artykule i kolejnych w tej serii jest HttpClient. Do\u0142\u0105czy\u0142a do Javy w inkubatorze w wersji 9, a jako standardowa cz\u0119\u015b\u0107 JDK w wersji 11. Jest ona nast\u0119pc\u0105 HttpURLConnection, kt\u00f3ra z racji skomplikowanego u\u017cycia przewa\u017cnie zast\u0119powana by\u0142a zewn\u0119trznymi bibliotekami. Po przeczytaniu artyku\u0142u, polecam wyszuka\u0107 spos\u00f3b u\u017cycia poprzedniczki, by przekona\u0107 si\u0119 jak bardzo tw\u00f3rcy Javy upro\u015bcili programistom \u017cycie.<\/p>\n

Plain text – Lorem ipsum generator<\/h2>\n

W tym artykule skorzystamy z API generatora Lorem ipsum<\/a>. Czym jest Lorem ipsum<\/a>? W skr\u00f3cie – to nic nie znacz\u0105cy fragment tekstu, stosowany jako \u201cwype\u0142niacz\u201d na wzorach stron internetowych, plakat\u00f3w i innego rodzaju grafik. Dla nas istotne jest to, \u017ce API zwraca nam prosty tekst – \u201cplain text\u201d.<\/p>\n

Lorem ipsum – dokumentacja<\/h2>\n

Od czego zaczynamy? Oczywi\u015bcie – od przeczytania dokumentacji! Ta znajduje si\u0119 na samym dole strony https:\/\/loripsum.net i m\u00f3wi:<\/p>\n

How to use the API\nJust do a GET request on loripsum.net\/api, to get some placeholder text. You can add extra parameters to specify the output you're going to get. Say, you need 10 short paragraphs with headings, use loripsum.net\/api\/10\/short\/headers.\n\n(integer) - The number of paragraphs to generate.\nshort, medium, long, verylong - The average length of a paragraph.\ndecorate - Add bold, italic and marked text.\nlink - Add links.\nul - Add unordered lists.\nol - Add numbered lists.\ndl - Add description lists.\nbq - Add blockquotes.\ncode - Add code samples.\nheaders - Add headers.\nallcaps - Use ALL CAPS.\nprude - Prude version.\nplaintext - Return plain text, no HTML.<\/pre>\n
Czego si\u0119 z niej dowiedzieli\u015bmy? Po pierwsze – adres strony, kt\u00f3r\u0105 musimy odwiedzi\u0107, by dosta\u0107 tylko interesuj\u0105cy nas tekst, bez ca\u0142ej otoczki strony internetowej – \u201cloripsum.net\/api\u201d<\/a>. Mo\u017cemy go odwiedzi\u0107 r\u00f3wnie\u017c w przegl\u0105darce internetowej. Co si\u0119 pod nim znajduje? Tekst, ale ze znacznikami HTML oznaczaj\u0105cymi nowy paragraf – \u201c<p>\u201d. Nie jest to nam do niczego potrzebne. Na ca\u0142e szcz\u0119\u015bcie zapytanie mo\u017cemy sparametryzowa\u0107.<\/p>\n
Odwied\u017amy wi\u0119c przyk\u0142adowy adres z parametrami podany w dokumentacji – \u201cloripsum.net\/api\/10\/short\/headers\u201d<\/a>. Co powinni\u015bmy dosta\u0107? 10 kr\u00f3tkich akapit\u00f3w i nag\u0142\u00f3wki. Zgadza si\u0119 – je\u017celi we\u017amiemy pod uwag\u0119, \u017ce nag\u0142\u00f3wki nie wliczaj\u0105 si\u0119 do liczby akapit\u00f3w. Ale takie zapytanie te\u017c nas nie interesuje. My chcemy prosty, kr\u00f3tki tekst bez znacznik\u00f3w, kt\u00f3ry \u0142atwo wy\u015bwietlimy w konsoli. Jeden akapit nam starczy. Jaki adres wpiszemy? Po spojrzeniu do dokumentacji, mo\u017cemy stworzy\u0107 co\u015b takiego: loripsum.net\/api\/1\/short\/plaintext<\/a>.<\/p>\n
Lorem ipsum – implementacja<\/h2>\n
Najtrudniejsza cz\u0119\u015b\u0107 za nami, teraz czas to \u201ctylko\u201d zaimplementowa\u0107 ????!<\/p>\n
Boilerplate code<\/strong><\/p>\n
Na pocz\u0105tek stw\u00f3rzmy \u201cwydmuszk\u0119\u201d prostej klasy Main. W polu \u201cLOREM_URL\u201d b\u0119dziemy przechowywa\u0107 interesuj\u0105cy nas adres API, w standardowej metodzie #main b\u0119dziemy wy\u015bwietla\u0107 Stringa, kt\u00f3rego otrzymamy z metody #getLoremIpsum. Ta ostatnia metoda b\u0119dzie zawiera\u0142a ca\u0142\u0105 nasz\u0105 implementacj\u0119 w miejscu komentarza, kt\u00f3ry znajduje si\u0119 w poni\u017cszym kodzie.<\/p>\n
Spaghetti code<\/h2>\n
Pisanie takiego proceduralnego kodu, gdzie wszystko odbywa si\u0119 linijka po linijce, nie jest uznawane za dobr\u0105 praktyk\u0119 w j\u0119zykach obiektowych (jakim jest Java).<\/p>\n
Przez zwolennik\u00f3w czystego kodu wy\u015bmiewane jest jako \u201cspaghetti code\u201d. I s\u0142usznie! W nast\u0119pnych artyku\u0142ach z tej serii skupimy si\u0119 na lepszej enkapsulacji logiki w klasach. Je\u017celi na rekrutacji dostaniesz dostatecznie du\u017co czasu na wykonanie zadania, r\u00f3wnie\u017c nie poleca\u0142bym Ci pisa\u0107 kodu w ten spos\u00f3b. Tym razem jednak, z racji tego, \u017ce kod kt\u00f3ry dzi\u015b napiszemy jest do\u015b\u0107 kr\u00f3tki, a tak\u017ce by przejrzy\u015bcie pokaza\u0107 kolejne kroki, pozwolimy sobie na to.<\/p>\n
Drugim grzechem, kt\u00f3ry pope\u0142nimy, jest dodanie do sygnatury metody \u201cthrows Exception\u201d. Jedna z metod, kt\u00f3re wykorzystamy, rzuca wyj\u0105tki i normalnie powinni\u015bmy je odpowiednio obs\u0142u\u017cy\u0107. Nie zrobimy tego, gdy\u017c nasz \u201cspaghetti code\u201d by\u0142by przez to troch\u0119 mniej czytelny, czego chcia\u0142bym unikn\u0105\u0107. Drugim powodem jest to, by zrobi\u0107 to lege artis, musia\u0142bym si\u0119 troch\u0119 rozpisa\u0107 o wyj\u0105tkach, ich rodzajach oraz obs\u0142udze, a nie jest to tematem tego artyku\u0142u. Warto jednak przyswoi\u0107 sobie t\u0119 wiedz\u0119 z innych \u017ar\u00f3de\u0142 i na rekrutacji, w miar\u0119 mo\u017cliwo\u015bci, wykaza\u0107 si\u0119 ni\u0105.<\/p>\n
public class Main {\n    private static final String LOREM_URL =\n                        \"https:\/\/loripsum.net\/api\/1\/short\/plaintext\";\n\n    public static void main(String[] args) throws Exception {\n        System.out.println(getLoremIpsum());\n    }\n\n    private static String getLoremIpsum() throws Exception {\n        \/\/ todo: implement me!\n        return null;\n    }\n}<\/pre>\n
HttpClient<\/strong><\/h2>\n
Najwy\u017cszy czas stworzy\u0107 klienta HTTP! Odruchowo chcia\u0142oby si\u0119 u\u017cy\u0107 konstruktora i zainicjalizowa\u0107 naszego HttpClient przez u\u017cycie s\u0142owa kluczowego \u201cnew\u201d:<\/p>\n
HttpClient client = new HttpClient();<\/pre>\n
Jest to jednak niemo\u017cliwe! Klasa ta jest klas\u0105 abstrakcyjn\u0105, wi\u0119c nie mo\u017cemy stworzy\u0107 jej instancji. Jednak po wpisaniu kropki po jej nazwie IDE podpowiada nam, \u017ce s\u0105 dost\u0119pne dwie metody:<\/p>\n
HttpClient.newHttpClient()\nHttpClient.newBuilder()\n<\/pre>\n
Pierwsza z nich to statyczna metoda fabrykuj\u0105ca zwracaj\u0105ca nam klas\u0119 implementuj\u0105c\u0105 HttpClient posiadaj\u0105cego domy\u015bln\u0105 konfiguracj\u0119. W skr\u00f3cie – dostajemy to, co chcemy – prostego klienta HTTP. Druga metoda zwraca nam klas\u0119 buduj\u0105c\u0105 – buildera, kt\u00f3ry umo\u017cliwi nam dodatkow\u0105 konfiguracj\u0119 naszego klienta, je\u017celi b\u0119dzie to potrzebne. Na razie domy\u015blny klient Http nam starczy, wi\u0119c u\u017cywamy tej pierwszej.<\/p>\n
HttpRequest<\/strong><\/h2>\n
Przygotujmy teraz zapytanie, kt\u00f3re wy\u015ble nasz klient. Zapytanie to po angielsku request, wi\u0119c mia\u0142oby sens, gdyby potrzebna nam klasa nazywa\u0142a si\u0119 HttpRequest. I tak faktycznie jest! Ach, jak przyjemnie korzysta\u0107 z bibliotek, kt\u00f3re maj\u0105 dok\u0142adnie takie nazwy jakich si\u0119 spodziewasz. Zabieramy si\u0119 za stworzenie instancji i ponownie nie mo\u017cemy zrobi\u0107 tego przez konstruktor. Jakie podpowiedzi daje nam IDE?<\/p>\n
HttpRequest.newBuilder()\nHttpRequest.newBuilder(URI uri)\n<\/pre>\n
Nie ma .newHttpRequest? C\u00f3\u017c, brak domy\u015blnego zapytania ma sens, w ko\u0144cu za ka\u017cdym razem jak je tworzymy, b\u0119dziemy chcieli pewnie uderza\u0107 do innego adresu. Skorzystamy, wi\u0119c z metody, kt\u00f3ra umo\u017cliwi nam skonfigurowanie requestu, zanim go utworzymy, dzi\u0119ki wykorzystaniu wzorca projektowego budowniczy – builder. Tym razem u\u017cyjemy pierwszej, bezparametrowej metody.<\/p>\n
HttpRequest request = HttpRequest.newBuilder();<\/pre>\n
Po napisaniu powy\u017cszego kodu IDE krzyczy, \u017ce typ si\u0119 nie zgadza. Dlaczego? Metoda newBuilder zwraca nam w ko\u0144cu buildera, nie HttpRequest. Musimy wi\u0119c zmieni\u0107 nasz\u0105 deklaracj\u0119 na nast\u0119puj\u0105c\u0105:<\/p>\n
HttpRequest.Builder builder = HttpRequest.newBuilder();<\/pre>\n
Czas teraz skonfigurowa\u0107 nasze zapytanie. Pierwsze co zrobimy, to dodanie adresu naszego zapytania:<\/p>\n
builder.uri(\"https:\/\/loripsum.net\/api\/1\/plaintext\");<\/pre>\n
Co dalej?<\/h2>\n
I zn\u00f3w IDE krzyczy, \u017ce co\u015b jest nie tak. Tym razem z typem parametru. Kompilator chcia\u0142by URI, a my dali\u015bmy Stringa. Jak stworzy\u0107 URI? Sprawd\u017amy, co nam podpowie IDE po kropce:<\/p>\n
URI.create(String str)<\/pre>\n
Po raz kolejny autorzy popisali si\u0119 nazewnictwem! Chcesz stworzy\u0107 URI? Masz metod\u0119 URI create. Jeste\u015bmy te\u017c w stanie stworzy\u0107 ten obiekt poprzez konstruktor, ale on rzuca wyj\u0105tek typu checked, kt\u00f3ry musieliby\u015bmy obs\u0142u\u017cy\u0107. A jak wspomina\u0142em wcze\u015bniej, nie b\u0119dziemy tym razem zajmowa\u0107 si\u0119 obs\u0142ug\u0105 wyj\u0105tk\u00f3w. Dodam tylko, \u017ce po spojrzeniu w \u017ar\u00f3d\u0142a mo\u017cemy zobaczy\u0107, \u017ce metoda create pod spodem korzysta z konstruktora i tylko opakowuje wyj\u0105tek w taki, kt\u00f3rego nie musimy obs\u0142u\u017cy\u0107. Tak\u017ce wci\u0105\u017c istnieje ryzyko, \u017ce taki wyj\u0105tek poleci.<\/p>\n
W ramach zasady czystego kodu – \u201cno magic numbers\u201d – umie\u015bcili\u015bmy przezornie nasz adres w statycznym i finalnym polu o nazwie LOREM_URL, mo\u017cemy wi\u0119c go tutaj u\u017cy\u0107.<\/p>\n
URI loremUri = URI.create(LOREM_URL);<\/pre>\n
Pozostaje nam przekazanie tego obiektu naszemu budowniczemu:<\/p>\n
builder.uri(loremUri);<\/pre>\n
Zanim zako\u0144czymy budow\u0119 naszego zapytania, chcia\u0142bym \u017ceby\u015bmy dodali jeszcze jedn\u0105 konfiguracj\u0119. W dokumentacji mamy wzmiank\u0119 o tym, \u017ce nasz request ma wykorzystywa\u0107 metod\u0119 GET. Jest to co prawda domy\u015blna metoda zapytania, ale chcia\u0142bym \u017ceby\u015bmy przyzwyczaili si\u0119 do samej nazwy i nie zdziwi\u0142o nas, gdy innym razem zostaniemy poproszeni o u\u017cycie innej – jak POST, czy DELETE. Jak to zrobimy? Ponownie autorzy stan\u0119li na wysoko\u015bci zadania – metod\u0105 GET.<\/p>\n
builder.GET();<\/pre>\n
Przeczytaj tak\u017ce:
\nCzy po wielu latach w innym zawodzie mo\u017cna zosta\u0107 Java Developerem?<\/a><\/span><\/div>\n
Co z zapytaniem?<\/h2>\n
Na tym ko\u0144czymy nasz\u0105 konfiguracj\u0119, ale gdzie jest nasze zapytanie? Jeszcze nie powsta\u0142o. W ko\u0144cu nie powiedzieli\u015bmy naszemu budowniczemu, \u017ceby nam je zbudowa\u0142. Jak to zrobimy? Pewnie si\u0119 ju\u017c domy\u015blacie – budowniczy zbuduj.<\/p>\n
HttpRequest request = builder.build();<\/pre>\n
Tym razem w ko\u0144cu zwr\u00f3cone zostanie nasze zapytanie. B\u0119dzie ono niemutowalne (ang. immutable), co oznacza, \u017ce nie b\u0119dziemy w stanie go edytowa\u0107. By uderzy\u0107 do innego adresu, albo z inn\u0105 metod\u0105 – b\u0119dziemy musieli stworzy\u0107 nowe. Jak teraz wygl\u0105da nasz kod?<\/p>\n
URI uri = URI.create(LOREM_URL);\nHttpRequest.Builder builder = HttpRequest.newBuilder();\nbuilder.uri(uri);\nbuilder.GET();\nHttpRequest request = builder.build();\n\n<\/pre>\n
Dwie metody, kt\u00f3rych u\u017cywamy nie maj\u0105 \u017cadnej deklaracji. Co one zwracaj\u0105? R\u00f3wnie\u017c naszego buildera. Oznacza to, \u017ce mogliby\u015bmy to zapisa\u0107 w spos\u00f3b nast\u0119puj\u0105cy:<\/p>\n
HttpRequest.Builder builder;\nbuilder = HttpRequest.newBuilder();\nbuilder = builder.uri(uri);\nbuilder = builder.GET();\n<\/pre>\n
Ale zaraz, skoro w jednej linii zwracamy buildera, a w nast\u0119pnej si\u0119 do niego zn\u00f3w odwo\u0142ujemy\u2026 To czy nie mogliby\u015bmy zrobi\u0107 tego w jednej linii? Bez \u015brednik\u00f3w?<\/p>\n
HttpRequest.Builder builder = HttpRequest.newBuilder().uri(uri).GET();<\/pre>\n
Jasne! Co wi\u0119cej, w og\u00f3le nie musimy deklarowa\u0107 naszego budowniczego! W ko\u0144cu jest on nam potrzebny jedynie tymczasowo. To czego b\u0119dziemy potrzebowa\u0107, to request, kt\u00f3re zwr\u00f3ci nam ostatnia metoda – build. W ramach czytelno\u015bci rozbijemy tylko metody na oddzielne linie:<\/p>\n
HttpRequest request = HttpRequest.newBuilder()\n                                 .uri(loremUri)\n                                 .GET()\n                                 .build();\n<\/pre>\n
Deklarujemy tylko obiekt HttpRequest, kt\u00f3ry zwraca nam ostatnia metoda w naszym kombo – build. Pozosta\u0142e metody wci\u0105\u017c zwracaj\u0105 buildera, ale jako \u017ce od razu wywo\u0142ujemy na nim kolejne, nie ma potrzeby jego deklarowania. Ten rodzaj nazywany jest fluent builder i z uwagi na przejrzysto\u015b\u0107 jest bardzo cz\u0119sto wykorzystywany w nowoczesnych bibliotekach.<\/p>\n
HttpResponse<\/strong><\/h2>\n
Mamy klienta, mamy r\u00f3wnie\u017c zapytanie. Pozosta\u0142o je ju\u017c tylko wys\u0142a\u0107 i sprawdzi\u0107 odpowied\u017a! Jakie metody sugeruje nam IDE dla naszego klienta? Send wydaje si\u0119 sensowna:<\/p>\n
client.send(HttpRequest request,\n            HttpResponse.BodyHandler<T> responseBodyHandler)\n<\/pre>\n
Potrzebne s\u0105 nam dwa parametry, request ju\u017c mamy, ale czym jest BodyHandler?
\nOdpowied\u017a HTTP (response) sk\u0142ada si\u0119 z trzech cz\u0119\u015bci: statusu (status line), nag\u0142\u00f3wk\u00f3w (headers) i cia\u0142a (body). BodyHandler to obiekt, kt\u00f3ry pomo\u017ce nam obs\u0142u\u017cy\u0107 cia\u0142o odpowiedzi. My oczekujemy prostego tekstu, wi\u0119c potrzebujemy takiego, kt\u00f3ry obs\u0142u\u017cy nam Stringi. Jak go stworzy\u0107? Poprzez statyczn\u0105 metod\u0119 fabrykuj\u0105c\u0105:<\/p>\n
HttpResponse.BodyHandlers.ofString();<\/pre>\n
By zwi\u0119kszy\u0107 czytelno\u015b\u0107 kodu i m\u00f3c skorzysta\u0107 tylko z nazwy metody ofString pos\u0142u\u017cymy si\u0119 importem statycznym, kt\u00f3ry dodamy ponad deklaracj\u0105 klasy:<\/p>\n
import static java.net.http.HttpResponse.BodyHandlers.ofString;<\/pre>\n
Dzi\u0119ki czemu wys\u0142anie naszego zapytania b\u0119dzie wygl\u0105da\u0142o w spos\u00f3b nast\u0119puj\u0105cy:<\/p>\n
HttpResponse<String> response = client.send(request, ofString());<\/pre>\n
Je\u017celi IDE podkre\u015bla Ci t\u0119 metod\u0119, spowodowane jest to tym, \u017ce rzuca ona wyj\u0105tki, kt\u00f3re nale\u017cy obs\u0142u\u017cy\u0107. Jak wspomnia\u0142em na pocz\u0105tku, w tym artykule nie b\u0119d\u0119 porusza\u0142 tego tematu, dlatego do sygnatury metody doda\u0142em:<\/p>\n
throws Exception<\/pre>\n
Nale\u017cy jednak pami\u0119ta\u0107, \u017ce jest to obej\u015bcie problemu na potrzeby uproszczenia kodu w artykule, nie jego rozwi\u0105zanie, kt\u00f3re nale\u017ca\u0142oby stosowa\u0107 w kodzie produkcyjnym.
\nWr\u00f3\u0107my teraz do naszej odpowiedzi. Jak wspomina\u0142em wcze\u015bniej, sk\u0142ada si\u0119 ona z kilku cz\u0119\u015bci. Ta, na kt\u00f3rej nam obecnie zale\u017cy, to cia\u0142o. Wydobycie jej jest bardzo proste:<\/p>\n
response.body();<\/pre>\n
Rezultat<\/strong><\/h2>\n
I to ju\u017c wszystko! Po drobnych zmianach nasz kod ostatecznie b\u0119dzie wygl\u0105da\u0142 w spos\u00f3b nast\u0119puj\u0105cy:<\/p>\n
import java.net.URI;\nimport java.net.http.HttpClient;\nimport java.net.http.HttpRequest;\n\nimport static java.net.http.HttpResponse.BodyHandlers.ofString;\n\npublic class LoremMain {\n    private static final URI LOREM_URI =\n               URI.create(\"https:\/\/loripsum.net\/api\/1\/short\/plaintext\");\n\n    public static void main(String[] args) throws Exception {\n        System.out.println(getLoremIpsum());\n    }\n\n    private static String getLoremIpsum() throws Exception {\n        HttpClient client = HttpClient.newHttpClient();\n\n        HttpRequest request = HttpRequest.newBuilder()\n                .uri(LOREM_URI)\n                .GET()\n                .build();\n\n        return client.send(request, ofString())\n                .body();\n    }\n}<\/pre>\n
Pozosta\u0142o tylko uruchomi\u0107 metod\u0119 main i zobaczy\u0107 odpowied\u017a, kt\u00f3ra powinna si\u0119 wy\u015bwietli\u0107 w terminalu. Ja po pierwszym uruchomieniu otrzyma\u0142em:<\/p>\n
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duo Reges: constructio interrete. Quae cum dixisset, finem ille. Eaedem res maneant alio modo. Si longus, levis; Gerendus est mos, modo recte sentiat.<\/pre>\n
Twoja odpowied\u017a b\u0119dzie si\u0119 lekko r\u00f3\u017cni\u0142a, jako \u017ce API za ka\u017cdym razem generuj\u0119 inn\u0105. Jedynie pierwsze zdanie b\u0119dzie takie samo.<\/p>\n
Podsumowanie<\/h2>\n
Mam nadziej\u0119, \u017ce zgodzisz si\u0119 ze mn\u0105, \u017ce wysy\u0142anie zapyta\u0144 przy pomocy klienta HTTP jest \u0142atwe i przyjemne. Uda\u0142o si\u0119 nam to za pomoc\u0105 tylko kilku linijek kodu! Oczywi\u015bcie to dopiero pocz\u0105tek. Zapytanie kt\u00f3re otrzymali\u015bmy to by\u0142 jedynie prosty tekst. W nast\u0119pnych artyku\u0142ach z tej serii b\u0119dziemy stopniowo rozszerza\u0107 wiedz\u0119. Zaczniemy od odbierania obiekt\u00f3w typu JSON, kt\u00f3re b\u0119dziemy mapowa\u0107 na stworzone przez nas klasy. Zajmiemy si\u0119 te\u017c obs\u0142ug\u0105 b\u0142\u0119d\u00f3w i autoryzacj\u0105.<\/p>\n
Autor:<\/strong>
\nHubert Pie\u015bniak<\/a><\/strong><\/p>\n
\"Hubert<\/figure>\n
Software Engineer w EPAM Systems, koduj\u0105cy w Javie. Od dziecka pasjonat technologii, kt\u00f3remu programowanie jako hobby towarzyszy\u0142o od najm\u0142odszych lat. Do bran\u017cy IT trafi\u0142 jednak bardzo okr\u0119\u017cn\u0105 drog\u0105. Studiowa\u0142 Ekonomi\u0119 na SGH, UEP i Sogang University w Seulu. Do niedawna prowadzi\u0142 najwi\u0119kszy klub bilardowy na Pomorzu, wcze\u015bniej sklepy jubilerskie do kt\u00f3rych importowa\u0142 towar z W\u0142och, Turcji i Tajlandii, tu\u017c po tym jak reprezentowa\u0142 firm\u0119 sprzedaj\u0105c\u0105 mufy do kabli wysokonapi\u0119ciowych. Cz\u0142owiek wielu pasji i zainteresowa\u0144.<\/p>\n