Cara Membuat API REST pertama anda dengan Fastify

Takeaways Key

Fastify menyediakan alternatif yang ringan dan cepat untuk membina API REST, mengatasi rangka kerja Node.js lain seperti Express dan HAPI.
Menyediakan API Fastify melibatkan langkah -langkah mudah seperti memulakan projek, memasang Fasttify, dan membuat pelayan asas dan persediaan laluan.
Ekosistem Plugin yang mantap Fastify membolehkan integrasi mudah dan lanjutan fungsi, meningkatkan pengalaman pemaju tanpa mencipta semula roda.
Menambah Pengesahan Skema dalam Fastify memastikan permintaan dan respons API mematuhi format yang telah ditetapkan, meningkatkan kebolehpercayaan dan pengendalian kesilapan.
Menggunakan cangkuk Fastify membolehkan pemaju memintas pelbagai acara kitaran hayat, yang menawarkan kawalan yang lebih besar ke atas aliran aplikasi dan tingkah laku.

Fasttify adalah rangka kerja yang direka untuk pembangunan web back-end. Ia menawarkan alternatif yang lebih ringan untuk kerangka API Node.js yang lebih berat, seperti HAPI dan Express. Dari Julai 2020, Fultify telah mengeluarkan versi ketiga rangka kerja.

Versi ketiga ini dilengkapi dengan kebolehan pengesahan yang lebih baik untuk mengesahkan permintaan masuk dan keluar, sebagai parameter permintaan. Lebih -lebih lagi, versi ketiga rangka kerja menyatukan tuntutannya sebagai rangka kerja Node.js terpantas berbanding dengan KOA, Resitfy, HAPI, dan Express. Maklumat lanjut boleh didapati di halaman penanda aras.

Fasttify telah mendapat banyak populariti kerana reka bentuk ringannya. Walau bagaimanapun, banyak perhatian pergi ke ekosistem pluginnya. Fasttify telah mengadopsi idea bahawa segala -galanya adalah plugin, sedangkan dengan JavaScript, semuanya adalah objek. Ini membolehkan anda dengan cepat merangkumi fungsi untuk projek anda sebagai plugin dan mengedarkannya supaya projek -projek lain dapat menggunakan kod anda.

mari kita mulakan dengan tutorial ini. Anda akan mempelajari aspek berikut Fastify:

bagaimana untuk menyediakan API Fastify pertama anda
bagaimana untuk menentukan laluan API fasttify
Cara Menambah Pengesahan Skema ke Permintaan
bagaimana memuatkan dan menggunakan fastlify plugin
bagaimana untuk menentukan cangkuk fasttify

Keperluan dan Pemasangan

untuk mengikuti tutorial ini, anda perlukan:

versi node.js terbaru
alat untuk menghantar permintaan, seperti curl atau posman

Seterusnya, pastikan untuk membuat projek Node.js kosong. Jika anda belum mempunyai satu lagi, anda boleh menggunakan arahan berikut untuk menubuhkan projek anda:

<span>npm init -y
</span>

Akhir sekali, kami ingin menambah kebergantungan ini kepada projek kami:

<span>npm i fastify --save
</span>

semua baik? Mari buat persediaan API asas kami dalam langkah seterusnya.

Langkah 1: Persediaan API Asas

Pertama, mari buat persediaan API asas kami. Untuk bermula, kita perlu membuat fail baru yang dipanggil Index.js dalam Root Projek kami:

<span>touch index.js
</span>

Seterusnya, mari tambahkan persediaan pelayan asas. Salin kod di bawah:

<span>npm init -y
</span>

Terdapat beberapa perkara yang berlaku di sini. Kami terlebih dahulu memuatkan objek aplikasi Fasttify dan membolehkan pembalakan. Seterusnya, kami mengisytiharkan laluan akar yang membalas dengan tindak balas JSON. Bahagian terakhir coretan kod menunjukkan bahawa kami sedang mendengar di Port 3000 untuk permohonan untuk menerima permintaan.

