公告

mysql的增删改查

回顾：这是之前开发的增删改查——

/**
 * 这个模块用来模拟数据库的 增、删、改、查
 */
module.exports = {
    getUserList() {
        return [
            {
                id: 1,
                name: 'eric',
                city: '北京'
            },
            {
                id: 2,
                name: 'xiaoming',
                city: '广州'
            }
        ]
    },
    addUser(userObj) {
        return {
            code: 0,
            msg: '新增成功',
            data: null
        }
    },
    delectUser(id) {
        return {
            code: 0,
            msg: '删除成功',
            data: null
        }
    },
    updateUser(id, userObj) {
        return {
            code: 0,
            msg: '更新成功',
            data: null
        }
    }
}

controller/user.js

/**
 * 这个模块专门用来路由请求
 * 针对不同的请求方法和路径，调用不同的方法
 */

const url = require('url')
const {getUserList, addUser, delectUser, updateUser} = require('../controller/user')

function handleRequest(req, res) {
    let urlObj = url.parse(req.url, true);
    console.log(urlObj)
    if (urlObj.pathname === '/api/getUserList' && req.method === 'GET') {
        return getUserList();
    }
    if (urlObj.pathname === '/api/addUser' && req.method === 'POST') {
        return addUser(req.body);
    }
    if (urlObj.pathname === '/api/delectUser' && req.method === 'POST') {
        return delectUser(urlObj.query.id);
    }
    if (urlObj.pathname === '/api/updateUser' && req.method === 'POST') {
        return updateUser(urlObj.query.id, req.body);
    }
}

module.exports = handleRequest

router/index.js

const http = require('http');
const routerModal = require('./router/index')


const getPostData = (req) => {
    /**
     * 把接收请求body的IO操作放在Promise对象中
     * 看起来更加美观，用起来也方便
     */
    return new Promise((resolve, reject) => {
        if (req.method !== 'POST') {   //如果不是POST请求，直接返回
            resolve({})
            return
        }
        let postData = '';
        req.on('data', chunk => {
            postData += chunk;
        })
        req.on('end', () => {
            console.log(postData)
            resolve(JSON.parse(postData))
        })
    })
}

const server = http.createServer((req, res) => {
    //设置允许跨域的域名，*代表允许任意域名跨域，也可以设置白名单列表
    // 什么是跨域？用户请求A地址，但A地址的后端又去请求了B地址拿数据，就需要在B地址的后端设置请求头，允许A地址的跨域
    res.setHeader("Access-Control-Allow-Origin", "http://127.0.0.1:5501");
    //解决浏览器汉字显示乱码问题
    res.writeHead(200, {'content-type': 'application/json;charset=UTF-8'})
    getPostData(req).then((data) => {
        req.body = data
        let resultData = routerModal(req, res);
        if (resultData) {
            res.end(JSON.stringify(resultData))
        } else {
            res.writeHead(404, {'content-type': 'text/html'})
            res.end('404 not found')
        }
    })

})

server.listen(3000, () => {
    console.log('监听3000端口')
})

server.js

安装mysql：`node install mysql`

1、连接数据库执行查询语句：

const mysql = require('mysql')

//创建连接
const conn = mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: '123456789',
    port: '3306',
    database: 'user_test'
})
//建立连接
conn.connect()

//执行sql语句
let sql = 'select * from user where name = ? and city = ?'
conn.query(sql, ['eric1', '广州'], (err, result) => {
    if (err) throw err
    console.log(result)
})

//关闭连接
conn.end()

2、使用连接池：

我们可以看到，回调里面是不能返回结果的。所以需要Promise和async+await来处理

const mysql = require('mysql')

//创建连接池
const pool = mysql.createPool({
  connectionLimit: 10,  // 最大连接数
  host: 'localhost',
  user: 'root',
  password: '123456789',
  port: '3306',
  database: 'user_test'
})

//获取连接
pool.getConnection((err, conn) => {
  if (err) throw err
  let sql = 'select * from user where city = ?'

  //执行sql语句
  conn.query(sql, ['广州'], (err, result) => {
    conn.release()  // 结果查询到之后，先释放连接
    if (err) throw err
    console.log(result)
  })
})

3、将连接封装成query方法：

先封装数据库查询：由于回调函数不能直接返回，要先封装成Promise

db_config.js

let dbOption = {
  connectionLimit: 10,
  host: 'localhost',
  user: 'root',
  password: '123456789',
  port: '3306',
  database: 'user_test'
}

module.exports = dbOption

