关于node.js:koa实战

我的项目初始化

// 初始化我的项目，生成 package.json
npm init

指定入口文件 main.js

我的项目的根底搭建

创立 src 工作目录

创立 main.js 主入口文件

在 main.js 中引入 koa

const koa = require('koa')
const app = new Koa()

app.listen(3000, () => {
  // 监听胜利的回调
  console.log('server is running:http://localhost:3000')
})

node main.js 后即可通过拜访 http://localhost:3000，拜访到此我的项目

我的项目的根本优化

主动重启

// 热更新，只在开发模式下才会用的到
npm install nodemon -D

这时候咱们装置的 nodemon 会在 package.json 中的 devDependencies 下

批改 script 选项

"scripts":{"dev":"nodemon ./src/main.js"}

应用 nodemon 启动，开发过程中的改变会主动重启

配置文件

咱们开发的过程中还须要辨别环境，开发、正式、测试等

// 装置 dotenv
npm install dotenv -S

在我的项目的根目录下创立 .env 文件

尽可能早的在我的项目中引入 dotenv 并进行环境变量的配置

const dotenv = require('dotenv')
dotenv.config()
// 通过了下面的配置，咱们在.env 文件中所配置的环境变量就曾经被加载进 process.env 中了
// 能够将环境变量导出，在须要用到的时候进行引入
module.exports = process.env

这样咱们就在我的项目中配置了环境变量，配置环境变量还有另外一种形式，就是在 package.json 中的 script 中配置执行的命令，并指定环境变量，这样咱们就不必新开一个文件在 js 文件中援用了

增加路由

// 这是一个构造函数
const Router = require('koa-router')
const router = new Router({prefix: '/user'})

router.post('/register', (ctx, next) => {})

通过引入 koa 的路由中间件 koa-router，咱们能够设置我的项目的路由，通过在构造函数中传入 prefix:'/user' 能够设置路由的前缀，以作为不同功能模块的辨别

目录构造的划分

咱们在 main.js 中引入了 koa 启动了服务

又在 main.js 中引入了 koa-router 设置了我的项目的路由

然而随着性能的逐步增多，我的项目变大，咱们不能把所有的货色都写在 main.js 中，咱们须要做功能模块的辨别

抽离路由

在 src 目录下新建 router 文件夹，这个文件夹专门寄存并治理我的项目中的路由。

• 如果须要新增 user 的路由，就新建 user.route.js 文件

• 如果须要新增 order 的路由，就新建 order.route.js 文件

  const Router = require('koa-router')
  const router = new Router({prefix: '/order'})
  router.post('/add', addOrderController)
  
  module.exports = router
  

新建好了各个功能模块的路由，咱们须要一个 index.js 文件来作为路由的总入口文件，它负责引入各个功能模块的路由

const Router = require('koa-router')
const router = new Router()
const fs = require('fs')

// 须要应用 nodejs 的 fs 模块，来进行文件的读取和引入
fs.readdirSync(__dirname).forEach((file) => {// 读取当前目录下的文件['user.route.js','order.route.js']
  if (file !== 'index.js') {const currentFile = require('./' + file)
    // 注册路由
    router.use(currentFile.routes())
  }
})

module.exports = router

这样咱们所有的路由都注册在了 index.js 中的总路由中，咱们只须要在 main.js 中注册在 app 上，就能够实现路由的性能

const router = require('./router') // 引入 index.js 能够不必写

app.use(router.routes())
// 这个是路由做的 http 容许的申请办法解决，如果不写这条语句，那么在应用别的 httpMethod 申请时，会抛出 500 的谬误，加上了这一句，在申请办法不当的时候，会进行提醒
app.use(router.allowedMethods())

抽离 app 服务

咱们须要在 src 底下新建一个 app 文件夹专门治理咱们的服务，因为有时候咱们可能在一个我的项目中应用多个服务。可能是 express、可能是 koa、也可能是 node 中 http 模块

• 在 src 下新建 app 目录
• 在 app 目录下新建一个 index.js 文件，这个文件用于编写咱们当初这个我的项目中次要用的服务，例如 koa，其余的服务可新开文件编写。

const koa = require('koa')
const app = new Koa()
const router = require('./router')

app.use(router.routes())
app.use(router.allowedMethods())

// 注册号路由之后将 app 导出
module.exports = app

这样咱们将服务抽离进去，在 main.js 中进行引入的时候，将 app 服务引入并监听即可

const app = require('./app/index.js')

