devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

node.js—基于Egg框架的简单后端搭建（包含传参数据库操作）_eggjs

作者：AllinToyou | 2024-02-29 09:40:24

赞

踩

eggjs

1、Egg.js 是什么?

Egg.js 为企业级框架和应用而生，我们希望由 Egg.js 孕育出更多上层框架，帮助开发团队和开发人员降低开发和维护成本。

与社区框架的差异

Express 是 Node.js 社区广泛使用的框架，简单且扩展性强，非常适合做个人项目。但框架本身缺少约定，标准的 MVC 模型会有各种千奇百怪的写法。Egg 按照约定进行开发，奉行『约定优于配置』，团队协作成本低。

Sails 是和 Egg 一样奉行『约定优于配置』的框架，扩展性也非常好。但是相比 Egg，Sails 支持 Blueprint REST API、WaterLine 这样可扩展的 ORM、前端集成、WebSocket 等，但这些功能都是由 Sails 提供的。而 Egg 不直接提供功能，只是集成各种功能插件，比如实现 egg-blueprint，egg-waterline 等这样的插件，再使用 sails-egg 框架整合这些插件就可以替代 Sails 了。

特性

2、搭建配置项目 

 快速初始化

我们推荐直接使用脚手架，只需几条简单指令，即可快速生成项目（npm >=6.1.0）:

  1. 创建项目文件夹（egg-example），并且进入该文件夹
  2. $ mkdir egg-example && cd egg-example
  3. 初始化项目
  4. $ npm init egg --type=simple
  5. 安装项目依赖
  6. $ npm i
  7. 启动
  8. $ npm run dev
  9.  
  10. 浏览器直接打开这个端口： http://localhost:7001

 项目完整目录结构：

egg-project
├── package.json
├── app.js (可选)
├── agent.js (可选)
├── app
|   ├── router.js
│   ├── controller
│   |   └── home.js
│   ├── service (可选)
│   |   └── user.js
│   ├── middleware (可选)
│   |   └── response_time.js
│   ├── schedule (可选)
│   |   └── my_task.js
│   ├── public (可选)
│   |   └── reset.css
│   ├── view (可选)
│   |   └── home.tpl
│   └── extend (可选)
│       ├── helper.js (可选)
│       ├── request.js (可选)
│       ├── response.js (可选)
│       ├── context.js (可选)
│       ├── application.js (可选)
│       └── agent.js (可选)
├── config
|   ├── plugin.js
|   ├── config.default.js
│   ├── config.prod.js
|   ├── config.test.js (可选)
|   ├── config.local.js (可选)
|   └── config.unittest.js (可选)
└── test
    ├── middleware
    |   └── response_time.test.js
    └── controller
        └── home.test.js

虽然开始我们有些目录没有，当我们需要用到哪些目录在创建

编写 Controller 

第一步需要编写的是 Controller 和 Router。 

路由（Router）

Router 主要用来描述请求 URL 和具体承担执行动作的 Controller 的对应关系， 框架约定了 app/router.js 文件用于统一所有路由规则。

通过统一的配置，我们可以避免路由规则逻辑散落在多个地方，从而出现未知的冲突，集中在一起我们可以更方便的来查看全局的路由规则。

  • app/router.js 里面定义 URL 路由规则
  1. // app/router.js
  2. module.exports = (app) => {
  3.   const { router, controller } = app;
  4.   router.get('/user/:id', controller.user.info);
  5. };
  • app/controller 目录下面实现 Controller
  1. // app/controller/user.js
  2. class UserController extends Controller {
  3.   async info() {
  4.     const { ctx } = this;
  5.     ctx.body = {
  6.       name: `hello ${ctx.params.id}`,
  7.     };
  8.   }
  9. }

什么是 Controller

我们通过 Router 将用户的请求基于 method 和 URL 分发到了对应的 Controller 上，那 Controller 负责做什么？

简单的说 Controller 负责解析用户的输入，处理后返回相应的结果，例如

  • 在 RESTful 接口中，Controller 接受用户的参数，从数据库中查找内容返回给用户或者将用户的请求更新到数据库中。
  • 在 HTML 页面请求中，Controller 根据用户访问不同的 URL，渲染不同的模板得到 HTML 返回给用户。
  • 在代理服务器中，Controller 将用户的请求转发到其他服务器上，并将其他服务器的处理结果返回给用户。

框架推荐 Controller 层主要对用户的请求参数进行处理（校验、转换），然后调用对应的 service 方法处理业务，得到业务结果后封装并返回：

  1. 获取用户通过 HTTP 传递过来的请求参数。
  2. 校验、组装参数。
  3. 调用 Service 进行业务处理，必要时处理转换 Service 的返回结果，让它适应用户的需求。
  4. 通过 HTTP 将结果响应给用户。

