nodejs之express路由分级

nodejs之express路由分级

本文章建议只做参考,不需要原文都复制进行测试

当然,这是按照我的需求npm的包,可以根据自己的需求npm包,不过有几个是必须的,我会进行标注
首先新建一个文件夹,npm init -yes初始化
express

npm install express --save

body-parser获取前端传递过来的数据

npm install body-parser --save

md5加密

npm install md5 --save

mysql 连接数据库,这里可以是其它的数据库,比如MongoDB数据库

npm install mysql --save

cors解决跨域,这里可以根据情况使用

npm install cors --save

connect-multiparty文件上传

npm install connect-multiparty --save

下面是我的代码
app.js

// 本项目入口
const express = require("express")
// 获取前端传递过来的数据
const bodyParser = require("body-parser")
// 引入path
const path = require("path")
//引入登陆注册路由
const LoginToRegister = require("./routers/LoginToRegister")
// 引入垃圾分类数据路由
const GC = require("./routers/gc")

// 创建WEB服务器对象
const app = express()
// 设置端口
let port = 3000

app.use(express.json())
// 添加中间件,将post请求的参数转换为对象
app.use(
  bodyParser.urlencoded({
    extended: false,
  })
)

// 使用Cors模块,用于解决跨域问题
const cors = require("cors")

// 使用cors中间件
app.use(
  cors({
    origin: [
      "http://localhost:8080",
      "http://127.0.0.1:8080",
      "http://localhost:8081",
      "http://127.0.0.1:8081",
    ],
  })
)

// 静态资源管理
app.use("/public", express.static(path.join(__dirname, "public")))
// app.use("/publicc", express.static("./publicCopy"))

// 使用登录注册路由,给登录注册路由添加前缀
app.use("/v1/LG", LoginToRegister)
// 使用垃圾分类数据路由，添加前缀
app.use("/v1/GC", GC)

app.listen(port, () => {
  console.log(`server in running at http://localhost:${port}`)
})

// 添加错误处理中间件
app.use((err, req, res, next) => {
  console.log(err) // 打印传递过来的错误
  res.status(500).send({ code: 500, msg: "服务器端错误" })
})

/utils/db.js

const mysql = require("mysql")

// 创建连接池
let pool = mysql.createPool({
  host: "localhost", // 连接的服务器(代码托管到线上后,此处需改为内网ip,而非外网)
  port: 3306, // mysql服务运行的端口
  database: "garbage_sorting", //选择需要连接的数据库
  user: "root", //数据库用户名
  password: "", //数据库密码
  connectionLimit: 20, //最大连接数
  charset: "utf8", //数据库服务器的编码方式
})

module.exports = pool

/routers/gc.js

const express = require("express")

// 引入连接池对象
const pool = require("../utils/db")
// console.log(pool)

// 创建路由器对象
const gc = express.Router()

// 预估重量查询
gc.get("/estimateWeight", (req, res) => {
  let sql = "SELECT * FROM weight"
  pool.query(sql, (err, results) => {
    if (err) {
      res.send({ message: "SQL Error", code: 500 })
    } else {
      res.send({ message: "success", code: 200, results })
    }
  })
})

//回收分类查询
gc.get("/sortChoice", (req, res) => {
  let sql = "SELECT * FROM sort_choice"
  pool.query(sql, (err, results) => {
    if (err) {
      res.send({ message: "SQL Error", code: 500 })
    } else {
      res.send({ message: "success", code: 200, results })
    }
  })
})

// 根据查询垃圾的类别及其类别的所有数据
gc.get("/search_garbageClass/:garbageName", (req, res) => {
  let garbage = req.params.garbageName //从前端接收过来的要查询的垃圾
  let sql =
    "select * from garbage_classes WHERE garbage_class_id=(select garbage_class_id from garbage where garbage_name= ? );"
  pool.query(sql, [garbage], (err, results) => {
    if (err) {
      res.send({ message: "fault", code: 201 })
    } else {
      res.send({ message: "success", code: 200, result: results[0] })
    }
  })
})

// 查询所有垃圾的数据
gc.get("/getGarbages", (req, res) => {
  let sql =
    "select g.garbage_id,g.garbage_name,g.garbage_remark,gc.garbage_class_name from garbage g INNER JOIN garbage_classes gc on g.garbage_class_id=gc.garbage_class_id"
  pool.query(sql, (err, results) => {
    if (err) {
      res.send({ message: "fault", code: 201 })
    } else {
      res.send({ message: "success", code: 200, results: results })
    }
  })
})

// 模糊搜索查询垃圾
gc.get("/searchGarbage/:search", (req, res) => {
  let search = req.params.search
  // console.log(search)
  let sql =
    "select g.garbage_id,g.garbage_name,g.garbage_remark,gc.garbage_class_name from garbage g INNER JOIN garbage_classes gc on g.garbage_class_id=gc.garbage_class_id where garbage_name like ?"
  pool.query(sql, ["%" + search + "%"], (err, results) => {
    if (err) {
      res.send({ message: "fault", code: 201 })
    } else {
      res.send({ message: "success", code: 200, results: results })
    }
  })
})

