Membuat API RESTful dengan Express 4

dengan pembebasan Express 4 ia telah mendapat lebih mudah untuk mencipta API yang tenang. Jika anda membuat aplikasi halaman tunggal, anda pasti memerlukan perkhidmatan web yang tenang yang menyokong operasi CRUD. Tutorial terakhir saya yang difokuskan untuk membuat aplikasi CRUD halaman tunggal dengan sumber $ Angular. Tutorial ini menerangkan cara merancang API Backend untuk aplikasi CRUD menggunakan Express 4.

hanya ambil perhatian bahawa banyak telah diubah sejak Express 3. Tutorial ini tidak menjelaskan bagaimana untuk menaik taraf aplikasi anda dari Express 3 untuk menyatakan 4. Sebaliknya ia akan meliputi cara membuat API dengan Express 4 secara langsung. Jadi, mari kita mulakan.

Takeaways Key

Express 4 memudahkan penciptaan API yang tenang, menjadikannya lebih mudah untuk merancang API backend untuk aplikasi CRUD.
Express 4 memerlukan parser badan dimuat turun secara berasingan kerana ia tidak lagi menjadi sebahagian daripada teras ekspres. Modul ini digunakan untuk menghuraikan badan permintaan masuk, yang membolehkan akses kepada badan permintaan pos melalui req.body.
Kaedah Express 4 Express.Router () mencipta contoh router baru yang boleh menentukan middlewares dan laluan. Contoh penghala ini kemudiannya boleh digunakan dalam aplikasi utama seperti mana -mana middleware lain dengan memanggil app.use ().
Express 4 menyokong kaedah HTTP standard, seperti Get, Post, Put, and Delete, untuk melaksanakan operasi CRUD pada pangkalan data, dalam kes ini, pangkalan data filem. Ini dilakukan melalui membuat laluan yang mengendalikan permintaan HTTP ini.

Membuat API untuk aplikasi filem

Aplikasi kami akan menjadi pangkalan data filem mudah yang menyokong operasi CRUD asas. Kami akan menggunakan Express 4 sebagai Rangka Kerja Web dan Mongoosejs sebagai alat pemodelan objek. Untuk menyimpan entri filem, kami akan menggunakan MongoDB.

Sebelum pergi lebih jauh mari kita lihat apa yang akan kelihatan seperti API:

Struktur direktori

kami akan menggunakan struktur direktori berikut dalam aplikasi kami:

Berikut adalah beberapa perkara mengenai struktur direktori di atas:

tong bin/www.js digunakan untuk bootstrap aplikasi kami.

Direktori model menyimpan model mongoose kami. Untuk aplikasi ini, kami akan mempunyai satu fail yang dipanggil Movie.js.
Direktori laluan akan menyimpan semua laluan ekspres.
app.js memegang konfigurasi untuk aplikasi ekspres kami.
4. Akhirnya, node_modules dan pakej.json adalah komponen biasa aplikasi node.js.

Mendapatkan kebergantungan yang diperlukan

untuk membuat API kami akan menggunakan modul berikut:

Express

Parser badan
Mongoose
3. Nota-Parser badan bukan sebahagian daripada teras ekspres lagi. Anda perlu memuat turun modul secara berasingan. Jadi, kami telah menyenaraikannya dalam pakej.json.

Untuk mendapatkan pakej ini, kami akan menyenaraikannya sebagai kebergantungan dalam pakej.json kami. Inilah fail pakej.json kami:

<span>{
</span>  <span>"name": "Movie CRUD API",
</span>  <span>"version": "0.0.1",
</span>  <span>"private": true,
</span>  <span>"scripts": {
</span>    <span>"start": "node ./bin/www"
</span>  <span>},
</span>  <span>"main":"./bin/www",
</span>  <span>"engines": {
</span>     <span>"node": "0.10.x"
</span>   <span>},
</span>  <span>"dependencies": {
</span>    <span>"express": "~4.2.0",
</span>    <span>"body-parser": "~1.0.0",
</span>    <span>"mongoose": "~3.8.11"
</span>  <span>}
</span><span>}</span>

hanya jalankan NPM Pasang dan semua kebergantungan akan dimuat turun dan diletakkan di bawah direktori Node_modules.

Membuat model

