MEAN Stack - Node.js, express - Instytut Informatyki Teoretycznej i

Transkrypt

MEAN Stack - Node.js, express
Technologie zarządzania treścią
dr inż. Robert Perliński
[email protected]
Politechnika Częstochowska
Instytut Informatyki Teoretycznej i Stosowanej
4 października 2016
1/55
Plan prezentacji
1
Wprowadzenie do MEAN Stack
2
NodeJS
npm
Wysołania zwrotne
3
ExpressJS
Obsługa formularzy, GET i POST
Przesyłanie plików
REST API
4
Źródła
2/55
MEAN Stack
3/55
MEAN Stack
MongoDB – darmowa, otwarta baza NoSQL, przechowuje dokumenty
w formacie JSON (BSON), dostarcza wsłasny język zapytań,
Express.js – framework JavaScript wspierający tworzenie aplikacji
MVC po stronie serwera, pozwala użytkownikom tworzyć trasy
(routes) i wykorzystywać szablony,
Angular.js – otwarty framework JavsScript wykorzystujący MVC do
tworzenia aplikacji internetowych działających po stronie klienta w
technologi SPA, wspierany i firmowany przez Google, obecnie
występuje w dwóch zupełnie odmiennych wersjach (1.5 i 2.0),
Node.js – środowisko JavaScript obsługujące operacje wejścia/wyjścia
sterowane zdarzeniami, działające po stronie serwera, bazujące na
silniku Google V8.
4/55
MEAN Stack
5/55
Zalety MEAN Stack
Jeden język do wszystkiego - cały zespół używa tylko JavaScript (na
serwerze jak i po stronie klienta), obiekty JavaScript po prostu
zapisujemy w MongoDB.
Można uruchomić niemal na każdym urządzeniu czy platformie - duża
przenośność kodu.
Technologia ta jest prawie zupełnie darmowa.
Bardzo dobre wsparcie dla przetwarzania w chmurze czy pojedynczych
funkcjonalności jako usług sieciowych, np. baz danych NoSQL
(compose.io czy mongolab.com). Można łatwo wykorzystać dostępne
usługi hostingowe, np. https://www.heroku.com.
6/55
Node.js
https://nodejs.org/en/
platforma działająca po stronie serwera na bazie silnika Google Chrome V8,
zaprojektowany przez Ryana Dahl w 2009 roku,
ma służyć prostemu tworzeniu szybkich i skalowalnych aplikacji
internetowych,
open source,
całkowicie darmowe,
aplikacje napisane w Node.js działają na OS X, MS Windows i Linux’ie,
używane przez tysiące programistów na całym świecie.
/* Program Hello World w Node.js */
console.log("Hello World!");
7/55
Node.js
zalecany do tworzenia aplikacji:
z dużą liczbą operacji wejścia/wyjścia,
strumieniowania danych, np. video,
Single Page Applications (SPA),
udostępniających API w formacie JSON,
z intensywną wymianą danych w czasie rzeczywistym na wielu
urządzeniach, np. portale społecznościowe,
nie zalecany przy aplikacjach intensywnie wykorzystujących procesor (CPU),
npm - system pakietów Node.js - największy zbiór bibliotek open source na
świecie (ponad 330 000) → łatwa produkcja aplikacji internetowych,
Node.js = środowisko uruchomieniowe + biblioteki JavaScript
wykorzystuje biblioteki libuv
8/55
Cechy Node.js
Asynchroniczność i sterowanie zdarzeniami
Serwer wywołuje kolejne API, jedno po drugim.
Nie czeka na zakończenie wywołanej funkcji aby zwrócić dane.
Za wszystko odpowiada mechanizm obsługi zdarzeń.
Duża szybkość - silnik Chrome V8 zapewnia dużą szybkość w wykonywaniu kodu.
Jednowątkowość z zachowaniem dużej skalowalności
Node.js używa modelu jednowątkowego z pętlą zdarzeń.
Potrafi obsłużyć znacznie więcej żądań niż tradycyjne serwery (np. Apache).
Mechanizm zdarzeń pomaga serwerowi na udzielanie odpowiedzi w sposób
nieblokujący,
pozwala to na wysoką skalowalność.
W klasycznych serwerach jest tworzona ograniczona liczba wątków obsługujących
żądania.
Licencja - Node.js jest tworzony na licencji MIT.
Projekty, aplikacjie, firmy - długa lista wykorzystywania Node.js: eBay, General
Electric, GoDaddy, Microsoft, PayPal, Uber, Wikipins, Yahoo, Yammer...
9/55
libUV
https://github.com/libuv/libuv
międzyplatformowa biblioteka skupiająca się na asynchronicznych operacjach
wejścia/wyjścia,
stworzona pierwotnie dla Node.js, używana obecnie przez: Luvit, Julia, pyuv
i inne,
niektóre cechy:
wydajna pętla obsługująca zdarzenia,
asynchroniczna obsługa gniazd TCP i UDP,
asynchroniczna obsługa plików i systemu plików,
obsługa sygnałów, obsługa zdarzeń systemu plików,
zegar wysokiej rozdzielczości
10/55
Najważniejsze części Node.js
Najważniejsze części Node.js przedstawiono na rysunku:
11/55
Pełna lista modułów Node.js
Dokumentacja Node.js, v5.10.0
Assertion Testing
Child Processes
Console
DNS
Events
HTTP
Net
Process
Readline
String Decoder
TTY
Utilities
Buffer
Cluster
Crypto
Domain
File System
HTTPS
OS
Punycode
REPL
Timers
UDP/Datagram
V8
C/C++ Addons
Command Line Options
Debugger
Errors
Globals
Modules
Path
Query Strings
Stream
TLS/SSL
URL
VM
ZLIB
12/55
Obiekty globalne w Node.js
Obiekty globalne w Node.js są dostępne we wszystkich modułach, nie trzeba ich w
żaden sposób dołączać.
filename - nazwa pliku, którego kod jest wykonywany, zawra całą ścieżkę,
dirname - nazwa katalogu wraz z całą ścieżką, w którym znajduje się
wykonywany plik,
setTimeout(cb, ms) - uruchamianie funkcji zwrotniej po określonej liczbie ms,
clearTimeout(t) - zatrzymywanie licznika czasu utworzonego wcześniej funkcją
setTimeout(),
setInterval(cb, ms) -uruchamianie funkcji zwrotnej co określoną liczbę ms.
function printHello(){
console.log( "Hello, World!");
}
// Wywołanie funkcji po upływie 2 s
var t = setTimeout(printHello, 2000);
// Usunięcie licznika czasu
clearTimeout(t);
13/55
Obiekty globalne w Node.js
Inne często wykorzystywane obiekty globalne to:
console - drukowanie wiadomości w różnych poziomach błędu na stdout albo stderr,
zawiera metody:
log(), info(), warn(), error(), dir(), trace(), assert() - wyświetlanie wiadomości
informacyjnych w różny sposób,
console.time(label) - zapamiętuje punkt czasowy związany z etykietą,
console.timeEnd(label) - koniec przedziału czasowego z wiązanego z podaną
etykietą, wyświetla przedział czasu,
process - obiekt może emitować następujące zdarzenia:
exit - emitowane tuż przed zakończeniem procesu,
beforeExit - emitowane kiedy Node opróżnił już pętle zdarzeń i nie ma innych zadań,
uncaughtException - emitowane, kiedy eskalacja wyjątków wróci aż do pętli zdarzeń,
zdarzenia konkretnych sygnałów - emitowane, kiedy system otrzyma konkretne
zdarzenia, np. SIGINT, SIGHUP, ...
Procesy mają też szereg użytecznych
właściwości: stdout, stderr, stdin, argv, execPath, execArgv, env, exitCode, version,
versions, config, pid, title, arch, platform, mainModule,
metod: abort(), chdir(directory), cwd(), exit([code]), getgid(), setgid(id), getuid(),
setuid(id), getgroups(), setgroups(groups), initgroups(user, extra group), kill(pid[,
signal]), memoryUsage(), nextTick(callback), umask([mask]), uptime(), hrtime().
14/55
Użyteczne moduły w Node.js
Najbardziej powszechnie i często używane moduły Node.js:
moduł os (Operating System) - podstawowe infomacje związane z systemem operacyjnym
(pamięć, procesor, ...)
moduł path - przechowywanie i przetwarzanie ścieżek plików i katalogów,
moduł net - pozwala na tworzenie zarówno serwerów jak i klientów, łączenie się,
przesyłanie informacji w postaci strumieniowej,
moduł dns - pozwala na obsługę DNS (sprawdanie adresów, różne typy adresów DNS,
kody błędów),
moduł domain - pozwala na wychwytywanie nieobsłużonych błędów.
var os = require("os");
console.log('endianness : ' + os.endianness());
console.log('type : ' + os.type());
console.log('platform : ' + os.platform());
console.log('total memory : ' + os.totalmem() + " bytes.");
console.log('free memory : ' + os.freemem() + " bytes.");
endianness : LE
type : Linux
platform : linux
total memory : 8110882816 bytes.
free memory : 4815204352 bytes.
15/55
REPL Terminal
Read Eval Print Loop (REPL) - środowisko komputerowe, np. Linux Shell, w którym
polecenia są automatycznie przetwarzane i wyniki są wyświetlane w trybi interakcyjnym.
Node.js też ma takie środowisko:
Read - wczytuje dane od użytkownika, parsuje do struktur JavaScript i
przechowuje w pamięci,
Eval - bierze wprowadzone dane i je oblicza, wyznacza wartości,
Print - wyświetla wyniki,
Loop - trzy powyższe przetwarza w pęltli aż do dwukrotnego nacieśnięcia Ctrl+c.
$ node
> 1 + ( 2 * 3 ) - 4
3
> a = 12 // zachowane w zmiennej i wyswietlone
12
> var b = 12 // zachowane w zmiennej ale nie wyswietlone (var)
undefined
> (a+b)*2
48
> console.log(a+b)
24
undefined
16/55
REPL Terminal - wiele linii i
mamy możliwość pisania wyrażeń składających się z wielu linii,
symbol podkreślenia ( ) zwraca ostatni wynik:
> x = 5
5
> while(x>0) {
... --x;
... console.log(x);
... }
4
3
2
1
0
undefined
> x+8
8
> _
8
17/55
REPL Terminal - polecenia
Ctrl+c - przerywanie aktualnego polecenia,
Ctrl+c dwa razy - zamykanie Node REPL,
Ctrl+d - zamykanie Node REPL,
Klawisze Góra/Dół - historia polecenie, potrzednie/następne polecenie,
klawisz Tab - lista aktualnych komend,
.help - lista wszystkich komend,
.break albo .clear - wyjście z wieloliniowego wyrażenia,
.save nazwaPliku - zapis sesji Node REPL do pliku,
.load nazwaPliku - wczytanie zawartości pliku do bieżącej sesji.
18/55
npm
npm - menadżer pakietów dla node.js (dla JavaScript).
zbiór pakietów/modułów dla Node.js dostępnych online:
https://www.npmjs.com/
narzędzie do instalacji pakietów Node.js, zarządza wersjami i
zależnościami pakietów Node.js
dokumnetacja - https://docs.npmjs.com/
najczęściej instalowane pakiety: npm, express, less, browserify, pm2, ...
$
$
$
$
npm --version
sudo npm install npm -g
npm install <Nazwa Modułu>
npm install express
19/55
npm - globalna i lokalna instalacja modułów
Pakiety lokalne:
domyślnie pakiety instalowane są lokalnie w katalogu node modules
w folderze, w którym jest aplikacja Node.js,
lokalne pakiety są dostępne poprzez metodę require(),
lista lokalnych pakietów/modułów: npm ls.
Pakiety globalne:
globalne pakiety znajdują się w strukturze systemu plików komputera,
nie można ich wczytać używając require(),
instalacja pakietu globalnie: npm install express -g,
lista globalnych pakietów: npm ls -g.
20/55
Tworzenie pakietu
Tworzenie pakietu: npm init
polecenie pyta o najważniejsze dane pakietu (proponując domyślne wartości),
tworzony jest plik package.json, np.:
{
"name": "rest",
"version": "1.0.0",
"description": "hello world restfull api",
"main": "server.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [
"restfull"
],
"author": "rperlinski",
"license": "ISC"
}
21/55
Plik package.json
package.json - plik odpowiedzialny za zarządzanie lokalnie zainstalowanymi
pakietami:
przechowuje informacje o zależnościach w naszym projekcie,
pozwala określić wersje pakietów których używa nasz projekt,
pozwala na odtworzenie naszej aplikacji - łatwość w dzieleniu się naszym
projektem
Minimum pliku package.json to nazwa i wersja:
{
"name": "moj-pakiet",
"version": "1.0.0"
}
22/55
Tworzenie pakietu, instalacja
Instalacja pakietów
mkdir rest; cd rest
npm init - inicjalizacja, tworzy plik package.json
npm install express, albo lepiej
npm install --save express - dodaje zależności do pliku
package.json:
...
"license": "ISC",
"dependencies": {
"express": "^4.13.4"
}
}
23/55
Atrybuty w pliku package.json
name - nazwa pakietu, atrybut obowiązkowy, tylko małe litery, jedno
słowo - nie ma spacji, dopuszczalne myślniki (-) i podkreślenia ( ),
version - wersja pakietu, atrybut obowiązkowy,
description - opis pakietu,
homepage - strona domowa pakietu,
author - autor pakietu,
contributors - współautorzy pakietu,
dependencies - lista zależności, npm automatycznie instaluje wszystkie
podane zależności w katalogu node modules naszego pakietu,
repository - typ repozytorium i URL pakietu,
main - punkt wejściowy pakietu,
keywords - słowa kluczowe.
24/55
Inne polecenia npm
npm uninstall express - odinstalowanie modułu express,
npm update express - wywoływane po zmianach w pliku package.json,
autoamtycznie aktualizuje zależności,
npm search express - wyszukiwanie pakietów korzystając z polecenia npm,
npm init - generowanie pliku package.json co tworzy nowy moduł/pakiet,
npm adduser - dodanie użytkownika do repozytorium npm (nazwa i
poprawny email) i następnie można ...
npm publish - publikowanie naszego pakietu, będzie można go instalować
poleceniem npm install :)
25/55
Wywołania zwrotne I
Wywołanie zwrotne (ang. callback) - technika programowania będąca
odwrotnością wywołania funkcji.
Użytkownik rejestruje funkcję do późniejszego wywołania.
Funkcje biblioteki wywołają ją w stosownym czasie.
Zwykle to programista sam wywołuje funkcje dostarczane przez bibliotekę.
Wywołanie zwrotnie:
asynchroniczny odpowiednik funkcji,
jest wykonywane kiedy zakończy się pewne zadanie,
kawałek wykonywalnego kodu, który przekazywany jako argument do innego
kodu, od którego oczekujemy, że wywoła przekazany kod w odpowiednim
czasie.
Node używa tego bardzo intensywnie.
Duża część API do Node jest tak napisana, aby wspierać wywołania zwrotne.
26/55
Wywołania zwrotne II
Programy z funkcjami synchronicznymi:
wykonują się sekwencyjnie,
z punktu widzenia programisty łatwiej implementować logikę aplikacji.
Programy działające asynchronicznie:
nie wykonują się sekwencyjnie,
jeśli fragment kodu potrzebuje określonych danych powinien być
umieszczony w tym samym bloku kodu, żeby wykonanie tych
zależnych od siebie instrukcji było sekwencyjne.
27/55
Wywołania zwrotne na przykładzie
Odczyt z pliku może być:
synchroniczny - czekamy na zwrócenie danych zawartych w pliku,
asynchroniczny:
funkcja zaczyna czytać plik ale ...
od razu zwraca sterowanie,
wykonywane są kolejne instrukcje;
zakończenie odczytywania danych z pliku wykonuje wywołanie zwrotne,
jako parametr przekazywana jest zawartość pliku,
nie ma tutaj blokowania.
Wniosek:
wysoka skalowalność Node.js (nawet 1 mln żądań na sekundę),
przetwarzanie dużej liczby żądań bez oczekiwania na zwrócone wyniki.
28/55
Podwójne API Node.js
File System - metody asynchroniczne
fs.access(path[, mode], callback)
fs.close(fd, callback)
fs.exists(path, callback)
fs.read(fd, buffer, offset, length, position, callback)
fs.unlink(path, callback)
...
File System - metody synchroniczne
fs.accessSync(path[, mode])
fs.closeSync(fd)
fs.existsSync(path)
fs.readSync(fd, buffer, offset, length, position)
fs.unlinkSync(path)
...
29/55
Wywołania zwrotne - odczyt z pliku, przykład
wywołanie synchroniczne
var fs = require("fs");
var data = fs.readFileSync('dane.txt');
console.log(data.toString());
console.log("Koniec programu");
Litwo, Ojczyzno moja! ty jesteś jak zdrowie;
Ile cię trzeba cenić, ten tylko się dowie, ...
Koniec programu
wywołanie asynchroniczne
fs.readFile('dane.txt', function (err, data) {
if (err) return console.error(err);
console.log(data.toString());
});
console.log("Koniec programu");
Koniec programu
Litwo, Ojczyzno moja! ty jesteś jak zdrowie;
Ile cię trzeba cenić, ten tylko się dowie, ...
30/55
Pierwszy projekt w Node.js
Większość aplikacji Node.js składa się z 3 części:
import wymaganych modułów - używa się dyrektywy require,
utworzenie serwera - serwer będzie oczekiwał na żadania klientów i zwracał
odpowiedzi,
odczytywanie żądań i zwracanie odpowiedzi - podstawowe działanie serwera.
var http = require("http");
var server = http.createServer(function (request, response) {
// Wysyłanie nagłówków protokołu HTTP
// Status HTTP: 200 : OK, Content Type: text/plain
response.writeHead(200, {'Content-Type': 'text/plain'});
// Wysyłanie ciała odpowiedzi, niezależnie od rodzaju żądania
response.end('Pierwszy projekt w Node.js\n');
});
server.listen(5000);
console.log('Server działa na http://127.0.0.1:5000/');
31/55
Serwer sieciowy
Serwer sieciowy:
aplikacja obsługująca żądania HTTP przesyłane od klientów, np.
przeglądarki, w odpowiedzi zwracająca strony internetowe,
zwykle dostarczane są dokumenty HTML razem z obrazkami, stylami
CSS i skryptami,
większość serwerów obsługuje skrypty po stronie serwera w jednym z
wielu języków,
serwery wykonują określone zadania, pobierają dane z bazy,
przetwarzają skomplikowaną logikę ...
przykładem może być serwer Apache.
32/55
Architektura aplikacji internetowej
Klasyczny podział aplikacji internetowej na cztery warstwy:
Klient - przeglądarki internetowe (w tym z urządzeń mobilnych) i aplikacje
wykonujące żądania HTTP,
Serwer internetowy - przechwytuje żadania od klientów i zwraca im odpowiedzi,
Warstwa biznesowa - zawiera aplikację serwerową wykorzystywaną przez serwer
internetowy; komunikuje się z warstwą danych,
Dane - zawiera dane w bazie danych albo dostępnych z innego źródła.
33/55
Tworzenie serwera z użyciem Node.js i http
var http = require('http');
var fs = require('fs');
var url = require('url');
http.createServer( function (request, response) {
// Parsuje żądanie zawierające nazwę pliku
var pathname = url.parse(request.url).pathname;
// Wyświetlanie nazwy pliku, którego dotyczyło żądanie
console.log("Request for " + pathname + " received.");
fs.readFile(pathname.substr(1), function (err, data) {
if (err) {
console.log(err);
response.writeHead(404, {'Content-Type': 'text/html'});
} else {
response.writeHead(200, {'Content-Type': 'text/html'});
response.write(data.toString()); // zwracanie treści wybranego pliku
}
response.end(); // wysyłanie odpowiedzi
});
}).listen(5000);
console.log('Serwer uruchomiony na http://127.0.0.1:5000/');
34/55
Tworzenie serwera z użyciem Node.js
index.html
<html>
<head>
<title>Pierwszy projekt</title>
</head>
<body>
</body>
</html>
$ node server.js
Serwer uruchomiony na http://127.0.0.1:5000/
Otwieramy w przeglądarce: http://localhost:5000/index.html
35/55
Tworzenie klienta z użyciem Node.js i http
var http = require('http');
// Opcje użyte w żądaniu
var options = {
host: 'localhost', port: '5000', path: '/index.html'
};
// Funkcja zwrotna obsługująca zwrócone dane
var callback = function(response){
// Dopisywanie napływających danych do strunienia
var body = '';
response.on('data', function(data) {
body += data;
});
response.on('end', function() {
// Wypisanie danych po ich otrzymaniu w pełni
console.log(body);
});
}
// Wysłanie żądania do seerwera
var req = http.request(options, callback);
req.end();
36/55
Tworzenie klienta z użyciem Node.js
Wywołanie aplikacji klienta w innym terminalu, wynik działania:
$ node client.js
<html>
<head>
<title>Pierwszy projekt</title>
</head>
<body>
</body>
</html>
37/55
Express
http://expressjs.com/
Express to szybki, elastyczny (nie wymuszający konkretnych rozwiązań),
minimalistyczny szablon aplikacji internetowych i mobilnych dla Node.js.
Express:
udostępnia solidną funkcjonalność do budowania aplikacji,
pozwala na szybkie budowanie aplikacji bazujących na Node.js,
pozwala na utworzenie warstw pośredniczących odpowiadających na
żądania HTTP,
dostarcza mechanizm trasowania (ang. routing) - różne akcje dla
różnych metod i adresów URL,
pozwala na dynamiczne renderowanie stron HTML poprzez
przekazywanie argumentów do szablonów.
38/55
ExpressJS i warstwy pośrednie
Instalacja: npm install express
ExpressJS to komplenty framework.
Działa z szablonami (jade, ejs, handlebars, hogan.js)
i kompilatorami CSS (less, stylus, compass).
Dzięki wartstwom pośredniczącym (oprogramowanie pośredniczące)
obsługuje również: ciasteczka, sesje, buforowanie, CSRF, kompresję i
wiele innych.
Oprogramowanie pośredniczące:
łańcuch/stos programów przetwarzających każde żądanie do serwera.
Takich programów w stosie może być dowolna liczba,
przetwarzanie odbywa się jeden po drugim.
Niektóre z nich mogą zmieniać żądanie, tworzyć logi czy inne dane,
przekazywać je do następnych (next()) programów w strumieniu.
39/55
Express-middlewares
Warstwy pośredniczące dodajemy do ExpressJS używając app.use dla
dowolnej metody albo app.VERB (np. app.get, app.delete, app.post,
app.update, ...)
40/55
Express - instalacja
$ npm install express --save
Inne ważne moduły, które warto od razu zainstalować:
body-parser - warstwa pośrednia obsługująca JSON, Raw, Text i
dane formularza przekazane w URL,
cookie-parser - przetwarza nagłówki ciasteczek (cookie header) i
dodaje obiekt do req.cookies, w którym klucze to nazwy
przesłanych ciasteczek,
multer - warstwa pośrednia w Node.js do obsługi
multipart/form-data (kodowanie danych z formularza).
41/55
Express, Hello World
hello.js
var express = require('express');
var app = express();
app.get('/', function (req, res) {
res.send('Hello World');
})
var server = app.listen(5000, function () {
var host = server.address().address
var port = server.address().port
console.log("Przykładowa aplikacja nasłuchuje na http://%s:%s", host, port)
})
Wynik:
$ node hello.js
Otwieramy w przeglądarce: http://localhost:5000/
Przykładowa aplikacja nasłuchuje na http://0.0.0.0:5000
Express używa funkcji zwrotnych z argumentami req i res (obiekty request
i response), które zawierają bardzo dużo informacji i żądaniu i odpowiedzi.
42/55
Express, trasowanie I
Reakcje na żądania użytkowników w punktach końcowych (URI, metody protokołu HTTP).
console.log("Otrzymano żądanie GET dla strony głównej");
res.send('Hello GET');
})
app.post('/', function (req, res) {
console.log("Otrzymano żądanie POST dla strony głównej");
res.send('Hello POST');
})
app.delete('/usun', function (req, res) {
console.log("Otrzymano żądanie DELETE dla strony /usun");
res.send('Hello DELETE');
})
app.get('/user_list', function (req, res) {
console.log("Otrzymano żądanie GET dla strony /user_list");
res.send('Lista użytkowników');
})
app.get('/ab*cd', function(req, res) {
// wzorzec strony: abcd, abxcd, ab123cd, ...
console.log("Otrzymano żądanie GET dla strony /ab*cd");
res.send('Wzorzec strony dopasowany');
})
})
43/55
Express, trasowanie II
Kolejne żądania:
GET
POST
DELETE
GET
GET
GET
GET
GET
-
http://localhost:5000/
http://localhost:5000
http://localhost:5000/usun
http://localhost:5000/user_list
http://localhost:5000/abcd
http://localhost:5000/ab123cd
http://localhost:5000/abXXcd
http://localhost:5000/abcdef
//
//
//
//
//
//
//
//
Hello GET
Hello POST
Hello DELETE
Lista użytkowników
Wzorzec strony dopasowany
Cannot GET /abcdef
Reakcja serwera:
http://localhost:5000/ Przykładowa aplikacja nasłuchuje na http://0.0.0.0:5000
Otrzymano żądanie GET dla strony głównej
Otrzymano żądanie POST dla strony głównej
Otrzymano żądanie DELETE dla strony /usun
Otrzymano żądanie GET dla strony /user_list
Otrzymano żądanie GET dla strony /ab*cd
44/55
Express, statyczne pliki
Express posiada wbudowaną warstwę pośrednią express.static, która pozwala na udostępnianie
statycznych plików (obrazy, CSS, HTML, JavaScript, ...)
Wystarczy przekazać nazwę katalogu, z którego pliki będą dostępnę poprzez serwer:
app.use(express.static(’public’));
app.use(express.static('public'));
res.send('Hello World');
})
})
Wywołanie: http://localhost:5000/npmLogo.png
wyświetli odpowiedni plik znajdujący się w katalogu public.
45/55
Formularze, metoda GET
form get.js
app.get('/get.html', function (req, res) {
res.sendFile( __dirname + "/" + "get.html" );
})
app.get('/form_get', function (req, res) {
response = {
imie:req.query.imie,
nazwisko:req.query.nazwisko
};
console.log(response);
res.end(JSON.stringify(response));
})
app.listen(5000);
get.html
<html>
<body>
<form action="http://127.0.0.1:5000/form_get" method="GET">
Imie: <input type="text" name="imie"> <br>
Nazwisko: <input type="text" name="nazwisko">
<input type="submit" value="Wyślij">
</form>
</body>
</html>
46/55
Formularze, metoda POST
form post.js
var bodyParser = require('body-parser');
var urlencodedParser = bodyParser.urlencoded({ extended: false }) // application/x-www-form-urlencoded
app.post('/form_post', urlencodedParser, function (req, res) {
response = {
imie:req.body.imie,
nazwisko:req.body.nazwisko
};
console.log(response);
res.end(JSON.stringify(response));
})
app.listen(5000);
post.html
<html>
<body>
<form action="http://127.0.0.1:5000/form_post" method="POST">
Imie: <input type="text" name="imie"> <br>
Nazwisko: <input type="text" name="nazwisko">
<input type="submit" value="Wyślij">
</form>
</body>
</html>
47/55
Formularze, przesyłanie plików I
file upload.js
var bodyParser = require('body-parser');
var multer = require('multer');
app.use(bodyParser.urlencoded({ extended: false }));
var upload = multer({ dest: 'uploads/' }).single('file');
app.post('/file_upload', function(req, res) {
upload(req, res, function (err) {
if (err) {
// błąd przy wczytywaniu/przesyłaniu pliku
return
}
// wszystko poszło dobrze
console.log(req.file); // req.file zawiera opis przesyłanego pliku
console.log(req.body); // req.body przechowuje pola tekstowe, jeśli takie były
response = {
message:'Plik wczytany poprawnie',
filename:req.file.filename,
originalname:req.file.originalname,
mimetype:req.file.mimetype,
size:req.file.size
};
res.end( JSON.stringify( response ) );
})
})
var server = app.listen(5000);
48/55
Formularze, przesyłanie plików II
file.html
<html>
<head>
</head>
<body>
Wybierz plik do wysłania: <br />
<form action="http://127.0.0.1:5000/file_upload" method="POST"
enctype="multipart/form-data">
<input type="file" name="file" size="50" /> <br>
<input type="submit" value="Wyślij plik" />
</form>
</body>
</html>
49/55
Express, cookie-parser
https://github.com/expressjs/cookie-parser
$ npm install cookie-parser
cookies.js
var express
= require('express')
var cookieParser = require('cookie-parser')
var app = express()
app.use(cookieParser())
app.get('/', function(req, res) {
console.log("Cookies: ", req.cookies)
})
app.listen(5000);
Wynik:
$ curl http://127.0.0.1:5000 --cookie "name=Jan;pozd=Hello"
Cookies:
{ name: 'Jan', pozd: 'Hello' }
50/55
API, metoda GET
server.js
app.get('/listUsers', function (req, res) {
fs.readFile( __dirname + "/" + "users.json", 'utf8', function (err, data) {
console.log( data );
res.end( data );
});
})
app.listen(5000);
Żądanie: http://localhost:5000/listUsers
{
"user1" : { "name" : "johnw", "password" : "dogville321",
"profession" : "film_director", "id": 1 },
"user2" : { "name" : "Halina", "password" : "MojeHaslo123",
"profession" : "pisarka", "id": 2 },
"user3" : { "name" : "jnowak", "password" : "wiosna2016",
"profession" : "malarz", "id": 3 }
}
51/55
API, metoda GET, konkretny użytkownik
server.js
app.get('/:id', function (req, res) {
users = JSON.parse( data );
var user = users["user" + req.params.id]
console.log( user );
res.end( JSON.stringify(user));
});
})
app.listen(5000);
Żądanie: http://localhost:5000/1
{
"name":"johnw", "password":"dogville321",
"profession":"film_director", "id":1
}
52/55
API, metoda POST
server.js
...
var user = {
"user4" : {
"name" : "kim2l", "password" : "a2vxZH45Xr",
"profession" : "programmer", "id": 4 }
}
app.get('/addUser', function (req, res) {
data = JSON.parse( data );
data["user4"] = user["user4"];
res.end( JSON.stringify(data));
});
})
...
Żądanie: http://localhost:5000/addUser
{
...
"user4" : { "name" : "kim2l", "password" : "a2vxZH45Xr",
"profession" : "programmer", "id": 4 }
}
53/55
API, metoda DELETE
server.js
...
var id = 2;
app.get('/deleteUser', function (req, res) {
data = JSON.parse( data );
delete data["user" + id];
res.end( JSON.stringify(data));
});
})
...
Żądanie: http://localhost:5000/deleteUser
{
"user1" : { "name" : "johnw", "password" : "dogville321",
"profession" : "film_director", "id": 1 },
"user3" : { "name" : "jnowak", "password" : "wiosna2016",
"profession" : "malarz", "id": 3 }
}
54/55
Źródła
https://nodejs.org/en/
https://en.wikipedia.org/wiki/Node.js
http://expressjs.com/
https://en.wikipedia.org/wiki/Express.js
http://www.tutorialspoint.com/nodejs/index.htm
https://www.npmjs.com/
https://github.com/libuv/libuv
https://en.wikipedia.org/wiki/Callback_(computer_programming)
55/55

MEAN Stack - Node.js, express - Instytut Informatyki Teoretycznej i

Transkrypt

Podobne dokumenty

Bardzo szybkie wprowadzenie do Node.js