所有的 Controller 文件都必须放在 app/controller 目录下，可以支持多级目录，访问的时候可以通过目录名级联访问。Controller 支持多种形式进行编写，可以根据不同的项目场景和开发习惯来选择。 

3、框架内置基础对象（重点理解）

初步介绍一下框架中内置的一些基础对象，包括从 Koa 继承而来的 4 个对象（Application, Context, Request, Response)

Application

Application 是全局应用对象，在一个应用中，只会实例化一个，它继承自 Koa.Application，在它上面我们可以挂载一些全局的方法和对象。我们可以轻松的在插件或者应用中扩展 Application 对象。

获取方式

Application 对象几乎可以在编写应用时的任何一个地方获取到，下面介绍几个经常用到的获取方式：

几乎所有被框架 Loader 加载的文件（Controller，Service，Schedule 等），都可以 export 一个函数，这个函数会被 Loader 调用，并使用 app 作为参数：

  1. // app/controller/user.js
  2. class UserController extends Controller {
  3.   async fetch() {
  4.     this.ctx.body = this.app.cache.get(this.ctx.query.id);
  5.   }
  6. }

Context 

 Context 是一个请求级别的对象，继承自 Koa.Context。在每一次收到用户请求时，框架会实例化一个 Context 对象，这个对象封装了这次用户请求的信息，并提供了许多便捷的方法来获取请求参数或者设置响应信息。框架会将所有的 Service 挂载到 Context 实例上，一些插件也会将一些其他的方法和对象挂载到它上面（egg-sequelize 会将所有的 model 挂载在 Context 上）。

 获取方式

最常见的 Context 实例获取方式是在 Middleware, Controller 以及 Service 中。Controller 中的获取方式在上面的例子中已经展示过了，在 Service 中获取和 Controller 中获取的方式一样，在 Middleware 中获取 Context 实例则和 Koa 框架在中间件中获取 Context 对象的方式一致。

框架的 Middleware 同时支持 Koa v1 和 Koa v2 两种不同的中间件写法，根据不同的写法，获取 Context 实例的方式也稍有不同（例子）：

  1. // app.js
  2. module.exports = (app) => {
  3.   app.beforeStart(async () => {
  4.     const ctx = app.createAnonymousContext();
  5.     // preload before app start
  6.     await ctx.service.posts.load();
  7.   });
  8. };

 Request & Response

Request 是一个请求级别的对象，继承自 Koa.Request。封装了 Node.js 原生的 HTTP Request 对象，提供了一系列辅助方法获取 HTTP 请求常用参数。

Response 是一个请求级别的对象，继承自 Koa.Response。封装了 Node.js 原生的 HTTP Response 对象，提供了一系列辅助方法设置 HTTP 响应。

获取方式 

可以在 Context 的实例上获取到当前请求的 Request(ctx.request) 和 Response(ctx.response) 实例。（例子）

  1. // app/controller/user.js
  2. class UserController extends Controller {
  3.   async fetch() {
  4.     const { app, ctx } = this;
  5.     const id = ctx.request.query.id;
  6.     ctx.response.body = app.cache.get(id);
  7.   }
  8. }
  • 如上面例子中的 ctx.request.query.id 和 ctx.query.id 是等价的，ctx.response.body= 和 ctx.body= 是等价的。
  • 需要注意的是，获取 POST 的 body 应该使用 ctx.request.body，而不是 ctx.body。

 4、带大家写后台接口（router、Controller、service）

学生信息接口API。

安装egg-MySql和配置本地数据库

本地数据库最好部署在自己服务器，没有待会再给大家讲一下连接本地数据库

egg-mysql

框架提供了 egg-mysql 插件来访问 MySQL 数据库。这个插件既可以访问普通的 MySQL 数据库，也可以访问基于 MySQL 协议的在线数据库服务。

安装与配置

安装对应的插件 egg-mysql ：

$ npm i --save egg-mysql

开启插件：

  1. // config/plugin.js
  2. exports.mysql = {
  3.   enable: true,
  4.   package: 'egg-mysql',
  5. };

我的：

 在 config/config.${env}.js 配置各个环境的数据库连接信息。

单数据源

如果我们的应用只需要访问一个 MySQL 数据库实例，可以如下配置：

  1. // config/config.${env}.js
  2. exports.mysql = {
  3.   // 单数据库信息配置
  4.   client: {
  5.     // 端口号，没有服务器就些本地127.0.0.1
  6.     host: 'mysql.com',
  7.     // 端口号
  8.     port: '3306',
  9.     // 用户名
  10.     user: 'test_user',
  11.     // 密码
  12.     password: 'test_password',
  13.     // 数据库名
  14.     database: 'test',
  15.   },
  16.   // 是否加载到 app 上，默认开启
  17.   app: true,
  18.   // 是否加载到 agent 上，默认关闭
  19.   agent: false,
  20. };