conn.js

const mysql = require('mysql')
const dbOption = require('../config/db_config')

//创建连接池
const pool = mysql.createPool(dbOption)

// 把查询先封装成Promise
function query(sql, params) {
    return new Promise((resolve, reject) => {
        pool.getConnection((err, conn) => {
            //获取连接失败就reject并返回
            if (err) {
                reject(err)
                return
            }
            //执行sql语句
            conn.query(sql, params, (err, result) => {
                conn.release()
                //执行失败就reject并返回
                if (err) {
                    reject(err)
                    return
                }
                //执行成功把result交给then
                resolve(result)
            })
        })
    })
}

module.exports = query

注意这个result，增删改查SQL语句返回的result不同

Insert语句：

delete语句：

update语句：

select语句：

4、增：

先定义一个async+await方法addUser去执行查询，这是在Dao层定义的

  async addUser(userObj){
    console.log(userObj);
    let {name,city,sex} = userObj
    let sql = 'insert into user (name,city,sex) values (?,?,?)'
    let resultData = await query(sql,[name,city,sex])
    if(resultData){
      return {
        msg:'新增成功'
      }
    }else{
      return {
        msg:'新增失败'
      }
    }
  }

再在路由层去调用async方法addUser，注意这个resultData是Promise对象

const url = require('url')
const {addUser} = require('../controller/user')
function handleRequest(req,res) {
  let urlObj = url.parse(req.url,true);
  if(urlObj.pathname === '/api/addUser'&&req.method === 'POST'){
    let resultData = addUser(req.body);return resultData;
  }
}

module.exports = handleRequest

最后在主程序中.then去使用：

let result =handleRequest(req, res);
if (result) {
  result.then(resultData =>{
    res.end(JSON.stringify(resultData))
  })  
} else {
  res.writeHead(404, { 'content-type': 'text/html' })
  res.end('404 not found')
}

5、删：

dao层

async delectUser(id){
let sql = 'delete from user where id = ?'
let resultData = await query(sql,[id])
if(resultData.affectedRows > 0){
  return {
    msg:'删除成功'
  }
}else{
  return {
    msg:'删除失败'
  }
}
}

路由层

const url = require('url')
const {delectUser} = require('../controller/user')
function handleRequest(req,res) {
  let urlObj = url.parse(req.url,true);
  if(urlObj.pathname === '/api/delectUser'&&req.method === 'POST'){
    let resultData = delectUser(urlObj.query.id);
    return resultData;
  }
}

module.exports = handleRequest

主程序同上

6、改：

dao层

async updateUser(id,userObj){
// console.log(id,userObj);
let {name,city,sex} = userObj
let sql = 'update user set name = ?,city = ?,sex = ? where id = ?'
let resultData = await query(sql,[name,city,sex,id])
if(resultData.affectedRows > 0){
  return {
    msg:'更新成功'
  }
}else{
  return {
    msg:'更新失败'
  }
}
}

路由层

const url = require('url')
const {updateUser} = require('../controller/user')
function handleRequest(req,res) {
  let urlObj = url.parse(req.url,true);
  if(urlObj.pathname === '/api/updateUser'&&req.method === 'POST'){
    let resultData = updateUser(urlObj.query.id,req.body);
    return resultData;
  }
}

module.exports = handleRequest

主程序同上

7、查：

dao层

async getUserList(urlParams){
let {name,city} = urlParams
let sql = 'select * from user where 1=1 '
if(name){
  sql += 'and name = ?'
}
if(city){
  sql += 'and city = ?'
}
let resultData = await query(sql,[name,city])
return resultData
}

路由层

const url = require('url')
const {getUserList} = require('../controller/user')
function handleRequest(req,res) {
  let urlObj = url.parse(req.url,true);
  if(urlObj.pathname === '/api/getUserList'&&req.method === 'GET'){
    let resultData = getUserList(urlObj.query)
    return resultData;
  }
}

module.exports = handleRequest

主程序同上

8、总结

为什么这里的resultData依然是Promise对象？因为addUser前面没有await

9、更简单的实现方式：

posted on 2022-07-16 12:48 要一直走下去阅读(220) 评论(0) 收藏举报

刷新页面返回顶部

要一直走下去

公告

mysql的增删改查

1、连接数据库执行查询语句：

2、使用连接池：

3、将连接封装成query方法 ：

4、增：

5、删 ：

6、改 ：

7、查 ：

8、总结

9、更简单的实现方式：

3、将连接封装成query方法：

5、删：

6、改：

7、查：