Cara memindahkan aplikasi anda dari ekspres ke fastlify

Express pernah menjadi rangka kerja yang paling popular untuk membangunkan aplikasi web menggunakan Node.js. Walau bagaimanapun, rangka kerja telah mengurangkan perkembangan aktif dalam beberapa tahun kebelakangan ini, mengakibatkan kekurangan sokongan untuk ciri -ciri JavaScript moden. Pada masa yang sama, banyak rangka kerja baru yang mengamalkan pendekatan yang berbeza untuk pembangunan aplikasi Node.js muncul, dan Fasttify adalah salah satu daripada mereka.

Artikel ini akan meneroka mengapa Fastify telah menjadi alternatif yang menarik untuk pembangunan aplikasi web Node.js. Kami akan belajar bagaimana untuk mengelakkan menulis semula aplikasi ekspres yang sedia ada dari awal dan sebaliknya bergerak untuk mengikat langkah demi langkah. Selepas mengkaji artikel ini, anda akan dapat dengan yakin memindahkan aplikasi ekspres anda yang sedia ada dan mula mengambil kesempatan daripada rangka kerja Fastify.

Syarat -syarat berikut mesti dipenuhi semasa membaca artikel ini:

biasa dengan membuat aplikasi ekspres asas, menentukan penghalaan, dan mengkonfigurasi middleware.
biasa dengan arahan berjalan di terminal.
node.js & gt; = v14.13.0 dipasang. Ini memberikan kami sokongan yang baik untuk modul ECMAScript (ES) dan membolehkan kami menggunakan menunggu peringkat atas. Contoh kod dalam artikel ini menggunakan sintaks modul ES (import / eksport).

Semua kod sampel dalam artikel ini boleh didapati di GitHub dan anda boleh melayari, memuat turun dan bereksperimen dengannya.

Versi video artikel ini juga boleh didapati di laman web saya.

mata utama

Fastify menyediakan pengesahan dan pembalakan terbina dalam, sokongan asynchronous asli, dan parsing JSON automatik, meningkatkan kecekapan pembangunan dan prestasi aplikasi berbanding dengan Express.
• Plug-in memudahkan penghijrahan secara beransur-ansur dari Express untuk mengikat dengan membenarkan penggunaan middleware dan penghalaan ekspres dalam rangka kerja Fastify.
• Ujian integrasi harus dirangka-bebas untuk memastikan mereka tetap sah sebelum dan selepas penghijrahan, dengan itu memudahkan proses ujian. fastify-express
Refactoring melibatkan penggantian kod ekspres dengan fastlify setara, seperti menggunakan sistem penghalaan dan pemalam Fastify dan bukannya router ekspres dan middleware.
Proses penghijrahan boleh diadakan, terlebih dahulu mengintegrasikan Fastify ke dalam aplikasi ekspres yang sedia ada, dan kemudian secara beransur -ansur menggantikan komponen ekspres.
Selepas berhijrah, pastikan anda menggantikan middleware Express pihak ketiga dengan plugin Fastify yang setara untuk memanfaatkan prestasi dan keupayaan Fultify.
• faedah berpindah dari ekspres ke fastify

Jika anda sudah biasa dengan aplikasi Node.js bangunan menggunakan Express, anda mungkin tertanya -tanya apa manfaat memindahkan aplikasi Express sedia ada anda untuk mengikat. Berikut adalah beberapa sebab penting untuk mempertimbangkan penghijrahan:

Pengesahan dan pembalakan keluar dari kotak. Ciri -ciri ini biasanya diperlukan semasa membina aplikasi web. Apabila menggunakan Fasttify, tidak perlu memilih dan mengintegrasikan perpustakaan untuk tugas -tugas ini, kerana ia memberikan kita keupayaan ini. Kami akan mengetahui lebih lanjut mengenai ciri -ciri ini kemudian dalam artikel ini.

• Sokongan asli untuk kod tak segerak. Fastify menangani janji dan menyokong async/menunggu. Ini bermakna laluan itu akan menangkap janji -janji yang ditolak untuk kami. Ini membolehkan kita menulis kod tak segerak dengan selamat. Ia juga membolehkan kita melakukan beberapa perkara yang ringkas, seperti menghantar nilai pulangan fungsi pengendali penghalaan secara automatik sebagai badan tindak balas:

  <code>  app.get("/user/:id", async (request) => await getUser(request.params.id));
  </code>