mari kita sahkan jika persediaan pelayan asas anda berfungsi. Pertama, kita perlu memulakan pelayan dengan menjalankan fail index.js:

<span>npm i fastify --save
</span>

Selepas itu, navigasi ke http: // localhost: 3000 dalam penyemak imbas anda. Anda harus melihat tindak balas berikut:

<span>touch index.js
</span>

kejayaan? Mari pergi ke Langkah 2 untuk menentukan laluan CRUD yang berbeza.

Langkah 2: Tentukan Laluan CRUD

API tidak berguna dengan hanya mendapatkan laluan. Mari kita tentukan lebih banyak laluan untuk mengendalikan blog. Oleh itu, mari kita buat laluan berikut:

• Dapatkan semua blog di /API /Blogs
• Dapatkan satu blog di/api/blog/: id
• post tambah blog di /api /blog
• meletakkan blog kemas kini di/api/blog/: id
• Padam Blog Padam di/API/Blogs/: id

Perkara pertama yang perlu dilakukan ialah membuat pengawal blog.

Langkah 2.1: Buat Pengawal Blog

Untuk memastikan kod kami bersih, mari kita tentukan folder pengawal dalam root projek. Di sini, kami membuat fail yang dipanggil Blogs.js.

Fail ini mengandungi beberapa data demo untuk mengelakkan merumitkan tutorial ini dengan integrasi pangkalan data. Oleh itu, kami menggunakan array yang mengandungi objek blog yang masing -masing mengandungi medan ID dan tajuk.

Selain itu, kami menentukan pengendali yang berbeza untuk semua laluan di atas dalam fail ini. Pengendali sentiasa menerima parameter REQ (permintaan) dan balas. Parameter permintaan berguna untuk mengakses parameter permintaan atau data badan permintaan.

tambahkan kod berikut ke fail /controller/blogs.js anda:

<span>// Require the framework and instantiate it
</span><span>const app = require('fastify')({
</span>    <span>logger: true
</span><span>})
</span>
<span>// Declare a route
</span>app<span>.get('/', function (req<span>, reply</span>) {
</span>    reply<span>.send({ hello: 'world' })
</span><span>})
</span>
<span>// Run the server!
</span>app<span>.listen(3000, (err<span>, address</span>) => {
</span>    <span>if (err) {
</span>        app<span>.log.error(err)
</span>        process<span>.exit(1)
</span>    <span>}
</span>    app<span>.log.info(<span>`server listening on <span>${address}</span>`</span>)
</span><span>})
</span>

Perhatikan bagaimana kita boleh mengakses parameter permintaan untuk laluan seperti/API/Blogs/: id melalui req.params.id. Untuk pos dan meletakkan laluan, kami boleh mengakses badan permintaan melalui Req.body.

Dalam langkah 2.2, kami akan menyambungkan pengendali laluan ke objek laluan.

Langkah 2.2: Tentukan laluan blog dan pengawal blog pasangan

Sekali lagi, untuk memastikan kod kami bersih, mari kita tentukan folder laluan dalam root projek. Di sini, kami membuat fail yang dipanggil Blogs.js. Fail ini memegang objek laluan untuk laluan blog kami:

<span>node index.js
</span>

bernasib baik, fastify membolehkan kita menentukan array yang mengandungi objek laluan. Di sini, kita boleh pasangan pengendali yang telah kami tentukan sebelum ini ke laluan yang berbeza. Jangan lupa untuk memerlukan pengawal blog. Mari kita lihat:

<span>{
</span>    <span>"hello": "world"
</span><span>}
</span>

Sekarang kami telah menentukan semua laluan. Walau bagaimanapun, Fasttify tidak tahu mengenai laluan ini. Langkah seterusnya menunjukkan bagaimana anda boleh mendaftarkan laluan dengan objek aplikasi Fasttify anda.

Langkah 2.3: Daftar Fasttify Routes

Dalam langkah ini, kami akan mendaftarkan Fasttify Routes ke objek App. Pertama, kita memuat semua laluan blog. Seterusnya, kami gelung ke atas semua laluan untuk mendaftarkannya satu demi satu:

