node.js学习模块化 express框架 mongodb 接口会话控制

最新推荐文章于 2024-02-01 16:37:57 发布

shyhsgs

最新推荐文章于 2024-02-01 16:37:57 发布

阅读量94

点赞数

分类专栏： node.js 文章标签： node.js 学习

本文链接：https://blog.csdn.net/qq_64655972/article/details/132778860

版权

node.js 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

模块化

模块化认识

//注意:在使用require加载用户自定义模块期间,可以省略.js 的后缀名

Node.js中的模块作用域

防止了全局变量污染的问题

向外共享模块作用域中的成员

他们俩个===比较为true 但

所以建议不要在一个模块内同时使用exports 和module.exports

规范

npm与包

Node.js 中的第三方模块又叫做包。
就像电脑和计算机指的是相同的东西，第三方模块和包指的是同一个概念，只不过叫法不同。

不同于Node.js 中的内置模块与自定义模块，包是由第三方个人或团队开发出来的，免费供所有人使用。注意:Node.js 中的包都是免费且开源的，不需要付费即可免费下载使用。

由于Node.js的内置模块仅提供了一些底层的API，导致在基于内置模块进行项目开发的时，效率很低.包是基于内置模块封装出来的，提供了更高级、更方便的API，极大的提高了开发效率。
包和内置模块之间的关系，类似于jQuery和浏览器内置API之间的关系。

在powershell终端无法顺利使用这个脚本，将终端类型改为第三个 cmd即可

配置命令别名

初体验

包管理配置文件

解决下载速度

非必需

包的分类

nvm 的使用

nvm 全称 Node Version Manager 顾名思义它是用来管理 node 版本的工具，方便切换不同版本的

Node.js

首先先下载 nvm ，下载地址 https://github.com/coreybutler/nvm-windows/releases ，

选择 nvm - setup.exe 下载即可

express框架

使用

//导入 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()
});

express 中间件

什么是中间件
中间件(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('<h1>404 Not Found</h1>')
})

//监听端口, 启动服务
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('<h1>404 Not Found</h1>')
})

//监听端口, 启动服务
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('<h1>404 Not Found</h1>');
      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('<h1>404 Not Found</h1>')
})

//监听端口, 启动服务
app.listen(3000, () => {
  console.log('服务已经启动, 端口 3000 正在监听中....')
})

模板引擎 ejs

什么是模板引擎
模板引擎是分离用户界面和业务数据的一种技术

什么是EJS
EJS是一个高效的Javascript的模板引擎。

官网: https://ejs.co/
中文站: https://ejs.bootcss.com/

渲染列表

条件渲染

express 中的使用

express-generator 的使用

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

MongoDB是一个基于分布式文件存储的数据库，由C++语言编写。它旨在为WEB应用提供可扩展的高性能数据存储解决方案。MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。它支持的数据结构非常松散，是类似json的bson格式，因此可以存储比较复杂的数据类型。

MongoDB最大的特点是它支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。

MongoDB可以在任何地方运行，无论是笔记本电脑，还是数据中心。

MongoDB是一个基于分布式文件存储的数据库，官方地址https://www.mongodb.com/

数据库是什么
数据库(DataBase）是按照数据结构来组织、存储和管理数据的应用程序

数据库的作用
数据库的主要作用就是管理数据，对数据进行增(c）、删（d)、改（u)、查（r)

数据库管理数据的特点
相比于纯文件管理数据，数据库管理数据有如下特点:
1．速度更快
2．扩展性更强
3．安全性更强
为什么选择Mongodb
操作语法与JavaScript类似，容易上手，学习成本低

概念

数据库（ database ）数据库是一个数据仓库，数据库服务下可以创建很多数据库，数据库中可以存

放很多集合

集合（ collection ）集合类似于 JS 中的数组，在集合中可以存放很多文档

文档（ document ）文档是数据库中的最小单位，类似于 JS 中的对象

大家可以通过 JSON 文件来理解 Mongodb 中的概念

一个 JSON 文件好比是一个数据库，一个 Mongodb 服务下可以有 N 个数据库

JSON 文件中的一级属性的数组值好比是集合

数组中的对象好比是文档

对象中的属性有时也称之为字段

一般情况下

一个项目使用一个数据库

一个集合会存储同一种类型的数据

下载与安装使用

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(查询条件)

连接使用

Mongoose 是一个对象文档模型库，方便使用代码操作 mongodb 数据库

//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;

接口

接口是前后端通信的桥梁

简单理解：一个接口就是服务中的一个路由规则，根据请求响应结果

接口的英文单词是 API (Application Program Interface) ，所以有时也称之为 API 接口

这里的接口指的是『数据接口』，与编程语言（ Java ， Go 等）中的接口语法不同

接口的作用

实现前后端通信

接口的开发与调用

大多数接口都是由后端工程师开发的，开发语言不限

一般情况下接口都是由前端工程师调用的，但有时后端工程师也会调用接口，比如短信接口，支付接口等

接口分享网站 https://www.free-api.com/doc/325

RESTful API

RESTful API 是一种特殊风格的接口，主要特点有如下几个：

URL 中的路径表示资源，路径中不能有动词，例如 create , delete , update 等这些都不能有

操作资源要与 HTTP 请求方法对应

操作结果要与 HTTP 响应状态码对应

规则示例

json-server

json-server 本身是一个 JS 编写的工具包，可以快速搭建 RESTful API 服务

官方地址 : https://github.com/typicode/json-server

操作步骤：

会话控制

所谓会话控制就是对会话进行控制
HTTP是一种无状态的协议，它没有办法区分多次的请求是否来自于同一个客户端，无法区分用户而产品中又大量存在的这样的需求，所以我们需要通过会话控制来解决该问题
常见的会话控制技术有三种:

cookie
sessiono
token

cokie

cookie 是 HTTP 服务器发送到用户浏览器并保存在本地的一小块数据

cookie 是保存在浏览器端的一小块数据

cookie 是按照域名划分保存的

特点

浏览器向服务器发送请求时，会自动将当前域名下可用的 cookie 设置在请求头中，然后传递给服务器

这个请求头的名字也叫 cookie ，所以将 cookie 理解为一个 HTTP 的请求头也是可以的

流程

不同浏览器中的 cookie 是相互独立的，不共享

express 中可以使用 cookie - parser 进行cookie的处理

//导入 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);

session

session 是保存在服务器端的一块儿数据，保存当前访问用户的相关信息

作用

实现会话控制，可以识别用户的身份，快速获取当前用户的相关信息

运行流程

填写账号和密码校验身份，校验通过后创建 session 信息，然后将 session_id 的值通过响应头返回给浏览器

session 的代码操作

express 中可以使用 express - session 对 session 进行操作

//导入 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);

session与cookie区别

token

token 是服务端生成并返回给 HTTP 客户端的一串加密字符串， token 中保存着用户信息

token 的作用

实现会话控制，可以识别用户的身份，主要用于移动端 APP

token 的工作流程

5.4 token 的特点

服务端压力更小

数据存储在客户端

相对更安全

数据加密

可以避免 CSRF （跨站请求伪造）

扩展性更强

服务间可以共享

增加服务节点更简单

JWT

JWT （ JSON Web Token ）是目前最流行的跨域认证解决方案，可用于基于 token 的身份验证

JWT 使 token 的生成与校验更规范

我们可以使用 jsonwebtoken 包来操作 token

//导入 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);
})