• secara automatik menghuraikan dan bersiri JSON. Kami tidak perlu mengkonfigurasi Fastify untuk menghuraikan badan permintaan JSON, dan tidak perlu bersiri objek ke JSON untuk respons. Ia secara automatik akan mengendalikan semua ini untuk kita:

  <code>  app.get("/user/:id", async (request, reply) => {
      const name = request.body.name;
  
      reply.send({ user: { name } });
    });
  </code>

• Mesra pemaju. Dengan API yang jelas dan ekspresif, dan sokongan yang sangat baik untuk TypeScript, Fasttify direka dengan pengalaman pemaju dalam fikiran.

• Kelajuan pantas. Kami tidak mahu rangka kerja menjadi sumber kemunculan prestasi dalam aplikasi kami. Berita baiknya ialah Fasttify dibina untuk mencapai prestasi tinggi. Penanda aras Fastify menunjukkan bagaimana ia dibandingkan dengan kerangka web Node.js lain.

• secara aktif membangun. Rangka kerja Fastify berada di bawah pembangunan aktif. Penambahbaikan pelepasan dan pembetulan pepijat/keselamatan secara teratur.

bagaimana dengan yakin berhijrah API

kami ingin memastikan bahawa ia masih berfungsi seperti yang dijangkakan selepas permohonan itu dipindahkan untuk mengikat. Satu perkara yang membantu kita melihat kesilapan atau mengenal pasti perubahan yang tidak dijangka ialah ujian integrasi API.

ujian integrasi menguji komponen aplikasi dengan cara yang berbeza daripada ujian unit. Ujian unit fungsi komponen individu. Ujian integrasi membolehkan kami mengesahkan tingkah laku pelbagai komponen yang bekerja bersama -sama.

Jika kita menulis ujian integrasi API untuk aplikasi ekspres, kita mahu dapat menjalankan ujian yang sama selepas memindahkan permohonan untuk mengikat. Semasa menulis ujian integrasi untuk API, perkara berikut perlu dipertimbangkan:

• mereka tidak sepatutnya terikat kepada rangka kerja tertentu. Kami mahu dapat menjalankan ujian yang sama sebelum dan selepas penghijrahan tanpa mengubah ujian atau mana -mana perpustakaan yang kami gunakan.
• Pastikan ia mudah. Sekurang -kurangnya, ujian integrasi harus membuat permintaan ke titik akhir yang terdedah oleh API dan mengesahkan bahawa respons telah dikembalikan, tetapi tidak selalunya lebih. Kami mungkin ingin menyemak kod status HTTP tertentu atau tajuk tindak balas, tetapi kami harus cuba membuat ujian semudah mungkin.
• Pilih alat yang anda kenal. Terdapat banyak alat yang berbeza yang dapat membantu kami membuat dan menjalankan ujian API, tetapi penting untuk menggunakan alat yang kami kenal. Untuk menulis ujian integrasi yang berkesan, kita perlu mengeluarkan permintaan HTTP dan menegaskan respons dari API kami. Secara umumnya, kami tidak memerlukan banyak perpustakaan atau alat untuk mencapai matlamat ini.

Kami tidak akan terperinci tentang cara melaksanakan ujian integrasi API dalam artikel ini, tetapi anda harus mempertimbangkan menulisnya sebelum melakukan migrasi kerangka.

berhijrah dari Express untuk mengikat menggunakan Fastify-Express

Idea untuk memindahkan aplikasi ekspres sedia ada kepada rangka kerja yang sama sekali berbeza mungkin kelihatan agak menakutkan. Nasib baik, pasukan Fastify mencipta plugin - fastlify -express - yang dapat membantu memudahkan laluan penghijrahan.

Plugin Fultify-Express menambah keserasian ekspres penuh untuk mengikat. Ia menyediakan kaedah penggunaan () yang boleh kita gunakan untuk menambah middleware dan laluan Express ke pelayan Fastify kami. Ini memberi kita pilihan untuk secara beransur -ansur memindahkan bahagian -bahagian aplikasi Express sedia ada kami untuk mengikat.

Ini adalah contoh penghala ekspres:

<code>  app.get("/user/:id", async (request) => await getUser(request.params.id));
</code>

kemudian kita boleh menggunakan fastify-express untuk menambah penghala ekspres sedia ada kepada contoh pelayan Fastify:

<code>  app.get("/user/:id", async (request, reply) => {
    const name = request.body.name;

    reply.send({ user: { name } });
  });
</code>

Selepas seketika, kami akan meneroka butiran semua kerja ini ketika kami mula memindahkan permohonan untuk mengikat.

Adalah penting untuk diperhatikan bahawa menggunakan plugin Fastify-Express bukan penyelesaian jangka panjang. Sekiranya kita ingin mendapatkan manfaat penuh Fastify, akhirnya kita perlu memindahkan kod aplikasi khusus Express kami. Walau bagaimanapun, plugin Fastify-Express memberi kita peluang untuk berhijrah untuk mengikat fasa.

Aplikasi Express Contoh kami

kami akan membina aplikasi Express sampel dan kemudian memindahkannya untuk menggunakan rangka kerja Fastify. Sekarang mari kita lihat kodnya.

Ketergantungan yang diperlukan

Pertama, mari buat projek baru:

<code>// src/routes.js
const router = express.Router();

router.get("/:user_id", function getUser(request, response, next) {
  response.json({});
});

export default router;
</code>

kami kemudian akan menjalankan arahan ini di terminal untuk memasang kebergantungan yang diperlukan oleh aplikasi ekspres kami:

<code>// src/server.js

import Fastify from "fastify";
import ExpressPlugin from "fastify-express";

import routes from "./routes.js";

const fastify = Fastify();

await fastify.register(ExpressPlugin);

fastify.use("/user", routes);

await fastify.listen(3000);
</code>

Akhirnya, buka pakej.json dan tambahkan baris berikut di atas bahagian skrip:

<code>mkdir express-to-fastify-migration
cd express-to-fastify-migration
npm init -y
</code>

Ini akan membolehkan kami memuatkan modul ES dalam permohonan kami.

modul penghalaan

kami akan membuat contoh penghala ekspres untuk membantu kami merangkumi penghalaan dan middleware kami. Router di Express boleh digunakan untuk membantu kami menyusun aplikasi ke dalam modul diskret. Sebagai contoh, kami mungkin mempunyai penghala untuk /penghalaan pengguna dan lain -lain untuk /alamat penghalaan. Kami akan melihat kemudian bagaimana ini membantu kami untuk mengekspresikan aplikasi ekspres untuk mengikat.

mari kita buat contoh penghala dan tambahkan beberapa middleware kepadanya:

<code>npm install express cors
</code>

Dalam kod di atas, kami mengkonfigurasi dua contoh middleware ekspres:

• express.json (). Fungsi middleware ini dibina menjadi ekspres. Ia mengendalikan menguraikan badan permintaan JSON.
• cors. Middleware ini membantu kami menambah tajuk CORS ke respons API kami. Ia akan membolehkan API kami dipanggil dari laman web.

Alat middleware ini akan dijalankan terhadap sebarang permintaan yang dibuat oleh mana -mana laluan yang kami tentukan pada penghala ini.

Sekarang kita telah mengkonfigurasi middleware, kita boleh menambah laluan pertama ke penghala kita:

<code>"type": "module",
</code>

Dalam aplikasi sebenar, fungsi pengendali penghalaan di atas akan mengesahkan data yang diterima dan kemudian hubungi pangkalan data untuk membuat rekod pengguna baru. Untuk contoh ini, kami menghantar data yang diterima sebagai badan tindak balas.

sekarang kami akan menambah laluan untuk mendapatkan pengguna:

<code>  app.get("/user/:id", async (request) => await getUser(request.params.id));
</code>

Seperti penghalaan pos, pengendali penghalaan di atas biasanya memanggil pangkalan data untuk mendapatkan data pengguna, tetapi untuk contoh ini, kami telah mengasah objek untuk menghantar badan respons.

Akhirnya, kami akan mengeksport objek penghala supaya kami dapat mengimportnya dalam modul lain:

<code>  app.get("/user/:id", async (request, reply) => {
    const name = request.body.name;

    reply.send({ user: { name } });
  });
</code>

Modul App