<span>npm init -y
</span>

selesai? Sudah tiba masanya untuk mengesahkan jika laluan blog berfungsi. Putar pelayan menggunakan nod index.js dan lawati http: // localhost: 3000/blog/1 untuk mendapatkan blog pertama dari data demo. Anda harus melihat hasil berikut:

<span>npm i fastify --save
</span>

semua baik? Mari kita pelajari dalam langkah 3 Bagaimana untuk menambah pengesahan skema kepada permintaan dan respons.

Langkah 3: Menambah Pengesahan Skema

Langkah ini mengajar anda cara menambah pengesahan skema ke projek anda. Kami boleh menggunakan kunci skema dalam definisi laluan kami untuk lulus skema pengesahan ke laluan tertentu.

Mari kita mulakan dengan menentukan skema untuk laluan/API/blog/: id untuk mengesahkan parameter permintaan dan tindak balas. Keperluan?

1. : parameter ID mestilah jenis rentetan
2. Respons mesti mengandungi objek dengan dua ID Properties (Integer) dan Tajuk (String)

Tambahkan objek pengesahan berikut ke fail Laluan/Blogs.js anda:

<span>touch index.js
</span>

Untuk menyambungkan objek pengesahan ke laluan kami, kami perlu menentukan kunci skema. Cari/API/Blogs/: Laluan ID dalam pelbagai laluan dan tukar objek dengan sewajarnya:

<span>// Require the framework and instantiate it
</span><span>const app = require('fastify')({
</span>    <span>logger: true
</span><span>})
</span>
<span>// Declare a route
</span>app<span>.get('/', function (req<span>, reply</span>) {
</span>    reply<span>.send({ hello: 'world' })
</span><span>})
</span>
<span>// Run the server!
</span>app<span>.listen(3000, (err<span>, address</span>) => {
</span>    <span>if (err) {
</span>        app<span>.log.error(err)
</span>        process<span>.exit(1)
</span>    <span>}
</span>    app<span>.log.info(<span>`server listening on <span>${address}</span>`</span>)
</span><span>})
</span>

mari kita lakukan yang sama untuk menambah postingan blog /API /blog. Di sini, kami ingin mengesahkan sama ada objek Req.body mengandungi parameter tajuk. Mari kita lihat:

<span>node index.js
</span>

Seterusnya, kita perlu menyambungkan objek pengesahan sekali lagi ke laluan yang betul:

<span>{
</span>    <span>"hello": "world"
</span><span>}
</span>

Untuk mengesahkan pengesahan kami, mari kita ambil blog dengan ID 3. Buka penyemak imbas anda di http: // localhost: 3000/api/blog/3. Anda harus melihat tindak balas berikut:

<span>// Demo data
</span><span>let blogs = [
</span>    <span>{
</span>        <span>id: 1,
</span>        <span>title: 'This is an experiment'
</span>    <span>},
</span>    <span>{
</span>        <span>id: 2,
</span>        <span>title: 'Fastify is pretty cool'
</span>    <span>},
</span>    <span>{
</span>        <span>id: 3,
</span>        <span>title: 'Just another blog, yea!'
</span>    <span>}
</span><span>]
</span>
<span>// Handlers
</span><span>const getAllBlogs = async (req<span>, reply</span>) => {
</span>    <span>return blogs
</span><span>}
</span>
<span>const getBlog = async (req<span>, reply</span>) => {
</span>    <span>const id = Number(req.params.id) // blog ID
</span>    <span>const blog = blogs.find(blog => blog.id === id)
</span>    <span>return blog
</span><span>}
</span>
<span>const addBlog = async (req<span>, reply</span>) => {
</span>    <span>const id = blogs.length + 1 // generate new ID
</span>    <span>const newBlog = {
</span>        id<span>,
</span>        <span>title: req.body.title
</span>    <span>}
</span>
    blogs<span>.push(newBlog)
</span>    <span>return newBlog
</span><span>}
</span>
<span>const updateBlog = async (req<span>, reply</span>) => {
</span>    <span>const id = Number(req.params.id)
</span>    blogs <span>= blogs.map(blog => {
</span>        <span>if (blog.id === id) {
</span>            <span>return {
</span>                id<span>,
</span>                <span>title: req.body.title
</span>            <span>}
</span>        <span>}
</span>    <span>})
</span>
    <span>return {
</span>        id<span>,
</span>        <span>title: req.body.title
</span>    <span>}
</span><span>}
</span>
<span>const deleteBlog = async (req<span>, reply</span>) => {
</span>    <span>const id = Number(req.params.id)
</span>
    blogs <span>= blogs.filter(blog => blog.id !== id)
</span>    <span>return { msg: <span>`Blog with ID <span>${id}</span> is deleted`</span> }
</span><span>}
</span>
module<span>.exports = {
</span>    getAllBlogs<span>,
</span>    getBlog<span>,
</span>    addBlog<span>,
</span>    updateBlog<span>,
</span>    deleteBlog
<span>}
</span>

