路由级别的中间件应用

路由级别的中间件应用

路由级别的中间件是Koa2框架中非常重要的概念，它允许我们在特定路由上应用中间件，而不是全局应用。这种方式可以更精确地控制中间件的执行范围，提高代码的可维护性和性能。

路由中间件的基本用法

在Koa2中，我们可以通过router.use()方法在特定路由上应用中间件。这种方式比全局中间件更加灵活，因为它只会在匹配的路由上执行。

const Koa = require('koa');
const Router = require('koa-router');

const app = new Koa();
const router = new Router();

// 定义一个简单的中间件
const logger = async (ctx, next) => {
  console.log(`Request URL: ${ctx.url}`);
  await next();
};

// 在特定路由上应用中间件
router.get('/user', logger, async (ctx) => {
  ctx.body = 'User Page';
});

app.use(router.routes());
app.listen(3000);

路由中间件的执行顺序

路由中间件的执行顺序非常重要，它决定了请求处理的流程。在Koa2中，中间件按照定义的顺序依次执行。

const auth = async (ctx, next) => {
  if (!ctx.headers.authorization) {
    ctx.status = 401;
    ctx.body = 'Unauthorized';
    return;
  }
  await next();
};

const validate = async (ctx, next) => {
  if (!ctx.query.id) {
    ctx.status = 400;
    ctx.body = 'ID is required';
    return;
  }
  await next();
};

router.get('/profile', auth, validate, async (ctx) => {
  ctx.body = `Profile for user ${ctx.query.id}`;
});

路由中间件的嵌套使用

我们可以将多个中间件组合在一起，形成中间件链，这在处理复杂业务逻辑时非常有用。

const checkAdmin = async (ctx, next) => {
  if (ctx.query.role !== 'admin') {
    ctx.status = 403;
    ctx.body = 'Forbidden';
    return;
  }
  await next();
};

const adminRoutes = new Router();
adminRoutes.get('/dashboard', checkAdmin, async (ctx) => {
  ctx.body = 'Admin Dashboard';
});

// 将adminRoutes作为子路由挂载到主路由
router.use('/admin', adminRoutes.routes(), adminRoutes.allowedMethods());

路由中间件的参数传递

中间件之间可以通过ctx对象传递数据，这使得我们可以构建更加灵活的中间件链。

const fetchUser = async (ctx, next) => {
  ctx.user = { id: 123, name: 'John Doe' };
  await next();
};

const checkPermission = async (ctx, next) => {
  if (!ctx.user) {
    ctx.status = 401;
    ctx.body = 'User not found';
    return;
  }
  await next();
};

router.get('/account', fetchUser, checkPermission, async (ctx) => {
  ctx.body = `Welcome, ${ctx.user.name}`;
});

路由中间件的错误处理

在路由级别处理错误可以让我们更精确地控制错误响应。

const errorHandler = async (ctx, next) => {
  try {
    await next();
  } catch (err) {
    ctx.status = err.status || 500;
    ctx.body = {
      error: err.message
    };
    ctx.app.emit('error', err, ctx);
  }
};

const riskyOperation = async (ctx) => {
  if (Math.random() > 0.5) {
    throw new Error('Something went wrong');
  }
  ctx.body = 'Operation succeeded';
};

router.get('/operation', errorHandler, riskyOperation);

路由中间件的性能优化

通过路由级别的中间件，我们可以避免不必要的中间件执行，从而提高应用性能。

const heavyMiddleware = async (ctx, next) => {
  // 模拟耗时操作
  await new Promise(resolve => setTimeout(resolve, 100));
  console.log('Heavy middleware executed');
  await next();
};

// 只在需要的地方使用heavyMiddleware
router.get('/report', heavyMiddleware, async (ctx) => {
  ctx.body = 'Report generated';
});

// 其他路由不会执行heavyMiddleware
router.get('/status', async (ctx) => {
  ctx.body = 'OK';
});

路由中间件的实际应用场景

在实际项目中，路由中间件可以用于各种场景，如权限控制、数据验证、日志记录等。

// API版本控制中间件
const versionControl = (version) => {
  return async (ctx, next) => {
    ctx.state.apiVersion = version;
    await next();
  };
};

// 数据验证中间件
const validatePost = async (ctx, next) => {
  if (!ctx.request.body.title) {
    ctx.status = 400;
    ctx.body = 'Title is required';
    return;
  }
  await next();
};

