Apakah itu nod middleware

Perisian tengah nod terutamanya merujuk kepada kaedah merangkum pemprosesan terperinci permintaan http Intipatinya adalah untuk membenarkan penapis tertentu memprosesnya sebelum memasuki pemprosesan perniagaan khusus untuk aplikasi web, memperkenalkan perisian pertengahan Node boleh Memudahkan dan merangkum beberapa asas butiran pemprosesan logik.

Persekitaran pengendalian tutorial ini: sistem Windows 10, nod v12.21.0, komputer Dell G3.

Apakah perisian pertengahan nod?

Penjelasan mendalam tentang prinsip middleware nodejs

Kata Pengantar

Middleware adalah antara sistem aplikasi dan perisian sistem Ia adalah sejenis perisian yang menggunakan perkhidmatan asas (fungsi) yang disediakan oleh perisian sistem untuk menyambungkan pelbagai bahagian sistem aplikasi atau aplikasi yang berbeza pada rangkaian, dan boleh mencapai tujuan perkongsian sumber dan perkongsian fungsi.

Dalam NodeJS, perisian tengah terutamanya merujuk kepada kaedah merangkum http pemprosesan butiran permintaan. Kita semua tahu bahawa terdapat banyak tindakan yang terlibat dalam permintaan http, seperti berikut: Penapisan IP Pemindahan rentetan pertanyaan Minta penghuraian badan Pemprosesan maklumat kuki Semakan kebenaran Pengesahan Pengelogan Perisian tengah pengurusan sesi (sesi) Perisian tengah pemampatan Gzip (seperti pemampat) * Pengendalian ralat

Sudah tentu terdapat banyak tindakan pemprosesan tersuai Untuk Untuk Web aplikasi, kami tidak mahu memahami setiap butiran kerja pemprosesan, tetapi berharap untuk menumpukan pada pembangunan perniagaan untuk meningkatkan kecekapan pembangunan, jadi kami memperkenalkan Node Middleware untuk memudahkan dan merangkum pemprosesan logik asas ini butiran.

perisian tengah nod pada asasnya membolehkan penapis khusus

Rangka kerja nodej arus perdana yang kita lihat pada masa ini, seperti

sambung, koa, express, telur, sarang, dsb. semuanya tidak dapat dipisahkan daripada konsep reka bentuk middleware, jadi untuk memberi semua orang intip lebih mendalam ke dalam nodej Di dunia, kami telah mengkaji secara perbandingan prinsip pelaksanaan middleware.

Teks

Setelah memahami konsep middleware nod, kami akan melaksanakan middleware secara manual, dan akhirnya kami akan analisa secara ringkas Mari kita lihat idea-idea pelaksanaan middleware dalam koa Rangka artikel adalah seperti berikut:

Pelaksanaan prinsip teras perisian tengah nod Kaedah pelaksanaan kunci tengah koa* Gunakan mekanisme perisian tengah koa untuk melaksanakan. middleware koa anda sendiri

nod Pelaksanaan prinsip teras middleware

Daripada pengenalan di atas, kita dapat melihat bahawa middleware ialah logik pemprosesan dari permulaan permintaan http hingga akhir respons. Ia biasanya perlu memproses permintaan dan tindak balas Apabila kami melaksanakan mod middleware nod, kami juga Satu isu yang perlu dipertimbangkan ialah kewujudan berbilang middleware. Jika tidak, hanya middleware pertama akan dilaksanakan dalam proses dari permintaan kepada tindak balas, jadi perisian pertengahan asas kami bentuk Seperti berikut:

const middleware = (req, res, next) => {
  // 请求处理逻辑  next()}

Seterusnya, mari kita tulis kes mudah untuk melihat bagaimana middleware dilaksanakan.

// 定义几个中间间函数const m1 = (req, res, next) => {
  console.log('m1 run')
  next()}const m2 = (req, res, next) => {
  console.log('m2 run')
  next()}const m3 = (req, res, next) => {
  console.log('m3 run')
  next()}// 中间件集合const middlewares = [m1, m2, m3]function useApp (req, res) {
  const next = () => {
    // 获取第一个中间件    const middleware = middlewares.shift()
    if (middleware) {
      middleware(req, res, next)
    }
  }
  next()}// 第一次请求流进入useApp()