Sekarang, mari kita membuat kesilapan dan ubah pengesahan param untuk medan ID dari Sting ke objek seperti:

<span>mkdir routes
</span><span>cd routes
</span><span>touch blogs.js
</span>

Apabila meminta sumber yang sama dari API anda, anda akan menerima mesej ralat berikut.

<span>const blogController = require('../controller/blogs');
</span>
<span>const routes = [{
</span>        <span>method: 'GET',
</span>        <span>url: '/api/blogs',
</span>        <span>handler: blogController.getAllBlogs
</span>    <span>},
</span>    <span>{
</span>        <span>method: 'GET',
</span>        <span>url: '/api/blogs/:id',
</span>        <span>handler: blogController.getBlog
</span>    <span>},
</span>    <span>{
</span>        <span>method: 'POST',
</span>        <span>url: '/api/blogs',
</span>        <span>handler: blogController.addBlog
</span>    <span>},
</span>    <span>{
</span>        <span>method: 'PUT',
</span>        <span>url: '/api/blogs/:id',
</span>        <span>handler: blogController.updateBlog
</span>    <span>},
</span>    <span>{
</span>        <span>method: 'DELETE',
</span>        <span>url: '/api/blogs/:id',
</span>        <span>handler: blogController.deleteBlog
</span>    <span>}
</span><span>]
</span>module<span>.exports = routes
</span>

Adakah anda melihat ralatnya? Baik! Mari kita kembali perubahan kepada rentetan untuk mengelakkan kesilapan masa depan dan bergerak ke langkah seterusnya.

Langkah 4: Muatkan Plugin Fastlify

di sini, mari kita gunakan ekosistem plugin kaya Fastify. Anda boleh mencari plugin yang membantu anda dengan pelbagai tugas, seperti integrasi pangkalan data atau persediaan kebenaran. Kenapa anda menghabiskan masa menulis kebenaran dari awal semasa anda boleh menggunakan plugin Fastify? Sering kali, anda ingin mencari pakej di luar ekosistem Fastify yang membantu anda dengan masalah atau tugas tertentu. Walau bagaimanapun, dengan menyediakan ekosistem plugin yang kaya, Fasttify menjadi penyelesaian sehenti yang pasti meningkatkan pengalaman pemaju!

Nota cepat mengenai plugin: Anda boleh membuat plugin anda sendiri untuk merangkum fungsi. Selain itu, anda boleh memuatkan plugin tersebut ke objek aplikasi Fastify anda. Secara lalai, Fasttify akan memuatkan plugin terlebih dahulu dari ekosistem Fasttify. Selepas itu, plugin tersuai dimuatkan.

OK, mari kita praktikal! Saya ingin menggunakan plugin Fastify-ENV, yang membantu anda memuatkan pembolehubah persekitaran dan menetapkan lalai untuk setiap pembolehubah. Oleh itu, mari tambahkan kebergantungan ini kepada projek kami:

<span>npm init -y
</span>

Seterusnya, kita boleh memuatkan kebergantungan selepas memuatkan objek aplikasi Fasttify dalam fail index.js. Fail index.js anda kelihatan seperti ini:

<span>npm i fastify --save
</span>

Perhatikan bahawa kita perlu menentukan objek Opsyen yang memberitahu plugin Fastify-ENV apa yang dibolehbarisan untuk mencari dan yang mungkir hendak ditetapkan. Di sini, saya ingin memuatkan pembolehubah port dengan nilai lalai 1000.

Secara lalai, plugin Fastify-ENV akan menjadikan semua pembolehubah persekitaran tersedia melalui objek aplikasi Fasttify seperti SO: app.config.port. Kenapa? Plugin Fastify-ENV melampirkan konfigurasi yang dimuatkan ke confkey, yang secara lalai ditetapkan ke konfigurasi. Walau bagaimanapun, jika anda mahu, anda boleh mengubahnya ke kunci lain.

Mulakan projek dengan nod index.js dan memantau output. Anda harus melihat pembolehubah port yang dicetak di terminal anda.

plugin lain yang menarik untuk digunakan?

1. Fasttify-Auth: Jalankan pelbagai fungsi auth dalam fastify
2. fastify-bearer-auth: plugin pengarang pembawa untuk fastify
3. Fasttify-Caching: Cache-Side Cache dan Sokongan ETAG
4. Fasttify-CORS: Membolehkan penggunaan CORS dalam aplikasi Fastify

Langkah 5: Tentukan cangkuk

Akhir sekali, mari kita tentukan beberapa cangkuk. Dari dokumentasi Fasttify Hooks, kami dapat membaca perkara berikut. "Cangkuk didaftarkan dengan kaedah fastify.addhook dan membolehkan anda mendengar peristiwa tertentu dalam kitaran hayat permohonan atau permintaan/tindak balas. Anda perlu mendaftarkan cangkuk sebelum acara itu dicetuskan, jika tidak, peristiwa itu hilang. "

Pastikan untuk menentukan cangkuk sebelum anda menentukan sebarang laluan:

<span>touch index.js
</span>

Seperti yang anda lihat, fungsi Addhook mula -mula menerima cangkuk yang ingin anda dengar. Dalam contoh kami, kami ingin mendengar laluan baru yang didaftarkan dengan permohonan itu. Seterusnya, fungsi panggil balik menerima hujah RouteOptions yang mengandungi banyak maklumat, seperti URL laluan atau kaedah laluan.

butiran khusus untuk cangkuk onroute boleh didapati dalam dokumentasi.

mari kita mulakan API dengan nod index.js untuk melihat laluan mana yang telah didaftarkan. Output terminal anda sepatutnya kelihatan seperti ini:

<span>// Require the framework and instantiate it
</span><span>const app = require('fastify')({
</span>    <span>logger: true
</span><span>})
</span>
<span>// Declare a route
</span>app<span>.get('/', function (req<span>, reply</span>) {
</span>    reply<span>.send({ hello: 'world' })
</span><span>})
</span>
<span>// Run the server!
</span>app<span>.listen(3000, (err<span>, address</span>) => {
</span>    <span>if (err) {
</span>        app<span>.log.error(err)
</span>        process<span>.exit(1)
</span>    <span>}
</span>    app<span>.log.info(<span>`server listening on <span>${address}</span>`</span>)
</span><span>})
</span>

mendapat output yang sama? Kejayaan! Pada masa yang sama, ini adalah akhir tutorial Fastify. Mari kita bungkus projek ini dengan kesimpulan yang singkat.

membungkus

Fasttify adalah projek yang hebat dan ringan yang membolehkan anda menggunakan ekosistem pluginnya yang kaya. Daripada mewujudkan fungsi dari awal, anda boleh menggunakan plugin sedia ada. Dalam erti kata lain, Fasttify bertindak sebagai kedai sehenti untuk pemaju, pasti meningkatkan pengalaman pemaju.

Secara peribadi, saya suka fungsi cangkuk Fasttify kerana anda boleh mendengar pelbagai acara kitaran hayat dalam permohonan anda.

Untuk mengetahui lebih lanjut mengenai Fasttify, lihat halaman dokumentasi berikut:

• bagaimana membuat plugin tersuai?
• bagaimana untuk menambah sokongan typescript?
• bagaimana menggunakan middleware seperti cors?

anda juga boleh menyemak repo untuk pengenalan ini di GitHub.

Soalan Lazim (Soalan Lazim) Mengenai Membuat API REST dengan Fastify

Apakah prasyarat untuk mencipta API REST dengan Fastify? Anda juga harus mempunyai Node.js dan NPM yang dipasang pada komputer anda. Node.js adalah runtime JavaScript yang membolehkan anda menjalankan JavaScript di pelayan anda, sementara NPM adalah pengurus pakej untuk node.js yang membolehkan anda memasang dan menguruskan pakej yang bergantung kepada projek anda. Pasang Fasttify?

Anda boleh memasang Fasttify menggunakan NPM, Pengurus Pakej Node.js. Buka terminal anda dan jalankan arahan berikut: NPM Pasang Fastify. Ini akan memasang Fasttify dalam direktori projek semasa anda. Pastikan anda berada di direktori yang betul sebelum menjalankan arahan. bagaimana saya membuat pelayan dengan fastify?

permohonan anda. Kemudian, anda boleh membuat contoh Fastify baru. Berikut adalah contoh asas:

constylify = memerlukan ('fasttify') ({logger: true})

fastify.listen (3000, (err, alamat) => {

jika (err) lemparkan err

fastify.log.info (`Server mendengar pada $ {alamat}}`)

)

bagaimana saya menentukan laluan dalam fastify?

Dalam Fasttify, anda menentukan laluan menggunakan kaedah laluan. Kaedah ini mengambil objek sebagai hujah, yang mentakrifkan sifat laluan. Berikut adalah contoh:

fastify.route ({
kaedah: 'get',

url: '/',

handler: function (request, balas) {

Balas .send ({hello: 'world'})

}
})

Bagaimana saya mengendalikan kesilapan dalam fastify? Anda boleh menggunakan kod objek balasan dan menghantar kaedah untuk menghantar respons ralat. Berikut adalah contoh:

fastify.get ('/error', fungsi (permintaan, balasan) { Reply.code (500) .send (ralat baru ('ralat pelayan dalaman'))
})

Bagaimana saya menggunakan plugin dalam fastify?

Fastify mempunyai seni bina plugin yang kuat yang membolehkan anda melanjutkan fungsinya. Anda boleh menggunakan kaedah daftar untuk mendaftarkan plugin. Berikut adalah contoh:

fastify.register (memerlukan ('fastify-cors'), { asal: true
})

Bagaimana saya mengesahkan permintaan dalam fastify?

Anda boleh menggunakan perpustakaan ini untuk mengesahkan permintaan masuk dan bersiri respons keluar. Berikut adalah contoh:

fastify.route ({
kaedah: 'post',
url: '/validate',
skema: {
body: {
Jenis: 'Objek',
Diperlukan: ['Nama', 'E -mel'],
Properties: {
Nama: {type: 'String'},
email: {type: 'String '}
}
}
},
handler: function (request, balas) {
Reply.send ({hello:' world '})
}
} ? Berikut adalah contoh:

fastify.Inject ({

kaedah: 'get',

url: '/',

}, (err, response) => {
console.log (response.payload)
})

Bagaimana saya menggunakan aplikasi Fastify saya? Anda boleh menggunakan platform seperti Heroku, AWS, atau Google Cloud Platform. Pastikan untuk menetapkan pembolehubah persekitaran NODE_ENV kepada pengeluaran apabila menggunakan aplikasi anda. Anda boleh menggunakan sintaks async/menunggu di pengendali laluan anda untuk menulis kod asynchronous dengan cara yang lebih mudah dibaca. Berikut adalah contoh:

fastify.get ('/async', fungsi async (permintaan, balasan) {
const result = menunggu someAsyncoperation ()

hasil pengembalian

})

Atas ialah kandungan terperinci Cara Membuat API REST pertama anda dengan Fastify. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!