Node - 从0基础到实战企业官网

大家好，我是考100分的小小码，祝大家学习进步，加薪顺利呀。今天说一说Node – 从0基础到实战企业官网,希望您对编程的造诣更进一步.

Create by jsliang on 2018-11-8 13:42:42
Recently revised in 2018-12-23 21:59:20

Hello 小伙伴们，如果觉得本文还不错，记得点个赞或者给个 star，你们的赞和 star 是我编写更多更精彩文章的动力！GitHub 地址

【2019-08-16】Hello 小伙伴们，由于 jsliang 对文档库进行了重构，这篇文章的一些链接可能失效，而 jsliang 没有精力维护掘金这边的旧文章，对此深感抱歉。请需要获取最新文章的小伙伴，点击上面的 GitHub 地址，去文档库查看调整后的文章。

本文重点内容

Node 基础 – 通过对 Node 基础的了解学习，打下 Node 基础
Node API – 开启服务提供 API 给前端调用
Node 连接 MySQL – 通过 npm 安装 mysql，从而实现数据库的链接
Node 实战 – 企业官网从 0 开始，打造能注册、登录以及留言的企业官网
Node 部署 – 如何通过部署云服务器，让小伙伴们可以查看到你的网站

本文延伸链接

Node 部署项目、云服务器以及域名的使用：链接
本文 Node 基础代码下载地址：链接
本文 Node 成品代码下载地址：链接

本文成品演示

Node 项目演示：

Node - 从0基础到实战企业官网

一目录

不折腾的前端，和咸鱼有什么区别

目录
一目录
二前言
三基础学习
3.1 HTTP – 开始 Node 之旅
3.2 URL 模块
3.3 CommonJS
3.4 包与 npm
3.5 fs 文件管理
3.6 fs 案例
3.7 fs 流
3.8 创建 Web 服务器
3.9 非阻塞 I/O 事件驱动
3.10 get 与 post
3.11 Node 连接 MySQL
四 Web 实战 —— 企业官网
4.1 编程环境
4.2 后端接口
4.3 注册功能
4.4 登录功能
4.5 留言功能
五工具整合
5.1 supervisor – 监听 Node 改动
5.2 PM2 – Node 进程管理
六参考资料
七线上部署
八归纳总结

二前言

返回目录

本文主要目的：

整合 Node 基础，加深 jsliang 对 Node 的学习了解，并且方便日后复习。
整合 Node 工具，方便查找在 Node 开发中，有哪些工具比较有利于开发。
给初学 Node 的小伙伴做一个参考，如有疑问还请在 QQ 群：798961601 中咨询。

~~1. fs.stat 检测是文件还是目录~~
~~2. fs.mkdir 创建目录~~
~~3. fs.writeFile 创建写入文件~~
~~4. fs.appendFile 追加文件~~
~~5. fs.readFile 读取文件~~
~~6. fs.readdir 读取目录~~
7. fs.rename 重命名
~~8. fs.rmdir 删除目录~~
~~9. fs.unlink 删除文件~~

很好，我们就剩下重命名了：

05_fs.js

let fs = require('fs');

// 7. fs.rename 重命名
fs.rename('index.js', 'jsliang.js', (err) => {
  if(err) {
    console.log(err);
    return false;
  } else {
    console.log("重命名成功！");
  }
})

当然，如果 fs.rename 还有更劲爆的功能：剪切

05_fs.js

let fs = require('fs');

// 7. fs.rename 重命名
fs.rename('jsliang.js', 'node_modules/jsliang.js', (err) => {
  if(err) {
    console.log(err);
    return false;
  } else {
    console.log("剪切成功！");
  }
})

OK，通通搞定，现在目录变成了：

Node - 从0基础到实战企业官网

3.6 fs 案例

返回目录

在上一章节中，我们了解了 fs 的文件管理。
那么，在这里，我们尝试使用 fs 做点小事情：

06_fsDemo.js

/** * 1. fs.stat 检测是文件还是目录 * 2. fs.mkdir 创建目录 * 3. fs.writeFile 创建写入文件 * 4. fs.appendFile 追加文件 * 5. fs.readFile 读取文件 * 6. fs.readdir 读取目录 * 7. fs.rename 重命名 * 8. fs.rmdir 删除目录 * 9. fs.unlink 删除文件 */

// 1. 判断服务器上面有没有 upload 目录，没有就创建这个目录
// 2. 找出 html 目录下面的所有的目录，然后打印出来

let fs = require('fs');

// 图片上传
fs.stat('upload', (err, stats) => {
  // 判断有没有 upload 目录
  if(err) {
    // 如果没有
    fs.mkdir('upload', (error) => {
      if(error) {
        console.log(error);
        return false;
      } else {
        console.log("创建 upload 目录成功！");
      }
    })
  } else {
    // 如果有
    console.log(stats.isDirectory());
    console.log("有 upload 目录，你可以做更多操作！");
  }
})

// 读取目录全部文件
fs.readdir('node_modules', (err, files) => {
  if(err) {
    console.log(err);
    return false;
  } else {
    // 判断是目录还是文件夹
    console.log(files);

    let filesArr = [];

    (function getFile(i) {
      
      // 循环结束
      if(i == files.length) {
        // 打印出所有目录
        console.log("目录：");
        console.log(filesArr);
        return false;
      }

      // 判断目录是文件还是文件夹
      fs.stat('node_modules/' + files[i], (error, stats) => {

        if(stats.isDirectory()) {
          filesArr.push(files[i]);
        }

        // 递归调用
        getFile(i+1);
        
      })
    })(0)
  }
})

3.7 fs 流

返回目录

话不多说，我们了解下 fs 流及其读取：

// 新建 fs
const fs = require('fs');
// 流的方式读取文件
let fileReadStream = fs.createReadStream('index.js');
// 读取次数
let count = 0;
// 保存数据
let str = '';
// 开始读取
fileReadStream.on('data', (chunk) => {
  console.log(`${++count} 接收到：${chunk.length}`);
  // Console：1 接收到：30
  str += chunk;
})
// 读取完成
fileReadStream.on('end', () => {
  console.log("——结束——");
  console.log(count);
  console.log(str);

  // Console：——结束——
  // 1
  // console.log("Hello World！");
})
// 读取失败
fileReadStream.on('error', (error) => {
  console.log(error);
})

