express搭建服务器

01 项目初始化

# 01-项目初始化 
# 生成 package.json 文件
npm init -y

# 02-关联远程仓库
git init

# 03-在项目根目录下创建 .gitignore 文件，此配置文件用于设置哪些文件不用上传到github上

02 安装项目依赖

# 安装项目依赖
npm i express mongoose --save

03 新建文件目录

# 01-创建 public 文件夹 用于存储客户端所用的样式、脚本、静态文件等

# 02-在public文件夹下创建 css、img、js 文件夹

# 03-在项目根目录下创建 app.js 文件 

04 生成APP服务

# 01-引入express
# 02-创建APP服务
# 03-开放静态资源
# 04-处理请求
# 05-开放端口

• app.js

var express = require('express')
var router = require('./router/router.js')

var bodyParser = require('body-parser')

var app = express()

// 配置art-template
app.engine('html', require('express-art-template'))


// 开放静态资源
app.use('/node_modules/',express.static('./node_modules/'))
app.use('/public/',express.static('./public/'))

// 配置body-parser
app.use(bodyParser.urlencoded({ extended: false }))
app.use(bodyParser.json())

// 配置路由
// router(app)

// 将路由容器挂载到 app 服务中
// app.use(router)
app.use(router)

// 设置端口号
app.listen(3000,() => {
  console.log('Server is running...')
})

---

• router.js

var express = require('express')
// var Student = require('../students')
var Student = require('../mongoose')

// express 提供了一中方法用来包装路由

// 1.创建一个路由容器
var router = express.Router()

// 2.将路由都挂载到Router容器上

/**
 * 渲染学生页面
 */
router.get('/students', (req, res) => {
  // readFile() 读取的文件均是字符串（二进制）
  //  1. readFile() 函数第二个参数可以省略，也可以指定编码格式，例如：'utf-8' 能够解析我们认识的字符
  //  2.也可以通过 data.toString() 的方式进行转换
  // fs.readFile('./db.json', 'utf-8', (err, data) => {
  //   if (err) {
  //     return res.status(500).send('Server error.')
  //   }
  //   // 从文件中读取的数据是字符串，要将字符串转换为对象才能进一步操作数据
  //   var students = JSON.parse(data).students
  //   res.render('index.html', {
  //     fruits: [
  //       '苹果',
  //       '橘子',
  //       '香蕉'
  //     ],
  //     students: students
  //   })
  // })
  Student.find(function (err, students) {
    if (err) {
      return res.status(500).send('Server error.')
    }
    res.render('index.html', {
      fruits: [
        '苹果',
        '橘子',
        '香蕉'
      ],
      students: students
    })
  })
})

/**
 * 渲染——添加学生页面
 */
router.get('/students/new', (req, res) => {
  res.render('new.html')
})

/**
 * 处理——添加学生
 */
router.post('/students/new', (req, res) => {
  // 1.获取表单数据
  // 2.处理
  // 3.发送响应
  new Student(req.body).save(function (err) {
    if (err) {
      return res.status(500).send('Server error.')
    }
    res.redirect('/students')
  })
})

/**
 * 渲染——编辑学生页面
 */
router.get('/students/edit', (req, res) => {
  // 1. 根据ID获取要编辑的学生
  // 2. 通过art-template渲染页面
  //    console.log(req.query)
  // 3. 重定向
  Student.findById(req.query.id.replace(/"/g, ''), (err, result) => {
    if (err) {
      return res.status(500).send('Server error.')
    }
    res.render('edit.html', { result: result })
  })
})

/**
 * 处理——编辑学生
 */