Oleh kerana kita sedang membina API untuk pangkalan data filem kita akan membuat model filem. Buat fail bernama Movie.js dan masukkannya dalam direktori Model. Kandungan fail ini, ditunjukkan di bawah, buat model mongoose.

<span>var mongoose=require('mongoose');
</span><span>var Schema=mongoose.<span>Schema</span>;
</span>
<span>var movieSchema = new Schema({
</span>  <span>title: String,
</span>  <span>releaseYear: String,
</span>  <span>director: String,
</span>  <span>genre: String
</span><span>});
</span>
module<span>.exports = mongoose.model('Movie', movieSchema);</span>

Dalam coretan sebelumnya kami membuat model baru, filem. Setiap filem mempunyai empat sifat yang berkaitan dengannya - tajuk, tahun pelepasan, pengarah, dan genre. Akhirnya, kami meletakkan model dalam modul.exports supaya kami dapat mengaksesnya dari luar.

Membuat laluan

Semua laluan kami pergi ke laluan/filem.js. Untuk memulakan, tambahkan yang berikut ke fail filem.js anda:

<span>var Movie = require('../models/movie');
</span><span>var express = require('express');
</span><span>var router = express.<span>Router</span>();</span>

Express 4 mempunyai kaedah baru yang dipanggil Express.Router () yang memberikan kita contoh penghala baru. Ia boleh digunakan untuk menentukan middlewares dan laluan. Titik menarik mengenai penghala ekspres adalah bahawa ia sama seperti aplikasi mini. Anda boleh menentukan middlewares dan laluan menggunakan penghala ini dan kemudian hanya menggunakannya dalam aplikasi utama anda seperti mana -mana middleware lain dengan memanggil app.use ().

mendapatkan semua filem

Apabila pengguna menghantar permintaan GET ke /API /filem, kami harus menghantar respons yang mengandungi semua filem. Berikut adalah coretan yang mewujudkan laluan untuk ini.

router<span>.route('/movies').get(function(req<span>, res</span>) {
</span>  <span>Movie.find(function(err<span>, movies</span>) {
</span>    <span>if (err) {
</span>      <span>return res.send(err);
</span>    <span>}
</span>
    res<span>.json(movies);
</span>  <span>});
</span><span>});</span>

Router.Route () Mengembalikan satu contoh laluan yang boleh digunakan untuk mengkonfigurasi satu atau lebih kata kerja HTTP. Di sini, kami ingin menyokong permintaan GET. Jadi, kami panggil mendapatkan () dan lulus panggilan balik yang akan dipanggil apabila permintaan tiba. Di dalam panggilan balik kami mengambil semua filem menggunakan Mongoose dan menghantarnya kembali kepada pelanggan sebagai JSON.

mencipta filem baru

API kami harus membuat filem baru dalam pangkalan data apabila permintaan pos dibuat ke /API /filem. Rentetan JSON mesti dihantar sebagai badan permintaan. Kami akan menggunakan laluan yang sama, /filem, tetapi gunakan kaedah pos () dan bukannya GET ().

inilah kod:

router<span>.route('/movies').post(function(req<span>, res</span>) {
</span>  <span>var movie = new Movie(req.body);
</span>
  movie<span>.save(function(err) {
</span>    <span>if (err) {
</span>      <span>return res.send(err);
</span>    <span>}
</span>
    res<span>.send({ message: 'Movie Added' });
</span>  <span>});
</span><span>});</span>

di sini, kami membuat contoh filem baru dari badan permintaan. Di sinilah badan parser digunakan. Kemudian kami hanya menyimpan filem baru dan menghantar respons yang menunjukkan bahawa operasi itu berjaya.

Perhatikan bahawa kaedah mendapatkan (), pos (), dan lain -lain. Kembalikan contoh laluan yang sama. Oleh itu, anda boleh berantai dua panggilan sebelumnya seperti yang ditunjukkan di bawah.

router<span>.route('/movies')
</span>  <span>.get(function(req<span>, res</span>) {
</span>    <span>Movie.find(function(err<span>, movies</span>) {
</span>      <span>if (err) {
</span>        <span>return res.send(err);
</span>      <span>}
</span>
      res<span>.json(movies);
</span>    <span>});
</span>  <span>})
</span>  <span>.post(function(req<span>, res</span>) {
</span>    <span>var movie = new Movie(req.body);
</span>
    movie<span>.save(function(err) {
</span>      <span>if (err) {
</span>        <span>return res.send(err);
</span>      <span>}
</span>
      res<span>.send({ message: 'Movie Added' });
</span>    <span>});
</span>  <span>});</span>