Sekarang kita akan membuat modul aplikasi:

<code>// src/routes.js
const router = express.Router();

router.get("/:user_id", function getUser(request, response, next) {
  response.json({});
});

export default router;
</code>

Dalam modul ini, kami menentukan fungsi yang mencipta contoh pelayan Express baru. Kami kemudian menambah objek penghala ke contoh pelayan.

modul pelayan

Akhirnya, kami akan membuat modul pelayan. Modul ini menggunakan fungsi BuildApp () yang kami tentukan dalam modul aplikasi untuk membuat contoh pelayan Express baru. Ia kemudian memulakan pelayan Express kami dengan mengkonfigurasinya untuk mendengar di port 3000:

<code>// src/server.js

import Fastify from "fastify";
import ExpressPlugin from "fastify-express";

import routes from "./routes.js";

const fastify = Fastify();

await fastify.register(ExpressPlugin);

fastify.use("/user", routes);

await fastify.listen(3000);
</code>

Jalankan aplikasi kami

kami kini mempunyai aplikasi Express Runnable lengkap yang boleh kami jalankan di terminal:

<code>mkdir express-to-fastify-migration
cd express-to-fastify-migration
npm init -y
</code>

di terminal lain, kita boleh menggunakan curl untuk membuat permintaan kepada API untuk mengesahkan sama ada ia berfungsi:

<code>npm install express cors
</code>

kita harus menerima respons seperti berikut:

<code>"type": "module",
</code>

memindahkan permohonan kami dari Express untuk mengikat

Sekarang kita mempunyai aplikasi Express yang lengkap yang kita akan berhijrah untuk menggunakan rangka kerja Fastify.

Ketergantungan yang diperlukan

kita perlu memasang tiga kebergantungan:

• Rangka Kerja Fasttify
• Plugin Fasttify-Express
• Plugin Fasttify -CORS - Ini adalah versi porting middleware Express Cors yang aplikasi kami sudah menggunakan

mari kita jalankan arahan ini di terminal untuk memasangnya:

<code>// src/routes.js

import express from "express";
import cors from "cors";

const router = express.Router();

router.use(express.json());

router.use(cors({ origin: true }));
</code>

Anda boleh melihat perbezaan dalam perubahan kod ini pada GitHub.

refactor modul aplikasi kami

Sekarang kita mempunyai dependensi yang dipasang, kita perlu refactor modul aplikasi kami. Kami akan mengubahnya menjadi:

• Import fastify dan fastlify-express dan bukannya ekspres
• Buat contoh pelayan Fastify dan bukannya contoh pelayan ekspres
• Tambahkan objek Router Express kami ke pelayan menggunakan plugin fastify-express

inilah yang kita kelihatan seperti selepas kita membuat perubahan ini:

<code>// src/routes.js

router.post("/", function createUser(request, response, next) {
  const newUser = request.body;

  if (!newUser) {
    return next(new Error("Error creating user"));
  }

  response.status(201).json(newUser);
});
</code>

Anda boleh melihat perbezaan dalam perubahan kod ini pada GitHub.

anda akan melihat dalam kod di atas bahawa apabila kami membuat contoh pelayan Fastify, kami lulus pilihan Logger. Ini membolehkan ciri pembalakan terbina dalam Fasttify. Kami akan mengetahui lebih lanjut mengenai perkara ini kemudian.

refactor modul pelayan kami

Sekarang kita perlu menukar modul pelayan kami untuk berfungsi dengan contoh pelayan Fastify:

<code>// src/routes.js

router.get("/:user_id", function getUser(request, response, next) {
  const user = {
    id: request.params.user_id,
    first_name: "Bobinsky",
    last_name: "Oso",
  };

  response.json(user);
});
</code>

Anda boleh melihat perbezaan dalam perubahan kod ini pada GitHub.

Sejak Fastify secara asli menyokong janji, dalam kod di atas kita boleh menggunakan menunggu dan kemudian menggunakan ciri pembalakan terbina dalam Fasttify untuk menangkap dan log sebarang kesilapan.

Langkah seterusnya

Permohonan kami kini menggunakan Fasttify ke permintaan laluan dan menghantar respons. Ia penuh, tetapi penghalaan kami masih menggunakan Express. Untuk berhijrah sepenuhnya untuk menyatakan, kita perlu memindahkan laluan kita untuk menggunakan Fastify juga.