router.post('/students/edit', (req, res) => {
  // 1.获取表单数据
  // 2.更新
  //  Student.updata()
  // 3.发送响应
  var id = req.body.id.replace(/"/g, "")
  Student.findByIdAndUpdate(id, req.body, function (err) {
    if (err) {
      return res.status(500).send('Server error.')
    }
    res.redirect('/students')
  })
})

/**
 * 处理——删除学生
 */
router.get('/students/delete', (req, res) => {
  var id = req.query.id.replace(/"/g, "")
  Student.findByIdAndRemove(id, function (err) {
    if (err) {
      return res.status(500).send('Server error.')
    }
    res.redirect('/students')
  })
})



// 3.导出路由对象
module.exports = router

// 配置路由
// module.exports = function (app) {
//   app.get('/', (req, res) => {
//     // readFile() 读取的文件均是字符串（二进制）
//     //  1. readFile() 函数第二个参数可以省略，也可以指定编码格式，例如：'utf-8' 能够解析我们认识的字符
//     //  2.也可以通过 data.toString() 的方式进行转换
//     fs.readFile('./db.json', 'utf-8', (err, data) => {
//       if (err) {
//         return res.status(500).send('Server error.')
//       }
//       // 从文件中读取的数据是字符串，要将字符串转换为对象才能进一步操作数据
//       var students = JSON.parse(data).students
//       res.render('index.html', {
//         fruits: [
//           '苹果',
//           '橘子',
//           '香蕉'
//         ],
//         students: students
//       })
//     })
//   })
// }

• students.js

/**
 * students.js
 * 数据操作文件模块
 * 职责：操作文件中的数据，只处理数据，不关心业务
 */


var fs = require('fs')
var dbPath = './db.json'

/**
 * 根据ID获取指定学生
 */
exports.findById = function (id, callback) {
  fs.readFile(dbPath, 'utf8', (err, data) => {
    if (err) {
      return callback(err)
    }
    var students = JSON.parse(data).students
    var result = students.find(item => {
      return item.id === parseInt(id)
    })
    callback(null, result)
  })
}

/**
 * 获取所有学生
 */
exports.find = function (callback) {
  fs.readFile(dbPath, 'utf-8', (err, data) => {
    if (err) {
      return callback(err)
    }
    callback(null, JSON.parse(data).students)
  })
}

/**
 * 添加保存学生
 */
exports.save = function (student, callback) {
  // 读取数据文件
  fs.readFile(dbPath, 'utf-8', (err, data) => {
    if (err) {
      return callback(err)
    }
    // 将字符串格式转为对象，操作对象
    var students = JSON.parse(data).students

    // 设置ID
    student.id = students.length + 1
    students.push(student)

    // 将对象转为db.json能保存的格式字符串
    var fileData = JSON.stringify({
      students: students
    })

    // 写入文件中
    fs.writeFile(dbPath, fileData, err => {
      if (err) {
        return callback(err)
      }
      callback(null)
    })
  })
}

/**
 * 更新学生
 */
exports.update = function (student, callback) {
  // student.id = student.id *1
  student.id = parseInt(student.id)
  fs.readFile(dbPath, 'utf-8', (err, data) => {
    if (err) {
      return callback(err)
    }
    var students = JSON.parse(data).students

    // 遍历students数组，根据ID找到要修改的对象
    var stu = students.find(function (item) {
      return item.id === student.id
    })

    for (var key in student) {
      stu[key] = student[key]
    }

    // 转换成文件能保存的格式
    var updatelate = JSON.stringify({
      students: students
    })

    // 将修改后的数据写入文件中
    fs.writeFile(dbPath, updatelate, err => {
      if (err) {
        return callback(err)
      }
      callback(null)
    })
  })
}


/**
 * 删除学生
 */
exports.delete = function (id, callback) {
  id = parseInt(id)
  fs.readFile(dbPath, 'utf8', (err, data) => {
    if (err) {
      return callback(err)
    }
    var students = JSON.parse(data).students
    // console.log(students)
    for (const item of students) {
      if (item.id === id) {
        students.splice(id-1,1)
      }
    }
    // console.log(students)
    var remDate = JSON.stringify({
      students: students
    })
    fs.writeFile(dbPath, remDate, err => {
      if (err) {
        return callback(err)
      }
      callback(null)
    })
  })
}

• mongoose.js

var mongoose = require('mongoose')

mongoose.connect('mongodb://localhost/test',{useNewUrlParser: true})
mongoose.set('useFindAndModify', false);

var Schema = mongoose.Schema

var studentSchema = new Schema({
  name: {
    type: String,
    required: true
  },
  gender: {
    type: Number,
    enum: [0, 1],
    default: 0
  },
  age: {
    type: Number,
  },
  hobbies: {
    type: String,
  },
})

module.exports = mongoose.model('Student', studentSchema)