koa2 连接 mysql 数据库实现增删改查操作

创建项目

安装 ko2 脚手架：

$ npm install -g koa-generator

创建项目并初始化依赖：

$ koa2 -e kao2-demo
$ cd koa2-demo
$ npm install

配置不同环境变量下的启动命令：

# 安装 cross-env
$ npm install cross-env --save-dev

修改 package.json 文件：

{
    "scripts": {
        "start": "node bin/www",
        "dev": "cross-env NODE_ENV=dev ./node_modules/.bin/nodemon bin/www",
        "prd": "cross-env NODE_ENV=production pm2 start bin/www",
        "test": "echo \"Error: no test specified\" && exit 1"
    }
}

发送请求

在路由文件中处理 http 请求，以 routes/index.js 文件为例：

const router = require('koa-router')()

// get请求
router.get('/profile/:username', async (ctx, next) => {
  // 获取动态参数
  const { username } = ctx.params
  // 响应json数据
  ctx.body = {
    title: 'this is profile page',
    user: {
      username
    }
  }
})

// post请求
router.post('/login', async (ctx, next) => {
  // 获取post请求参数
  const { username, password } = ctx.request.body
  ctx.body = {
    code: 200,
    msg: 'login success',
    user: {
      username,
      password
    }
  }
})

module.exports = router

使用 postman 分别发送 get 和 post 请求测试：

# get请求
http://localhoost:3000/profile/tom

# post请求
http://localhost:3000/login

mysql 的使用

安装依赖：

$ npm install mysql2 sequelize --save

连接数据库：

// seq.js

const Sequelize = require('sequelize')

const conf = {
  host: 'localhost',
  dialect: 'mysql'
}

// 线上环境使用连接池
// conf.pool = {
//   max: 5, // 连接池中最大的连接数量
//   min: 0, // 连接池中最小的连接数量
//   idle: 10000, // 一个连接在10s之内没有被使用，则释放
// }

const seq = new Sequelize('datasets', 'root', 'root', conf)

module.exports = seq

创建连接：

// sync.js

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

// 测试连接
seq.authenticate().then(() => {
  console.log('mysql ok')
}).catch(() => {
  console.log('mysql no')
})

// 执行同步，force 为true时删除旧表再创建新表
seq.sync({ force: false }).then(() => {
  console.log('sync ok')
  process.exit()
})

创建数据模型：

// model.js

const Sequelize = require('sequelize')
const seq = require('./seq')

// 创建Users模型
const Users = seq.define('users', {
  id: {
    type: Sequelize.INTEGER, // varchar(255)
    allowNull: false, // 不为空
    primaryKey: true, // 主键
    comment: '用户ID' // 备注
  },
  username: {
    type: Sequelize.STRING,
  },
  pwd: {
    type: Sequelize.STRING
  },
  nikename: {
    type: Sequelize.STRING
  }
})

// 创建blog模型
const Blogs = seq.define('blogs', {
  title: {
    type: Sequelize.STRING,
    allowNull: false
  },
  desc: {
    type: Sequelize.STRING,
    allowNull: false
  },
  content: {
    type: Sequelize.TEXT, // 大文本类型
    allowNull: false
  },
  userId: {
    type: Sequelize.INTEGER,
    allowNull: false
  }
})

// 外键关联
Blogs.belongsTo(Users, {
  foreignKey: 'userId' // 创建外键 Blogs.userId -> Users.id
})

Users.hasMany(Blogs, {
  foreignKey: 'userId' // 创建外键 Blogs.userId -> Users.id
})

// Blogs.belongsTo(Users)

module.exports = {
  Users,
  Blogs
}

插入数据

// create.js

const { Users } = require('./model')

!(async function() {
  // 创建用户
  const zhangsan = await Users.create({
    id: '112',
    username: '李四',
    pwd: '123456',
    nikename: 'hello'
  })

  console.log('插入数据：', zhangsan.dataValues)
})()

查询数据

// select.js

const { Blogs, Users } = require('./model')

!(async function() {
  // 查询一条数据
  const zhangsan = await Users.findOne({
    where: {
      username: '张三'
    }
  })
  console.log('查询一条数据：', zhangsan.dataValues)

  // 查询特定列
  const names = await Users.findOne({
    attributes: ['username', 'nikename']
  })
  console.log('查询特定列：', names.dataValues)

  // 查询列表
  const list = await Users.findAll({
    where: {
      id: 1
    },
    order: [
      ['id', 'desc'] // 降序
    ]
  })
  console.log('查询所有数据：', list.map(users => users.dataValues))

  // 分页
  const pageList = await Users.findAll({
    limit: 2, // 限制本次查询条数（每页条数）
    offset: 0, // 跳过多少条（起始位置）
    order: [
      ['id', 'asc'] // 升序
    ]
  })
  console.log('分页查询：', pageList.map(users => users.dataValues))

  // 查询总数
  const usersCount = await Users.findAndCountAll({
    limit: 2, // 限制本次查询条数（每页条数）
    offset: 0, // 跳过多少条（起始位置）
    order: [
      ['id', 'asc'] // 升序
    ]
  })
  console.log('查询总数：',
    usersCount.count, // 所有总数，不考虑分页
    usersCount.rows.map(users => users.dataValues)
  )

  // 连表查询1：通过Blogs查询Users
  const blogListWithUser = await Blogs.findAndCountAll({
    order: [
      ['id', 'desc']
    ],
    include: [
      {
        model: Users,
        attributes: ['username', 'nikename'],
        where: {
          username: '张三'
        }
      }
    ]
  })
  console.log('查询结果：',
    blogListWithUser.count,
    blogListWithUser.rows.map(blogs => {
      const blogVals = blogs.dataValues
      blogVals.user = blogVals.user.dataValues // 多对一关系
      return blogVals
    })
  )

  // 连表查询2：通过Users查询Blogs
  const usersListWithBlogs = await Users.findAndCountAll({
    attributes: ['username', 'nikename'],
    include: [
      {
        model: Blogs
      }
    ]
  })
  console.log('查询结果：',
    usersListWithBlogs.count,
    usersListWithBlogs.rows.map(users => {
      const userVals = users.dataValues
      userVals.blogs = userVals.blogs.map(blog => blog.dataValues) // 一对多关系
      return userVals
    })
  );
})()

修改数据

// update.js

const { Users } = require('./model')

!(async function() {
  // 修改用户信息
  const updateRes = await Users.update({
    nikename: 'zhangsan' // 修改的值
  }, {
    where: {
      username: '张三' // 条件
    }
  })
  console.log('修改结果：', updateRes[0] > 0)
})()

删除数据

// delete.js

const { Users } = require('./model')

!(async function() {
  // 删除一条数据
  const deleteRes = await Users.destroy({
    where: {
      id: 111
    }
  })
  console.log('删除结果：', deleteRes > 0)
})()

模糊查询

// select.js

const { Blogs, Users } = require('./model')
const Op = require('sequelize').Op // 必须要导入

!(async function(keywords) {
  // 分页查询
  const pageList = await Users.findAll({
    limit: 2, // 限制本次查询条数（每页条数）
    offset: 0, // 跳过多少条（起始位置）
    order: [
      ['id', 'asc'] // 升序
    ],
    where: { // 查询条件
        nikename: {
            [Op.like]: `%${keywords}%`  // 关键词
        },
        id: '1234565'
    }
  })
  console.log('分页查询：', pageList.map(users => users.dataValues))
})()