Mengemas kini filem

Jika pengguna ingin mengemas kini filem, mereka perlu menghantar permintaan Put ke/API/Filem/: ID dengan rentetan JSON sebagai badan permintaan. Kami menggunakan parameter yang dinamakan: ID untuk mengakses filem sedia ada. Seperti yang kita gunakan MongoDB, semua filem kita mempunyai pengenal unik yang dipanggil _ID. Jadi, kita hanya perlu mengambil parameter: id dan gunakannya untuk mencari filem tertentu. Kod untuk melakukan ini ditunjukkan di bawah.

<span>{
</span>  <span>"name": "Movie CRUD API",
</span>  <span>"version": "0.0.1",
</span>  <span>"private": true,
</span>  <span>"scripts": {
</span>    <span>"start": "node ./bin/www"
</span>  <span>},
</span>  <span>"main":"./bin/www",
</span>  <span>"engines": {
</span>     <span>"node": "0.10.x"
</span>   <span>},
</span>  <span>"dependencies": {
</span>    <span>"express": "~4.2.0",
</span>    <span>"body-parser": "~1.0.0",
</span>    <span>"mongoose": "~3.8.11"
</span>  <span>}
</span><span>}</span>

di sini, kami membuat laluan /filem baru /: id dan gunakan kaedah yang diletakkan (). Invokasi filem.findone ({_id: req.params.id}) digunakan untuk mencari filem yang ID diluluskan dalam URL. Sebaik sahaja kami mempunyai contoh filem, kami mengemas kini berdasarkan JSON yang diluluskan dalam badan permintaan. Akhirnya, kami menyimpan filem ini dan menghantar respons kepada pelanggan.

Mendapatkan filem

Untuk membaca filem tunggal, pengguna perlu menghantar permintaan GET ke laluan/API/filem/: ID. Kami akan menggunakan laluan yang sama seperti di atas, tetapi gunakan GET () kali ini.

<span>var mongoose=require('mongoose');
</span><span>var Schema=mongoose.<span>Schema</span>;
</span>
<span>var movieSchema = new Schema({
</span>  <span>title: String,
</span>  <span>releaseYear: String,
</span>  <span>director: String,
</span>  <span>genre: String
</span><span>});
</span>
module<span>.exports = mongoose.model('Movie', movieSchema);</span>

selebihnya kod itu cukup mudah. Kami mengambil filem berdasarkan ID yang diluluskan dan menghantarnya kepada pengguna.

Menghapus filem

Untuk memadam filem, pengguna harus menghantar permintaan padam ke/API/MOVIE/: ID. Sekali lagi, laluannya sama seperti di atas, tetapi kaedahnya berbeza (iaitu padam ()).

<span>var Movie = require('../models/movie');
</span><span>var express = require('express');
</span><span>var router = express.<span>Router</span>();</span>

filem kaedah.remove () memadam filem dari pangkalan data, dan kami menghantar mesej kepada pengguna yang menunjukkan kejayaan.

Sekarang kita semua sudah siap. Tetapi tunggu! Kita perlu meletakkan contoh penghala dalam modul.exports supaya kita boleh menggunakannya dalam aplikasi kita sebagai middlewaree. Jadi, ini adalah baris terakhir dalam filem.js fail:

router<span>.route('/movies').get(function(req<span>, res</span>) {
</span>  <span>Movie.find(function(err<span>, movies</span>) {
</span>    <span>if (err) {
</span>      <span>return res.send(err);
</span>    <span>}
</span>
    res<span>.json(movies);
</span>  <span>});
</span><span>});</span>

Mengkonfigurasi aplikasi

Semua konfigurasi kami masuk ke app.js. Kami mulakan dengan memerlukan modul yang diperlukan:

router<span>.route('/movies').post(function(req<span>, res</span>) {
</span>  <span>var movie = new Movie(req.body);
</span>
  movie<span>.save(function(err) {
</span>    <span>if (err) {
</span>      <span>return res.send(err);
</span>    <span>}
</span>
    res<span>.send({ message: 'Movie Added' });
</span>  <span>});
</span><span>});</span>

Langkah seterusnya adalah menyambung ke MongoDB melalui Mongoose:

router<span>.route('/movies')
</span>  <span>.get(function(req<span>, res</span>) {
</span>    <span>Movie.find(function(err<span>, movies</span>) {
</span>      <span>if (err) {
</span>        <span>return res.send(err);
</span>      <span>}
</span>
      res<span>.json(movies);
</span>    <span>});
</span>  <span>})
</span>  <span>.post(function(req<span>, res</span>) {
</span>    <span>var movie = new Movie(req.body);
</span>
    movie<span>.save(function(err) {
</span>      <span>if (err) {
</span>        <span>return res.send(err);
</span>      <span>}
</span>
      res<span>.send({ message: 'Movie Added' });
</span>    <span>});
</span>  <span>});</span>

Akhirnya, kita mengkonfigurasi middleware:

router<span>.route('/movies/:id').put(function(req<span>,res</span>){
</span>  <span>Movie.findOne({ _id: req.params.id }, function(err<span>, movie</span>) {
</span>    <span>if (err) {
</span>      <span>return res.send(err);
</span>    <span>}
</span>
    <span>for (prop in req.body) {
</span>      movie<span>[prop] = req.body[prop];
</span>    <span>}
</span>
    <span>// save the movie
</span>    movie<span>.save(function(err) {
</span>      <span>if (err) {
</span>        <span>return res.send(err);
</span>      <span>}
</span>
      res<span>.json({ message: 'Movie updated!' });
</span>    <span>});
</span>  <span>});
</span><span>});</span>

seperti yang anda lihat saya telah menggunakan penghala seperti mana -mana middleware lain. Saya lulus /API sebagai hujah pertama untuk app.use () supaya middleware laluan dipetakan ke /API. Jadi, pada akhirnya URL API kami menjadi:

• /api/filem
• /api/filem/: id

bootstrapping

Kod berikut dimasukkan ke dalam bin/www.js, yang bootstraps aplikasi kami:

router<span>.route('/movies/:id').get(function(req<span>, res</span>) {
</span>  <span>Movie.findOne({ _id: req.params.id}, function(err<span>, movie</span>) {
</span>    <span>if (err) {
</span>      <span>return res.send(err);
</span>    <span>}
</span>
    res<span>.json(movie);
</span>  <span>});
</span><span>});</span>

dengan menjalankan nod bin/www.js, API anda harus naik!

Menguji API

Sekarang kita telah mencipta API kita harus mengujinya untuk memastikan semuanya berfungsi seperti yang diharapkan. Anda boleh menggunakan Postman, sambungan Chrome, untuk menguji semua titik akhir anda. Berikut adalah beberapa tangkapan skrin yang menunjukkan pos dan mendapatkan permintaan yang diuji di Postman.

Kesimpulan

Ini adalah gambaran asas bagaimana anda boleh membuat API yang tenang dengan mudah dengan nod dan ekspres. Jika anda ingin menggali lebih mendalam ke dalam Express pastikan anda menyemak dokumen mereka. Sekiranya anda ingin menambah atau bertanya sesuatu, sila komen.

kod sumber untuk aplikasi tersedia untuk dimuat turun di GitHub.

Soalan Lazim (Soalan Lazim) Mengenai Mewujudkan API RESTful dengan Express 4

Apakah perbezaan antara API yang tenang dan jenis API lain? Mereka tidak bertauliah, yang bermaksud setiap permintaan dari klien ke pelayan mesti mengandungi semua maklumat yang diperlukan untuk memahami dan memproses permintaan. Ini berbeza daripada jenis API lain, seperti sabun, yang dapat mengekalkan keadaan antara permintaan. API yang tenang juga menggunakan kaedah HTTP standard, seperti Get, Post, Put, Padam, menjadikannya mudah difahami dan digunakan. 4, anda boleh membuat laluan asas menggunakan kaedah app.get (). Kaedah ini mengambil dua hujah: jalan dan fungsi panggil balik. Fungsi panggil balik dilaksanakan apabila permintaan GET dibuat ke laluan yang ditentukan. Berikut adalah contoh:

app.get ('/', function (req, res) { res.send ('hello world!'); ); Permintaan GET dibuat ke Laluan Root ('/'), pelayan akan bertindak balas dengan 'Hello World!'.

Bagaimana saya mengendalikan permintaan pos di Express 4? Permintaan pos masuk Express 4, anda boleh menggunakan kaedah app.post (). Kaedah ini berfungsi sama dengan app.get (), tetapi ia digunakan untuk permintaan pos dan bukannya mendapatkan permintaan. Berikut adalah contoh:

app.post ('/', fungsi (req, res) { res.send ('permintaan pos yang diterima'); ); Permintaan pos dibuat ke laluan akar ('/'), pelayan akan bertindak balas dengan 'permintaan pos yang diterima'. > Middleware Fungsi adalah fungsi yang mempunyai akses kepada objek permintaan (REQ), objek tindak balas (RES), dan fungsi seterusnya dalam kitaran permintaan permintaan aplikasi. Fungsi seterusnya adalah fungsi dalam penghala ekspres yang, apabila dipanggil, melaksanakan middleware yang berjaya middleware semasa. Fungsi middleware boleh melaksanakan tugas-tugas berikut: Melaksanakan sebarang kod, buat perubahan pada permintaan dan objek tindak balas, tamatkan kitaran permintaan-tindak balas, hubungi middleware seterusnya dalam timbunan. 4?

Express 4 menyediakan pengendali ralat terbina dalam, yang menjaga sebarang kesilapan yang mungkin berlaku dalam aplikasinya. Jika anda perlu mengendalikan kesilapan tertentu, anda boleh membuat fungsi middleware pengendalian kesilapan anda sendiri. Berikut adalah contoh:
app.use (function (err, req, res, next) { console.error (err.stack); res.status (500) .send ('Sesuatu yang pecah! ');

Bagaimana saya menggunakan parameter dalam 4 laluan Express?

Anda boleh menggunakan parameter laluan untuk menangkap nilai dinamik dalam URL. Nilai -nilai ini kemudiannya boleh digunakan oleh pengendali laluan anda. Berikut adalah contoh:
app.get ('/users/: userId', function (req, res) { res.send ('id user adalah:' req.params.userid); } );
Dalam contoh ini, apabila permintaan GET dibuat kepada '/pengguna/123', pelayan akan bertindak balas dengan 'ID Pengguna ialah: 123'. Dalam Express 4?

Express 4 menyediakan fungsi middleware terbina dalam, Express.Static (), untuk melayani fail statik. Anda boleh menggunakannya untuk menyampaikan fail dari direktori pada pelayan anda. Berikut adalah contoh:

app.use (Express.Static ('public'));

Dalam contoh ini, fail dalam direktori 'awam' boleh diakses terus dari url akar ('/').

Bagaimana saya menggunakan middleware badan-parser di Express 4?
Middleware badan-parser digunakan untuk menghuraikan badan permintaan masuk. Ini membolehkan anda mengakses badan permintaan pos melalui Req.body. Berikut adalah contoh:
var bodyParser = memerlukan ('body-parser');

app.use (bodyParser.json ()); );

Dalam contoh ini, middleware badan-parser dikonfigurasi untuk menghuraikan badan json dan url yang dikodkan. Saya mengendalikan 404 kesilapan dalam Express 4?

Anda boleh mengendalikan 404 ralat dengan menambahkan fungsi middleware pada akhir stack middleware anda. Fungsi ini akan dilaksanakan jika tiada pengendali laluan lain atau fungsi middleware telah mengendalikan permintaan tersebut. Berikut adalah contoh:
app.use (fungsi (req, res, seterusnya) { res.status (404) .send ('Maaf, kita tidak dapat mencari itu!'); 🎜> Dalam contoh ini, jika permintaan dibuat ke jalan yang tidak wujud, pelayan akan bertindak balas dengan kod status 404 dan mesej 'Maaf, kita tidak dapat mencari itu!'.

Bagaimana Saya Menggunakan Express Router dalam Express 4?

Express Router adalah aplikasi mini di Express 4 yang membolehkan anda mengatur laluan anda dengan cara modular. Anda boleh membuat penghala baru dengan Express.Router (), tambah middleware dan laluan kepadanya, dan kemudian gunakannya dalam aplikasi anda dengan app.use (). Berikut adalah contoh:

var router = express.Router ();

router.get ('/', function (req, res) { res.send ('Hello from the router!');

});
app.use ('/router', router);
Dalam contoh ini, apabila permintaan mendapatkan dibuat kepada '/penghala', pelayan akan Balas dengan 'Hello from the Router!'.

Atas ialah kandungan terperinci Membuat API RESTful dengan Express 4. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!