在这里，我们通过 fs 模块的 createReadStream 创建了读取流，然后读取文件 index.js，从而最后在控制台输出了：

1 接收到：259
——结束——
1
console.log("尽信书，不如无书；尽看代码，不如删掉这些文件。");
console.log("尽信书，不如无书；尽看代码，不如删掉这些文件。");
console.log("尽信书，不如无书；尽看代码，不如删掉这些文件。");

其中 console.log() 那三行就是 index.js 的文本内容。

然后，我们试下流的存入：

let fs = require('fs');
let data = 'console.log("Hello World! 我要存入数据！")';

// 创建一个可以写入的流，写入到文件 index.js 中
let writeStream = fs.createWriteStream('index.js');
// 开始写入
writeStream.write(data, 'utf8');
// 写入完成
writeStream.end();
writeStream.on('finish', () => {
  console.log('写入完成！');
  // Console：写入完成
});

我们打开 index.js，会发现里面的内容变成了 console.log("Hello World! 我要存入数据！")，依次，我们通过流的形式进行了读取和写入的操作。

3.8 创建 Web 服务器

返回目录

在这里，我们利用 http 模块、url 模块、path 模块、fs 模块创建一个 Web 服务器。

什么是 Web 服务器？
Web 服务器一般指网站服务器，是指驻留于因特网上某种类型计算机的程序，可以像浏览器等 Web 客户端提供文档，也可以放置网站文件，让全世界浏览；可以放置数据文件，让全世界下载。目前最主流的三个 Web 服务器是 Apache、Nginx、IIS。

下面，我们使用 Node 来创建一个 Web 服务：

Node - 从0基础到实战企业官网

08_WebService.js

// 引入 http 模块
let http = require("http");

// 引入 fs 模块
let fs = require("fs");

http.createServer((req, res) => {
  // 获取响应路径
  let pathName = req.url;

  // 默认加载路径
  if (pathName == "/") {
    // 默认加载的首页
    pathName = "index.html";
  }

  // 过滤 /favicon.ico 的请求
  if (pathName != "/favicon.ico") {
    // 获取 08_WebService 下的 index.html
    fs.readFile("./08_WebService/" + pathName, (err, data) => {
      if (err) {
        
        // 如果不存在这个文件
        
        console.log("404 Not Found!");
        fs.readFile('./08_WebService/404.html', (errorNotFound, dataNotFound) => {
          if(errorNotFound) {
            console.log(errorNotFound);
          } else {
            res.writeHead(200, {
              "Content-Type": "text/html; charset='utf-8'"
            });
            // 读取写入文件
            res.write(dataNotFound);
            // 结束响应
            res.end();
          }
        })
        return;
      } else {

        // 返回这个文件
        
        // 设置请求头
        res.writeHead(200, {
          "Content-Type": "text/html; charset='utf-8'"
        });
        // 读取写入文件
        res.write(data);
        // 结束响应
        res.end();
      }
    });
  }
}).listen(8080);

这样，我们在浏览器输入 localhost:8080 即可以看到：

Node - 从0基础到实战企业官网

好家伙，感情它就加载了整个 index.html 文件，连 CSS 这些没引入么？
所以，下一步，我们要动态加载 html、css 以及 js：

08_WebService.js

// 引入 http 模块
let http = require("http");

// 引入 fs 模块
let fs = require("fs");

// 引入 url 模块
let url = require("url");

// 引入 path 模块
let path = require("path");

http.createServer((req, res) => {
  
  // 获取响应路径
  let pathName = url.parse(req.url).pathname;

  // 默认加载路径
  if (pathName == "/") {
    // 默认加载的首页
    pathName = "index.html";
  }

  // 获取文件的后缀名
  let extName = path.extname(pathName);

  // 过滤 /favicon.ico 的请求
  if (pathName != "/favicon.ico") {
    // 获取 08_WebService 下的 index.html
    fs.readFile("./08_WebService/" + pathName, (err, data) => {
      // 如果不存在这个文件
      if (err) {
        console.log("404 Not Found!");
        fs.readFile(
          "./08_WebService/404.html",
          (errorNotFound, dataNotFound) => {
            if (errorNotFound) {
              console.log(errorNotFound);
            } else {
              res.writeHead(200, {
                "Content-Type": "text/html; charset='utf-8'"
              });
              // 读取写入文件
              res.write(dataNotFound);
              // 结束响应
              res.end();
            }
          }
        );
        return;
      }
      // 返回这个文件
      else {
        // 获取文件类型
        let ext = getExt(extName);

        // 设置请求头
        res.writeHead(200, {
          "Content-Type": ext + "; charset='utf-8'"
        });
        // 读取写入文件
        res.write(data);
        // 结束响应
        res.end();
      }
    });
  }
}).listen(8080);

// 获取后缀名
getExt = (extName) => {
  switch(extName) {
    case '.html': return 'text/html';
    case '.css': return 'text/css';
    case '.js': return 'text/js';
    default: return 'text/html';
  }
}

这样，当我们再次请求的时候，浏览器就变成了：

Node - 从0基础到实战企业官网

当然，在上面，我们仅仅模拟了 html、css、js 这三种文件类型而已，我们需要模拟更多的文件类型：

08_ext.json

 代码详情请点击上面的链接

在上面的 json 文件中，我们定义了各种的文件类型，此刻文件目录如下所示：

Node - 从0基础到实战企业官网

这时候，我们需要修改下我们的 js 文件，让它适应多种请求响应了：

08_WebService.js

// 引入 http 模块
let http = require("http");

// 引入 fs 模块
let fs = require("fs");

// 引入 url 模块
let url = require("url");

// 引入 path 模块
let path = require("path");