我的：

使用方式：

await app.mysql.query(sql, values); // 单实例可以直接通过 app.mysql 访问

 多数据源：MySQL - Egg

建表：

编写service层（操作数据库）

  1. // service/student.js
  2. const { Service } = require("egg");
  3.  
  4. class studentService extends Service {
  5.   // 查询所有学生信息
  6.   async findAll() {
  7.     let { mysql } = this.app;
  8.     const students = await mysql.select("student_information");
  9.     console.log(students);
  10.     return students;
  11.   }
  12.  
  13.   // 根据id查询学生数据
  14.   async findById(id) {
  15.     let { mysql } = this.app;
  16.     const student = await mysql.get("student_information", { student_id: id });
  17.     console.log(student);
  18.     return student;
  19.   }
  20.  
  21.   // 更新插入学生数据
  22.   async saveOrUpdate(student) {
  23.     let result = null;
  24.     if (student.id) {
  25.       result = await this.app.mysql.update("student_information", student);
  26.     } else {
  27.       result = await this.app.mysql.insert("student_information", student);
  28.     }
  29.     return result;
  30.   }
  31.  
  32.   // 根据id删除学生数据
  33.   async deleteById(id) {
  34.     const result = await this.app.mysql.delete("student_information", { id });
  35.   }
  36. }
  37.  
  38. module.exports = studentService;

封装Response

  1. // 封装响应体
  2. // utils/Response.js
  3.  
  4. class Response {
  5.   constructor(message, data) {
  6.     this.message = message;
  7.     this.data = data;
  8.     this.status = 200;
  9.     this.timestamp = new Date().getTime();
  10.   }
  11. }
  12.  
  13. module.exports = Response;

编写Controller层

  1. // controller/students.js
  2. "use strict";
  3.  
  4. const Controller = require("egg").Controller;
  5.  
  6. // 引入响应体
  7. let Response = require("../utils/Response");
  8.  
  9. class StudentController extends Controller {
  10.   // vscode 有默认的用户片段 输入controller即可生成
  11.   async findAll() {
  12.     // egg规定方法都是异步的
  13.     // 应该是底层把egg相关的东西都挂上去了
  14.     const { ctx, service } = this;
  15.     // 调用service层查询方法
  16.     let students = await service.student.findAll();
  17.     // 接口返回内容
  18.     ctx.body = new Response("查询成功", students);
  19.   }
  20.  
  21.   // 根据id查询学生信息
  22.   async findById() {
  23.     let { ctx, service } = this;
  24.     // 1、获取参数
  25.     let id = ctx.query.id;
  26.     console.log(id);
  27.     // 调用service层方法
  28.     // await service.findById(id);
  29.     let student = await service.student.findById(id);
  30.     // 给出响应
  31.     ctx.body = new Response("查询成功", student);
  32.   }
  33.  
  34.   async lists() {
  35.     const { ctx } = this;
  36.  
  37.     await new Promise((resolve) => {
  38.       // 模拟接口延迟
  39.       setTimeout(() => {
  40.         resolve();
  41.       }, 1500);
  42.     });
  43.  
  44.     ctx.body = [{ id: 123 }];
  45.   }
  46. }
  47.  
  48. module.exports = StudentController;

路由router

  1. // app/router.js
  2. "use strict";
  3.  
  4. /**
  5.  * @param {Egg.Application} app - egg application
  6.  */
  7. module.exports = (app) => {
  8.   const { router, controller } = app;
  9.  
  10.   router.get("/", controller.home.index);
  11.   router.post("/logon", controller.logon.logon);
  12.   router.get("/student", controller.student.findAll); // 新增
  13.   // 根据id查询学生信息;
  14.   router.get("/student/findById", controller.student.findById);
  15.   router.get("/student/lists", controller.student.lists); // 新增
  16. };

当我们用axios访问是会出现跨域问题，我们用中间件解决一下：

cors中间件就是解决跨域的，express和egg框架都是可以用的，安装：

$ npm install cors --save

开启中间件：

  1.   // plugin.js
  2.   cors: {
  3.     enable: true,
  4.     package: "egg-cors",
  5.   },

配置白名单，将所有的请求方式都添加进来

  1.   // config.default.js
  2.   config.cors = {
  3.     origin: "*",
  4.     allowMethods: "GET,HEAD,PUT,POST,DELETE,PATCH,OPTIONS",
  5.   };

 这样应该就没有什么问题了，就可以通过Ajax或者axios请求刚写的接口！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/164871
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号