中间件

egg说明

Egg 是基于 Koa 实现的，所以 Egg 的中间件形式和 Koa 的中间件形式是一样的，都是基于洋葱圈模型。每次我们编写一个中间件，就相当于在洋葱外面包了一层。

一般来说中间件也会有自己的配置。在框架中，一个完整的中间件是包含了配置处理的。我们约定一个中间件是一个放置在 app/middleware 目录下的单独文件，它需要 exports 一个普通的 function，接受两个参数：

options: 中间件的配置项，框架会将 app.config[${middlewareName}] 传递进来。
app: 当前应用 Application 的实例。

示例

中间件

async function middlewareFn (ctx, next) {
  await next();
}

config/config.default.js

module.exports = {
  // 配置需要的中间件，数组顺序即为中间件的加载顺序
  middleware: [ 'middlewareName' ],

  // 配置中间件的配置
  middlewareName: {
    option: 'value',
  },
};

该项目中使用的中间件及用途 （['fm', 'errorHandler', 'responseFormatter', 'jwtErrorHandler']）

• fm 处理输入相关数据的格式化
• errorHandler 处理相关报错
• responseFormatter 格式化输出数据格式
• jwtErrorHandler 处理JWT相关错误以及收集用户UA/ip等

app/middleware/fm.js

const { userAgent } = require('ua_parser');
module.exports = (options, app) => {
    //返回一个异步的方法
    return async(ctx, next) => {
        //打印时间操作
        // console.log(ctx.ip)
        // const JSON = userAgent(ctx.headers['user-agent']);

        let { query: { page = null, limit = null, status = null }, method } = ctx;
        if (method === 'GET') {
            !!page && (ctx.query.page = page * 1);
            !!limit && (ctx.query.limit = limit * 1);
            !!status && (ctx.query.status = status * 1)
        }
        await next();
    }
}

app/middleware/errorHandler.js

module.exports = () => {
    return async function errorHandler(ctx, next) {
        try {
            await next();
        } catch (err) {
            // console.log(err)
            let JSONS = Object.assign({}, ctx.app.config.JSONS);
            ctx.app.emit('error', err, ctx);
            const status = err.status || err.status_code || 500;
            // const error = status === 500 && ctx.app.config.env === 'prod' ?
            //     'Internal Server Error' :
            //     err.message;
            // if (status === 422) {
            //     ctx.body.detail = err.errors;
            // }
            ctx.status = status;
            ctx.body = Object.assign(JSONS, {
                code: err.error_code || status,
                // message: err.errors || err.message
                message: err.message || err.errors
            });
        }
    };
};

app/middleware/responseFormatter.js

module.exports = () => {
    return async function responseFormatter(ctx, next) {
        let JSONS = Object.assign({}, ctx.app.config.JSONS);
        await next();
        // console.log((ctx.body))
        const { code, message, data } = { code: 200, message: 'success', ...ctx.body };
        if (ctx.body) {
            ctx.body = {
                code,
                message,
                data: ctx.body.data ? ctx.body.data : (ctx.body['code'] ? [] : ctx.body) || [],
                _: new Date() - 0
            };
        } else {
            ctx.body = Object.assign(JSONS, {
                code: '404',
                message: '接口不存在，或被永久移除！'
            });
            ctx.status = 404
        }
    }
}

app/middleware/jwtErrorHandler.js

module.exports = (options, app) => {
    return async (ctx, next) => {
        try {
            await next();
            const {
                state: {
                    user: {
                        uid: _uid = null
                    } = {}
                } = {},
                ip
            } = ctx;
            const UA = ctx.headers['user-agent'];
            console.log(ip,UA);
        } catch (err) {
            if (
                ctx.path.includes('unauthorerror') &&
                err instanceof app.jwt.UnauthorizedError
            ) {
                ctx.status = 200;
                ctx.body = 'UnauthorizedError';
                return;
            }
            throw err;
        }
    };
};

框架扩展

在开发中，我们既可以使用已有的扩展 API 来方便开发，也可以对以上对象进行自定义扩展，进一步加强框架的功能。

目前该项目展示只用到Context和Helper两个扩展

Context

Context 指的是 Koa 的请求上下文，这是 请求级别 的对象，每次请求生成一个 Context 实例，通常我们也简写成 ctx。在所有的文档中，Context 和 ctx 都是指 Koa 的上下文对象。

app/extend/context.js

const uid = Symbol('Context#uid');
const apiscope = Symbol('Context#apiscope');
const mid = Symbol('Context#mid');
const openId = Symbol('Context#openId');
const role = Symbol('Context#role')
module.exports = {
    //获取用户id
    get uid() {
        !this[uid] && (this[uid] = this.state.user.uid);
        return this[uid]
    },
    //获取店铺id
    get mid() {
        // console.log(this.state.user); 查看token封装的数据
        !this[mid] && (this[mid] = this.state.user.mid);
        return this[mid]
    },
    //获取用户权限
    get role() {
        !this[role] && (this[role] = this.state.user.role);
        return this[role]
    },
    //获取用户openId
    get openId() {
        !this[openId] && (this[openId] = this.state.user.openId);
        return this[openId]
    },
    //ask授权接口信息（第三方调用）
    get apiscope() {
        !this[apiscope] && (this[apiscope] = this.state.user.apiscope);
        return this[apiscope]
    }
};