http.createServer((req, res) => {
  
  // 获取响应路径
  let pathName = url.parse(req.url).pathname;

  // 默认加载路径
  if (pathName == "/") {
    // 默认加载的首页
    pathName = "index.html";
  }

  // 获取文件的后缀名
  let extName = path.extname(pathName);

  // 过滤 /favicon.ico 的请求
  if (pathName != "/favicon.ico") {
    // 获取 08_WebService 下的 index.html
    fs.readFile("./08_WebService/" + pathName, (err, data) => {
      // 如果不存在这个文件
      if (err) {
        console.log("404 Not Found!");
        fs.readFile(
          "./08_WebService/404.html",
          (errorNotFound, dataNotFound) => {
            if (errorNotFound) {
              console.log(errorNotFound);
            } else {
              res.writeHead(200, {
                "Content-Type": "text/html; charset='utf-8'"
              });
              // 读取写入文件
              res.write(dataNotFound);
              // 结束响应
              res.end();
            }
          }
        );
        return;
      }
      // 返回这个文件
      else {
        // 获取文件类型
        let ext = getExt(extName);
        console.log(ext);

        // 设置请求头
        res.writeHead(200, {
          "Content-Type": ext + "; charset='utf-8'"
        });
        // 读取写入文件
        res.write(data);
        // 结束响应
        res.end();
      }
    });
  }
}).listen(8080);

// 获取后缀名
getExt = (extName) => {
  // readFile 是异步操作，所以需要使用 readFileSync
  let data = fs.readFileSync('./08_ext.json');
  let ext = JSON.parse(data.toString());
  return ext[extName];
}

如此，我们做了个简单的 Web 服务器。

3.9 非阻塞 I/O 事件驱动

返回目录

Java、PHP 或者 .NET 等服务端语言，会为每一个客户端的连接创建一个新的线程。
Node 不会为每一个客户连接创建一个新的线程，而仅仅使用一个线程。
当有用户连接了，就会触发一个内部事件，通过非租塞 I/O、事件驱动机制，让 Node 程序宏观上也是并行的。
使用 Node，一个 8GB 内存的服务器，可以同时处理超过 4 万用户的连接。

在这一章节中，主要解决：

Node 的非阻塞 I/O 是什么？
Node events 模块是什么？

首先，在我们正常编程中，我们是希望程序能够一行一行按照我们的意愿编写的：

09_io.js

console.log("1");

console.log("2");

console.log("3");

/** * Console： * 1 * 2 * 3 */

但是，事与愿违。
我们有时候，会执行一些异步方法（函数）：

09_io.js

console.log("1");

// console.log("2");
let fs = require('fs');
getExt = () => {
  fs.readFile('08_ext.json', (err, data) => {
    console.log("2");
  })
}
getExt();

console.log("3");

/** * Console： * 1 * 3 * 2 */

在上面代码中，由于 fs.readFile 是 Node 的异步函数。所以，程序先执行了 1 和 3，最后才执行 fs.readFile 的 2 部分。

在这里，可以看出 Node 不会因为一段代码的逻辑错误，从而导致其他代码无法运行。

这样子，就导致了一个问题：步骤 3 可能拿不到步骤 2 的执行结果了！这就是 Node 的非租塞性 I/O 驱动。
那么，我们有没有办法解决这个问题呢？
有的！

通过回调函数
通过 Node 的 events 模块

首先，我们通过回调函数来解决这个异步问题：

09_io.js

let fs = require("fs");

getExt = (callback) => {
  fs.readFile('08_ext.json', (err, data) => {
    callback(data);
  })  
}

getExt( (result) => {
  console.log(result.toString());
})

通过回调，我们可以将 getExt 的数据提取出来。

然后，我们通过 Node 的 events 模块来解决这个异步问题：

// 引入 fs 模块
let fs = require("fs");

/** * Node 事件循环： * 1. Node 是单进程单线程应用程序，但是通过事件和回调支持并发，所以性能非常高。 * 2. Node 的每一个 API 都是异步的，并作为一个独立线程运行，使用异步函数调用，并处理并发。 * 3. Node 有多个内置的事件，我们可以通过引入 events 模块，并通过实例化 EventEmitter 类来绑定和监听事件。 */

// 引入 events 模块
let events = require("events");
// 实例化事件对象
let EventEmitter = new events.EventEmitter();

getExt = () => {
  fs.readFile('08_ext.json', (err, data) => {
    // 将 data 广播出去
    EventEmitter.emit('data', data.toString());
  })  
};

getExt();

// 监听 data
EventEmitter.on('data', (ext) => {
  console.log(ext);
});

在这里，EventEmitter.on 通过监听 data 的形式，获取了 getExt 内部的执行结果。
如此，我们就了解了 Node 的 I/O 事件及 events 模块

3.10 get 与 post

返回目录

Node - 从0基础到实战企业官网

话不多说，先上代码：

index.js

// 加载 http 模块
var http = require('http');

// 虚拟 SQL 读取出来的数据
var items = [];

// 创建 http 服务
http.createServer(function (req, res) {
  
  // 设置跨域的域名，* 代表允许任意域名跨域
  res.setHeader('Access-Control-Allow-Origin', '*');
  // 设置 header 类型
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
  // 跨域允许的请求方式
  res.setHeader('Content-Type', 'application/json');

  // 判断请求
  switch (req.method) {
    
    // post 请求时，浏览器会先发一次 options 请求，如果请求通过，则继续发送正式的 post 请求
    case 'OPTIONS':
      res.statusCode = 200;
      res.end();
      break;
    
      // 如果是 get 请求，则直接返回 items 数组
    case 'GET':
      let data = JSON.stringify(items);
      res.write(data);
      res.end();
      break;
      
    // 如果是 post 请求
    case 'POST':
      let item = '';
      // 读取每次发送的数据
      req.on('data', function (chunk) {
        item += chunk;
      });
      // 数据发送完成
      req.on('end', function () {
        // 存入
        item = JSON.parse(item);
        items.push(item.item);
        // 将数据返回到客户端
        let data = JSON.stringify(items);
        res.write(data);
        res.end();
      });
      break;
  }
}).listen(3000)

console.log('http server is start...');