refactor modul penghalaan kami

Routing dalam aplikasi ekspres dikemas dalam router ekspres. Kami refactored router ini ke plugin fastify. Plug-in adalah ciri Fasttify yang membolehkan kami merangkumi penghalaan dan mana-mana ciri yang berkaitan.

kita akan bermula dengan mengeluarkan beberapa baris khusus ekspres ke refactor modul penghalaan kami (src/routes.js):

<code>  app.get("/user/:id", async (request) => await getUser(request.params.id));
</code>

maka kita perlu menukar eksport modul lalai ke fungsi asynchronous yang menerima contoh pelayan Fastify. Ini adalah asas plugin Fastify. Selebihnya kod dalam modul penghalaan kami akan dipindahkan ke fungsi plugin ini:

<code>  app.get("/user/:id", async (request, reply) => {
    const name = request.body.name;

    reply.send({ user: { name } });
  });
</code>

Agar middleware kami dan penghalaan untuk bekerja dengan Fasttify, kita perlu menukar:

• Tukar rujukan penghala ke fastify
• Tukar fungsi pengendali laluan ke fungsi asynchronous
• Tukar parameter fungsi pengendali laluan dari (permintaan, tindak balas, seterusnya) ke (permintaan, balasan)
• Tukar rujukan tindak balas kepada balasan
• Tukar response.json () Panggil ke Reply.Send ()
• Tukar contoh seterusnya (ralat) untuk membuang ralat

Setelah membuat semua perubahan ini, modul penghalaan kami kini menjadi plugin fastify dengan routing fastify:

<code>// src/routes.js
const router = express.Router();

router.get("/:user_id", function getUser(request, response, next) {
  response.json({});
});

export default router;
</code>

Sekarang kita perlu menukar modul aplikasi kami (SRC/APP.JS) untuk menggunakan plugin yang kami dieksport dari modul penghalaan. Ini bermakna menggantikan panggilan fasttify.use () dengan panggilan untuk fastify.register ():

<code>// src/server.js

import Fastify from "fastify";
import ExpressPlugin from "fastify-express";

import routes from "./routes.js";

const fastify = Fastify();

await fastify.register(ExpressPlugin);

fastify.use("/user", routes);

await fastify.listen(3000);
</code>

Anda boleh melihat perbezaan dalam perubahan kod ini pada GitHub.

Aplikasi Express Contoh kami hanya mempunyai satu penghala, jadi kami dapat memindahkan semua laluan dalam aplikasi untuk menggunakan Fasttify pada satu masa. Walau bagaimanapun, jika kami mempunyai aplikasi Express yang lebih besar dengan pelbagai router, kami boleh memindahkan setiap penghala untuk mengikat langkah demi langkah pada satu masa.

Gantikan middleware dengan plug-in

Permohonan kami berada dalam keadaan baik dan kami hampir sepenuhnya memindahkannya dari Express untuk mengikat. Satu lagi perkara yang perlu dipindahkan: penggunaan pakej middleware Cors Express kami. Kami memasang plugin Fastify-CORS sebelum ini, dan sekarang kami perlu menambahkannya dalam aplikasi kami untuk menggantikan middleware CORS.

Dalam modul penghalaan kami (src/routes.js), kita perlu menggantikan import middleware CORS:

<code>mkdir express-to-fastify-migration
cd express-to-fastify-migration
npm init -y
</code>

maka kita perlu menggantikan panggilan untuk fastify.use () dengan panggilan untuk fastify.register ():

<code>npm install express cors
</code>

Perhatikan bahawa apabila kita mendaftarkan plugin dengan Fasttify, kita perlu lulus fungsi plugin dan objek pilihan sebagai parameter berasingan.

Oleh kerana kami tidak lagi menggunakan fungsi penggunaan () yang disediakan oleh plugin Fastify-Express, kami boleh mengeluarkannya sepenuhnya dari aplikasi kami. Untuk melakukan ini, mari padam baris berikut dari modul aplikasi kami (src/app.js):

<code>  app.get("/user/:id", async (request) => await getUser(request.params.id));
</code>

Anda boleh melihat perbezaan dalam perubahan kod ini pada GitHub.

