koa2 데이터api 중간부품 디자인 모델의 실현 방법

모든 데이터베이스 읽기를 가정하면 httpapi 인터페이스 요청은 하나의 중간부품으로 중간부품을 플러그인으로 삼아 데이터를 얻을 위치를 삽입합니다.
api.js

module.exports = async (ctx, next) => {
 ctx.share_data.api_data = await axios.get('/api');

 await next();
};

db.js

module.exports = async (ctx, next) => {
 ctx.share_data.db_data = await mysql_query('SELECT XXX').catch(() => {});

 await next();
};

직렬 연결
app.js

const api = require('api.js');
const db = require('db.js');
          
app.get('/get-api', api, (ctx) => ctx.body = ctx.share_data);
app.get('/get-db', db, (ctx) => ctx.body = ctx.share_data);
app.get('/get-api-and-db', api, db, (ctx) => ctx.body = ctx.share_data);

보기에는 매우 조화롭지만, 만약 여러 개의 데이터 중간부품이 직렬로 연결되면 인터페이스의 응답 시간은 모든 중간부품의 총체이다.
병발하다
하나의 compose 함수를 의미할 수 있으며, 병발된 중간부품을 포장해야 한다
super-compose.js

module.exports = (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 async (context = {}, next = f => f) => {
  await Promise.all(
   middleware.map(middleware => {
    return new Promise((rs, rj) => {
     middleware(context, () => Promise.resolve())
      .then(rs)
      .catch(rj);
    });
   }),
  );

  await next();
 };
};

app.js

const api = require('api.js');
const db = require('db.js');
const superCompose = require('super-compose.js');
          
app.get('/get-api-and-db', superCompose([api, db]), (ctx) => ctx.body = ctx.share_data);

의존 관계
해결된 것 같지만 상하문 의존이 있는 상황을 어떻게 처리합니까?예:api_1api의 데이터에 의존합니다.
고치다js, 캐시 검사까지.여러 번compose에 의해 호출될 수 있는 반복 인터페이스 처리

module.exports = async (ctx, next) => {
 if (ctx.share_data.api_data) {
  return await next();
 }

 ctx.share_data.api_data = await axios.get('/api');

 await next();
};

api-1.js

const api = require('api.js');

module.exports = compose([
 api,
 async (ctx, next) => {
  const { api_data: { api_data: { id = 0 } = {} } = {} } = ctx;

  if (id < 0) {
   await next();
  } else {
   ctx.api_data.api_1_data = await axios.get('/api', { params: { id } });
  }

  await next();
 },
])

app.js

const api_1 = require('api_1.js');
const db = require('db.js');
const superCompose = require('super-compose.js');
          
app.get('/get-api-and-db', superCompose([api_1, db]), (ctx) => ctx.body = ctx.share_data);

중간부품을 건너뛰다
때로는 특정한 조건에 따라 일부 인터페이스를 돌려 호출해야 한다
개조하api.js, 필터 목록 추가

module.exports = async (ctx, next) => {
 const { break_list = [] } = ctx;


 if (break_list.includes('api_data')) {
  //  。
  //  ， 。
  // ctx.break_list = break_list.filter(v => v !== 'api_data')
  return await next();
 } else {
  ctx.share_data.api_data = await axios.get('/api');
 }

 await next();
}

app.js

const api = require('api.js');
const db = require('db.js');
const superCompose = require('super-compose.js');
          
app.get(
 '/get-api-and-db',
 async (ctx, next) => {
  ctx.break_list = ['api_data'];
  await next();
 },
 superCompose([api, db]),
 ctx => (ctx.body = ctx.share_data)
);

데이터 병합 처리
슈퍼-compose와koa-compose를 결합하여 모든 필요한 중간부품을 조합하여 페이지에 대한 컨트롤러를 작성합니다

const api = require('api.js');
const db = require('db.js');
const superCompose = require('super-compose.js');
const compost = rquire('koa-compose')

const babala = compose([
 superCompose([api, db]),
 async (ctx, next) => {
  const {
   share_data: { api_data: { id = 0 } = {}, db_data: { title } = {} } = {},
  } = ctx;

  ctx.body = { id, title };
  // OR
  // ctx.share_data.babala = {}
 },
]);

app.get(
 '/get-api-and-db',
 babala
);

결말
자주 나타나는 함수 내의 대량의 인터페이스, 논리 조작, 긴 상하문 논리를 해결한다.

app.get('/api', async ctx => {
 const api_1 = await axios.get('/api_1');
 await api_2 = await axios.get('/api_2');

 // ...
 // ...
 //  
 // ... 
 
 const [api_3, api_4] = await new Promise.all([axios.get('/api_3'), axios.get('/api_4')]);
 
 // ...
 // ...
 //  
 // ...

 ctx.body = {};
});

이상은 바로koa2 데이터api중간부품 디자인 모델의 실현 방법에 대한 상세한 내용입니다. 더 많은 koa2중간부품 디자인 모델에 대한 자료는 저희 다른 관련 글을 주목해 주십시오!