Introduction to koa (III) koa routing

stay Koa Application , You usually use koa-router modular , Provide support for routing . Then why do I need routing ？ Friends who do front and back-end separation development have all met , When docking interfaces, the background will provide an address , Request this address , The corresponding data processing can be realized by transmitting the corresponding parameters . You can put this An interface is understood as the address of a route .

1 koa-router Use

1.1 Installation and introduction

• npm i koa-router --save newly build router.js file const Koa = require('koa') const Router = require('koa-router') const app = new Koa() const router = new Router() router.get('/', ctx => { ctx.body = ' Hello , Uncertainty of measurement ' }) // Registered routing app.use(router.routes()) // Auto enrichment response Corresponding head , When the response state is not set (status) Automatically set when , Set at the end of all routing middleware ( overall situation , recommend ), You can also set a specific route （ Local ）, for example ：router.get('/index', router.allowedMethods()); This is equivalent to when visiting /index It's only set up when app.use(router.allowedMethods()) app.listen(3000, () => { console.log(' monitor 3000 port ') }) Add, delete, and change the route of the query // To obtain a list of , Returns an array of router.get('/', ctx => { ctx.body = [] }) // according to id Get an item , Returns the object router.get('/:id', ctx => { ctx.body = {} }) // Create a new item router.post('/', ctx => { ctx.body = {} }) // according to id Update an item router.put('/:id', ctx => { ctx.body = {} }) // according to id Delete an item router.delete('/:id', ctx => { ctx.body = {} })koa-router（ Support basic common http Method （'HEAD','OPTIONS','GET','PUT','PATCH','POST','DELETE'）, The obscure request method will return 501 Status code ）
• If you want to add logical judgment before routing , For example, do you have permission to access , Middleware can be inserted into the route // Define middleware const auth = async (ctx, next) => { if (ctx.url !== '/users') { ctx.throw(401) } await next() } // Inject router.post('/users', auth, ctx => { ctx.body = ctx.request.body })

1.2 Parameters to obtain

• get To obtain parameters (ctx.params perhaps ctx.request.params)// Get a single parameter router.get('/:id', ctx => { ctx.body = ctx.params }) // Get multiple parameters router.get('/:id/:age', ctx => { ctx.body = ctx.request.params })

• post To obtain parameters （ctx.request.body） Third party middleware is required to obtain parameters ,koa-bodyparser：npm i koa-bodyparser --saveconst Koa = require('koa') const Router = require('koa-router') const bodyParser = require('koa-bodyparser') const app = new Koa() const router = new Router() router.post('/', ctx => { ctx.body = ctx.request.body }) // Put it in front of the route app.use(bodyParser()) app.use(router.routes()) app.use(router.allowedMethods()) app.listen(3000, () => { console.log(' monitor 3000 port ') })

2 Route encapsulation

It is impossible for our development projects to write routes in index.js In the entry file , You need to use a separate routing folder to manage , Just import one in the entry file .

• Root creation app/routes/home.jsconst Router = require('koa-router') const router = new Router() router.get('/', (ctx) => { ctx.body = ' home page ' }) module.exports = routerconst Router = require('koa-router') // ** Configure routing prefix ** const router = new Router({ prefix: '/users' }) router.get('/', (ctx) => { ctx.body = ' User list ' }) router.get('/:id', ctx => { ctx.body = ` user id：${ctx.params.id}` }) module.exports = router Because there are many interfaces for routing in a project , It can't be at the entrance index.js Each of them should introduce , Therefore, all routes need to be handled , In this way, you only need to import one in the entry file
• establish app/routes/users.js
• establish app/routers/index.jsconst fs = require('fs') module.exports = app => { // Read all files in the current directory fs.readdirSync(__dirname).forEach(file => { // Remove inductive `index.js` file , All others must be registered to `app` in if (file === 'index.js') return const router = require(`./${file}`) app.use(router.routes()).use(router.allowedMethods()) }) }... // introduce const routing = require('./routes') ... // Use routing(app) ...
• stay app/index.js Introduction in

3 Using the controller

We are now processing the data （ Although the data has not been written yet , Write dead ） Together with routing , This is not convenient for maintenance , And the later data processing is complicated , It will appear that the routing file is very bloated , We should separate routing files from data processing .

• establish app/controllers/home.jsclass HomeCtl { index(ctx) { ctx.body = ' This is the home page ' } } module.exports = new HomeCtl()
• modify app/routes/home.jsconst Router = require('koa-router') const router = new Router() // const { index } = require('../controllers/home') router.get('/', index) module.exports = router
• establish app/controllers/users.jsclass UsersCtl { async find(ctx) { // Operating the database must await ctx.body = ' User list ' } async findById(ctx) { ctx.body = ` user id：${ctx.params.id}` } } module.exports = new UsersCtl

attach ： Onion model

Through the introduction of the previous two sections, I believe that you have made a good understanding of Koa Understand the implementation mechanism of , In especial await next() After execution, the middleware will return to continue to execute the unexecuted logic , Without feeling the author's ingenious design ideas . Let's briefly understand the implementation idea , The core code is koa-componse in , There's not much code , Let's simply learn ：

function compose(middleware) {
  return function(context) {
    //  We actually just returned the first item of middleware , But the first item will execute recursively 
    return dispatch(0);

    function dispatch(i) {
      let fn = middleware[i];
      try {
        //  Every time you execute  fn  Function time ,fn  Contained in the  next  function (dispatch(i + 1)), So we have to execute first  next  Code , Go back and execute the following code of the middleware 
        return Promise.resolve(fn(context, dispatch.bind(null, i + 1));
      } catch (err) {
        return Promise.reject(err);
      }
    }
  };
}

• Define the middleware array to be tested const middleware = [ async (ctx, next) => { console.log("1"); await next(); console.log("3"); }, async (ctx, next) => { console.log("2"); } ]; We can see , Execute in the middleware await next(), It's actually execution ：await dispatch.bind(null, i + 1). So it looks like , The current middleware will stop its logic , Process the next middleware first . Because of every dispatch, All return to the new Promise. therefore async Will wait Promise When the state changes, you can go back and continue to execute your own logic .
• Simply write a method to execute according to the onion model （ Don't consider the online articles , Just pure execution ）let middlewares = [ async (next) => { console.log(1) await next() console.log(3) }, async (next) => { console.log(2) await next() }, async (next) => { console.log('test') } ] function componse() { return dispatch(0) async function dispatch(i) { let fn = middlewares[i] await fn(dispatch.bind(null, i + 1)) } } componse()

In the next article, we will learn database The operation of , If it helps you , Welcome to pay attention ！ Thank you for reading ！