Padam kebergantungan ekspres

Penghijrahan permohonan kami dari Express ke Fastify telah selesai! Sekarang kita boleh mengeluarkan kebergantungan yang berkaitan dengan ekspres dengan menjalankan arahan ini di terminal:

<code>  app.get("/user/:id", async (request, reply) => {
    const name = request.body.name;

    reply.send({ user: { name } });
  });
</code>

Anda boleh melihat perbezaan dalam perubahan kod ini pada GitHub.

Jalankan Aplikasi Migrasi Kami

Sekarang kita telah memindahkan sepenuhnya permohonan itu untuk mengikat, ini adalah masa yang baik untuk memeriksa sama ada semuanya masih berfungsi seperti yang diharapkan. Mari kita jalankan perintah yang sama yang kita lari sebelum apabila permohonan itu menggunakan Express.

Pertama, kami akan menjalankan aplikasi di terminal:

<code>// src/routes.js
const router = express.Router();

router.get("/:user_id", function getUser(request, response, next) {
  response.json({});
});

export default router;
</code>

Kemudian, di terminal lain, kami akan menggunakan Curl untuk membuat permintaan kepada API untuk mengesahkan bahawa ia berfungsi seperti yang diharapkan:

<code>// src/server.js

import Fastify from "fastify";
import ExpressPlugin from "fastify-express";

import routes from "./routes.js";

const fastify = Fastify();

await fastify.register(ExpressPlugin);

fastify.use("/user", routes);

await fastify.listen(3000);
</code>

kita harus menerima respons seperti berikut:

<code>mkdir express-to-fastify-migration
cd express-to-fastify-migration
npm init -y
</code>

menghilangkan middleware

Aplikasi Express Contoh kami hanya menggunakan beberapa fungsi middleware, tetapi aplikasi Express dunia sebenar kami mungkin menggunakan lebih banyak. Seperti yang dapat kita lihat, plugin Fastify-Express membolehkan kita terus menggunakan middleware Express (jika diperlukan). Ini membolehkan kami melambatkan menulis semula middleware Express Custom kami sendiri untuk mengikat plugin. Tetapi bagaimana kita menggantikan middleware Express pihak ketiga?

bernasib baik, Fastify menyediakan ekosistem plugin yang sihat. Berikut adalah beberapa pakej middleware Express yang popular yang boleh kita ganti dengan plugin Fastify:

• cors ➜ fastify-cors
• Helmet ➜ Fasttify-Helmet
Express-Sesi ➜ Fastify-Server-Sesi
• express-jwt ➜ fastify-jwt
• HTTP-ERRORS ➜ Fastify-Sensible
• serve-static ➜ fastify-static
• multer ➜ fastify-multer
Beberapa plugin Fasttify adalah port langsung atau pembalut untuk rakan -rakan ekspres mereka. Ini bermakna kita biasanya tidak perlu menukar pilihan konfigurasi yang dihantar ke plugin Fastify.

anda boleh mencari senarai lengkap plugin pada halaman Ecosystem Fasttify.

menggunakan sepenuhnya fastify

Sekarang bahawa kita telah mula mengenali Fastify dengan memindahkan aplikasi ekspres, sudah tiba masanya untuk melihat ciri -ciri Fastify lain yang boleh kita manfaat dari.

Pengesahan

Fasttify menyediakan fungsi pengesahan permintaan. Ia menggunakan AJV (satu lagi Validator Skema JSON) di latar belakang, yang membolehkan kami menentukan peraturan pengesahan menggunakan skema JSON.

Ini adalah contoh menggunakan mod JSON untuk mengesahkan badan permintaan pada laluan pos:

ralat pengesahan secara automatik diformat dan dihantar sebagai tindak balas JSON:

<code>npm install express cors
</code>

Ketahui lebih lanjut dalam dokumentasi Pengesahan dan Serialization Fasttify.

<code>"type": "module",
</code>

rekod log

logging log dalam aplikasi Node.js boleh menjejaskan prestasi secara negatif dalam persekitaran pengeluaran. Ini kerana bersiri dan memindahkan data log di tempat lain (contohnya, kepada Elasticsearch) melibatkan banyak langkah. Pengoptimuman yang tinggi dalam aplikasi ini sangat penting.