Daripada kod di atas, tidak sukar untuk kita mencari peranan

seterusnya, yang merupakan parameter utama untuk secara automatik panggil rantaian middleware. Hasil cetakan adalah seperti berikut:

m1 runm2 runm3 run

Di atas melaksanakan mod pelaksanaan middleware asas, tetapi kita juga perlu mempertimbangkan isu tak segerak atas sokongan modul atau API pihak ketiga, seperti pengesahan, pengenalan dan perkhidmatan lain, kami perlu menambah perisian tengah tak segerak pada perisian tengah tak segerak Melaksanakan seterusnya dalam panggilan balik boleh memastikan urutan pelaksanaan panggilan biasa, seperti yang ditunjukkan dalam kod berikut :

const m2 = (req, res, next) => {
  fetch('/xxxxx').then(res => {
    next()
  })}

Terdapat juga senario middleware, seperti logging middleware, meminta pemantauan middleware , mereka akan melaksanakan logik yang berkaitan sebelum dan selepas pemprosesan perniagaan Pada masa ini, kita perlu melakukannya dapat melakukan pemprosesan sekunder pada fungsi

next Kita boleh membungkus nilai pulangan next ke dalam promise, membolehkannya meneruskan pemprosesan logik middleware melalui then panggil balik selepas pemprosesan perniagaan selesai Seperti yang ditunjukkan di bawah:

function useApp (req, res) {
  const next = () => {
    const middleware = middlewares.shift()
    if (middleware) {
      // 将返回值包装为Promise对象      return Promise.resolve(middleware(req, res, next))
    }else {
      return Promise.resolve("end")
    }
  }
  next()}

Pada masa ini kita boleh Ia dipanggil dengan cara berikut:

const m1 = (req, res, next) => {
  console.log('m1 start')
  return next().then(() => {
    console.log('m1 end')
  })}

Di atas kami telah melaksanakan corak reka bentuk middleware yang asas Sudah tentu, kami juga boleh menggunakan async dan menunggu untuk melaksanakannya :

在koa2框架中, 中间件的实现方式也是将next()方法返回值封装为Promise对象，实现了其提出的洋葱圈模型，如下图所示:

koa中间件实现方式

koa2框架的中间件实现原理很优雅，笔者觉得很必要研究一下, 这里展示一下其核心思路:

function compose (middleware) {
  // 提前判断中间件类型,防止后续错误  if (!Array.isArray(middleware)) throw new TypeError('Middleware stack must be an array!')
  for (const fn of middleware) {
    // 中间件必须为函数类型    if (typeof fn !== 'function') throw new TypeError('Middleware must be composed of functions!')
  }
  return function (context, next) {
    // 采用闭包将索引缓存,来实现调用计数    let index = -1
    return dispatch(0)
    function dispatch (i) {
      // 防止next()方法重复调用      if (i 

利用koa中间件机制实现一个自己的koa中间件

学习了中间件的设计机制和原理, 我们是不是想马上写一个中间件呢? 笔者这里给大家举一个例子. 在H5-Dooring项目的服务端代码中, 我们需要对用户登录权限进行分发, 此时我们提供统一个中间件来处理, 如下代码所示:

// 模拟数据库操作const token = db.user();// router或者koa的中间件一定要用await处理next，否则将不能正常响应数据export default async (ctx, next) => {
  const t = ctx.request.header.authorization
  let uid = ctx.request.header['x-requested-with']
  let uidArr = uid.split(',')
  if(uidArr.length > 1) {
      uid = uidArr.pop().trim()
  }
    if(token[uid] && token[uid][1] === t) {
        await next()
    }else {
        ctx.status = 403;
        ctx.body = {
            state: 403,
            msg: '你没有权限操作'
        }
    }  }

以上代码即实现用户登录态处理, 如果用户在没有登录的情况下防问任何需要登录的接口, 都将返回权限不足或则在请求库中让其重定向到登录页面.

推荐学习：《node.js视频教程》

Atas ialah kandungan terperinci Apakah itu nod middleware. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!