Analysis of KOA - onion model

1. What is? koa？

Koa It's a streamlined node frame , Considered the second generation Node frame , Its biggest feature is the unique middleware process control , It's a typical onion model , Its core work includes the following two aspects ：

1. take node Native req and res Package into a context object .
2. be based on async/await Middleware onion model mechanism .

2.koa1 and koa2 What is the difference in the source code ？

1. Koa1 It's using generator、yield The pattern of .
2. Koa2 It uses async/await + Promise The pattern of .

3. What is an onion model .

Koa The onion model is based on next() The function is the split point , From the outside to the inside Request The logic of , Then from the inside out Response The logic of , there request The logic of , We can understand it as next Previous content ,response The logic is next What follows the function , It can also be said that every middleware has two processing opportunities . The core principle of onion model is mainly based on compose Method .

Here's the picture ：

The following is an example of an onion code ：

const Koa = require('koa');

//Applications
const app = new Koa();

//  middleware 1
app.use((ctx, next) => {
    
  console.log(1);
  next();
  console.log(2);
});

//  middleware  2 
app.use((ctx, next) => {
    
  console.log(3);
  next();
  console.log(4);
});

app.listen(7000, '0.0.0.0', () => {
    
    console.log(`Server is starting`);
});

//  The printing order of middleware is 1 -> 3 -> 4 -> 2

4. The source code parsing

1. use Method

When using middleware , First use use Method ,use The method will say that the incoming middleware callback function is stored in middleware Middleware array .

2. listen Method

When executed app.listen When listening to the port , In fact, it calls http Modular createServer Method , Then pass in the built-in callback Method , This callback The method will use Method stored middleware The middleware array is passed to compose function .

3. compose Method

compose Method is the core of onion model ,compose One of the methods is dispatch Method , On the first call , It executes the first middleware function , When the middleware function is executed, it is called again dispatch function , In other words, it forms a recursive , This is it. next The reason why the next middleware will be executed when the function is executed , So an onion model is formed .

function compose (middleware) {
    
	// context:  Context 
	// next：next function 
  return function (context, next) {
    
    // last called middleware #
    let index = -1
    //  At the beginning, it was passed in as  0, It will increase in the future 
    return dispatch(0)
    function dispatch (i) {
    
      //  If there is no increase , Then it indicates that... Has been executed multiple times 
      if (i <= index) return Promise.reject(new Error('next() called multiple times'))
      index = i
      
      //  Get the current middleware 
      let fn = middleware[i]
      
      if (i === middleware.length) fn = next
      
      //  When  fn  When it's empty , It's going to execute  next()  The later part of the code 
      if (!fn) return Promise.resolve()
      
      try {
    
        //  Execution middleware , Note these two parameters , They are all parameters passed by middleware , The first is context , The second is  next  function 
        //  That is to say, execution  next  That is, call  dispatch  Function 
        return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
      } catch (err) {
    
        return Promise.reject(err)
      }
    }
  }
}

5. Why do you need an onion model ？

Because a lot of times , In a app There are many Middleware , Some middleware need to rely on the results of other middleware , The onion model can guarantee the execution order , If there is no onion model , The order of execution may not be what we expected .