NodeJS: Prosty serwer i klient TCP
w Praktyce
10 godz. 44 min · Node.js · Full-stack i Programowanie
Piotr PalarzWeb DeveloperCzego się nauczysz
- Omówienie platformy Node.js od podstaw
- Techniki tworzenia aplikacji typu CLI
- Rózne metody tworzenia serwerów sieciowych
- Omówienie wewnetrznej budowy platformy Node.js
- Prace z zewnetrznymi modulami i npm
- Framework express.js i wspólprace z baza danych MongoDB
- Przyklady praktycznych aplikacji
- Mase cennych porad i wskazówek
Co znajdziesz w Kursie?
W kursie tym poznasz platformę Node.js od podstaw, aż po bardziej zaawansowane koncepcje. Zaczniemy od omówienia czym jest Node, a także jakie może być zastosowanie tej technologii. Następnie przejdziemy przez proces instalacji i napisanie swojego pierwszego skryptu. Już na samym początku dokładnie omówimy tworzenie własnych modułów, gdyż jest to wiedza niezbędna, by dobrze zrozumieć funkcjonowanie Node. Następnie dowiesz się czym są zdarzenia, jak działa model “publish / subscribe”, a także czym jest “event-driven development”. Chwilę później omówimy pracę z buforami, stream’ami, a także ze standardowym wejściem i wyjściem. Ta wiedza pozwoli Ci zrozumieć jak tworzone aplikacje mogą otrzymywać od użytkownika dane oraz jak je wyświetlają.
Praca z Systemem Plików
Niezwykle ważnym rozdziałem będzie ten, poświęcony pracy z systemem plików. Szczególnie dla dewelopera, pracującego dotychczas z językiem JavaScript wyłącznie w środowisku przeglądarki internetowej. Node pozwala bowiem tworzyć nowe pliki, zapisywać w nich dane oraz odczytywać i usuwać pliki i katalogi. Przy wszystkich tych operacjach, niezwykle ważna jest jednak asynchroniczna natura Node. Dowiesz się jak działa, a także jakie są jej zalety. Na tym etapie nie zabraknie oczywiście praktycznego projektu, którym będzie aplikacja typu CLI (Command Line Interface). Pozwoli nam ona grupowo zmienić nazwy wielu plików, według podanego wzorca.
Tworzenie Serwerów Siecowych
W kolejnym rozdziale poruszymy fundamentalną dla Node kwestię, mianowicie tworzenie serwerów sieciowych. Zaczniemy od najniższego poziomu, tworząc prosty serwer bazujący na protokole TCP/IP. Wiedza w jaki sposób Node radzi sobie z takim zadaniem, pozwoli później lepiej zrozumieć wyższe warstwy, takie jak np. HTTP czy WebSockets. Chwilę później stworzymy swój pierwszy serwer HTTP, do którego będzie można wysyłać zapytania wprost z przeglądarki internetowej. Omówimy również jak w Node wykorzystać bezpieczne szyfrowanie HTTPS.Na tym etapie będziesz już miał solidną wiedzę jak pracować z Node, jednak zanim przejdziemy dalej, zatrzymamy się, by omówić jak dokładnie działa Node.js, a także jak ta platforma została zbudowana. Dwie dość obszerne lekcje, będą być może jednymi z najważniejszych w tym kursie. Dowiesz się w nich czym jest, a także jak działa jednowątkowa pętla zdarzeń, czym jest proces i wątek, a także zobaczysz kod źródłowy Node.js i wszystkie bloki budulcowe, z jakich Node się składa. To naszym zdaniem niezwykle ważny temat, często jednak pomijany w wielu materiałach. Dzięki dogłębnemu zrozumieniu jednowątkowej natury języka JavaScript i asynchroniczności Node, będziesz mógł tworzyć dużo lepsze aplikacje.
Node.js + Express.js + MongoDB
Node.js posiada kilkanaście wbudowanych modułów, z których w dowolnej chwili można skorzystać. Wszystkie jednak dają nam dużą, niskopoziomową kontrolę, ale czasami sporo kodu należy napisać, by zrealizować jakieś zadanie. Jest to jednak świadomy wybór twórców Node, gdyż całą resztę świetnych rozwiązań, dopisuje nieustannie ogólnoświatowa społeczność deweloperów. Zdecydowana większość z modułów ląduje w rejestrze npm. Jest to genialny package manager, który pozwoli nam wyszukiwać, pobierać i aktualizować niezliczoną ilość modułów. Dowiesz się zatem jak korzystać z npm, a chwilę później zaczniemy wykorzystywać zgromadzone tam moduły w dalszej pracy.Jednym z najpopularniejszych modułów jest express.js, który pozwala w bardzo prosty sposób tworzyć serwery HTTP. Grzechem byłoby zatem z niego nie skorzystać. Dowiesz się wszystkiego co niezbędne, by zacząć tworzyć własne aplikacje bazujące na protokole HTTP z użyciem express.js, a także kilku dodatków do tego systemu. Zobaczysz jak routować zapytania, jak korzystać z middleware czy serwować statyczne pliki. Następnie omówimy współpracę z bazą danych MongoDB i z jej wykorzystaniem stworzymy API typu REST. Stworzona aplikacja pozwoli odczytywać dane z bazy i przesyłać je do klienta w formacie JSON, a także dodawać nowe dane, aktualizować i usuwać je. Wszystko to zgodnie z dobrymi praktykami pracy z REST.
Praktyczny Projekt i ES6
Chwilę później czeka Cię kolejny praktyczny projekt - skracacz linków. Stworzymy wspólnie aplikację, która pozwoli skrócić dowolny adres URL do krótkiej formy. Oczywiście będzie działać również w drugą stronę! Kiedy przejdziemy pod skrócony adres, przekieruje nas do odpowiedniej witryny. Node.js to platforma wręcz stworzona do tworzenia aplikacji typu real-time, dlatego w kolejnym rodziale podejmiemy temat technologii WebSockets. Dowiesz się jakie są jej zalety, a także jak pracować z nią po stronie serwera i klienta. Tutaj czeka nas kolejny praktyczny, niezwykle ciekawy projekt. Wykonamy bowiem czat grupowy. Aplikacja ta pozwoli dowolnej ilości użytkowników podłączyć się do czatu podając swój nick, a następnie wysyłać widoczne dla wszystkich wiadomości. Zaimplementujemy nawet takie rozwiązania jak wyświetlanie statusów o dołączeniu kogoś do czatu, a także o jego opuszczeniu.W przedostatnim rodziale tego kursu podejmiemy tematykę dobrych praktyk pracy z Node.js. Na początku omówimy najważniejsze konstrukcje nowej specyfikacji EcmaScript 2015, które są znakomicie wspierane w Node. Chwilę później omówimy jak korzystanie z Promises uprości, a także ulepszy nasz kod. Wśród dobrych praktyk nie zabraknie również informacji o debugowaniu aplikacji. Zobaczysz sprawdzone sposoby, by znaleźć błędy lub lepiej, krok po kroku, zrozumieć jak działa napisany wcześniej kod. Dowiesz się również jak pracować z błędami, by Twoje aplikacje działały w sposób przewidywalny.
Praktyczny projekt z Git i Heroku
Ostatni rozdział w całości został poświęcony temu, co zwykle jest pomijane w innych materiałach, mianowicie wdrażaniu aplikacji do produkcji. Przez cały ten kurs pracować będziemy lokalnie, lecz kiedy aplikacje są już gotowe, wypadałoby udostępnić je światu. Wdrażanie aplikacji napisanych z użyciem Node.js nie jest jednak tak oczywiste, jak np. wgrywanie WordPress’a u wybranego hostingodawcy. Ty będziesz miał jednak możliwość zobaczyć, jak wdrożyć napisany przez nas grupowy czat na platformie Heroku. Jest to bardzo popularny serwis działający jako PaaS (Platform as a Service). Za darmo będziesz mógł w ciągu kilku chwil uruchomić swoją aplikację.Zobaczysz o co należy zadbać, by wszystko poszło gładko. Serwisy typu PaaS dbają o bardzo wiele aspektów wdrażania i serwowania naszych aplikacji, takich jak bezpieczeństwo oraz nieustanną dostępność. Mają jednak pewne ograniczenia. Z tego powodu, dowiesz się również jak wdrożyć swoją aplikację na serwerze wirtualnym VPS z systemem Ubuntu Server. Takie rozwiązanie daje nam całkowitą kontrolę, ale także obarczone jest większą odpowiedzialnością. Zaczniemy od instalacji na serwerze platformy Node.js, systemu kontroli wersji GIT, a także innych niezbędnych modułów
Konfiguracja środowiska i porady
Następnie zobaczysz jak skonfigurować swoje lokalne środowisko tak, by za pomocą GIT’a wysyłać kod do zdalnego serwera, a potem jednym poleceniem wdrażać go do produkcji. Dowiesz się również jak jednocześnie serwować wersję produkcyjną oraz developmencką. W rodziale tym poruszymy również inne kwestie, takie jak procesy potomne czy tworzenie klastrów. Dzięki tej wiedzy, będziesz mógł maksymalnie wykorzystać dostępne zasoby serwera. Na sam koniec tego kursu rzucimy okiem również na inne, nie przedstawione wcześniej zastosowania Node, a także nakreślimy dalszą drogę nauki w tym zakresie.
Dla kogo jest ten kurs?
Kurs ten jest dla wszystkich osób, które dobrze czują się w technologiach frontendowych, tj. HTML, CSS i JavaScript, a teraz chcą rozpocząć swoją przygodę z back-endem. Im zatem lepiej znasz język JavaScript, tym więcej wyciśniesz z Node, natomiast nie jest wymagana bardzo zaawansowana wiedza z zakresu tego języka.
Tą lekcją rozpoczynamy rozdział o serwerach, czyli być może najciekawszy rozdział w tym kursie i
jedną z najlepszych rzeczy, jakie oferuje Node.js. Natomiast to, co pokazałam ci do tej pory, na pewno
ci się przyda i ta wiedza na pewno nie pójdzie na marne, bo jeszcze będziemy ją wielokrotnie wykorzystywać.
Niemniej jednak być może sięgnąłeś po kurs Node.js właśnie po to, aby nauczyć się tworzyć aplikacje sieciowe
czy głównie takie back endy bazujące na protokole HTTP.
I to będzie właśnie w tym rozdziale. Jesteśmy na stronie dokumentacji Node i przejdź sobie tutaj do net.
I w tym miejscu mamy moduł net odpowiedzialny za komunikację sieciową w Node i pokażę ci teraz, jak z
niego korzystać.
Natomiast powiem ci od razu szczerze, że nie będziesz z niego prawdopodobnie korzystał bezpośrednio, chyba
że będziesz naprawdę pisał jakieś aplikacje sieciowe niskiego poziomu.
Ja nigdy z niego bezpośrednio nie korzystałem, ale później zobaczysz moduł HTTP, czy np. WebSockets i
one korzystają pod spodem z tego modułu net. Czyli Node.js implementuje sobie taki moduł net i później w
innych swoich własnych modułach z niego wielokrotnie korzysta, ale również i my możemy z niego korzystać.
Będę chciał ci pokazać w tej lekcji, jak utworzyć prosty serwer bazujący na protokole TCP IP.
Czyli na tym, co jest tak naprawdę podstawą całej sieci, jaką znamy, zarówno w sieci lokalnej, jak i w internecie.
Za każdym razem, gdy wchodzimy na dowolną stronę, nawet tutaj poprzez HTTPS, to pod spodem tak czy siak
to wszystko korzysta z protokołu TCP IP.
I serwer, który teraz stworzymy, będzie takim właśnie prostym serwerem na niskim poziomie
w Node.js. Ja już tutaj sobie zaimportowałem file system, bo będzie nam potrzebny, a także ten moduł net - tutaj
jest require net.
Jeżeli jesteś ciekaw, jaka jest dokładnie ta nazwa, którą tutaj podajemy, to ona zawsze tutaj w
dokumentacji niżej się pojawia. I teraz będę chciał utworzyć serwer, dlatego utworzę stałą.
Możesz również zrobić zmienną. Nazwiemy ją server i następnie odwołamy się do net i mamy metodę
createServer.
Ta metoda przyjmuje funkcję, która się będzie wykonywać dla każdego podłączonego klienta. I ta funkcja otrzyma
socket, czyli właśnie podłączonego klienta.
I teraz znowu gdybyś przeszedł do strony dokumentacji, w to miejsce Class net Socket, to wszystko, co widzisz
tutaj, czyli wszystkie eventy - bo taki socket dziedziczy z EventEmittera wszystkie metody, wszystkie właściwości,
które widzisz poniżej, socket i kropka -
one wszystkie dotyczą dokładnie tego obiektu. Czyli tutaj, odwołując się do socket, masz dostęp do wszystkiego,
co jest w tym miejscu.
Niemniej jednak prawdopodobnie aż tak bardzo cię to nie będzie na ten moment interesowało.
Teraz mamy jakby już zalążek takiego serwera, ale należy go jeszcze uruchomić, czyli odwołamy się do server
i mamy metodę listen.
Ta metoda przyjmuje tutaj port, na którym chcemy nasłuchiwać. Wpiszmy sobie może port 8080 i możemy podać, ale nie musimy,
funkcję, która wywoła się, kiedy poprawnie taki serwer zostanie utworzony. Chciałbym w tej funkcji sobie tylko
wpisać console.log, że serwer został uruchomiony i napiszemy pod adresem 127.0.0.1: 8080. 127.0.0.1
to jest po prostu localhost i teraz za moment ten serwer uruchomimy.
Ale chciałbym jeszcze przejść tutaj i na moment się zatrzymać.
Ta funkcja wykona się za każdym razem, gdy podłączy się do tego serwera jakiś klient.
Czyli potrzebujemy klienta.
Klientem jest po prostu program, który potrafi się komunikować po protokole TCP IP, czyli z przeglądarki
internetowej przez HTTP
tutaj się nie podłączymy.
Niemniej jednak przeglądarki oczywiście korzystają z protokołu TCP IP.
Ale na niższych warstwach.
Dlatego zaraz pokażę ci, jak z pomocą programu Telnet możemy to zrobić.
Ale jeszcze zanim to zrobimy, to ważna informacja, że socket w tym miejscu jest to stream.
Na początku tego kursu wytłumaczyłem ci, jak działają streamy
właśnie po to, abyśmy ciągle mogli je wszędzie zauważać.
Widziałeś, że streamem może być plik.
Widziałeś, że może to być np. process.stdout czy stdin.
Ale tutaj znowu pojawia się stream, czyli socket pozwala nam korzystać z wszystkich metod dostępnych
na streamach, dlatego mamy coś takiego jak metodę write. Mogą ją tutaj wpisać.
Pamiętasz, że do pliku mogliśmy coś wpisywać w ten sposób albo do process.stdout.
Tutaj również możemy odwołać się do czegoś takiego i to zostanie za pomocą protokołu sieciowego wysłane.
Więc wpiszę tutaj Hello World! i raz jeszcze podsumuję, abyś był pewien, że dobrze to zrozumiałeś.
Ta funkcja wykona się za każdym razem, gdy ktoś się podłączy do serwera i ten ktoś będzie dostępny pod zmienną
socket, która jest również czy ten obiekt, który jest tutaj, jest streamem, a więc możemy odesłać coś do takiego
klienta za pomocą socket.write. Ok.
Uruchommy sobie za pomocą node index ten serwer. Mamy odpowiedni console.log i proces wisi - nie zakończył się,
bo serwer jest uruchomiony. I teraz potrzebujemy programu, który potrafi się do niego podłączyć.
Takim programem jest np. Telnet, który na Macu jest od razu dostępny. W większości dystrybucji linuksowych
też powinien być. W Windowsie pokażę za kilka chwil, jak go włączyć.
Dlatego otworzę nową kartę w terminalu i w tej karcie odwołam się do telnet.
Aby się podłączyć do tego serwera, muszę podać jego adres, więc mogę wpisać 127.0.0.1 lub localhost.
To jest to samo. I po spacji port.
Port jest to 8080, bo taki podaliśmy. I zauważ, że podłączyliśmy się do tego serwera i zobaczyliśmy Hello World!
odesłane właśnie stamtąd.
Ale zauważ, że ten proces się nie zakończył, a to oznacza, że połączenie jest wciąż aktywne.
Bardzo ważne jest to - i również ci to już pokazywałem w tym kursie - że wszystkie streamy owszem mają metodę
write, która pozwala tam coś wpisywać, ale ta metoda jakby nie kończy streamu, czyli metodą write możemy
wielokrotnie coś do streamu wpisywać.
W przypadku plików dodawalibyśmy coś do pliku, a w przypadku tutaj z sieciowego protokołu będziemy coś
tam przesyłać. Czyli wielokrotnie write możemy użyć. Natomiast później powinniśmy napisać socket.end, aby
zakończyć takie połączenie,
jeżeli nie chcemy, aby było ono podtrzymywane.
Być może pamiętasz, jak korzystaliśmy na streamach z metody pipe - tutaj również byśmy to mogli zrobić.
I metoda pipe jest o tyle fajna, że ona na samym końcu bez naszej uwagi już wykonuje metodę end - na każdym
streamie jest to potrzebne.
Natomiast co jest ciekawe, to metoda end również pozwala wpisać jakby ostatni chunk tych danych do wysłania,
dlatego jeżeli chciałbym wysłać coś do tego socket i od razu to zakończyć, no to mogę wpisać tutaj
Hello World! -
w ten sposób - i wtedy od razu zostanie to połączenie zakończone. Ale żeby nam to zadziałało, najpierw sobie to tutaj
zamkniemy, wciskając Ctrl i prawy nawias kwadratowy. I teraz wpiszę sobie q, aby to zakończyć. Muszę przejść
tutaj i nasz serwer zatrzymać. Bo to, co teraz tutaj wpisałem
samo się nie zaktualizuje. Ten kod został skompilowany do kodu natywnego i wczytany do pamięci, więc musimy
go ubić -
można powiedzieć brzydko - ten serwer i raz jeszcze wykonać, aby nowy kod został skompilowany.
I teraz jeżeli się Telnetem spróbuję podłączyć, to zauważ, że Hello World! zostało odesłane, ale następnie
również połączenie zostało przerwane. W ten sposób to zrobiliśmy z użyciem end.
Jeżeli jednak jesteś w systemie Windows i chciałbyś również skorzystać z Telnetu, to teraz pokażę ci, jak
to zrobić i będziemy mogli kontynuować tę lekcję.
Ok. Jesteśmy na moment w systemie Windows. Przejdziemy sobie do wiersza poleceń.
Wpiszę tutaj cmd, aby go wyszukać. I uruchomię jako administrator.
Oczywiście wyrażamy zgodę. I teraz jeżeli tutaj będę chciał wpisać telnet, to będziemy mieli taki właśnie
błąd, że telnet nie jest rozpoznawany.
Dlatego teraz pokażę ci, jak go włączyć. Musimy przejść do panelu sterowania
i tutaj z tej wyszukiwarki, którą widzisz w tym miejscu, wpiszemy sobie programy i funkcje.
Ok.
Teraz klikam sobie w to miejsce i z tej listy, która się pojawiła, będziemy musieli znaleźć Klient Telnet.
Zobaczmy.
Jest on w tym miejscu, zaznaczam checkbox i klikam Ok. Ok, po chwili zmiany zostały zaaplikowane. I teraz
możemy raz jeszcze spróbować wpisać tutaj telnet.
Tym razem, jak widzisz, już wszystko działa i możesz z tego programu skorzystać, tak jak przed momentem
pokazałem ci na Macu.
Natomiast jeżeli będziesz chciał z niego wyjść, to tutaj q wpisujemy jak quit i Enter, i możemy z niego
po prostu wyjść. A więc Telnet działa na Windowsie bez jakiejś dodatkowej instalacji.
Wróćmy zatem do naszego przykładu i zróbmy coś troszkę bardziej zaawansowanego.
Mianowicie chciałbym aby, taki serwer odsyłał poprzez 10 sekund do klienta jakieś informacje.
Wkleję zatem gotowy kod. Na początek tworzę zmienną counter 0, a następnie tworzę zmienną interval i do niej przypisuję
to, co zwróci nam setInterval. Czyli innymi słowy poprzez setInterval ustawiam, że chcę aby ta funkcja wykonywała
się co sekundę.
Ale zauważ, że jeżeli counter będzie miał wartość 10, a ten counter sobie tutaj zwiększamy, to chcę wyczyścić interval
poprzez clearInterval, który jest zapisany właśnie w tej zmiennej.
Jeżeli nie będzie miał wartości 10, czyli na początku, to chcę odwołać się do socket.write i wysłać tam zwiększony
o jeden counter.
Czyli na początku jest to 0, potem zwiększamy do 1. Natomiast korzystam tutaj z konstruktora string,
bo gdybym przekazał po prostu counter, czyli number, to mielibyśmy błąd, bo do streamów możemy przekazywać
tak jak w tym przypadku tylko stringi lub buffery. Żeby to było string, to korzystamy właśnie z takiego
zapisu. Czyli będziemy co sekundę wysyłać do takiego klienta zwiększony o jeden licznik, czyli właśnie
zmienną counter.
A jeżeli będzie miała wartość 10, to będziemy chcieli wyczyścić ten interval, aby on się już nie wykonywał
i zakończyć takie połączenie poprzez socket.end.
Zobaczmy.
Będę chciał teraz tutaj wyczyścić ekran i w poprzednim oknie zatrzymać serwer, uruchomić go od nowa, bo
dokonaliśmy zmian. Ok.
I tutaj raz jeszcze Telnetem się będę chciał podłączyć. I możemy zobaczyć, że mamy tutaj po kolei odsyłane wszystkie
te liczby.
One nie są w nowej linii, bo nigdzie tutaj nie dodałem nowej linii w tym miejscu. Do dziesięciu powinniśmy
odesłać i połączenie się zakończyło.
Widzisz zatem, jak to działa.
Na koniec będę chciał ci jeszcze pokazać, że możemy w Node.js tworzyć własne klienty. Bo utworzyliśmy serwer i
mówiłem ci, że potrzebujemy klienta, który potrafi się tam podłączyć.
Jednym z takich klientów jest np. Telnet, ale może to być dowolny inny program, który rozumie taki protokół.
Natomiast w Node.js można tworzyć również klienty.
I teraz utworzymy sobie klienta, który będzie się podłączał do tego serwera. Nie musimy go podłączać do tego
serwera - on może się podłączyć tak jak Telnet do dowolnego serwera, ale będziemy chcieli to zrobić tutaj.
Więc stworzę może troszkę miejsca i w tym miejscu utworzymy sobie takiego właśnie klienta.
Jest wiele metod na tworzenie nowego klienta i możemy utworzyć takiego klienta, później go podłączać itd,
ale skorzystamy z jednej z metod skróconych. Mianowicie net.connect i podamy tutaj w obiekcie
port, do jakiego chcemy się podłączyć. Nowy klient zostanie utworzony i od razu podłączony do takiego
serwera.
Natomiast serwer musi już działać.
Czyli w zasadzie powinniśmy to zrobić niżej, bo w tej linijce uruchamiamy taki serwer, a tutaj do niego
będziemy chcieli się podłączyć.
I teraz zarówno klient, jak i serwer dziedziczą z EventEmittera, czyli mają pewne zdarzenia, które znajdziesz
w dokumentacji. Będziemy z nich teraz korzystać i np. ten klient -
my go podłączyliśmy do tego serwera - a więc ta funkcja będzie wykonywana właśnie dla tego klienta i socket
w tym miejscu to będzie ten klient. Więc on będzie otrzymywał od serwera jakieś dane poprzez socket.write,
dlatego chcemy te dane w jakiś sposób odbierać i zrobimy to za pomocą zdarzenia.
Więc napiszemy client.on("data")
Tak nazywa się to zdarzenie, czyli za każdym razem, kiedy serwer nam coś wyśle, chcemy wywołać funkcję.
Funkcja ta przyjmie oczywiście te dane, więc zmienną nazwę sobie również data i coś z niej będziemy chcieli
zrobić.
Mianowicie ja będę chciał je zapisać do nowego pliku. Zrobimy to za pomocą modułu fs, czyli file system,
który na górze już sobie zaimportowałem. Wkleję teraz kod. Czyli w ten sposób do pliku data.txt będę chciał
dopisać to, co zostało nam przesłane i znak nowego wiersza.
I zauważ, co robię teraz. Otóż odwołuję się do client, czyli do naszego klienta, i mówię write: "Otrzymałem dane"
i te dane odsyłam.
Co to oznacza? Że w tym momencie to my do serwera coś wyślemy. Czyli możemy utworzyć klienta, który komunikuje
się z serwerem, nie tylko otrzymując dane, ale również je tam wysyłając. Ale żeby nasz serwer te dane w jakikolwiek
sposób odbierał,
tutaj mamy serwer, no to będziemy musieli do tego socketa przypisać również odpowiednie zdarzenie. Bo pamiętaj,
że kiedy się podłączany w tej linijce, to jesteśmy tutaj w socket i to do tego socket przypiszemy zdarzenie.
Bo za każdym razem kiedy wpiszę client.write, to wysyłamy dane właśnie do tego socket. Czyli możemy
tutaj przypisać zdarzenie w ten sposób. Ok.
Tak to będzie wyglądać.
To co zostanie nam przysłane, to nie będzie string, chociaż ja wysłałem string w tym miejscu, ale będzie
to buffer, dlatego możemy na bufferze skorzystać z metody toString. Dlatego nie są przesyłane stringi ale
buffery, że przecież do serwera możemy przesyłać dowolne dane.
Może to być np. streaming jakiegoś filmu czy muzyki.
Nie musi to być string.
W tym przypadku tutaj pod data abyśmy mieli string, to musimy się odwołać do metody toString albo wcześniej
ustawić odpowiednie kodowanie. I możemy to zrobić za pomocą client.setEncoding i podamy UTF-8.
Dzięki temu tutaj pod data będziemy mieli od razu string.
Będzie to sparsowane w UTF-8.
Natomiast tutaj tego nie zrobiliśmy, dlatego robimy to w ten oto sposób.
I teraz znowu sobie zakończymy to, co mieliśmy tutaj. Uruchamiam serwer od nowa i teraz mamy: "Otrzymałem dane".
One się tutaj wyświetlają.
To jest właśnie z tego console.loga. W zasadzie to z tego, bo my je odsyłamy do serwera. Mam nadzieję, że to widzisz.
Zaraz połączenie się zakończy, a w zasadzie powinno. Tak, połączenie się zakończyło, ale oczywiście serwer
dalej nasłuchuje. Dlatego proces się nie zakończył, ale zauważ, że pojawił się tutaj plik, do którego zapisywaliśmy
wszystko, co przesłał serwer. I zobaczysz, że w tym pliku dokładnie mamy tutaj wartości od 1 do 10.
I teraz możemy podłączyć do tego serwera kolejnego klienta i znowu wykona się ta funkcja i ten klient
będzie robił dokładnie to samo
czy otrzymywał te same informacje, które każdy inny podłączony klient. Ale dla każdego z nich mamy nową
wartość tej zmiennej counter.
Na koniec jeszcze ci pokażę jedno zdarzenie, które możesz przypisać do klienta. Jest to close.
W ten sposób. Czyli kiedy się zakończy połączenie z takim klientem poprzez end, to nam się to wyświetli.
Tutaj nam tego zabrakło, bo o tym zapomniałem, ale zróbmy to raz jeszcze. Będziemy widzieć poszczególne informacje.
One będą dodawane do pliku.
Poczekamy te kilka sekund i zobaczymy tutaj stosowny console.log. Widzimy - zakończono połączenie z serwerem.
I tutaj w data mamy kolejne informacje dopisane do tego pliku. W tej lekcji chciałem ci po prostu pokazać,
w jaki sposób możemy na najniższym poziomie w Node.js skorzystać z modułu net i utworzyć serwer bazujący
na tym protokole TCP IP.
Nie pokazałem ci wielu rzeczy, które są tutaj dostępne. Możesz w dokumentacji więcej o tym poczytać, ale
jak wspomniałem, na ten moment prawdopodobnie nie będzie ci to potrzebne.
Będziemy już niebawem korzystać z modułu HTTP, który korzysta z tego właśnie modułu net i też wygląda
dosyć podobnie.
Dlatego będziecie ci dużo łatwiej go zrozumieć.