// 添加垃圾
gc.get(
  "/addGarbage/:garbageName/:garbageClassId/:garbageRemark",
  (req, res) => {
    let garbageName = req.params.garbageName
    let garbageClassId = req.params.garbageClassId
    let garbageRemark = req.params.garbageRemark

    //以garbage_name为条件进行查找操作，以保证垃圾关键词的唯一性
    let sql =
      "SELECT count(garbage_id) as count from garbage where garbage_name=?"
    pool.query(sql, [garbageName], (error, results) => {
      let count = results[0].count
      if (count == 0) {
        sql =
          "INSERt into garbage (garbage_name,garbage_class_id,garbage_remark) values (?,?,?)"
        pool.query(
          sql,
          [garbageName, garbageClassId, garbageRemark],
          (err, results) => {
            if (err) {
              res.send({ message: "fault", code: 201 })
            } else {
              console.log(res)
              res.send({ message: "success", code: 200, results: results })
            }
          }
        )
      } else {
        res.send({ message: "关键词重复插入", code: 202 })
      }
    })
  }
)

// 删除多个垃圾
gc.post("/deleteGarbages", (req, res) => {
  let ids = req.body.garbageIds
  ids = ids.split(",").map(Number)
  ids = eval(ids)
  console.log(ids)
  let sql = `DELETE from garbage where garbage_id in (?)`
  // console.log(ids)
  pool.query(sql, [ids], (err, results) => {
    console.log(results)
    if (err) {
      res.send({ message: "删除失败", code: 201 })
    } else {
      if (results.affectedRows == 0) {
        return res.send({ message: "没有选中任何数据", code: 202 })
      }
      res.send({ message: "删除成功", code: 200 })
    }
  })
})

// 修改垃圾
gc.get(
  "/updateGarbage/:garbage_id/:garbage_name/:garbage_class_name/:garbage_remark",
  (req, res) => {
    let garbageId = req.params.garbage_id
    let garbageName = req.params.garbage_name
    let garbageClassId = req.params.garbage_class_name
    let garbageRemark = req.params.garbage_remark

    //以garbage_name为条件进行查找操作，以保证垃圾关键词的唯一性
    let sql =
      "SELECT count(garbage_id) as count from garbage where garbage_name=?"
    pool.query(sql, [garbageName], (error, results) => {
      let count = results[0].count
      if (count == 0) {
        sql =
          "UPDATE garbage SET garbage_name=?,garbage_class_id=?,garbage_remark=? WHERE garbage_id=?"
        pool.query(
          sql,
          [garbageName, garbageClassId, garbageRemark, garbageId],
          (err, results) => {
            if (err) {
              res.send({ message: "fault", code: 201 })
            } else {
              console.log(res)
              res.send({ message: "success", code: 200 })
            }
          }
        )
      } else {
        res.send({ message: "关键词重复插入", code: 202 })
      }
    })
  }
)

module.exports = gc

/routers/LoginToRegister.js

const express = require("express")

// 引入md5加密模块
const md5 = require("md5")

// 文件上传模块connect-multiparty
const multipart = require("connect-multiparty")
const multipartMiddleWare = multipart()

// 引入连接池对象
const pool = require("../utils/db")
// console.log(pool)

// 创建路由器对象
const lr = express.Router()

// 添加路由
lr.post("/register", multipartMiddleWare, (req, res) => {
  //console.log(md5('123456'));
  //获取用户名和密码信息
  let client_name = req.body.client_name
  let client_pwd = req.body.client_pwd
  let nickname = req.body.nickname
  let client_phone = req.body.client_phone
  //以client_name为条件进行查询操作,以保证用户名的唯一性
  let sql =
    "SELECT COUNT(client_id) AS count FROM clent_users where client_name=?"
  pool.query(sql, [client_name], (error, results) => {
    if (error) throw error
    let count = results[0].count
    if (count == 0) {
      // 将用户的相关信息插入到数据表
      sql = `INSERT clent_users(client_name,client_pwd,nickname,client_phone,client_head_url) VALUES(?,MD5(?),?,?,?)`
      pool.query(
        sql,
        [
          client_name,
          client_pwd,
          nickname,
          client_phone,
          "/head_portrait/011.jpg",
        ],
        (error, result) => {
          if (error) throw error
          res.send({ message: "ok", code: 200 })
        }
      )
    } else {
      res.send({ message: "user exists", code: 201 })
    }
  })
})
lr.post("/login", (req, res) => {
  //获取用户名和密码信息
  let client_name = req.body.client_name
  let client_pwd = req.body.client_pwd
  let nickname = req.body.nickname
  let id = req.body.id
  let url = req.body.url
  let sql =
    "SELECT client_id,client_name,nickname,client_head_url from clent_users where client_name=? AND client_pwd=MD5(?)"
  pool.query(
    sql,
    [client_name, client_pwd, nickname, id, url],
    (error, results) => {
      if (results.length == 0) {
        //登录失败
        if (error) throw error
        res.send({ mesage: "login failed", code: 201 })
      } else {
        res.send({ meessage: "ok", code: 200, result: results[0] })
      }
    }
  )
})

// 导出路由对象
module.exports = lr

本文章建议只做参考,不需要原文都复制进行测试