Pembalakan log disepadukan sepenuhnya ke dalam Fastify, yang bermaksud kita tidak perlu menghabiskan masa memilih dan mengintegrasikan pembalak. Fasttify menggunakan logger cepat dan fleksibel: pino. Ia menjana log dalam format JSON:

<code>  app.get("/user/:id", async (request) => await getUser(request.params.id));
</code>

Apabila kita membuat contoh pelayan Fastify, kita boleh mengaktifkan pembalakan dan menyesuaikan pilihan yang diluluskan kepada Pino. Fasttify kemudian secara automatik mengeluarkan mesej log seperti yang ditunjukkan di atas. Contoh Logger boleh didapati pada contoh pelayan Fastify (contohnya, fastify.log.info ("...")) dan semua objek permintaan (contohnya, request.log.info ("...")).

Ketahui lebih lanjut dalam dokumentasi pembalakan Fastify.

pengendalian ralat

Fastify menyediakan kaedah setErrorHandler () yang membolehkan kita secara jelas menentukan fungsi pengendalian ralat. Ini berbeza dari Express, di mana middleware pengendalian ralat hanya boleh dibezakan oleh parameter yang diterima (ERR, REQ, RES, NEXT) dan mesti ditambah dalam urutan tertentu.

Untuk fleksibiliti lengkap, kami boleh menentukan pengendali ralat Fastify yang berbeza dalam plugin yang berbeza. Ketahui lebih lanjut dalam dokumentasi ralat Fastify.

penghias

Penghias adalah ciri yang kuat dalam Fasttify yang membolehkan kami menyesuaikan teras Fasttify Objects -seperti contoh pelayan Fastify kami -serta permintaan dan balasan objek. Berikut adalah contoh penghias asas:

<code>  app.get("/user/:id", async (request, reply) => {
    const name = request.body.name;

    reply.send({ user: { name } });
  });
</code>

Penghias membolehkan kami menggunakan kandungan seperti sambungan pangkalan data atau melihat enjin sepanjang aplikasi Fasttify. Ketahui lebih lanjut dalam dokumentasi Fastify Decorator.

Kesimpulan

Dalam artikel ini, kami belajar bagaimana untuk memindahkan aplikasi Node.js sedia ada dari Express untuk mengikat. Kami telah mengetahui bagaimana plugin Fastify-Express dapat membantu kami secara beransur-ansur memindahkan aplikasi sedia ada. Ini membolehkan kami mula mendapat manfaat daripada ciri -ciri yang disediakan oleh Fasttify, walaupun bahagian aplikasi kami masih menggunakan Express.

Berikut adalah beberapa sumber yang mungkin anda dapati berguna apabila berhijrah dari ekspres ke fasttify:

• Kod sampel dalam artikel ini. Terokai kod dan jalankan aplikasi yang kami bina dalam artikel ini.
• Fasttify Documentation. Dokumentasi komprehensif untuk rangka kerja Fastify.
• Fasttify Ecosystem. Fastify Direktori Plugin. Mudah untuk mencari plugin untuk menggantikan middleware ekspres.
• Fastify Application Sample. Aplikasi sampel yang dibuat oleh salah satu penyelenggara utama Fasttify. Ia menunjukkan konsep fastifikasi teras, amalan terbaik, dan cadangan.
• Fasttify Community Discord Server. Tempat yang bagus untuk mendapatkan bantuan dan nasihat mengenai membangunkan aplikasi dengan Fastify.

Soalan Lazim untuk berhijrah dari Express ke Fastify

Apakah perbezaan utama antara Express dan Fasttify?

Express and Fasttify adalah rangka kerja web Node.js, tetapi mereka mempunyai beberapa perbezaan utama. Express adalah rangka kerja aplikasi web minimalis yang menyediakan antara muka yang mudah untuk membina aplikasi web dan API. Ia telah lama wujud, dengan komuniti yang besar dan middleware yang kaya. Fastify, sebaliknya, adalah rangka kerja yang lebih baru yang memberi tumpuan kepada menyediakan pengalaman pemaju terbaik dengan overhead yang minimum dan seni bina pemalam yang kuat. Ia direka dengan sangat cepat, oleh itu nama, dan tanda aras menunjukkan bahawa ia boleh mengendalikan lebih banyak permintaan sesaat daripada Express.