首先，我们加载了 http 模块，并创建了服务。
然后，我们设置了跨域的处理方式，允许进行跨域。
接着，我们进行了请求的判断处理，由于只做简单演练，故只判断是 get 请求还是 post 请求。
最后，我们将请求的结果返回给客户端。

在上面，我们进行了后端 Node 的部署，那么前端页面要怎么做呢？

index.html

<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width,initial-scale=1.0,maximum-scale=1.0,user-scalable=no">
  <meta http-equiv="X-⌃-Compatible" content="ie=edge">
  <title>Node Web</title>

</head>

<body>

  <div id="app">
    <h1>Todo List</h1>
    <ul>
      <li v-for="(item, index) in items" :key="index">{{ item }}</li>
    </ul>
    <input type="text" v-model="item">
    <button @click="postApi">添加</button>
  </div>

  <!-- cdn 引用：Vue 和 Node -->
  <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
  <script src="https://unpkg.com/axios/dist/axios.min.js"></script>
  
  <script> new Vue({ el: document.getElementById('app'), data: function () { return { items: [], item: '', } }, created() { // 进入页面请求数据 axios.get('http://localhost:3000/').then(res => { console.log("\n【API - get 数据】"); console.log(res); this.items = res.data; }).catch(function (err) { console.log(err) }) }, methods: { // 点击按钮提交数据 postApi() { axios.post('http://localhost:3000/', { item: this.item }).then(res => { console.log("\n【API - post 数据】") console.log(res); this.items = res.data; }).catch(function (err) { console.log(err) }) } } }) </script>
</body>

</html>

我们通过 Vue 进行了布局，通过 Axios 进行了接口的请求。从而完成了对数据的操作。

3.11 Node 连接 MySQL

返回目录

关于 MySQL 的安装，可以查看 jsliang 写的：MySQL 安装及图形化工具

首先，我们通过可视化工具进行表的设计：

名	类型	长度	键
id	int	11	主键
name	varchar	255
age	varchar	255

然后，我们进行表的填充：

id	name	age
1	jslliang	23
2	梁峻荣	23

接着，我们安装 Node 连接 MySQL 的包：

npm i mysql -D

再来，我们编写 Node 的 index.js：

index.js

var mysql = require('mysql');
var connection = mysql.createConnection({
  host: 'localhost',
  user: 'root',
  password: '123456',
  database: 'node'
});

connection.connect();

connection.query('SELECT * FROM user', function (error, results, fields) {
  if (error) throw error;
  console.log(results);
});

connection.end();

最后，我们通过 node index.js，打开该服务：

[ RowDataPacket { id: 1, name: 'jsliang', age: '23' },
  RowDataPacket { id: 2, name: '梁峻荣', age: '23' } ]

如此，我们便完成了 Node 连接 MySQL。

———————华丽分割线———————

当然，增删改查是后端的基本操作，所以在这里，我们可以补全基本的增删改查功能。

先看目录：

Node - 从0基础到实战企业官网

新增表字段

add.js

var mysql = require('mysql');
var connection = mysql.createConnection({
  host: 'localhost',
  user: 'root',
  password: '123456',
  database: 'node'
});

connection.connect();

let addSql = "INSERT INTO user(id,name,age) VALUES(0,?,?)";
let addSqlParams = ["jsliang", "23"];

connection.query(addSql, addSqlParams, function (err, res) {
  if (err) {
    console.log("新增错误：");
    console.log(err);
    return;
  } else {
    console.log("新增成功：");
    console.log(res);
  }
});

connection.end();

我们只需要直接 node add.js，就能往数据库中新增数据了。

删除表字段

delete.js

// 连接 MySQL
var mysql = require('mysql');
// MySQL 的连接信息
var connection = mysql.createConnection({
  host: 'localhost',
  user: 'root',
  password: '123456',
  database: 'node'
});

// 开始连接
connection.connect();

// 新增的 SQL 语句及新增的字段信息
var delSql = 'DELETE FROM user where id = 2';

// 连接 SQL 并实施语句
connection.query(delSql, function (err, res) {
  if (err) {
    console.log("删除错误：");
    console.log(err);
    return;
  } else {
    console.log("删除成功：");
    console.log(res);
  }
});

// 终止连接
connection.end();

修改表字段

update.js

// 连接 MySQL
var mysql = require('mysql');
// MySQL 的连接信息
var connection = mysql.createConnection({
  host: 'localhost',
  user: 'root',
  password: '123456',
  database: 'node'
});

// 开始连接
connection.connect();

// 新增的 SQL 语句及新增的字段信息
let updateSql = "UPDATE user SET name = ?,age = ? WHERE Id = ?";
let updateSqlParams = ["LiangJunrong", "23", 1];

// 连接 SQL 并实施语句
connection.query(updateSql, updateSqlParams, function (err, res) {
  if (err) {
    console.log("修改错误：");
    console.log(err);
    return;
  } else {
    console.log("修改成功：");
    console.log(res);
  }
});

// 终止连接
connection.end();

查询表字段

read.js

// 连接 MySQL
var mysql = require('mysql');
// MySQL 的连接信息
var connection = mysql.createConnection({
  host: 'localhost',
  user: 'root',
  password: '123456',
  database: 'node'
});

// 开始连接
connection.connect();

// 新增的 SQL 语句及新增的字段信息
let readSql = "SELECT * FROM user";

// 连接 SQL 并实施语句
connection.query(readSql, function (err, res) {
  if (err) throw err;
  console.log(res);
});

// 终止连接
connection.end();

以上，我们打通了 Node 与 MySQL 的壁垒，实现了数据的增删改查。

四 Web 实战 —— 企业官网

返回目录

在进行代码实战的时候，我们很多时候会遇到一些小事儿，例如：logo 制作、ico 制作、icon 挑选等……

下面这些都是 jsliang 平时碰到的，小伙伴有需要的可以 mark 啦~

另外，由于 HTML 与 CSS 没什么好讲的，所以本章节的前提静态页面 jsliang 已经写好了，小伙伴们在学习前可以预先下载：

本文静态页面代码地址

4.1 编程环境

返回目录

首先，我们查看下我们的前端基本代码：地址

Node - 从0基础到实战企业官网

如上，我们仅需要了解 FrontEndCode 目录以及 NodeWeb 目录即可，其他目录为上面章节练习参考。

然后，我们进行后端功能分析：

留言板。用户点击 留言板 的时候，需要先判断用户是否登录。如果用户尚未登录，则直接跳转到 登录页；如果用户登录了，则显示 留言板页面。

在 留言板页面 中，存在两个接口：

获取留言内容：调取 getMessage 接口，返回全部留言信息，由于预计信息不多，故这里不做分页功能，有需要的小伙伴在实现完这个功能后，可以进行分页接口的设计。
提交留言内容：调取 sendMessage 接口，将用户名、用户 id、留言内容发送给后端。

Node - 从0基础到实战企业官网

在 登录页面 中，存在一个接口：

Node - 从0基础到实战企业官网

在 注册页面 中，存在一个接口：

Node - 从0基础到实战企业官网

由此，我们可以设计下前后端的接口结合：

接口文档

接口	类型	参数	返回信息
`getMessage`：获取留言信息	get	无参	n 条记录：id(用户 id)、user_name(用户名)、user_message(用户留言内容)、time(留言时间)
`sendMessage`：提交留言信息	post	id(用户 id)、user_name(用户名)、user_message(用户留言内容)	status 状态
`login`：登录	post	id(用户 id)、user_name(用户名)、user_password(用户密码)	status 状态
`register`：注册	post	id(用户 id)、user_name(用户名)、user_password(用户密码)	status 状态

最后，我们进行 MySQL 数据库的表设计：

user 表

名	类型	长度	键
id	int	11	主键
user_name	varchar	255
user_password	varchar	255
time	datetime

message 表

名	类型	长度	键
id	int	11	主键
user_message	varchar	255
user_id	varchar	255	外键
user_name	varchar	255
time	datetime

4.2 后端接口

返回目录

在我们进行实操之前，先确认我们是否能写接口，所以我们可以新建一个 test 文件夹，里面放一个 index.html 以及一个 index.js 来测试一下。

- text
 - index.html
 - index.js

首先，我们就 4.1 提到的接口，提前进行后端接口的设置：

index.js

// 连接 MySQL：先安装 npm i mysql -D
var mysql = require('mysql');
// MySQL 的连接信息
var connection = mysql.createConnection({
  host: 'localhost',
  user: 'root',
  password: '123456',
  database: 'nodebase'
});
// 开始连接
connection.connect();

// 引入 http 模块：http 是提供 Web 服务的基础
const http = require("http");

// 引入 url 模块：url 是对用户提交的路径进行解析
const url = require("url");

// 引入 qs 模块：qs 是对路径进行 json 化或者将 json 转换为 string 路径
const qs = require("querystring");

// 用 http 模块创建服务
/** * req 获取 url 信息 (request) * res 浏览器返回响应信息 (response) */
http.createServer(function (req, res) {

  // 设置 cors 跨域
  res.setHeader("Access-Control-Allow-Origin", "*");
  // 设置 header 类型
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
  // 跨域允许的请求方式
  res.setHeader('Content-Type', 'application/json');

  if (req.method == "POST") { // 接口 POST 形式

    console.log("\n【POST 形式】");

    // 获取前端发来的路由地址
    let pathName = req.url;

    console.log("\n接口为：" + pathName);

    // 接收发送过来的参数
    let tempResult = "";

    // 数据接入中
    req.addListener("data", function (chunk) {
      tempResult += chunk;
    });

    // 数据接收完成
    req.addListener("end", function () {

      var result = JSON.stringify(qs.parse(tempResult));
      console.log("\n参数为：");
      console.log(result);

      if (pathName == "/sendMessage") { // 提交留言信息

        console.log("\n【API - 提交留言信息】");

      } else if (pathName == "/login") { // 登录

        console.log("\n【API - 登录】");

      } else if (pathName == "/register") { // 注册

        console.log("\n【API - 注册】");

      }
      // 接口信息处理完毕
    })
    // 数据接收完毕

  } else if (req.method == "GET") { // 接口 GET 形式

    console.log("\n【GET 形式】");

    // 解析 url 接口
    let pathName = url.parse(req.url).pathname;

    console.log("\n接口为：" + pathName);

    if (pathName == "/getMessage") { // 获取留言信息

      console.log("\n【API - 获取留言信息】");

    } else if(pathName == "/") { // 首页
      res.writeHead(200, {
        "Content-Type": "text/html;charset=UTF-8"
      });

      res.write('<h1 style="text-align:center">jsliang 前端有限公司服务已开启！</h1><h2 style="text-align:center">详情可见：<a href="https://github.com/LiangJunrong/document-library/blob/master/other-library/Node/NodeBase.md" target="_blank">Node 基础</a></h2>');

      res.end();
    }

  }

}).listen(8888); // 监听的端口

// 获取当前时间
function getNowFormatDate() {
  var date = new Date();
  var year = date.getFullYear(); // 年
  var month = date.getMonth() + 1; // 月
  var strDate = date.getDate(); // 日
  var hour = date.getHours(); // 时
  var minute = date.getMinutes(); // 分
  var second = date.getMinutes(); // 秒
  if (month >= 1 && month <= 9) {
    month = "0" + month;
  }
  if (strDate >= 0 && strDate <= 9) {
    strDate = "0" + strDate;
  }
  // 返回 yyyy-mm-dd hh:mm:ss 形式
  var currentdate = year + "-" + month + "-" + strDate + " " + hour + ":" + minute + ":" + second;
  return currentdate;
}

通过判断 req.method 属于 GET 还是 POST 形式，从而确定加载的接口：

在 POST 中，判断是属于 提交留言信息、登录还是注册；
在 GET 中，判断是不是 获取留言信息。

同时，我们在其中定义了 MySQL 的连接以及一个 getNowFormatDate 用来获取当前时间，格式为：2018-12-21 10:03:59

然后，我们通过一个前端页面来演示我们的接口是否能使用：

index.html

<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width,initial-scale=1.0,maximum-scale=1.0,user-scalable=no">
  <meta http-equiv="X-UA-Compatible" content="ie=edge">
  <title>演示代码</title>
</head>

<body>
  <div>
    <label for="user">用户名</label><input type="text" id="user">
  </div>
  <div>
    <label for="password">密&nbsp;&nbsp;&nbsp;码</label><input type="password" id="password">
  </div>
  <div>
    <button id="register">注册</button>
  </div>

  <script src="https://cdn.bootcss.com/jquery/3.3.1/jquery.js"></script>
  <script> $(function () { // 测试 get 接口 $.ajax({ url: "http://localhost:8888/getMessage", type: "POST", data: { username: "jsliang" }, success: function (res) { console.log(res); }, error: function (err) { console.log(err); } }) $("#register").click(function () { // 测试 post 接口 $.ajax({ url: "http://localhost:8888/login", type: "POST", data: { username: $("#user").val(), password: $("#password").val() }, success: function (res) { console.log(res); }, error: function (err) { console.log(err); } }) }) }); </script>
</body>

</html>

最后，我们通过 node index.js，并打开 index.html，通过 F12 控制台查看我们的接口是否正常：

Node - 从0基础到实战企业官网

可以看到我们的接口能正常调通，这样我们就可以连接数据库，进行这 4 个接口的设计了。

如果小伙伴们觉得每次更新 Node 代码后，又要重启一遍 node index.js 觉得麻烦，可以通过 supervisor 来监听 Node 代码的改动，supervisor 的安装使用：supervisor

4.3 注册功能

返回目录

很好，我们回到仿企业网站的页面上，准备编写接口以及丰富 Node 的接口。

首先，我们开启前端和 Node 服务：

打开命令行/终端
开启前端

cd FrontEndCode
live-server

安装 live-server：npm i live-server -g

开启后端

cd NodeWeb
supervisor index.js

安装 supervisor：npm i supervisor -g

然后，我们在注册页面通过点击事件来触发调接口：

register.html

<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta http-equiv="keywords" content="前端,jsliang,bootstrap,企业建站">
  <meta http-equiv="description" content="jsliang 为你打造最好的企业服务">
  <link rel="shortcut icon" href="./images/favicon.ico" type="image/x-icon" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta http-equiv="X-UA-Compatible" content="ie=edge">
  <title>注册-jsliang 前端有限公司</title>
  <link rel="stylesheet" href="./css/index.css">
  <link rel="stylesheet" href="./css/bootstrap.min.css">
</head>

<body>
  <!-- 省略 body 中代码，有需要的请前往第四章开头下载查看全部代码 -->

  <script src="./js/jquery-3.3.1.min.js"></script>
  <script src="./js/bootstrap.min.js"></script>
  <script src="./js/islogin.js"></script>
  <script> $(function () { $("#register-submit").click(function () { let userName = $("#userName").val(); let userPassword = $("#userPassword").val(); if (!userName) { alert("请输入用户名"); $("#userName").focus(); } else if (!userPassword) { alert("请输入密码"); $("#userPassword").focus(); } else if (userName.length > 10) { alert("请输入少于 10 位的用户名"); $("#userName").focus(); } else if (userPassword.length > 20) { alert("请输入少于 20 位的密码"); $("#userPassword").focus(); } else { // 如果用户输入的没毛病，那就加载接口 $.ajax({ url: "http://localhost:8888/register", type: 'post', dataType: 'json', data: { username: userName, password: userPassword }, success: function (res) { console.log(res); if (res.code == "0") { alert("注册成功，前往登录！"); window.location.href = "./login.html"; } }, error: function (err) { console.log(err.responseText); if (err.responseText == "注册失败，姓名重复！") { alert("用户名已被注册！"); } else if (err.responseText == "注册失败，名额已满！") { alert("注册失败，名额已满！"); } else if (err.responseText == "注册失败，密码为空！") { alert("注册失败，密码为空！"); } else if (err.responseText == "注册失败，姓名过长！") { alert("注册失败，姓名过长！"); } else if (err.responseText == "注册失败，密码过长！") { alert("注册失败，密码过长！"); } else { alert("未知错误！"); } } }) } }) }) </script>
</body>

</html>

如此，我们在用户点击注册按钮的时候，进行接口的调用，发送数据到了后端，如果成功了，那就弹窗，并跳转到登录页；如果没成功，就弹窗提示。

接着，我们编写 Node，前端调用接口后，Node 判断这两个参数是否为空，如果不为空，则将数据存储到数据库。

index.js

// ... 其他代码省略，请自行前往章节 4.2 后端接口 获取其他代码

if (pathName == "/sendMessage") { // 提交留言信息

  console.log("\n【API - 提交留言信息】");

} else if (pathName == "/login") { // 登录

  console.log("\n【API - 登录】");

} else if (pathName == "/register") { // 注册

  console.log("\n【API - 注册】");

  result = JSON.parse(result);

  let username = result.username; // 用户名
  let password = result.password; // 密码
  let time = getNowFormatDate(); // 时间

  if (!username) { // 用户名为空
    res.end("注册失败，用户名为空。");
    return;
  } else if (!password) { // 密码为空
    res.end("注册失败，密码为空！");
    return;
  } else if(username.length > 10) { // 姓名过长
    res.end("注册失败，姓名过长！");
    return;
  } else if(password.length > 20) { // 密码过长
    res.end("注册失败，密码过长！");
    return;
  } else {
    
    // 查询 user 表
    // 使用 Promise 的原因是因为中间调用了两次数据库，而数据库查询是异步的，所以需要用 Promise。
    new Promise( (resolve, reject) => {

      // 新增的 SQL 语句及新增的字段信息
      let readSql = "SELECT * FROM user";
      
      // 连接 SQL 并实施语句
      connection.query(readSql, function (error1, response1) {
        
        if (error1) { // 如果 SQL 语句错误
          throw error1;
        } else {
          
          console.log("\nSQL 查询结果：");

          // 将结果先去掉 RowDataPacket，再转换为 json 对象
          let newRes = JSON.parse(JSON.stringify(response1));
          console.log(newRes);

          // 判断姓名重复与否
          let userNameRepeat = false;
          for(let item in newRes) {
            if(newRes[item].user_name == username) {
              userNameRepeat = true;
            }
          }

          // 如果姓名重复
          if(userNameRepeat) {
            res.end("注册失败，姓名重复！");
            return;
          } else if(newRes.length > 300) { // 如果注册名额已满
            res.end("注册失败，名额已满！");
            return;
          } else { // 可以注册
            resolve();
          }
          
        }
      });

    }).then( () => {
      
      console.log("\n第二步：");
      
      // 新增的 SQL 语句及新增的字段信息
      let addSql = "INSERT INTO user(user_name,user_password, time) VALUES(?,?,?)";
      let addSqlParams = [result.username, result.password, time];

      // 连接 SQL 并实施语句
      connection.query(addSql, addSqlParams, function (error2, response2) {
        if (error2) { // 如果 SQL 语句错误
          console.log("新增错误：");
          console.log(error2);
          return;
        } else {
          console.log("\nSQL 查询结果：");
          console.log(response2);

          console.log("\n注册成功！");

          // 返回数据
          res.write(JSON.stringify({
            code: "0",
            message: "注册成功！"
          }));

          // 结束响应
          res.end();
        }
      });

    })
    // Promise 结束
  }
  // 注册流程结束
}

最后，我们在查看下该功能是否成功：

Node - 从0基础到实战企业官网

4.4 登录功能

返回目录

在上面，我们完成了注册功能，那么相对来说，登录功能就容易通了，因为查询部分我们已经试过了一次。

login.html

<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta http-equiv="keywords" content="前端,jsliang,bootstrap,企业建站">
  <meta http-equiv="description" content="jsliang 为你打造最好的企业服务">
  <link rel="shortcut icon" href="./images/favicon.ico" type="image/x-icon" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta http-equiv="X-UA-Compatible" content="ie=edge">
  <title>登录-jsliang 前端有限公司</title>
  <link rel="stylesheet" href="./css/index.css">
  <link rel="stylesheet" href="./css/bootstrap.min.css">
</head>

<body>
  
  <!-- 代码省略，有需要的小伙伴请在第四章前言部分下载代码 -->

  <script src="./js/jquery-3.3.1.min.js"></script>
  <script src="./js/bootstrap.min.js"></script>
  <script src="./js/islogin.js"></script>
  <script> $(function () { $("#login-submit").click(function () { let userName = $("#userName").val(); // 用户名 let userPassword = $("#userPassword").val(); // 密码 if (!userName) { alert("请输入用户名"); $("#userName").focus(); } else if (!userPassword) { alert("请输入密码"); $("#userPassword").focus(); } else if (userName.length > 10) { alert("请输入少于 10 位的用户名"); $("#userName").focus(); } else if (userPassword.length > 20) { alert("请输入少于 20 位的密码"); $("#userPassword").focus(); } else { $.ajax({ url: "http://localhost:8888/login", type: 'post', dataType: 'json', data: { username: userName, password: userPassword }, success: function (res) { console.log(res); if (res.code == "0") { sessionStorage.setItem("id", res.data.id); sessionStorage.setItem("userName", res.data.userName); alert("登录成功！"); window.location.href = "./messageBoard.html"; } else if (res.code == "1") { alert("登录失败，密码错误！"); } }, error: function (err) { console.log(err.responseText); if (err.responseText == "不存在该用户！") { alert("不存在该用户！"); } else if (err.responseText == "登录失败，用户名为空！") { alert("登录失败，用户名为空！"); } else if (err.responseText == "登录失败，密码为空！") { alert("登录失败，密码为空！"); } else if (err.responseText == "登录失败，姓名过长！") { alert("登录失败，姓名过长！"); } else if (err.responseText == "登录失败，密码过长！") { alert("登录失败，密码过长！"); } else { alert("未知错误！"); } } }) } }) }) </script>
</body>

</html>

编写完前端的代码后，我们进行 Node 代码的编辑：

index.js


// ... 其他代码省略，请自行前往章节 4.2 后端接口 获取其他代码

if (pathName == "/sendMessage") { // 提交留言信息

  console.log("\n【API - 提交留言信息】");

} else if (pathName == "/login") { // 登录

  console.log("\n【API - 登录】");

  result = JSON.parse(result);

  let username = result.username; // 用户名
  let password = result.password; // 密码

  if (!username) { // 用户名为空
    res.end("登录失败，用户名为空！");
    return;
  } else if (!password) { // 密码为空
    res.end("登录失败，密码为空！");
    return;
  } else if(username.length > 10) {
    res.end("登录失败，姓名过长！");
    return;
  } else if(password.length > 20) {
    res.end("登录失败，密码过长！");
    return;
  } else { 
    
    // 新增的 SQL 语句及新增的字段信息
    let readSql = "SELECT * FROM user WHERE user_name = '" + username + "'";

    // 连接 SQL 并实施语句
    connection.query(readSql, function (error1, response1) {
      if (error1) {
        throw error1;
      } else {
        if(response1 == undefined || response1.length == 0) { // 不存在用户
          res.end("\n不存在该用户！");
          return;
        } else { // 存在用户
          console.log("\n存在该用户！");

          let newRes = JSON.parse(JSON.stringify(response1));
          console.log(newRes);

          if(newRes[0].user_password == password) { // 密码正确
            // 返回数据
            res.write(JSON.stringify({
              code: "0",
              message: "登录成功！",
              data: {
                id: newRes[0].id,
                userName: newRes[0].user_name
              }
            }));

            res.end();
          } else { // 密码错误
            // 返回数据
            res.write(JSON.stringify({
              code: "1",
              message: "登录失败，密码错误！"
            }));

            res.end();
          }
          // 判断密码正确与否完毕
        }
        // 存在用户处理结束
      }
    });
  }
  // 登录步骤结束
} else if (pathName == "/register") { // 注册

  console.log("\n【API - 注册】");

}

很好，前端和后端都编写完毕，是时候查验下功能是否实现了：

Node - 从0基础到实战企业官网

4.5 留言功能

返回目录

现在，我们就剩下留言功能了，一鼓作气做好它吧！

messageBoard.html

<!-- 留言板 -->
<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta http-equiv="keywords" content="前端,jsliang,bootstrap,企业建站">
  <meta http-equiv="description" content="jsliang 为你打造最好的企业服务">
  <link rel="shortcut icon" href="./images/favicon.ico" type="image/x-icon" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta http-equiv="X-UA-Compatible" content="ie=edge">
  <title>留言板-jsliang 前端有限公司</title>
  <link rel="stylesheet" href="./css/index.css">
  <link rel="stylesheet" href="./css/bootstrap.min.css">
</head>

<body>
  
  <!-- 代码省略，基础代码请前往本章节前言下载 -->

  <script src="./js/jquery-3.3.1.min.js"></script>
  <script src="./js/bootstrap.min.js"></script>
  <script src="./js/islogin.js"></script>
  <script> $(function() { let userName = sessionStorage.getItem("userName"); let userId = sessionStorage.getItem("id"); // 查询留言板 if(userName && userId) { // 如果有存储 $.ajax({ url: "http://localhost:8888/getMessage", type: 'get', dataType: 'json', success: function (res) { console.log(res); let li = ``; for(let item in res.data) { li = li + ` <li> <span class="text-warning font-bold">☆ </span> <span class="user-message">${res.data[item].user_message}</span> <span>—— </span> <span class="user-name">${res.data[item].user_name} [${res.data[item].user_id}]</span> <span class="message-time">${res.data[item].time}</span> </li> `; } $("#message-board-ul").append(li); }, error: function (err) { console.log(err); } }) } else { // 如果没有存储 window.location.href = "../login.html"; } // 提交留言 $("#message-submit").click(function() { let messageText = $("#message").val() if(!messageText) { alert("留言内容不能为空"); } else if(messageText.length > 140) { alert("留言长度不能超过 140 位！"); } else { $.ajax({ url: "http://localhost:8888/sendMessage", type: 'post', dataType: 'json', data: { userid: userId, username: userName, message: messageText }, success: function (res) { console.log(res); if(res.code == "0") { alert("新增成功！"); window.location.reload(); } }, error: function (err) { console.log(err); console.log(err.responseText); if (err.responseText == "登录失败，留言内容为空！") { alert("登录失败，留言内容为空！"); } else if (err.responseText == "登录失败，字数超过限制！") { alert("登录失败，字数超过限制！"); } else { alert("未知错误！"); } } }) } }) }) </script>
</body>

</html>

接着编写下 Node 后端：

index.js


// ... 其他代码省略，请自行前往章节 4.2 后端接口 获取其他代码

if (pathName == "/sendMessage") { // 提交留言信息

  console.log("\n【API - 提交留言信息】");

  result = JSON.parse(result);

  let id = result.userid; // id
  let userName = result.username; // 用户名
  let messageText = result.message; // 留言内容
  let time = getNowFormatDate(); // 时间

  if(!messageText) {
    res.end("登录失败，留言内容为空！");
    return;
  } else if(messageText.length > 140) {
    res.end("登录失败，字数超过限制！");
    return;
  } else {
    
    // 新增的 SQL 语句及新增的字段信息
    let addSql = "INSERT INTO message(user_message, user_id, user_name, time) VALUES(?, ?, ?, ?)";
    let addSqlParams = [messageText, id, userName, time];

    // 连接 SQL 并实施语句
    connection.query(addSql, addSqlParams, function (error1, response1) {
      if (error1) { // 如果 SQL 语句错误
        throw error1;
      } else {
        console.log("\n新增成功！");

        // 返回数据
        res.write(JSON.stringify({
          code: "0",
          message: "新增成功！"
        }));

        // 结束响应
        res.end();
      }
    })
  }

} else if (pathName == "/login") { // 登录

  console.log("\n【API - 登录】");

} else if (pathName == "/register") { // 注册

  console.log("\n【API - 注册】");

}



// ... 其他代码省略，请自行前往章节 4.2 后端接口 获取其他代码



if (pathName == "/getMessage") { // 获取留言信息

  console.log("\n【API - 获取留言信息】");

  // 解析 url 参数部分
  let params = url.parse(req.url, true).query;

  console.log("\n参数为：");
  console.log(params);

  // 新增的 SQL 语句及新增的字段信息
  let readSql = "SELECT * FROM message";

  // 连接 SQL 并实施语句
  connection.query(readSql, function (error1, response1) {
    if (error1) {
      throw error1; 
    } else {
      
      let newRes = JSON.parse(JSON.stringify(response1));
      console.log(newRes);

      // 返回数据
      res.write(JSON.stringify({
        code: "1",
        message: "查询成功！",
        data: newRes
      }));

      // 结束响应
      res.end();
    }
  });
  // 查询完毕
} else if(pathName == "/") { // 首页
  res.writeHead(200, {
    "Content-Type": "text/html;charset=UTF-8"
  });

  res.write('<h1 style="text-align:center">jsliang 前端有限公司服务已开启！</h1><h2 style="text-align:center">详情可见：<a href="https://github.com/LiangJunrong/document-library/blob/master/other-library/Node/NodeBase.md" target="_blank">Node 基础</a></h2>');

  res.end();
}

敲完代码再看下功能是否实现：

Node - 从0基础到实战企业官网

综上，我们完成了所有的功能模块：注册、登录以及留言。

五工具整合

返回目录

工欲善其事，必先利其器。
掌控好了工具，可以方便你更快地进行开发。

5.1 supervisor – 监听 Node 改动

返回目录

supervisor 官网

正如其官网所说，它是一个进行控制系统：

安装插件：npm i supervisor -g
运行文件：supervisor app.js
查看运行：localhost:3000

平时，我们 node app.js 后，当我们修改了 app.js 的内容，就需要关闭 node 命令行再执行 node app.js。
而我们使用 supervisor 后，我们修改了 app.js 中的内容，只要点击保存，即可生效保存后的代码，实现实时监听 node 代码的变动。

关于这个工具，网上更详细的攻略有：