// 组合使用
const v1Router = new Router();
v1Router.use(versionControl('v1'));
v1Router.post('/posts', validatePost, async (ctx) => {
  ctx.body = {
    version: ctx.state.apiVersion,
    post: ctx.request.body
  };
});

router.use('/api', v1Router.routes());

路由中间件与第三方中间件的结合

我们可以将第三方中间件与自定义路由中间件结合使用，扩展应用功能。

const koaBody = require('koa-body');
const helmet = require('koa-helmet');

// 使用koa-body处理文件上传
router.post('/upload', 
  koaBody({ multipart: true }),
  async (ctx) => {
    const file = ctx.request.files.file;
    ctx.body = `File ${file.name} uploaded successfully`;
  }
);

// 使用helmet增强安全性
router.get('/secure', 
  helmet(), 
  async (ctx) => {
    ctx.body = 'Secure content';
  }
);

路由中间件的测试

测试路由中间件时，我们可以使用supertest等工具模拟HTTP请求。

const request = require('supertest');
const app = require('../app');

describe('Auth Middleware', () => {
  it('should return 401 without authorization header', async () => {
    const res = await request(app.callback())
      .get('/profile');
    expect(res.status).toBe(401);
  });

  it('should allow access with valid token', async () => {
    const res = await request(app.callback())
      .get('/profile')
      .set('Authorization', 'Bearer valid-token');
    expect(res.status).toBe(200);
  });
});

路由中间件的调试技巧

调试路由中间件时，可以使用koa-logger等工具查看中间件执行流程。

const logger = require('koa-logger');

app.use(logger());

// 自定义调试中间件
router.use(async (ctx, next) => {
  console.log('Before next:', ctx.path);
  await next();
  console.log('After next:', ctx.status);
});

// 这样可以看到完整的中间件执行流程

路由中间件的组合模式

我们可以将多个中间件组合成一个中间件，简化路由定义。

const compose = require('koa-compose');

const middlewares = compose([
  async (ctx, next) => {
    console.log('Middleware 1');
    await next();
  },
  async (ctx, next) => {
    console.log('Middleware 2');
    await next();
  },
  async (ctx) => {
    ctx.body = 'Hello World';
  }
]);

router.get('/composed', middlewares);

路由中间件的动态加载

在某些场景下，我们可能需要根据条件动态加载中间件。

const dynamicMiddleware = (condition) => {
  return async (ctx, next) => {
    if (condition(ctx)) {
      await next();
    } else {
      ctx.status = 403;
      ctx.body = 'Access denied';
    }
  };
};

router.get('/dynamic', 
  dynamicMiddleware(ctx => ctx.query.secret === '123'),
  async (ctx) => {
    ctx.body = 'You have access';
  }
);

路由中间件的缓存控制

我们可以使用中间件来实现路由级别的缓存控制。

const cacheControl = (maxAge) => {
  return async (ctx, next) => {
    await next();
    ctx.set('Cache-Control', `public, max-age=${maxAge}`);
  };
};

router.get('/cached', 
  cacheControl(3600),
  async (ctx) => {
    ctx.body = { data: 'This response is cached for 1 hour' };
  }
);

路由中间件的响应时间监控

通过中间件可以轻松实现路由响应时间的监控。

const responseTime = async (ctx, next) => {
  const start = Date.now();
  await next();
  const ms = Date.now() - start;
  ctx.set('X-Response-Time', `${ms}ms`);
};

router.get('/timed', 
  responseTime,
  async (ctx) => {
    await new Promise(resolve => setTimeout(resolve, 100));
    ctx.body = 'Timed response';
  }
);

路由中间件的AOP实践

面向切面编程(AOP)可以通过路由中间件优雅地实现。

const aspect = (before, after) => {
  return async (ctx, next) => {
    if (before) await before(ctx);
    await next();
    if (after) await after(ctx);
  };
};

const logBefore = async (ctx) => {
  console.log(`Starting request to ${ctx.path}`);
};

const logAfter = async (ctx) => {
  console.log(`Completed request to ${ctx.path} with status ${ctx.status}`);
};

router.get('/aop', 
  aspect(logBefore, logAfter),
  async (ctx) => {
    ctx.body = 'AOP in action';
  }
);