bagaimana untuk memindahkan aplikasi ekspres saya untuk membekalkan?

berpindah dari Express ke Fasttify termasuk beberapa langkah. Pertama, anda perlu memasang Fasttify dan menggantikan contoh Express dalam aplikasi dengan contoh Fastify. Anda kemudian perlu menggantikan middleware khusus Express dengan Fasttify Plugin atau kod tersuai. Anda juga perlu mengemas kini laluan anda untuk menggunakan sistem penghalaan Fasttify. Akhirnya, anda perlu mengemas kini kod pengendalian ralat anda untuk menggunakan mekanisme pengendalian ralat Fasttify.

Bolehkah saya menggunakan middleware ekspres dalam fastify?

Fasttify mempunyai sistem middleware sendiri, tetapi ia juga menyokong middleware gaya ekspres melalui plugin "Middie". Walau bagaimanapun, dengan menggunakan middleware Express dalam fasttify boleh menjejaskan prestasi, jadi disyorkan untuk menggunakan fastify plugin atau kod tersuai jika mungkin.

bagaimana menangani kesilapan dalam fastify?

Fasttify mempunyai mekanisme pengendalian ralat terbina dalam yang boleh anda gunakan untuk menangani kesilapan dalam aplikasi anda. Anda boleh menentukan pengendali ralat tersuai untuk laluan tertentu atau untuk keseluruhan aplikasi. Fastify juga menyokong sintaks async/menunggu, yang membuat pengendalian ralat lebih langsung daripada Express.

bagaimana menggunakan cangkuk dalam fastify?

Hook adalah ciri yang kuat dalam Fasttify yang membolehkan anda menjalankan kod tersuai pada tahap yang berlainan dalam kitaran hayat permintaan/tindak balas. Anda boleh menggunakan cangkuk untuk mengubah suai permintaan atau tindak balas, melakukan pengesahan, permintaan rekod, dan banyak lagi. Fasttify menyokong pelbagai cangkuk, termasuk "onrequest", "prehandler", "onsend", dan "onresponse".

bagaimana menggunakan plugin dalam fastify?

Plugin adalah ciri utama Fastify yang membolehkan anda melanjutkan fungsi aplikasi anda. Anda boleh menggunakan plugin untuk menambah ciri -ciri baru, mengintegrasikan dengan perkhidmatan lain, atau merangkumi logik aplikasi. Fasttify mempunyai ekosistem plugin yang kaya, dan anda juga boleh membuat plugin anda sendiri.

Bagaimana untuk menentukan laluan di Fastify?

Fasttify mempunyai sistem penghalaan yang kuat yang menyokong parameter, rentetan pertanyaan, kad liar, dll. Anda boleh menentukan laluan menggunakan kaedah "laluan", yang menerima objek pilihan yang menentukan kaedah, URL, pengendali, dan pilihan lain laluan.

bagaimana menghantar respons dalam fastify?

Di Fasttify, anda boleh menghantar respons menggunakan objek "Balas" yang dihantar kepada pengendali penghalaan. Terdapat beberapa cara untuk menghantar respons kepada objek "Balas", termasuk "Hantar", "Kod", "Header", dan "Type". Fastify juga secara automatik menyatukan respons JSON untuk prestasi.

bagaimana untuk melakukan pengesahan dalam fastify?

Fasttify menyokong permintaan dan pengesahan tindak balas menggunakan skema JSON. Anda boleh menentukan corak untuk laluan, dan Fasttify akan mengesahkan permintaan masuk secara automatik dan respons keluar berdasarkan corak ini. Ini membantu mengesan kesilapan awal dan meningkatkan kebolehpercayaan aplikasi.

Bagaimanakah Fastify meningkatkan prestasi?

Fasttify direka untuk cepat dan cekap. Ia menggunakan seni bina ringan, menyokong HTTP/2 dan HTTP/3, dan mempunyai sistem pemalam yang kuat yang meminimumkan overhead. Fastify juga secara automatik menyatukan respons JSON dan menyokong permintaan dan pengesahan tindak balas, yang membantu meningkatkan prestasi.

Atas ialah kandungan terperinci Cara memindahkan aplikasi anda dari ekspres ke fastlify. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!