app.listen(3000, () => {
  // 监听胜利的回调
  console.log('server is running:http://localhost:3000')
})

这样 main.js 就变的更加简洁了

抽离 controller

咱们在 user.route.js 中写下了这样的代码

router.post('/register', (ctx, next) => {})
// (ctx,next)=>{} 这个是用来解决 register 逻辑的函数，咱们能够把它抽离成一个 controller，专门用于解决各个拜访的逻辑

• 在 src 目录下新建一个文件夹 controller
• 在 controller 文件夹下新建一个文件，叫做 user.controller.js
• 在 controller 文件夹下新建一个文件，叫做 order.controller.js

class UserController {async registerUser() {// 这里解决 register 的逻辑}
  async loginUser() {// 这里解决 login 的逻辑}
}

module.exports = new UserController()

抽离进去之后在路由文件中引入相应的 controller

抽离 service

咱们在 controller 中要进行数据库的操作，咱们把操作数据库的这一部分，抽离为 service

• 在 src 文件夹下创立 service 文件夹
• 在 service 文件夹下创立 user.service.js

class UserService {
  // 解决创立用户的 service
  async createUser() {// 这个外部封装了数据库的操作}

  // 解决更新用户的 service
  async updateUser() {}
}

抽离数据库定义

sequelize这个包专门用于我的项目中解决关系型数据库的操作，它是基于 promise 的

咱们须要借助它来对数据库进行操作

• npm install sequelize -S先装置
• 在 src 下新建一个 db 目录用于治理此我的项目须要连贯的数据库
• 在 db 目录下新建一个 seq.js

const {Sequelize} = require('sequelize')
const {HOST, PORT /* 等等须要的配置 */} = process.env

// 实例化 sequelize 对象
const seq = new Sequelize(
  '要连贯的数据库名称',
  '数据路的用户名',
  '数据库的明码',
  {
    // options
    host: '要连贯的数据库的 host',
    port: '要连贯的数据路的端口',
    dialect: 'mysql', // 要操作的数据库类型
  }
)

// 实例化过后就进行连贯
seq
  .authenticate()
  .then((res) => {console.log(res, '连贯胜利的回调')
  })
  .catch((err) => {console.log(err, '连贯失败的回调')
  })

module.exports = seq

抽离 model

连贯好了数据库之后，咱们须要定义数据库表，这时候须要抽离一个 model 层，来定义数据库的表构造

• 在 src 下新建一个 model 目录
• 在 model 中新建一个 user.model.js，进行如下定义：
• 参考 nodejs 进阶视频解说：进入学习

const seq = require('../db/seq')

// 创立 User 表，表名为 user,user 中有各项字段
const User = seq.define('user', {
    {
      userName:{
       type:DataTypes.String,// DataTypes 是 Sequelize 中为咱们提供的类型，须要引入
       allowNull:false, // 是否容许空值，参考 Sequelize 文档
       unique:true,// 是否容许惟一
       comment:'字段正文',
    },
    {
      password:{
        type:DataTypes.String,
        allowNull:false,
        //...
      }
    }
  }
})

module.exports = User

当咱们定义好了 User 的 model 之后，就能够在 user.service.js 中引入并应用它

const User = require('../model/user.model.js')

class UserService {
  // 解决创立用户的 service
  async createUser(userName, password) {
    // 这个外部封装了数据库的操作, 都是基于 promise，须要进行 try...catch 谬误捕捉
    const res = User.create({userName, password})
    return res.dataValues
  }

