一、在controller层创建一个base.js，把增删改方法抽离成基类：

/**
 * author:hwf
 * 描述:进行增删改封装,这里只是适用于简单的增删改,对于复杂的逻辑处理,相应的重新编写文件
 */

'use strict';

// 创建基类控制器

const Controller = require('egg').Controller;

class BaseController extends Controller {

    // 成功
    success(data) {
        this.ctx.body = {
            code: 200,
            message: "请求成功",
            data
        }
    }

    // 失败
    error(error) {
        this.ctx.body = {
            code: 200,
            message: '请求失败',
            error
        }
    }
    // 查询用户
    async index() {
        const { service } = this;
        let List = await service[this.entity].list();
        this.success(List);
    }

    // 新增用户
    async create() {
        const { ctx, service } = this;
        let entity = ctx.request.body;
        await service[this.entity].create(entity);
        this.success('success');
    }

    // 更新用户
    async update() {
        const { ctx, service } = this;
        let id = ctx.params.id;
        const entity = ctx.request.body;
        entity.id = id;
        await service[this.entity].update(entity);
        this.success('success');
    }

    // 删除用户
    async destroy() {
        const { ctx, service } = this;
        let id = ctx.params.id;
        const entity = ctx.request.body;
        entity.id = id;
        await service[this.entity].destroy(entity);
        this.success('success');
    }
}

module.exports = BaseController;

二、在service层也创建一个base.js基类：

/**
 * author:hwf
 * 增删改的封装
 */
'use strict';
const Service = require('egg').Service;

class BaseService extends Service {

  // 查询列表
  async list() {
    return await this.app.mysql.select(this.entity);
  }

  // 新增
  async create(entity) {
    return await this.app.mysql.insert(this.entity, entity);
  }
  
  // 更新
  async update(entity) {
    return await this.app.mysql.update(this.entity, entity);
  }

  // 销毁
  async destroy(id) {
    return await this.app.mysql.delete(this.entity, entity);
  }
}

module.exports = BaseService;

三、把controller层user.js更改为：

// 引入基类
const BaseController = require('./base');

class UserController extends BaseController {
    constructor(ctx) {
        super(ctx);
        this.entity = 'user'; // 表名
    }
}

module.exports = UserController;

四、把service层user.js更改为：

// 引入基类service
'use strict';

const BaseService = require('./base');

class UserService extends BaseService {
  constructor(ctx) {
    super(ctx);
    this.entity = 'user';
  }
}

module.exports = UserService;

五、service层创建role.js：

// controller层
// 引入基类
'use strict';

const BaseController = require('./base');

class RoleController extends BaseController {
    constructor(ctx) {
        super(ctx);
        this.entity = 'role';
    }
}

module.exports = RoleController;

// service层
// 引入基类service
'use strict';
const BaseService = require('./base');

class RoleService extends BaseService {
  constructor(ctx) {
    super(ctx);
    this.entity = 'role';
  }
}

module.exports = RoleService;

六、routers.js添加路由：

'use strict';

/**
 * @param {Egg.Application} app - egg application
 * 配置路由
 */
module.exports = app => {
  const { router, controller } = app;
  router.get('/', controller.home.index);
  router.resources('user', '/api/user', controller.user);
  router.resources('role', '/api/role', controller.role);
};

七、效果：

八、总结：

	通过构造函数，实现只需要传不同的表名，就可以共用基类的增删改方法，没必要每创建一个controller就需要重复去写增删改方法，但这里只是一个简单的封装，如果有复杂的业务逻辑，需要单独剥离开来。
	温馨提示：可以结合我之前写的第一篇[egg文章](https://blog.csdn.net/Violent_clown/article/details/111502404#comments_14317637)
	交流请联系：1798274010@qq.com