本文介绍: Node.js1、初识Node.js与内置模块1.1 Node.js初识1.2 fs文件系统模块1.3 path路径模块1.4 http模块2、模块化2.1 模块化的基本概念2.2 Node.js中模块化2.3 npm与包2.4 模块的加载机制3、Express3.1 初识Express3.2 Express路由3.3 Express中间件3.4 使用Express写接口4、数据库与身份认证4.1 数据库的基本概念4.2 安装并配置MySQL4.3 MySQL的基本使用
Node.js
1、初识Node.js与内置模块
1.1 Node.js初识
Node.js的安装
-
安装包可以从Node.js的官网首页直接下载，进入到Node.js的官网首页(https://nodejs.org/en/) node.js中文网 (Node.js 中文网 (nodejs.cn))，点击绿色的按钮，下载所需的版本后，双击直接安装即可
-
Current为新特性尝鲜版，对热衷于尝试新特性的用户来说，推荐安装Current版本的Node.js。但是，Current 版本中可能存在隐藏的Bug 或安全性漏洞，因此不推荐在企业级项目中使用Current版本的Node.js
1.2 fs文件系统模块
fs.readFile(path[, options], callback)
// 1. 导入 fs 模块，来操作文件
const fs = require('fs')
// 2. 调用 fs.readFile() 方法读取文件
// 参数1：读取文件的存放路径
// 参数2：读取文件时候采用的编码格式，一般默认指定 utf8
// 参数3：回调函数，拿到读取失败和成功的结果 err dataStr
fs.readFile('./files/1.txt', 'utf8', function (err, dataStr) {
// 2.1 打印失败的结果
// 如果读取成功，则 err 的值为 null
// 如果读取失败，则 err 的值为 错误对象，dataStr 的值为 undefined
console.log(err)
console.log('-------')
// 2.2 打印成功的结果
console.log(dataStr)
})
const fs = require('fs')
fs.readFile('./files/1.txt', 'utf8', function(err, dataStr) {
if (err) {
return console.log('读取文件失败！' + err.message)
}
console.log('读取文件成功！' + dataStr)
})
fs.writeFile(file,data[, options], callback)
- 参数解读:
- 代码：
// 1. 导入 fs 文件系统模块
const fs = require('fs')
// 2. 调用 fs.writeFile() 方法，写入文件的内容
// 参数1：表示文件的存放路径
// 参数2：表示要写入的内容
// 参数3：回调函数
fs.writeFile('./files/2.txt', 'Hello', function (err) {
// 2.1 如果文件写入成功，则 err 的值等于 null
// 2.2 如果文件写入失败，则 err 的值等于一个 错误对象
// console.log(err)
if (err) {
return console.log('文件写入失败！' + err.message)
}
console.log('文件写入成功！')
})
// __dirname 表示当前文件所处的目录
fs.readFile(__dirname + '/files/1.txt', 'utf8', function(err, dataStr) {
if (err) {
return console.log('读取文件失败！' + err.message)
}
console.log('读取文件成功！' + dataStr)
})
1.3 path路径模块
路径拼接
path.join( [ .. .paths])
//注意： ../ 会抵消前面的路径
const pathStr = path.join('/a', '/b/c', '../', './d', 'e')
console.log(pathStr) // abde
fs.readFile(path.join(__dirname, './files/1.txt'), 'utf8', function (err, dataStr) {
if (err) {
return console.log(err.message)
}
console.log(dataStr)
})
path.basename(path[, ext])
const path = require('path')
// 定义文件的存放路径
const fpath = '/a/b/c/index.html'
const fullName = path.basename(fpath)
console.log(fullName)//index.html
const nameWithoutExt = path.basename(fpath, '.html')
console.log(nameWithoutExt)//index
获取路径中的文件扩展名
- 使用path.extname)方法，可以获取路径中的扩展名部分，语法格式如下:
path.extname(path)
const path = require('path')
// 这是文件的存放路径
const fpath = '/a/b/c/index.html'
const fext = path.extname(fpath)
console.log(fext)
1.4 http模块
- 在网络节点中，负责消费资源的电脑，叫做客户端;负责对外提供网络资源的电脑，叫做服务器
- http模块是Node.js官方提供的、用来创建web服务器的模块。通过http模块提供的 http.createServer(方法，就能方便的把一台普通的电脑，变成一台Web服务器，从而对外提供Web 资源服务
- 服务器和普通电脑的区别在于，服务器上安装了web服务器软件，例如:lIS、Apache等。通过安装这些服务器软件，就能把一台普通的电脑变成一台web服务器
- 在Node.js 中，我们不需要使用IIS、Apache等这些第三方web服务器软件。因为我们可以基于Node.js 提供的http模块，通过几行简单的代码，就能轻松的手写一个服务器软件，从而对外提供web服务
服务器相关概念：
1、IP地址
- IP地址就是互联网上每台计算机的唯一地址，因此IP地址具有唯一性。如果把“个人电脑”比作“一台电话”，那么“IP地址”就相当于“电话号码”，只有在知道对方IP地址的前提下，才能与对应的电脑之间进行数据通信
- IP地址的格式:通常用“点分十进制”表示成(a.b.c.d)的形式其中，a,b,c,d都是0~255之间的十进制整数。例如:用点分十进表示的IP地址(192.168.1.1)
- 注意:
- 尽管IP地址能够唯一地标记网络上的计算机，但IP地址是一长串数字，不直观，而且不便于记忆，于是人们又发明了另一套字符型的地址方案，即所谓的域名(Domain Name)地址
- IP地址和域名是——对应的关系，这份对应关系存放在一种叫做域名服务器(DNS,Domain name server)的电脑中。使用者只需通过好记的域名访问对应的服务器即可，对应的转换工作由域名服务器实现。因此，域名服务器就是提供IР地址和域名之问的转换服务的服务器
- 注意:
3、端口号
- 计算机中的端口号，就好像是现实生活中的门牌号一样。通过门牌号，外卖小哥可以在整栋大楼众多的房间中，准确把外卖送到你的手中
- 同样的道理，在一台电脑中，可以运行成百上千个web服务。每个web服务都对应一个唯一的端口号。客户端发送过来的网络请求，通过端口号，可以被准确地交给对应的web服务进行处理
- 注意:
- 导入http模块
- 启动服务器
// 1. 导入 http 模块
const http = require('http')
// 2. 创建 web 服务器实例
const server = http.createServer()
// 3. 为服务器实例绑定 request 事件，监听客户端的请求
server.on('request', function (req, res) {
console.log('Someone visit our web server.')
})
// 4. 启动服务器
server.listen(8080, function () {
console.log('server running at http://127.0.0.1:8080')
})
server.on('request', (req, res) => {
// req.url 是客户端请求的 URL 地址
const url = req.url
// req.method 是客户端请求的 method 类型
const method = req.method
const str = `Your request url is ${url}, and request method is ${method}`
console.log(str)
// 调用 res.end() 方法，向客户端响应一些内容
res.end(str)
})
server.on('request', (req, res) => {
// 定义一个字符串，包含中文的内容
const str = `您请求的 URL 地址是 ${req.url}，请求的 method 类型为 ${req.method}`
// 调用 res.setHeader() 方法，设置 Content-Type 响应头，解决中文乱码的问题
res.setHeader('Content-Type', 'text/html; charset=utf-8')
// res.end() 将内容响应给客户端
res.end(str)
})
- 获取请求的url地址
- 设置默认的响应内容为404 Not found
- 判断用户请求的是否为/或/index.html首页
- 判断用户请求的是否为/about.html关于页面
- 设置Content-Type响应头，防止中文乱码
- 使用res.end()把内容响应给客户端
- 代码：
const http = require('http')
const server = http.createServer()
server.on('request', (req, res) => {
// 1. 获取请求的 url 地址
const url = req.url
// 2. 设置默认的响应内容为 404 Not found
let content = '<h1>404 Not found!</h1>'
// 3. 判断用户请求的是否为 / 或 /index.html 首页
// 4. 判断用户请求的是否为 /about.html 关于页面
if (url === '/' || url === '/index.html') {
content = '<h1>首页</h1>'
} else if (url === '/about.html') {
content = '<h1>关于页面</h1>'
}
// 5. 设置 Content-Type 响应头，防止中文乱码
res.setHeader('Content-Type', 'text/html; charset=utf-8')
// 6. 使用 res.end() 把内容响应给客户端
res.end(content)
})
server.listen(80, () => {
console.log('server running at http://127.0.0.1')
})
2、模块化
2.1 模块化的基本概念
什么是模块化
- 模块化是指解决一个复杂问题时，自顶向下逐层把系统划分成若干模块的过程，对于整个系统来说，模块是可组合、分解和更换的单元
- 编程领域中的模块化，就是遵守固定的规则，把一个大文件拆成独立并互相依赖的多个小模块。
- 把代码进行模块化拆分的好处:
模块化规范
2.2 Node.js中模块化
Node.js中模块的分类
- Node.js 中根据模块来源的不同，将模块分为了3大类，分别是:
加载模块
Node.js中模块作用域
-
module.exports对象
在自定义模块中，可以使用module.exports对象，将模块内的成员共享出去，供外界使用。外界用require(方法导入自定义模块时，得到的就是 module.exports 所指向的对象
- 代码：
// 在外界使用 require 导入一个自定义模块的时候，得到的成员，
// 就是 那个模块中，通过 module.exports 指向的那个对象
const m = require('./自定义模块')
console.log(m)
// 在一个自定义模块中，默认情况下， module.exports = {}
const age = 20//*
// 1、向 module.exports 对象上挂载 username 属性
module.exports.username = 'zs'
// 2、向 module.exports 对象上挂载 sayHello 方法
module.exports.sayHello = function () {
console.log('Hello!')
}
module.exports.age = age//*
///3、让 module.exports 指向一个全新的对象
module.exports = {
nickname: '小黑',
sayHi() {
console.log('Hi!')
}
}
- exports 对象
由于module.exports单词写起来比较复杂，为了简化向外共享成员的代码，Node 提供了exports对象。默认情况下，exports和module.exports 指向同一个对象。最终共享的结果，还是以module.exports 指向的对象为准
Node.js中的模块化规范
2.3 npm与包
包
- Node.js 中的第三方模块又叫做包
- 不同于Node.js 中的内置模块与自定义模块，包是由第三方个人或团队开发出来的，免费供所有人使用(免费且开源)
- 由于Node.js的内置模块仅提供了一些底层的API，导致在基于内置模块进行项目开发的时，效率很低。包是基于内置模块封装出来的，提供了更高级、更方便的API，极大的提高了开发效率；包和内置模块之间的关系，类似于jQuery和浏览器内置API之间的关系
- 注意:
- 这个包管理工具的名字叫做Node Package Manager(简称npm包管理工具)，这个包管理工具随着Node.js 的安装包一起被安装到了用户的电脑上
- 大家可以在终端中执行npm -v命令，来查看自己电脑上所安装的npm包管理工具的版本号
- 在项目中安装指定名称的包：
npm install 包的完整名称;可简写为：npm i 包的完整名称 - 初次装包完成后，在项目文件夹下多一个叫做node_modules的文件夹和package–lock.json的配置文件
- 其中:
- 默认情况下，使用npm install命令安装包的时候，会自动安装最新版本的包。如果需要安装指定版本的包，可以在包名之后，通过**@符号指定具体的版本**，例如:
npm i moment@2.22.2 - 包的版本号是以“点分十进制”形式进行定义的，总共有三位数字，例如2.24.0其中每一位数字所代表的的含义如下:
包管理配置文件
-
npm 规定，在项目根目录中，必须提供一个叫做 package.json的包管理配置文件。用来记录与项目有关的一些配置信息。例如:
-
在项目根目录中，创建一个叫做package,json的配置文件，即可用来记录项目中安装了哪些包。从而方便剔除node_modules 目录之后，在团队成员之间共享项目的源代码
一次性安装所有的包
- 可以运行
npm install命令(或npm i)一次性安装所有的依赖包 - 执行npm install 命令时，npm包管理工具会先读取package.json 中的 dependencies节点
- 读取到记录的所有依赖包名称和版本号之后，npm包管理工具会把这些包一次性下载到项目中
卸载包
- 如果某些包只在项目开发阶段会用到，在项目上线之后不会用到，则建议把这些包记录到devDependencies节点中;与之对应的，如果某些包在开发和项目上线之后都需要用到，则建议把这些包记录到dependencies节点中
- 可以使用如下的命令，将包记录到devDependencies节点中:
npm i 包名-D(简写)npm install包名--save-dev(完整)
npm下包速度慢的解决
- 在使用npm下包的时候，默认从国外的 https://registry.npmjs.org/服务器进行下载，此时，网络数据的传输需要经过漫长的海底光缆，因此下包速度会很慢
- 淘宝在国内搭建了一个服务器，专门把国外官方服务器上的包同步到国内的服务器，然后在国内提供下包的服务；从而极大的提高了下包的速度
# 查看当前的下包镜像源
npm config get registry
# 将下包的镜像源切换为淘宝镜像源
npm config set registry=https : /lregistry.npm.taobao.org/
# 检查镜像源是否下载成功
npm config get registry
# 通过npm包管理器，将nrm安装为全局可用的工具
npm i nrm -g
# 查看所有可用的镜像源
nrm ls
# 将下包的镜像源切换为taobao镜像
nrm use taobao
包的分类
- 使用npm包管理工具下载的包，共分为两大类，分别是:
- 项目包
- 全局包
# 将i5ting_toc安装为全局包
npm install -g i5ting toc
# 调用i5ting_toc，轻松实现md转html的功能
i5ting_toc -f 要转换的md文件路径 -o
规范的包结构
2.4 模块的加载机制
内置模块的加载机制
自定义模块的加载机制
- 使用require()加载自定义模块时，必须指定以./或…/开头的路径标识符。在加载自定义模块时，如果没有指定./或…/这样的路径标识符，则node 会把它当作内置模块或第三方模块进行加载
- 同时，在使用require()导入自定义模块时，如果省略了文件的扩展名，则Nodejs 会按顺序分别尝试加载以下的文件:
第三方模块的加载机制
-
如果传递给require()的模块标识符不是一个内置模块，也没有以./或…/开头，则Node.js 会从当前模块的父目录开始，尝试从/node_modules文件夹中加载第三方模块
-
如果没有找到对应的第三方模块，则移动到再上一层父目录中，进行加载，直到文件系统的根目录
-
例如，假设在’C:Usersitheimaprojectfoojs’文件里调用require(“tools’)，则 Node.js 会按以下顺序找:
- C:Usersheimaprojectnode_modulestools
- C:Usersheimanode_modulestools
- C:Usersnode_modulestools
- C:node_modulestools
目录作为模块
- 在被加载的目录下查找一个叫做 package.json的文件，并寻找main属性，作为require()加载的入口
- 如果目录里没有package.json 文件，或者main入口不存在或无法解析，则Node.js将会试图加载目录下的 index.js文件
- 如果以上两步都失败了，则Nodejs 会在终端打印错误消息，报告模块的缺失: Error. Cannot find module ‘xxx’
3、Express
3.1 初识Express
-
Express 的本质:就是一个npm 上的第三方包，提供了快速创建web服务器的便捷方法
Express基本使用
- 代码：
// 1. 导入 express
const express = require('express')
// 2. 创建 web 服务器
const app = express()
// 3. 监听客户端的 GET 和 POST 请求，并向客户端响应具体的内容
app.get('/user', (req, res) => {
// 调用 express 提供的 res.send() 方法，向客户端响应一个 JSON 对象
res.send({ name: 'zs', age: 20, gender: '男' })
})
app.post('/user', (req, res) => {
// 调用 express 提供的 res.send() 方法，向客户端响应一个 文本字符串
res.send('请求成功')
})
app.get('/', (req, res) => {
// 通过 req.query 可以获取到客户端发送过来的 查询参数
// 注意：默认情况下，req.query 是一个空对象
console.log(req.query)
res.send(req.query)
})
// 注意：这里的 :id 是一个动态的参数
app.get('/user/:ids/:username', (req, res) => {
// req.params 是动态匹配到的 URL 参数，默认也是一个空对象
console.log(req.params)
res.send(req.params)
})
// 4. 启动 web 服务器
app.listen(80, () => {
console.log('express server running at http://127.0.0.1')
})
- express提供了一个非常好用的函数，叫做 express.static()，通过它，我们可以非常方便地创建一个静态资源服务器例如，通过如下代码就可以将public目录下的图片、CSS文件、JavaScript文件对外开放访问了
- 注意:Express在指定的静态目录中查找文件，并对外提供资源的访问路径。因此，存放静态文件的目录名不会出现在URL中
- 访问静态资源文件时，express.static()函数会根据目录的添加顺序查找所需的文件
- 代码：
const express = require('express')
const app = express()
// 在这里，调用 express.static() 方法，快速的对外提供静态资源
app.use('/files', express.static('./files'))//按添加顺序查找所需文件，挂载路径前缀
app.use(express.static('./clock'))
app.listen(80, () => {
console.log('express server running at http://127.0.0.1')
})
nodemon
- 在编写调试Nodejs项目的时候，如果修改了项目的代码，则需要频繁的手动close掉，然后再重新启动，非常繁琐；我们可以使用nodemon (https://www.npmjs.com/package/nodemon)这个工具，它能够监听项目文件的变动，当代码被修改后，nodemon 会自动帮我们重启项目，极大方便了开发和调试
- 在终端中，运行如下命令，即可将nodemon安装为全局可用的工具：
npm install -g nodemon - 使用：
node app.js=>nodemon app.js
3.2 Express路由
路由的概念
-
广义上来讲，路由就是映射关系
-
Express 中的路由分3部分组成，分别是请求的类型、请求的URL地址、处理函数，格式如下:
app.METHOD(PATH，HANDLER) -
在匹配时，会按照路由的顺序进行匹配，如果请求类型和请求的URL同时匹配成功，则Express 会将这次请求，转交给对应的function函数进行处理
路由的使用
- 最简单路由代码：
const express = require('express')
const app = express()
// 挂载路由
app.get('/', (req, res) => {
res.send('hello world.')
})
app.post('/', (req, res) => {
res.send('Post Request.')
})
app.listen(80, () => {
console.log('http://127.0.0.1')
})
// 1. 导入 express
const express = require('express')
// 2. 创建路由对象
const router = express.Router()
// 3. 挂载具体的路由
router.get('/user/list', (req, res) => {
res.send('Get user list.')
})
router.post('/user/add', (req, res) => {
res.send('Add new user.')
})
// 4. 向外导出路由对象
module.exports = router
- 注册路由模块代码：
// 1．导入路由模块
const userRouter = require( ' ./router/user.js ')
// 2．使用app.use()注册路由模块
app.use(userRouter)
// 注意： app.use() 函数的作用，就是来注册全局中间件
- 为路由模块添加前缀代码：
//使用app.use()注册路由模块，并添加统的访问前缀
app.use( ' /api ', userRouter)
3.3 Express中间件
中间件的概念
- Express的中间件，本质上就是一个function处理函数，Express中间件的格式如下:
中间件初体验
- 最简单的中间件函数：
//常量mw所指向的,就是一个中间件函数
const mw = function (req. res,next) {
console.log('这是一个最简单的中间件函数")
//注意:在当前中间件的业务处理完毕后，必须调用next()函数
//表示把流转关系转交给下一个中间件或路由
next()
}
- 全局生效的中间件：
//常量mw所指向的,就是一个中间件函数
const mw = function (req. res,next) {
console.log( "这是一个最简单的中间件函数")
next()
}
//全局生效的中间件
app.use(mw)
- 全局中间件的简化形式：
//全局生效的中间件
app.use(function (req,res,next) {
console.log( '这是一个最简单的中间件函数')
next()
})
- 定义多个全局中间件
app.use( function(req, res, next) //第1个全局中间
console.1og('调用了第1个全局中间件')
next()
})
app.use( function(req, res, next) //第2个全局中间件
console.log('调用了第2个全局中间件")
next()
})
app.get( ' /user ', (req, res) => {//请求这个路由，会依次触发上述两个全局中间件
res.send( ' Home page.")
})
- 局部生效的中间件
//定义中间件函数mw1
const mw1 = function(req. res,next) {
console.log("这是中间件函数")
next()
}
// mw1(中间件函数)这个中间件只在"当前路由中生效"，这种用法属于"局部生效的中间件"
app.get( '/'，mw1,function(req, res) {
res.send('Home page.')
})
//mw1这个中间件不会影响下面这个路由↓↓↓
app.get( ' /user '， function(req，res) {
res.send( 'User page.')
})
- 定义多个局部中间件
//以下两种写法是"完全等价"的，可根据自己的喜好，选择任意一种方式进行使用
app.get( ' / ' ,mw1,mw2，(req，res) => { res.send( 'Home page. ')})
app.get( ' / '，[mw1，mw2]，(req，res) => { res.send( 'Home page.')})
- 注意事项：
- —定要在路由之前注册中间件
- 客户端发送过来的请求，可以连续调用多个中间件进行处理
- 执行完中间件的业务代码之后，不要忘记调用next()函数
- 为了防止代码逻辑混乱，调用next()函数后不要再写额外的代码
- 连续调用多个中间件时，多个中间件之间，共享req和res对象
中间件分类
-
应用级别的中间件
-
路由级别的中间件
-
错误级别的中间件
- 错误级别中间件的作用:专门用来捕获整个项目中发生的异常错误，从而防止项目异常崩溃的问题
- 格式:错误级别中间件的 function 处理函数中，必须有4个形参，形参顺序从前到后，分别是(err,req, res, next)
- 代码：
// 导入 express 模块 const express = require('express') // 创建 express 的服务器实例 const app = express() // 1. 定义路由 app.get('/', (req, res) => { // 1.1 人为的制造错误 throw new Error('服务器内部发生了错误！') res.send('Home page.') }) // 2. 定义错误级别的中间件，捕获整个项目的异常错误，从而防止程序的崩溃,注册在所有路由之后 app.use((err, req, res, next) => { console.log('发生了错误！' + err.message) res.send('Error：' + err.message) }) // 调用 app.listen 方法，指定端口号并启动web服务器 app.listen(80, function () { console.log('Express server running at http://127.0.0.1') }) -
Express内置的中间件
// 导入 express 模块 const express = require('express') // 创建 express 的服务器实例 const app = express() // 注意：除了错误级别的中间件，其他的中间件，必须在路由之前进行配置 // 通过 express.json() 这个中间件，解析表单中的 JSON 格式的数据 app.use(express.json()) // 通过 express.urlencoded() 这个中间件，来解析 表单中的 url-encoded 格式的数据 app.use(express.urlencoded({ extended: false })) app.post('/user', (req, res) => { // 在服务器，可以使用 req.body 这个属性，来接收客户端发送过来的请求体数据 // 默认情况下，如果不配置解析表单数据的中间件，则 req.body 默认等于 undefined console.log(req.body) res.send('ok') }) app.post('/book', (req, res) => { // 在服务器端，可以通过 req,body 来获取 JSON 格式的表单数据和 url-encoded 格式的数据 console.log(req.body) res.send('ok') }) // 调用 app.listen 方法，指定端口号并启动web服务器 app.listen(80, function () { console.log('Express server running at http://127.0.0.1') }) -
第三方的中间件
自定义中间件
- 代码：
// 导入 express 模块
const express = require('express')
// 创建 express 的服务器实例
const app = express()
// 导入 Node.js 内置的 querystring 模块
const qs = require('querystring')
// 这是解析表单数据的中间件
app.use((req, res, next) => {
// 定义中间件具体的业务逻辑
// 1. 定义一个 str 字符串，专门用来存储客户端发送过来的请求体数据
let str = ''
// 2. 监听 req 的 data 事件
req.on('data', (chunk) => {
str += chunk
})
// 3. 监听 req 的 end 事件
req.on('end', () => {
// 在 str 中存放的是完整的请求体数据
// console.log(str)
// TODO: 把字符串格式的请求体数据，解析成对象格式
const body = qs.parse(str)
req.body = body
next()
})
})
app.post('/user', (req, res) => {
res.send(req.body)
})
// 调用 app.listen 方法，指定端口号并启动web服务器
app.listen(80, function () {
console.log('Express server running at http://127.0.0.1')
})
3.4 使用Express写接口
CORS跨域资源共享
- CORS (Cross-Origin Resource Sharing，跨域资源共享）由一系列HTTP响应头组成，这些HTTP响应头决定浏览器是否阻止前端JS代码跨域获取资源
- 浏览器的同源安全策略默认会阻止网页“跨域”获取资源。但如果接口服务器配置了CORS相关的HTTP响应头，就可以解除浏览器端的跨域访问限制
-
CORS的注意事项
-
响应头部中可以携带一个Access-Control-Allow-Origin字段，其语法如下:
Access-Control-Allow-origin: <origin> | *其中,origin参数的值指定了允许访问该资源的外域URL
res.setHeader( ' Access-Control-Allow-Origin ', 'http: /litcast.cn')
- 默认情况下，CORS仅支持客户端向服务器发送如下的9个请求头:
Accept、Accept-Language、Content-Language、DPR、Downlink、Save-Data、Viewport-Width、Width 、Content-Type (值仅限于text/plain、multipart/form-data、application/x-www-form-urlencoded三者之一);如果客户端向服务器发送了额外的请求头信息，则需要在服务器端，通过Access-Control-Allow-Headers 对额外的请求头进行声明，否则这次请求会失败!
//允许客户端额外向服务器发送Content-Type 请求头和X-Custom-Header请求头//注意:多个请求头之间使用英文的逗号进行分割
res.setHeader( ' Access-Control-Allow-Headers ' ，'Content-Type，x-Custom-Header ')
- 默认情况下，CORS仅支持客户端发起
GET、POST、HEAD请求。
如果客户端希望通过PUT、DELETE等方式请求服务器的资源，则需要在服务器端，通过Access-Control-Alow-Method来指明实际请求所允许使用的HTTP方法
//只允许POST、GET、DELETE、HEAD请求方法
res.setHeader ( ' Access-Control-Allow-Methods ','POST，GET，DELETE，HEAD" )
//允许所有的 HTTP请求方法
res.setHeader( 'Access-Control-Allow-Methods " , '*')
-
客户端在请求CORS接口时，根据请求方式和请求头的不同，可以将CORS的请求分为两大类，分别是:
- 简单请求 (客户端与服务器之间只会发生一次请求)
JSONP接口
-
概念:浏览器端通过< scrip t>标签的src 属性，请求服务器上的数据，同时，服务器返回一个函数的调用。这种请求数据的方式叫做JSONP
-
特点:
- JSONP 不属于真正的Ajax请求，因为它没有使用XMLHttpRequest这个对象
- JSONP仅支持GET请求，不支持 POST、PUT、DELETE 等请求
-
步骤：
-
代码：
// 导入 express
const express = require('express')
// 创建服务器实例
const app = express()
// 配置解析表单数据的中间件
app.use(express.urlencoded({ extended: false }))
// 必须在配置 cors 中间件之前，配置 JSONP 的接口
app.get('/api/jsonp', (req, res) => {
// TODO: 定义 JSONP 接口具体的实现过程
// 1. 得到函数的名称
const funcName = req.query.callback
// 2. 定义要发送到客户端的数据对象
const data = { name: 'zs', age: 22 }
// 3. 拼接出一个函数的调用
const scriptStr = `${funcName}(${JSON.stringify(data)})`
// 4. 把拼接的字符串，响应给客户端
res.send(scriptStr)
})
// 一定要在路由之前，配置 cors 这个中间件，从而解决接口跨域的问题
const cors = require('cors')
app.use(cors())
// 导入路由模块
const router = require('./apiRouter')
// 把路由模块，注册到 app 上
app.use('/api', router)
// 启动服务器
app.listen(80, () => {
console.log('express server running at http://127.0.0.1')
})
const express = require('express')
const router = express.Router()
// 在这里挂载对应的路由
router.get('/get', (req, res) => {
// 通过 req.query 获取客户端通过查询字符串，发送到服务器的数据
const query = req.query
// 调用 res.send() 方法，向客户端响应处理的结果
res.send({
status: 0, // 0 表示处理成功，1 表示处理失败
msg: 'GET 请求成功！', // 状态的描述
data: query, // 需要响应给客户端的数据
})
})
// 定义 POST 接口
router.post('/post', (req, res) => {
// 通过 req.body 获取请求体中包含的 url-encoded 格式的数据
const body = req.body
// 调用 res.send() 方法，向客户端响应结果
res.send({
status: 0,
msg: 'POST 请求成功！',
data: body,
})
})
// 定义 DELETE 接口
router.delete('/delete', (req, res) => {
res.send({
status: 0,
msg: 'DELETE请求成功',
})
})
module.exports = router
4、数据库与身份认证
4.1 数据库的基本概念
数据库的概念
* 整个Excel叫做工作簿
* users和books是工作表
* users 工作表中有3行数据
* 每行数据由6列信息组成，每列信息都有对应的数据类型
-
传统型数据库的数据组织结构
4.2 安装并配置MySQL
4.3 MySQL的基本使用
- 连接数据库
- 主界面的组成部分
- 创建数据库
- 创建数据表
-
DataType数据类型:
-
字段的特殊标识:
- 向表中写入数据
使用SQL管理数据库
SQL的SELECT语句
--这是注释
--从 FROM 指定的［表中］，查询出［所有的］数据。 * 表示［所有列］
SELECT * FROM 表名称
--从 FROM 指定的［表中］，查询出指定 列名称 （字段） 的数据
SELECT 列名称 FROM 表名称
SQL的INSERT INTO语句
--语法解读：向指定的表中，插入如下几列数据，列的值通过 values -----指定
--注意：列和值要一一对应，多个列和多个值之间，使用英文的逗号分隔
insert into table_name (列1,列2...) values (值1,值2...)
SQL的UPDATE语句
--语法解读：
--1.用update 指定要更新哪个表中的数据
--2.用 set 指定列对应的新值
--3.用 where 指定更新的条件
update 表名称 set 列名称 = 新值 where 列名称 = 某值
SQL的DELETE语句
- DELETE语句用于删除表中的行。语法格式如下:
--语法解读：
--从指定的表中，根据where条件，删除对应的数据行
delete from 表名称 where 列名称 = 值
- 从users表中，删除id为4的用户，示例如下:
SQL的WHERE子句
--查询语句中的 where 条件
select 列名称 from 表名称 where 列 运算符 值
--更新语句中的 where 条件
update 表名称 set 列=新值 where 列 运算符 值
--删除语句中的 where 条件
delete from 表名称 where 列 运算符 值
-
注意:在某些版本的SQL中，操作符<>可以写为!=
-
可以通过WHERE子句来限定SELECT的查询条件:
--查询status为1的所有用户
SELECT * FROM users WHERE status=1
--查询id 大于2的所有用户
SELECT * FROM users WHERE id>2
--查询username 不等于admin的所有用户
SELECT * FROM users WHERE username<> 'admin'
SQL的AND和OR运算符
-
AND表示必须同时满足多个条件，相当于JavaScript中的&&运算符，例如 if (a !== 10 && a !== 20)
-
OR表示只要满足任意一个条件即可，相当于JavaScript中||运算符，例如if(a !== 10||a !== 20)
SQL的OEDED BY子句
-
如果您希望按照降序对记录进行排序，可以使用DESC关键字
SQL的COUNT(*)语句
- COUNT(*)函数用于返回查询结果的总数据条数，语法格式如下:
SELECT COUNT(*) FROM 表名称
- 杳询users表中status为0的总数据条数:
- 如果希望给查询出来的列名称设置别名，可以使用AS关键字，示例如下:
4.4 在项目中操作MySql
步骤：
-
安装操作MySQL数据库的第三方模块(mysql)
npm install mysql
-
//1.导入mysql模块 const mysql = require('mysql') //2.建立与mysql数据库的连接关系 const db = mysql.createPool({ host: '127.0.0.1', //数据库的IP地址 user: 'root', //登录数据库的账号 password: '123456', //登录数据库的密码 database: 'my_db_01', //待操作的数据库 }) -
通过mysql模块执行SQL语句
//测试mysql模块能否正常工作 db.query('select 1', (err, results) => { //报错 if (err) return console.log(err.message) //正常 console.log(results) })
- 查：
//查询user表中所有的数据
const sqlStr = 'select * from users'
db.query(sqlStr, (err, results) => {
//报错
if (err) return console.log(err.message)
//正常
console.log(results)
})
- 增：
//新增数据
const user = { username: 'ironman', password: '123456' }
//定义待执行的SQL语句
const sqlStr = 'insert into users (username,password) values(?,?)'
//执行SQL语句
db.query(sqlStr, [user.username, user.password], (err, results) => {
//报错
if (err) return console.log(err.message)
//正常
if (results.affectedRows === 1) {
console.log('插入数据成功!')
}
})
//向表中新增数据时，如果数据对象的每个属性和数据表的字段一一对应，则可以通过如下方式快速插入数据
//新增数据
const user = { username: 'ironman', password: '123456' }
//定义待执行的SQL语句
const sqlStr = 'insert into users set ?'
//执行SQL语句
db.query(sqlStr, user, (err, results) => {
//报错
if (err) return console.log(err.message)
//正常
if (results.affectedRows === 1) {
console.log('插入数据成功!')
}
})
- 改：
//更新用户信息
const user = { id: 6, username: 'aaa', password: '000' }
//定义SQL语句
const sqlStr = 'update users set username=?,password=? where id=?'
//执行SQL语句
db.query(sqlStr, [user.ueername, user.password, user.id], (err, results) => {
//报错
if (err) return console.log(err.message)
//正常
if (results.affectedRows === 1) {
console.log('更新数据成功!')
}
})
//向表中新增数据时，如果数据对象的每个属性和数据表的字段—一对应，则可以通过如下方式快速更新数据
//更新用户信息
const user = { id: 6, username: 'aaa', password: '000' }
//定义SQL语句
const sqlStr = 'update users set ? where id=?'
//执行SQL语句
db.query(sqlStr, [user, user.id], (err, results) => {
//报错
if (err) return console.log(err.message)
//正常
if (results.affectedRows === 1) {
console.log('更新数据成功!')
}
})
- 删：
// 1．要执行的SQL语句
const sqlStr = 'DELETE FROM users WHERE id=?'
//2．调用db.query()执行SQL语句的同时，为占位符指定具体的值
//注意:如果SQL语句中有多个占位符，则必须使用数组为每个占位符指定具体的值"
//如果SQL语句中只有一个占位符，则可以省略数组
db.query(sqlStr, 5, (err, results) => {
if (err) return console.log(err.message)// 失败
if (results.affectedRows === 1) {
console.log('删除数据成功! ')
} // 成功
})
//所谓的标记删除，就是在表中设置类似于status这样的状态字段，来标记当前这条数据是否被删除
4.5 前后端的身份认证
Web开发模式
- 身份认证(Authentication)又称“身份验证”、“鉴权”，是指通过一定的手段，完成对用户身份的确认
- 如手机验证码登录、邮箱密码登录、二维码登录等等
- 对于服务端渲染和前后端分离这两种开发模式来说，分别有着不同的身份认证方案:
Session 认证机制
- HTTP协议的无状态性，指的是客户端的每次HTTP请求都是独立的，连续多个请求之间没有直接的关系，服务器不会主动保留每次HTTP请求的状态
- Cookie 是存储在用户浏览器中的一段不超过4KB的字符串。它由一个名称(Name)、一个值(Value)和其它几个用于控制Cookie 有效期、安全性、使用范围的可选属性组成
- 不同域名下的Cookie各自独立，每当客户端发起请求时，会自动把当前域名下所有未过期的Cookie一同发送到服务器
- Cookie的几大特性:
- 自动发送
- 域名独立
- 过期时限
- 4KB限制
- 由于Cookie 是存储在浏览器中的，而且浏览器也提供了读写Cookie的API，因此Cookie很容易被伪造，不具有安全性。因此不建议服务器将重要的隐私数据， 通过Cookie的形式发送给浏览器**(Cookie不具有安全性)**
- Session认证机制：
在Express中使用Session 认证
- 安装express-session中间件：
npm install express-session - 配置express-session中间件
- 向session中存数据
- 从session中取数据
- 清空session
- 代码：
// 导入 express 模块
const express = require('express')
// 创建 express 的服务器实例
const app = express()
// TODO_01：请配置 Session 中间件
const session = require('express-session')
app.use(
session({
secret: 'itheima',
resave: false,
saveUninitialized: true,
})
)
// 托管静态页面
app.use(express.static('./pages'))
// 解析 POST 提交过来的表单数据
app.use(express.urlencoded({ extended: false }))
// 登录的 API 接口
app.post('/api/login', (req, res) => {
// 判断用户提交的登录信息是否正确
if (req.body.username !== 'admin' || req.body.password !== '000000') {
return res.send({ status: 1, msg: '登录失败' })
}
// TODO_02：请将登录成功后的用户信息，保存到 Session 中
// 注意：只有成功配置了 express-session 这个中间件之后，才能够通过 req 点出来 session 这个属性
req.session.user = req.body // 用户的信息
req.session.islogin = true // 用户的登录状态
res.send({ status: 0, msg: '登录成功' })
})
// 获取用户姓名的接口
app.get('/api/username', (req, res) => {
// TODO_03：请从 Session 中获取用户的名称，响应给客户端
if (!req.session.islogin) {
return res.send({ status: 1, msg: 'fail' })
}
res.send({
status: 0,
msg: 'success',
username: req.session.user.username,
})
})
// 退出登录的接口
app.post('/api/logout', (req, res) => {
// TODO_04：清空 Session 信息
req.session.destroy()
res.send({
status: 0,
msg: '退出登录成功',
})
})
// 调用 app.listen 方法，指定端口号并启动web服务器
app.listen(80, function () {
console.log('Express server running at http://127.0.0.1:80')
})
JWT认证机制
- 当前端请求后端接口不存在跨域问题的时候，推荐使用Session身份认证机制
- 当前端需要跨域请求后端接口的时候，不推荐使用Session身份认证机制，推荐使用JWT认证机制(JSON Web Token目前最流行的跨域认证解决方案)
- JWT工作原理：用户的信息通过Token字符串的形式，保存在客户端浏览器中。服务器通过还原Token 字符串的形式来认证用户的身份
- JWT通常由三部分组成，分别是Header (头部) 、Payload(有效荷载） 、Signature(签名)，三者之间使用英文的“.”分隔；Payload部分才是真正的用户信息，它是用户信息经过加密之后生成的字符串，Header和Signature是安全性相关**的部分，只是为了保证Token的安全性
- 客户端收到服务器返回的JWT之后，通常会将它储存在localStorage或sessionStorage 中；此后，客户端每次与服务器通信，都要带上这个JWT的字符串，从而进行身份认证；推荐的做法是把JWT放在HTTP请求头的Authorization字段中：
Authorization: Bearer <token>
在Express中使用JWT
- 安装JWT相关的包：
npm install jsonwebtoken express-jwt - 导入JWT相关的包
- 定义secret密钥
- 在登录成功后生成JWT字符串
- 将JWT字符串还原为JSON对象
- 使用req.user获取用户信息
- 捕获解析JWT失败后产生的错误
- 代码：
// 导入 express 模块
const express = require('express')
// 创建 express 的服务器实例
const app = express()
// TODO_01：安装并导入 JWT 相关的两个包，分别是 jsonwebtoken 和 express-jwt
const jwt = require('jsonwebtoken')
const expressJWT = require('express-jwt')
// 允许跨域资源共享
const cors = require('cors')
app.use(cors())
// 解析 post 表单数据的中间件
const bodyParser = require('body-parser')
app.use(bodyParser.urlencoded({ extended: false }))
// TODO_02：定义 secret 密钥，建议将密钥命名为 secretKey
const secretKey = 'itheima No1 ^_^'
// TODO_04：注册将 JWT 字符串解析还原成 JSON 对象的中间件
// 注意：只要配置成功了 express-jwt 这个中间件，就可以把解析出来的用户信息，挂载到 req.user 属性上
app.use(expressJWT({ secret: secretKey }).unless({ path: [/^/api//] }))
// 登录接口
app.post('/api/login', function (req, res) {
// 将 req.body 请求体中的数据，转存为 userinfo 常量
const userinfo = req.body
// 登录失败
if (userinfo.username !== 'admin' || userinfo.password !== '000000') {
return res.send({
status: 400,
message: '登录失败！',
})
}
// 登录成功
// TODO_03：在登录成功之后，调用 jwt.sign() 方法生成 JWT 字符串。并通过 token 属性发送给客户端
// 参数1：用户的信息对象
// 参数2：加密的秘钥
// 参数3：配置对象，可以配置当前 token 的有效期
// 记住：千万不要把密码加密到 token 字符中
const tokenStr = jwt.sign({ username: userinfo.username }, secretKey, { expiresIn: '30s' })
res.send({
status: 200,
message: '登录成功！',
token: tokenStr, // 要发送给客户端的 token 字符串
})
})
// 这是一个有权限的 API 接口
app.get('/admin/getinfo', function (req, res) {
// TODO_05：使用 req.user 获取用户信息，并使用 data 属性将用户信息发送给客户端
console.log(req.user)
res.send({
status: 200,
message: '获取用户信息成功！',
data: req.user, // 要发送给客户端的用户信息
})
})
// TODO_06：使用全局错误处理中间件，捕获解析 JWT 失败后产生的错误
app.use((err, req, res, next) => {
// 这次错误是由 token 解析失败导致的
if (err.name === 'UnauthorizedError') {
return res.send({
status: 401,
message: '无效的token',
})
}
res.send({
status: 500,
message: '未知的错误',
})
})
// 调用 app.listen 方法，指定端口号并启动web服务器
app.listen(8888, function () {
console.log('Express server running at http://127.0.0.1:8888')
})
码：
// 导入 express 模块
const express = require('express')
// 创建 express 的服务器实例
const app = express()
// TODO_01：安装并导入 JWT 相关的两个包，分别是 jsonwebtoken 和 express-jwt
const jwt = require('jsonwebtoken')
const expressJWT = require('express-jwt')
// 允许跨域资源共享
const cors = require('cors')
app.use(cors())
// 解析 post 表单数据的中间件
const bodyParser = require('body-parser')
app.use(bodyParser.urlencoded({ extended: false }))
// TODO_02：定义 secret 密钥，建议将密钥命名为 secretKey
const secretKey = 'itheima No1 ^_^'
// TODO_04：注册将 JWT 字符串解析还原成 JSON 对象的中间件
// 注意：只要配置成功了 express-jwt 这个中间件，就可以把解析出来的用户信息，挂载到 req.user 属性上
app.use(expressJWT({ secret: secretKey }).unless({ path: [/^/api//] }))
// 登录接口
app.post('/api/login', function (req, res) {
// 将 req.body 请求体中的数据，转存为 userinfo 常量
const userinfo = req.body
// 登录失败
if (userinfo.username !== 'admin' || userinfo.password !== '000000') {
return res.send({
status: 400,
message: '登录失败！',
})
}
// 登录成功
// TODO_03：在登录成功之后，调用 jwt.sign() 方法生成 JWT 字符串。并通过 token 属性发送给客户端
// 参数1：用户的信息对象
// 参数2：加密的秘钥
// 参数3：配置对象，可以配置当前 token 的有效期
// 记住：千万不要把密码加密到 token 字符中
const tokenStr = jwt.sign({ username: userinfo.username }, secretKey, { expiresIn: '30s' })
res.send({
status: 200,
message: '登录成功！',
token: tokenStr, // 要发送给客户端的 token 字符串
})
})
// 这是一个有权限的 API 接口
app.get('/admin/getinfo', function (req, res) {
// TODO_05：使用 req.user 获取用户信息，并使用 data 属性将用户信息发送给客户端
console.log(req.user)
res.send({
status: 200,
message: '获取用户信息成功！',
data: req.user, // 要发送给客户端的用户信息
})
})
// TODO_06：使用全局错误处理中间件，捕获解析 JWT 失败后产生的错误
app.use((err, req, res, next) => {
// 这次错误是由 token 解析失败导致的
if (err.name === 'UnauthorizedError') {
return res.send({
status: 401,
message: '无效的token',
})
}
res.send({
status: 500,
message: '未知的错误',
})
})
// 调用 app.listen 方法，指定端口号并启动web服务器
app.listen(8888, function () {
console.log('Express server running at http://127.0.0.1:8888')
})
原文地址:https://blog.csdn.net/ASHIYI66/article/details/127956360
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若转载，请注明出处：http://www.7code.cn/show_11891.html
如若内容造成侵权/违法违规/事实不符，请联系代码007邮箱：suwngjj01@126.com进行投诉反馈，一经查实，立即删除！
声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。
