//注意:在使用require加载用户自定义模块期间,可以省略.js 的后缀名
他们俩个===比较 为true 但
所以建议不要在一个模块内同时使用exports 和module.exports
Node.js 中的第三方模块又叫做包。
就像电脑和计算机指的是相同的东西,第三方模块和包指的是同一个概念,只不过叫法不同。
不同于Node.js 中的内置模块与自定义模块,包是由第三方个人或团队开发出来的,免费供所有人使用。注意:Node.js 中的包都是免费且开源的,不需要付费即可免费下载使用。
由于Node.js的内置模块仅提供了一些底层的API,导致在基于内置模块进行项目开发的时,效率很低.包是基于内置模块封装出来的,提供了更高级、更方便的API,极大的提高了开发效率。
包和内置模块之间的关系,类似于jQuery和浏览器内置API之间的关系。
在powershell终端无法顺利使用这个脚本,将终端类型改为 第三个 cmd即可
配置命令别名
//导入 express
const express = require('express');
//创建应用对象
const app = express();
//创建路由
app.get('/home', (req, res) => {
res.end('hello express');
});
//首页路由
app.get('/', (req, res) => {
console.log(req.ip);
res.end('home');
});
//post
app.post('/login', (req, res) => {
res.end('login login')
});
//匹配所有的方法
app.all('/test', (req, res) => {
res.end('test test');
})
//404 响应
app.all('*', (req, res) => {
res.end('404 not Found')
});
//监听端口, 启动服务
app.listen(3000, () => {
console.log('服务已经启动, 端口 3000 正在监听中....')
})
//创建路由
app.get('/request', (req, res) => {
//原生操作
// console.log(req.method);
// console.log(req.url);
// console.log(req.httpVersion);
// console.log(req.headers);
// //express 操作
//请求方法
console.log(req.path);
//获取请求参数
console.log(req.query);
// //获取 ip
console.log(req.ip);
//获取请求头
console.log(req.get('host'));
res.end('hello express');
});
//创建路由
app.get('/response', (req, res) => {
//原生响应
// res.statusCode = 404;
// res.statusMessage = 'love';
// res.setHeader('xxx', 'yyy');
// res.write('hello express ')
// res.end('response');
//express 响应 send 自动处理中文乱码
// res.status(500);
// res.set('aaa','bbb');
// res.send('你好 Express');
res.status(500).set('abc','def').send('这都是 OK 的');
});
//创建路由
app.get('/other', (req, res) => {
//跳转响应
// res.redirect('http://atguigu.com');
//下载响应
// res.download(__dirname + '/package.json');
// JSON 响应
// res.json({
// name: '尚硅谷',
// slogon: '让天下没有难学的技术'
// })
//响应文件内容
res.sendFile(__dirname + '/test.html');// path.resolve()
});
什么是中间件
中间件(Middleware)本质是一个回调函数
中间件函数可以像路由回调一样访问请求对象(request),响应对象(response)
中间件的作用
中间件的作用就是使用函数封装公共操作,简化代码
中间件的类型
。全局中间件
。路由中间件
定义全局中间件
每一个请求到达服务端之后都会执行全局中间件
/**
* 记录每个请求的 url 与 IP 地址 服务器的访问日志
*/
//导入 express
const express = require('express');
const fs = require('fs');
const path = require('path');
//创建应用对象
const app = express();
//声明中间件函数
function recordMiddleware(req, res, next){
//获取 url 和 ip
let {url, ip} = req;
//将信息保存在文件中 access.log
fs.appendFileSync(path.resolve(__dirname, './access.log'), `${url} ${ip}\r\n`);
//调用 next
next();
}
//使用中间件函数
app.use(recordMiddleware);
//创建路由
app.get('/home', (req, res) => {
res.send('前台首页');
});
app.get('/admin', (req, res) => {
res.send('后台首页');
});
app.all('*',(req, res) => {
res.send('404 Not Found
')
})
//监听端口, 启动服务
app.listen(3000, () => {
console.log('服务已经启动, 端口 3000 正在监听中....')
})
/**
* 针对 /admin /setting 的请求, 要求 URL 携带 code=521 参数, 如未携带提示『暗号错误』
*/
//导入 express
const express = require('express');
//创建应用对象
const app = express();
//创建路由
app.get('/home', (req, res) => {
res.send('前台首页');
});
//声明中间件
let checkCodeMiddleware = (req, res, next) => {
//判断 URL 中是否 code 参数等于 521
if(req.query.code === '521'){
next();
}else{
res.send('暗号错误');
}
}
//后台
app.get('/admin', checkCodeMiddleware, (req, res) => {
res.send('后台首页');
});
//后台设置
app.get('/setting', checkCodeMiddleware, (req, res) => {
res.send('设置页面');
});
app.all('*',(req, res) => {
res.send('404 Not Found
')
})
//监听端口, 启动服务
app.listen(3000, () => {
console.log('服务已经启动, 端口 3000 正在监听中....')
})
//导入 express
const express = require('express');
//创建应用对象
const app = express();
//创建路由
app.get('/', (req, res) => {
res.send('我才是首页~~~');
});
//静态资源中间件设置
app.use(express.static(__dirname + '/public'));
//监听端口, 启动服务
app.listen(3000, () => {
console.log('服务已经启动, 端口 3000 正在监听中....')
})
/**
* 按照要求搭建 HTTP 服务
*
* GET /login 显示表单网页
* POST /login 获取表单中的『用户名』和『密码』
*/
//导入 express
const express = require('express');
const bodyParser = require('body-parser')
//创建应用对象
const app = express();
//解析 JSON 格式的请求体的中间件
// const jsonParser = bodyParser.json()
//解析 querystring 格式请求体的中间件 ?key1=value1&key2=value2 类似键值对
const urlencodedParser = bodyParser.urlencoded({ extended: false })
//创建路由规则 中间件函数执行完毕后就在req添加一个body属性
app.get('/login', (req, res) => {
// res.send('表单页面')
//响应 HTML 文件内容
res.sendFile(__dirname + '/11_form.html');
});
//post 规则
app.post('/login', urlencodedParser, (req, res) => {
//获取 用户名 和 密码
console.log(req.body);
res.send('获取用户的数据')
});
//启动服务
app.listen(3000, () => {
console.log('server is running...');
})
禁止该域名以外网站对网站资源的访问
利用referer请求头判定
//导入 express
const express = require('express');
//创建应用对象
const app = express();
//声明中间件
app.use((req, res, next) => {
//检测请求头中的 referer 是否为 127.0.0.1
//获取 referer
let referer = req.get('referer');
if(referer){
//实例化
let url = new URL(referer);
//获取 hostname
let hostname = url.hostname;
//判断
if(hostname !== '127.0.0.1'){
//响应 404
res.status(404).send('404 Not Found
');
return;
}
}
next();
});
//静态资源中间件设置
app.use(express.static(__dirname + '/public'));
//监听端口, 启动服务
app.listen(3000, () => {
console.log('服务已经启动, 端口 3000 正在监听中....')
})
/**
* 针对 /admin /setting 的请求, 要求 URL 携带 code=521 参数, 如未携带提示『暗号错误』
*/
//导入 express
const express = require('express');
const homeRouter = require('./routes/homeRouter');
const adminRouter = require('./routes/adminRouter');
//创建应用对象
const app = express();
//设置
app.use(homeRouter);
app.use(adminRouter);
app.all('*',(req, res) => {
res.send('404 Not Found
')
})
//监听端口, 启动服务
app.listen(3000, () => {
console.log('服务已经启动, 端口 3000 正在监听中....')
})
什么是模板引擎
模板引擎是分离用户界面和业务数据的一种技术
什么是EJS
EJS是一个高效的Javascript的模板引擎。
官网: https://ejs.co/
中文站: https://ejs.bootcss.com/
渲染列表
条件渲染
express-generator是Express框架的一个自动化项目生成器。它可以帮助开发者快速创建一个应用的骨架,包括自动创建项目文件夹、自动配置package.json文件等。
使用express-generator,你可以通过简单的命令行操作,快速生成一个基于Express框架的Web应用程序项目。具体使用方法如下:
安装Express
npm install express |
安装Express-generator:
npm install express-generator -g |
创建新的Express项目:
express project-name |
这将在当前文件夹下生成一个名为“project-name”的文件夹,其中包含了一个基本的Express应用程序项目结构和配置文件。
在生成的项目中,主要的文件和文件夹包括:
app.js
:应用程序的入口文件,其中包含了应用程序的主要逻辑和配置。package.json
:包含了应用程序的依赖项和配置信息,可以通过npm进行安装和更新。public
:存放应用程序的静态文件,如CSS、JavaScript、图片等。routes
:存放应用程序的路由监听代码相关文件。views
:存放应用程序的模板文件。bin
:其中包含了一个www
文件,这个文件通常包含一些全局配置项和命令行配置等。启动Express项目:
进入项目文件夹,然后执行以下命令启动服务器:
cd project-name && npm start |
以上就是使用express-generator创建Express项目的基本步骤。
文件上传
利用formidable 处理文件
案例实现 记账本
lowdb
LowDB 是一个小型、快速、轻量级的 JavaScript 数据库,它使用本地存储(localStorage 或 fileSystem)来存储数据,并提供类似 MongoDB 的 API 来访问和操作数据。LowDB 适用于浏览器和 Node.js 环境,可用于存储和管理小型应用程序的数据。
MongoDB是一个基于分布式文件存储的数据库,由C++语言编写。它旨在为WEB应用提供可扩展的高性能数据存储解决方案。MongoDB是一个介于关系数据库和非关系数据库之间的产品,是非关系数据库当中功能最丰富,最像关系数据库的。它支持的数据结构非常松散,是类似json的bson格式,因此可以存储比较复杂的数据类型。
MongoDB最大的特点是它支持的查询语言非常强大,其语法有点类似于面向对象的查询语言,几乎可以实现类似关系数据库单表查询的绝大部分功能,而且还支持对数据建立索引。
MongoDB可以在任何地方运行,无论是笔记本电脑,还是数据中心。
MongoDB是一个基于分布式文件存储的数据库,官方地址https://www.mongodb.com/
数据库是什么
数据库(DataBase)是按照数据结构来组织、存储和管理数据的应用程序
数据库的作用
数据库的主要作用就是管理数据,对数据进行增(c)、删(d)、改(u)、查(r)
数据库管理数据的特点
相比于纯文件管理数据,数据库管理数据有如下特点:
1.速度更快
2.扩展性更强
3.安全性更强
为什么选择Mongodb
操作语法与JavaScript类似,容易上手,学习成本低
MongoDB的安装配置教程(很详细,你想要的都在这里)_mongodb安装_狮子座的男孩的博客-CSDN博客
1. 显示所有的数据库
show dbs
2. 切换到指定的数据库,如果数据库不存在会自动创建数据库
use 数据库名
3. 显示当前所在的数据库
db
4. 删除当前数据库
use 库名
db.dropDatabase()
1. 创建集合
db.createCollection('集合名称')
2. 显示当前数据库中的所有集合
show collections
3.删除某个集合
db.集合名.drop()
4.重命名集合
db.集合名.renameCollection('newName')
1.插入文档
db.集合名.innsert(文档对象);
2.查询文档
db.集合名.find(查询条件)
_id 是 mongodb 自动生成的唯一编号,用来唯一标识文档
3. 更新文档
db.集合名.update(查询条件,新的文档)
db.集合名.update({name:'张三'},{$set:{age:19}})
4. 删除文档
db.集合名.remove(查询条件)
//1. 安装 mongoose
//2. 导入 mongoose
const mongoose = require('mongoose');
//设置 strictQuery 为 true
mongoose.set('strictQuery', true);
//3. 连接 mongodb 服务 数据库的名称
mongoose.connect('mongodb://127.0.0.1:27017/bilibili');
//4. 设置回调
// 设置连接成功的回调 once 一次 事件回调函数只执行一次
mongoose.connection.once('open', () => {
console.log('连接成功');
// app.listen(8080);
});
// 设置连接错误的回调
mongoose.connection.on('error', () => {
console.log('连接失败');
});
//设置连接关闭的回调
mongoose.connection.on('close', () => {
console.log('连接关闭');
});
//关闭 mongodb 的连接
// setTimeout(() => {
// mongoose.disconnect();
// }, 2000)
字段值验证
//1. 安装 mongoose
//2. 导入 mongoose
const mongoose = require('mongoose');
//设置 strictQuery 为 true
mongoose.set('strictQuery', true);
//3. 连接 mongodb 服务 数据库的名称
mongoose.connect('mongodb://127.0.0.1:27017/bilibili');
//4. 设置回调
// 设置连接成功的回调 once 一次 事件回调函数只执行一次
mongoose.connection.once('open', () => {
//5. 创建文档的结构对象
//设置集合中文档的属性以及属性值的类型
let BookSchema = new mongoose.Schema({
name: {
type: String,
required: true, // 表明该属性必须不为空
unique: true// 设置为独一无二的
},
author: {
type: String,
default: '匿名'
},
//类型
style: {
type: String,
//枚举
enum: ['言情','城市','志怪','恐怖']
},
price: Number
});
//6. 创建模型对象 对文档操作的封装对象
let BookModel = mongoose.model('books', BookSchema);
//7. 新增
BookModel.create({
name: '西游记',
// author: '吴承恩',
price: 19.9,
style: '志怪'
}, (err, data) => {
//判断是否有错误
if(err) {
console.log(err);
// console.log('插入失败~~~');
return;
}
//如果没有出错, 则输出插入后的文档对象
console.log(data);
//8. 关闭数据库连接 (项目运行过程中, 不会添加该代码)
mongoose.disconnect();
});
});
// 设置连接错误的回调
mongoose.connection.on('error', () => {
console.log('连接失败');
});
//设置连接关闭的回调
mongoose.connection.on('close', () => {
console.log('连接关闭');
});
//1. 安装 mongoose
//2. 导入 mongoose
const mongoose = require('mongoose');
//设置 strictQuery 为 true
mongoose.set('strictQuery', true);
//3. 连接 mongodb 服务 数据库的名称
mongoose.connect('mongodb://127.0.0.1:27017/bilibili');
//4. 设置回调
// 设置连接成功的回调 once 一次 事件回调函数只执行一次
mongoose.connection.once('open', () => {
//5. 创建文档的结构对象
//设置集合中文档的属性以及属性值的类型
let BookSchema = new mongoose.Schema({
name: String,
author: String,
price: Number,
is_hot: Boolean
});
//6. 创建模型对象 对文档操作的封装对象 mongoose 会使用集合名称的复数, 创建集合
let BookModel = mongoose.model('novel', BookSchema);
//7. 删除一条
// BookModel.deleteOne({ _id: '63f34af50cf203761ede1892' }, (err, data) => {
// //判断
// if (err) {
// console.log('删除失败~~~');
// return;
// }
// //输出 data
// console.log(data);
// });
//批量删除
BookModel.deleteMany({ is_hot: false }, (err, data) => {
//判断
if (err) {
console.log('删除失败~~~');
return;
}
//输出 data
console.log(data);
});
});
// 设置连接错误的回调
mongoose.connection.on('error', () => {
console.log('连接失败');
});
//设置连接关闭的回调
mongoose.connection.on('close', () => {
console.log('连接关闭');
});
//1. 安装 mongoose
//2. 导入 mongoose
const mongoose = require('mongoose');
//设置 strictQuery 为 true
mongoose.set('strictQuery', true);
//3. 连接 mongodb 服务 数据库的名称
mongoose.connect('mongodb://127.0.0.1:27017/bilibili');
//4. 设置回调
// 设置连接成功的回调 once 一次 事件回调函数只执行一次
mongoose.connection.once('open', () => {
//5. 创建文档的结构对象
//设置集合中文档的属性以及属性值的类型
let BookSchema = new mongoose.Schema({
name: String,
author: String,
price: Number,
is_hot: Boolean
});
//6. 创建模型对象 对文档操作的封装对象 mongoose 会使用集合名称的复数, 创建集合
let BookModel = mongoose.model('novel', BookSchema);
//7. 更新文档 更新一条
// BookModel.updateOne({name: '红楼梦'}, {price: 9.9}, (err, data) => {
// //判断 err
// if(err){
// console.log('更新失败~~');
// return;
// }
// //输出 data
// console.log(data);
// });
//批量更新
BookModel.updateMany({author: '余华'}, {is_hot: true}, (err, data) => {
//判断 err
if(err){
console.log('更新失败~~');
return;
}
//输出 data
console.log(data);
});
});
// 设置连接错误的回调
mongoose.connection.on('error', () => {
console.log('连接失败');
});
//设置连接关闭的回调
mongoose.connection.on('close', () => {
console.log('连接关闭');
});
//1. 安装 mongoose
//2. 导入 mongoose
const mongoose = require('mongoose');
//设置 strictQuery 为 true
mongoose.set('strictQuery', true);
//3. 连接 mongodb 服务 数据库的名称
mongoose.connect('mongodb://127.0.0.1:27017/bilibili');
//4. 设置回调
// 设置连接成功的回调 once 一次 事件回调函数只执行一次
mongoose.connection.once('open', () => {
//5. 创建文档的结构对象
//设置集合中文档的属性以及属性值的类型
let BookSchema = new mongoose.Schema({
name: String,
author: String,
price: Number,
is_hot: Boolean
});
//6. 创建模型对象 对文档操作的封装对象 mongoose 会使用集合名称的复数, 创建集合
let BookModel = mongoose.model('novel', BookSchema);
//7. 读取单条
// BookModel.findOne({name: '狂飙'}, (err, data) => {
// if(err){
// console.log('读取失败~~~');
// return;
// }
// //输出 data 变量的值
// console.log(data);
// })
//根据 ID 获取文档
// BookModel.findById('63f34af50cf203761ede1896', (err, data) => {
// if (err) {
// console.log('读取失败~~~');
// return;
// }
// //输出 data 变量的值
// console.log(data);
// })
//批量获取
// BookModel.find({ author: '余华' }, (err, data) => {
// if (err) {
// console.log('读取失败~~~');
// return;
// }
// //输出 data 变量的值
// console.log(data);
// });
//读取所有
BookModel.find((err, data) => {
if (err) {
console.log('读取失败~~~');
return;
}
//输出 data 变量的值
console.log(data);
})
});
// 设置连接错误的回调
mongoose.connection.on('error', () => {
console.log('连接失败');
});
//设置连接关闭的回调
mongoose.connection.on('close', () => {
console.log('连接关闭');
});
//4. 设置回调
// 设置连接成功的回调 once 一次 事件回调函数只执行一次
mongoose.connection.once('open', () => {
//5. 创建文档的结构对象
//设置集合中文档的属性以及属性值的类型
let BookSchema = new mongoose.Schema({
name: String,
author: String,
price: Number,
is_hot: Boolean
});
//6. 创建模型对象 对文档操作的封装对象 mongoose 会使用集合名称的复数, 创建集合
let BookModel = mongoose.model('novel', BookSchema);
//价格小于 20 的图书
// BookModel.find({price: {$lt: 20}}, (err, data) => {
// if(err) {
// console.log('读取失败~~');
// return;
// }
// console.log(data);
// })
//曹雪芹 或者 余华的书
// BookModel.find({$or: [{author: '曹雪芹'}, {author: '余华'}]}, (err, data) => {
// if (err) {
// console.log('读取失败~~');
// return;
// }
// console.log(data);
// })
//价格大于 30 且小于 70
// BookModel.find({$and: [{price: {$gt: 30}}, {price: {$lt: 70}}]}, (err, data) => {
// if (err) {
// console.log('读取失败~~');
// return;
// }
// console.log(data);
// })
//正则表达式, 搜索书籍名称中带有 `三` 的图书
// BookModel.find({name: /三/}, (err, data) => {
// if (err) {
// console.log('读取失败~~');
// return;
// }
// console.log(data);
// })
// 也是正则
BookModel.find({ name: new RegExp('三') }, (err, data) => {
if (err) {
console.log('读取失败~~');
return;
}
console.log(data);
})
});
//1. 安装 mongoose
//2. 导入 mongoose
const mongoose = require('mongoose');
//设置 strictQuery 为 true
mongoose.set('strictQuery', true);
//3. 连接 mongodb 服务 数据库的名称
mongoose.connect('mongodb://127.0.0.1:27017/bilibili');
//4. 设置回调
// 设置连接成功的回调 once 一次 事件回调函数只执行一次
mongoose.connection.once('open', () => {
//5. 创建文档的结构对象
//设置集合中文档的属性以及属性值的类型
let BookSchema = new mongoose.Schema({
name: String,
author: String,
price: Number,
is_hot: Boolean
});
//6. 创建模型对象 对文档操作的封装对象 mongoose 会使用集合名称的复数, 创建集合
let BookModel = mongoose.model('novel', BookSchema);
//7. 设置字段
// BookModel.find().select({name: 1, author: 1, _id: 0}).exec((err, data) => {
// if(err) {
// console.log('查询失败~~');
// return;
// }
// console.log(data);//返回值属性只有name author
// })
//数据排序 不需要id
// BookModel.find().select({name: 1, price: 1, _id: 0}).sort({price: -1}).exec((err, data) => {
// if(err) {
// console.log('查询失败~~');
// return;
// }
// console.log(data);
// })
//数据的截取
BookModel.find()
.select({name: 1, price: 1, _id: 0})
.sort({price: -1})
.skip(3)
.limit(3)
.exec((err, data) => {
if(err) {
console.log('查询失败~~');
return;
}
console.log(data);
})
});
// 设置连接错误的回调
mongoose.connection.on('error', () => {
console.log('连接失败');
});
//设置连接关闭的回调
mongoose.connection.on('close', () => {
console.log('连接关闭');
});
index.js
//导入 db 文件
const db = require('./db/db');
//导入 mongoose
const mongoose = require('mongoose');
//导入 BookModel
const BookModel = require('./models/BookModel');
// 调用函数
db(() => {
//7. 新增
BookModel.create({
name: '西游记',
author: '吴承恩',
price: 19.9
}, (err, data) => {
//判断是否有错误
if(err) {
console.log(err);
return;
}
//如果没有出错, 则输出插入后的文档对象
console.log(data);
//8. 关闭数据库连接 (项目运行过程中, 不会添加该代码)
mongoose.disconnect();
});
}, () => {
console.log('连接失败...');
});
db.js
/**
*
* @param {*} success 数据库连接成功的回调
* @param {*} error 数据库连接失败的回调
*/
module.exports = function (success, error) {
//判断 error 为其设置默认值
if(typeof error !== 'function'){
error = () => {
console.log('连接失败~~~');
}
}
//1. 安装 mongoose
//2. 导入 mongoose
const mongoose = require('mongoose');
//导入 配置文件
const {DBHOST, DBPORT, DBNAME} = require('../config/config.js');
//设置 strictQuery 为 true
mongoose.set('strictQuery', true);
//3. 连接 mongodb 服务 数据库的名称
mongoose.connect(`mongodb://${DBHOST}:${DBPORT}/${DBNAME}`);
//4. 设置回调
// 设置连接成功的回调 once 一次 事件回调函数只执行一次
mongoose.connection.once('open', () => {
success();
});
// 设置连接错误的回调
mongoose.connection.on('error', () => {
error();
});
//设置连接关闭的回调
mongoose.connection.on('close', () => {
console.log('连接关闭');
});
}
config.js
//配置文件
module.exports = {
DBHOST: '127.0.0.1',
DBPORT: 27017,
DBNAME: 'bilibili'
}
BookModel.js
//导入 mongoose
const mongoose = require('mongoose');
//创建文档的结构对象
//设置集合中文档的属性以及属性值的类型
let BookSchema = new mongoose.Schema({
name: String,
author: String,
price: Number
});
//创建模型对象 对文档操作的封装对象
let BookModel = mongoose.model('books', BookSchema);
//暴露模型对象
module.exports = BookModel;
MovieModel.js
//导入 mongoose
const mongoose = require('mongoose');
// 创建文档结构
const MovieSchema = new mongoose.Schema({
title: String,
director: String
});
//创建模型对象
const MovieModel = mongoose.model('movie', MovieSchema);
//暴露
module.exports = MovieModel;
所谓会话控制就是对会话进行控制
HTTP是一种无状态的协议,它没有办法区分多次的请求是否来自于同一个客户端,无法区分用户而产品中又大量存在的这样的需求,所以我们需要通过会话控制来解决该问题
常见的会话控制技术有三种:
流程
//导入 express
const express = require('express');
const cookieParser = require('cookie-parser')
//创建应用对象
const app = express();
app.use(cookieParser());
//创建路由规则
app.get('/set-cookie', (req, res) => {
// res.cookie('name', 'zhangsan'); // 会在浏览器关闭的时候, 销毁
res.cookie('name','lisi', {maxAge: 60 * 1000}) // max 最大 age 年龄 也就是生命周期
res.cookie('theme', 'blue');
res.send('home');
});
//删除 cookie
app.get('/remove-cookie', (req, res) => {
//调用方法
res.clearCookie('name');
res.send('删除成功~~');
});
//获取 cookie
app.get('/get-cookie', (req, res) => {
//获取 cookie
console.log(req.cookies);
res.send(`欢迎您 ${req.cookies.name}`);
})
//启动服务
app.listen(3000);
//导入 express
const express = require('express');
//2. 引入 express-session connect-mongo
const session = require("express-session");
const MongoStore = require('connect-mongo');
//创建应用对象
const app = express();
//3. 设置 session 的中间件
app.use(session({
name: 'sid', //设置cookie的name,默认值是:connect.sid
secret: 'atguigu', //参与加密的字符串(又称签名) 加盐
saveUninitialized: false, //是否为每次请求都设置一个cookie用来存储session的id
resave: true, //是否在每次请求时重新保存session 20 分钟 4:00 4:20
store: MongoStore.create({
mongoUrl: 'mongodb://127.0.0.1:27017/bilibili' //数据库的连接配置
}),
cookie: {
httpOnly: true, // 开启后前端无法通过 JS 操作
maxAge: 1000 * 60 * 5 // 这一条 是控制 sessionID 的过期时间的!!!
},
}))
//首页路由
app.get('/', (req, res) => {
res.send('home')
})
//登录 session 的设置 登录后 session-id已存道数据库
app.get('/login', (req, res) => {
// username=admin&password=admin
if(req.query.username === 'admin' && req.query.password === 'admin'){
//设置 session 信息
req.session.username = 'admin';
req.session.uid = '258aefccc';
//成功响应
res.send('登录成功');
}else{
res.send('登录失败~~');
}
})
//session 的读取
app.get('/cart', (req, res) => {
//检测 session 是否存在用户数据
if(req.session.username){
res.send(`购物车页面, 欢迎您 ${req.session.username}`)
}else{
res.send('您还没有登录~~');
}
});
//session 的销毁
app.get('/logout', (req, res) => {
req.session.destroy(() => {
res.send('退出成功~~');
})
})
//启动服务
app.listen(3000);
//导入 jsonwebtokan
const jwt = require('jsonwebtoken');
//创建 token
// jwt.sign(数据, 加密字符串, 配置对象)
let token = jwt.sign({
username: 'zhangsan'
}, 'atguigu', {
expiresIn: 60 //单位是 秒
})
//解析 token
jwt.verify(token, 'atguigu', (err, data) => {
if(err){
console.log('校验失败~~');
return
}
console.log(data);
})