  // 解决更新用户的 service
  async updateUser() {}
}

module.exports = new UserService()

抽离中间件

当咱们实现了这一系列的操作之后，就搭建起了一个接口编写的框架。咱们能够在每一个 controller 中编写对应的业务解决。然而在咱们编写接口的过程中，时常会碰到雷同或类似的解决模块，这时候咱们为了防止反复冗余的代码，须要把这些雷同或类似的性能抽离成中间件。

• 在 src 下新建一个文件夹叫做 middleware
• 在 middleware 中新建一个文件叫做 user.middleware.js

const validateUserInfo = (ctx, next) => {// 这里能够填充用户登录或注册时的校验办法}

const comparePassword = (ctx, next) => {// 这里能够填充批改明码时，两个明码进行比照的办法}

module.exports = {
  validateUserInfo,
  comparePassword,
}

抽离错误处理

Sequelize 是基于 promise 的数据库操作工具，咱们在进行数据库操作或者日常代码编写的时候要进行错误处理，将错误处理的这一部分抽离进去，也会不便咱们排查问题。

• 在 src 下新建一个 constant 问价夹，专门用来寄存代码中须要用到的常量
• 在 constant 文件夹下新建一个 err.type.js 用来存储返回给前端的谬误提醒

module.exports = {
  UserValidError = {
    code:'10001',
    message:'用户校验失败',
    result:''
  },
  UserLoginError = {
    code:'10002',
    message:'用户登录失败',
    result:''
  }
}

将谬误归集起来了之后，咱们只须要在捕捉到这个谬误的时候应用它

// ctx 中提供了以后的 app，其中有一个 emit 的办法，能够传递一个事件，前面为该事件须要的参数
ctx.app.emit('error', UserValidError, ctx)
// 在 app 中应用 on 作为接管
app.on('error', errHandler)

// errHandler
module.exports = (error, ctx) => {
  // 这里的 error 就是 UserValidError
  // ctx 就是传递过去的 ctx 上下文
  ctx.body = error // 把以后谬误返回给前端
}

至此咱们就实现了我的项目中的性能拆分，接下来就是在每个模块中填充相应的内容

注册接口的编写

注册的逻辑个别为用户提供用户名明码，传递给后端，后端拿到用户名和明码当前，首先要判断数据库中是否曾经存在此用户，如果曾经存在了这个用户，就返回提醒码并告知前端，此用户曾经注册。如果不存在，则对用户传递过去的明码进行加密，而后存储到数据库中。

这里只记录加密接口的步骤

// 应用 bcryptjs
const bcrypt = require('bcrypt')

const cryptPassword = async (ctx, next) => {const { password} = ctx.request.body
  const salt = bcrypt.genSaltSync(10) // 加盐
  const hash = bcrypt.hashSync(password, salt)
  ctx.request.body.password = hash
  await next()}

通过此步骤加密之后，咱们就能够往下解决注册是逻辑

• 从 request.body 中取出加密之后的明码
• 存储用户名和明码至数据库
• 向用户返回后果

登录接口的编写

登录的逻辑个别为，用户输出用户名和明码进行登录。咱们拿取到用户名和明码之后，要和数据库中的用户名和明码进行比拟，如果比拟失败，则返回用户失败的后果，否则登录胜利，胜利之后须要下发 token 以及 cookie 等。

这里只记录明码比照和 token 下发的步骤

// 明码比照
bcrypt.compareSync('以后明码', '用户传递过去的明码') // 如果雷同返回 true，如果不同返回 false

// 下发 token  须要用到 jsonwebtoken 这个库
// npm install jsonwebtoken -S
const jwt = require('jsonwebtoken')
// 从数据库中拿取出数据之后，除了明码以外，将其它的信息都用于 token 下发，也能够用作 userInfo 返回
const {password, ...res} = await getUserInfo({userName})
// 那么这个 res 就是咱们下发 token 须要用到
const token = jwt.sign(res, '本人设置的加密串', {expiresIn: '1d' /*token 的无效工夫 */,})
ctx.body = {
  code: 200,
  message: '登录胜利',
  result: {token,},
}

这样咱们就实现了登录的流程，将 token 下发给用户之后，用户当前的资源申请都须要将 token 携带过去，咱们进行验证，如果验证胜利，那么能够进行后续的操作，如果验证失败，那么用户就不能获取咱们的实在资源。

验证中间件的编写

因为咱们下发 token 之后的每一个接口都要通过验证之后能力向下进行，所以咱们须要编写一个验证 token 的中间件

• 在 middleware 这个文件加下创立 auth.middleware.js 文件

const jwt = require('jsonwebtoken')

const auth = (ctx, next) => {
  // 这里编写验证 token 的相干内容
  const {authorization} = ctx.request.header
  const token = authorization.replace('Bearer', '')

  try {
    // 如果通过验证，会把咱们先前用来生成 token 的信息返回，这里也就是除了 password 之外的其余用户信息
    const user = jwt.verify(token, '咱们先前设置的加密串')
    ctx.state.user = user // 咱们把通过验证的用户信息放入 state 属性下的 user 中
  } catch (error) {
    // 如果没有通过验证，那么有几种状况
    // error.name === TokenExpiredError
    // error.name === JsonWebTokenError
    // 详情参考 jsonwebtoken 这个库的介绍
  }
}

验证的中间件编写实现之后，咱们的每一次须要验证 token 的申请，都会应用到它

数据上传

编写接口的同时咱们要解决前端传递过去的数据，那么在 koa 中，数据上传须要用到一个中间件，就是koa-body

• npm install koa-body -S 装置依赖
• 在路由注册之前先注册koa-body

const KoaBody = require('koa-body')

app.use(
  KoaBody({// ...options})
)

// 注册路由
app.use(router.routes())

因为通过 koa-body 的解决，前端传递过去的申请数据会挂在ctx.request.body 上，咱们在后续的路由解决中，在此处获取并解决即可

koa-body 有很多选项（比方是否反对文件上传等），具体参考手册

动态资源管理

如果想要前端通过浏览器的 uri 拜访到本服务的动态资源，那么须要进行动态资源配置

须要应用到koa-static

• npm install koa-static -S

const koaStatic = require('koa-static')

app.use(koaStatic('动态资源门路，最好借助 path 模块'))

通过了这样的动态资源配置，前端就能够在浏览器上输出 uri 来拜访到本服务的动态资源

sequelize 的根本了解

模型 model 时 sequelize 的实质，是数据库中表的形象，在 sequelize 中是一个类

比如说，咱们要创立一个用户表，那么首先须要定义一个 User 类，这个 User 类就是 sequelize 的模型。表中的每一条数据都是一个对象，每一个对象都是这个类的实例。而咱们对 User 类的操作，或者是对实例（表中的每一条数据）的操作，都是相似操作 js 对象一样思维。有了这样的意识，能够帮忙咱们更好的了解 sequelize 的各项操作。

sequelize 文档

增删改查

做完后面的一些根底工作之后，最常见也是最常常写的就是 CRUD 了

新增接口

第一步：定义路由，恪守 restfull 标准，定义为router.post('/order','中间件 1','中间件 2')

第二步：在 controller 中定义解决该路由的中间件

第三步：在 service 中定义写入数据库的办法，如果这一步须要用到新的 model，则先在 model 中定义好数据字段

// 须要借助 sequelize 来进行数据库操作
// 先把 User 模型给引进来
const User = require('../model/user.model.js')
// 新增操作须要在 User 表中新增一条数据，从类的角度来说，就是创立一个实例
// 假如咱们此时是在 /src/service/user.service.js
class UserService {
  // 创立一个用于解决 User model 的类
  async addUser({id, userName}) {
    // ID，userName 是从 controller 中解析的
    // 模型中有一个创立的办法
    // 办法一：const res = await User.create({id, userName})
    // 在没有谬误的状况下，执行结束这个操作，就会在 user 表中新增一条数据
    // 办法二：// sequelize 的 model 为咱们提供了创立实例的办法 build
    const res = User.build({id, userName})
    // 然而此时的 build 的办法，仅仅是创立出的一个对象，示意能够将这个对象映射到数据库中的数据，这个对象还并未真正的保留在数据库中，咱们应该应用 save 办法，将其同步
    return res.save()
    // 执行完这一步才算是真正的同步至了数据库中
    // 倡议间接应用 create 办法，具体操作详见 sequelize 官网文档
  }
}
module.exports = new UserService()

第四步：留神谬误捕捉与错误处理

批改接口

第一步：定义路由，定义为router.put('/order/:id','中间件','中间件')

第二步：在 controller 中定义解决该路由的中间件

第三步：在 service 中定义批改数据库的办法

// 批改接口同新增接口
// 假如咱们此时在 /src/service/user.service.js
class UserService {
// 新增用户的接口
async addUser(){}
// 更新用户的接口
async updateUser({id,userName}){
 // sequelize 中为咱们提供的更新办法也有两种
 // 办法一：const res = await User.update({userName},{
   where:{
     id,
     userName
   }
 })
 // 办法二：const res = await User.create({id,userName})
 res.set({userName:'xxx'})
 return awaut res.save()}
}

第四步：留神谬误捕捉与错误处理

删除接口

删除首先要确定是应用硬删除，还是软删除。这二者的区别为硬删除为间接从数据库中的记录抹去，软删除为在数据库中减少一个标识字段，该字段标记了就代表删除了，但不是真正意义上的删除。

第一步：定义路由，定义为router.delete('/order/:id','中间件','中间件','中间件')

第二步：在 controller 中定义解决该路由的中间件

第三步：在 service 中定义删除该数据的办法，此时能够抉择硬删除，或者是软删除，详见sequelize 文档

查问接口

查问接口的思路同上