Node进阶第五天
为什么mysql不用开mongod –dbpath xx…
答:因为mysql会在”服务”中运行，也就是开机时自动启动并且长久驻扎在内存中了。
mongodb其实也能通过设置来设成windows中的服务。
案例:
01每次GET /的时候插入一条数据。
(具体api可以查看mongodb的文档)
const MongoClient = require('mongodb').MongoClient;
var express = require('express');
var app = express();
app.listen(3000);
app.get("/", (req, res) => {
const url = 'mongodb://localhost:27017/';
const dbName = 'myproject';
MongoClient.connect(url,{useNewUrlParser:true}, function (err, client) {
//回调函数表示连接成功做的事情
if(err){
console.log("数据库连接失败");
return;
}
console.log("数据库连接成功");
const db = client.db(dbName);
//插入数据，集合如果不存在，也没有关系，程序会帮你创建
db.collection('student').insertOne({
"name":"哈哈",
"age": parseInt(Math.random() *100 + 10)
},function(err,result){
if(err){
console.log(err);
return;
}
//插入之后做的事情，result表示插入结果。
console.log(result);
res.send(result);
client.close();
});
});
});
02把常用的增删改查，都封装成为module
DAO data access object 数据访问对象
是一个数据访问接口。
使用我们自己写的模块来完成数据库的操作。
一、 数据库
想想我们的百度百家Ajax案例，当时调用了百度的JSON，有一个参数叫做page=3,生成的JSON，
这个就是分页，就是我们像寻找所有的新闻，但是是位于第三页的新闻。那么有两种做法:
1) 错误的做法:就是将所有的result都读取到数组，然后进行数据操作，进行分页；
2) 正确的做法:就是在数据库中，只读取这么多内容。
错误的，我们试图每次都读取全部数据，但是这样开销很大
db.find(“student”,{},function(err,result){
for(var i = 10*page;i<10*(page+1);i++)
{
a.push(result[i]);
}
res.send(a);
});
所以，mongodb提供了傻傻的两个函数，极傻无比。
limit()、skip()
db.student.find().limit(4).skip(4);
limit表示读取的条数，skip表示略过的条数，limit和skip配合使用就是分页查询。
加入，第一页是page=0。每页10条，所以当前页的查询语句
db.student.find({}).limit(10).skip(page*10)
能分页的个数
db.student.stats().count;
案例源代码:
db.js:
//这个模块封装了所有对数据库的常用操作。
const MongoClient = require('mongodb').MongoClient;
const settings = require('../settings');
//不管数据库什么操作，都是先连接数据库，所以我们可以把连接数据库
//封装成内部函数
function __connectDB(callback) {
var url = settings.dburl; //从settings文件中读数据库地址
MongoClient.connect(url, function (err, client) {
const db = client.db('huha');
//这里是新增加的
if (err) {
callback(err, db);
return;
}
callback(err, db, client);
});
};
//插入数据
exports.insertOne = function (collectionName, json, callback) {
__connectDB(function (err, db, client) {
if (err) {
callback(err, null);
return;
}
db.collection(collectionName).insertOne(json, function (err, result) {
callback(err, result);
client.close();//关闭数据库
});
})
};
//查找数据,找到所有数据
exports.find = function (collectionName, json, C, D) {
var result = [];//结果数组
if (arguments.length == 3) {
console.log("有三个参数");
//那么参数C就是callback，参数D没有传。
var callback = C;
var skipnumber = 0;
//数目限制
var limit = 0;
} else if (arguments.length == 4) {
console.log("有四个参数");
var callback = D;
var args = C;
//应该省略的条数
var skipnumber = args.pageamount * args.page;
//数目限制
var limit = args.pageamount;
} else {
throw new Error("find函数的参数个数，必须是3个，或者4个");
}
//连接数据库，连接之后查找所有
__connectDB(function (err, db, client) {
var cursor = db.collection(collectionName).find(json).skip(skipnumber).limit(limit);
cursor.each(function (err, doc) {
if (err) {
callback(err, null);
return;
}
if (doc != null) {
result.push(doc); //放入结果数组
} else {
//遍历结束，没有更多的文档了
callback(null, result);
}
});
client.close();
});
}
//删除
exports.deleteMany = function (collectionName, json, callback) {
__connectDB(function (err, db, client) {
if (err) {
callback(err, null);
return;
}
//删除
db.collection(collectionName).deleteMany(
json,
function (err, results) {
console.log(results);
client.close();
callback();
}
);
});
}
//修改
exports.updateMany = function (collectionName, json1, json2, callback) {
__connectDB(function (err, db, client) {
db.collection(collectionName).updateMany(
json1,
json2,
function (err, results) {
callback(err, results);
});
});
}
settings.js:
module.exports = {
"dburl": 'mongodb://localhost:27017'
}
02.js:
var express = require('express');
var app = express();
var db = require('./model/db.js')
//增加
app.get('/', function (req, res) {
db.insertOne("student", { "name": "小红", "age": 18 }, function (err, result) {
if (err) {
console.log("插入失败");
return;
}
res.send("插入成功");
});
});
//查询
app.get('/du', function (req, res) {
//这个页面现在接收一个page参数,
var page = parseInt(req.query.page); //express中读取get参数很简单
//查找4个参数，在哪个集合查，查什么，分页设置，查完之后做什么
db.find("student", {}, function (err, result) {
if (err) {
console.log(err);
}
res.send(result);
});
});
//删除
app.get('/shan', function (req, res) {
var name = parseInt(req.query.name);
db.deleteMany("teacher", { "name": "小红" }, function (err, result) {
res.send(result);
});
});
//修改
app.get("/xiugai", function (req, res) {
db.updateMany("student", { "name": "小红" }, { $set: { "name": "呼哈" } }, function (err, result) {
if (err) {
console.log(err);
}
res.send(result);
});
});
app.listen(3000);
项目—小小留言本
做一个留言本，能够增删改:
ejs页面中，如果我们想使用underscore的模板，就会有模板冲突的问题。
underscore用的:
<script type="text/template" id="moban">
<div class="list-group">
<a href="#" class="list-group-item active">
<h4 class="list-group-item-heading"><%=xingming%>></h4>
<p class="list-group-item-text"><%=liuyan%></p>
</a>
</div>
</script>
ejs以为是自己的模板。所以报错，提示你没有传递姓名参数。
解决方法就是underscore源码。在源码中搜索<% 修改为{{即可。
项目整体目录结构：
03.js:
var express = require('express');
var app = express();
var db = require('./model/db.js');
var formidable = require('formidable');
var ObjectId = require('mongodb').ObjectId;
//设置模板引擎
app.set("view engine", "ejs");
//静态服务
app.use(express.static("./public"));
//显示留言列表
app.get("/", function (req, res, next) {
db.getAllCount("liuyanben", function (count) {
res.render('index', {
"pageamount": Math.ceil(count / 4)
});
});
});
//读取所有留言，这个页面是供ajax使用的
app.get("/du", function (req, res, next) {
//可以接受一个参数
var page = parseInt(req.query.page) || "0";
db.find("liuyanben", {}, { "sort": { "shijian": -1 }, "pageamount": 4, "page": page }, function (err, result) {
res.json({ "result": result });
});
});
//处理留言
app.post("/tijiao", function (req, res, next) {
console.log("对这里请求了");
var form = new formidable.IncomingForm();
form.parse(req, function (err, fields) {
//写入数据库
db.insertOne("liuyanben", {
"xingming": fields.xingming,
"liuyan": fields.liuyan,
"shijian": new Date()
}, function (err, result) {
if (err) {
res.send({ "result": -1 }); //-1是给ajax看的
return;
}
res.send({ "result": 1 });
});
console.log("收到请求了" + fields.xingming + fields.liuyan);
});
});
//得到总数量
app.get("/count", function (req, res) {
});
//删除
app.get('/shanchu', function (req, res, next) {
//得到参数
var id = req.query.id;
db.deleteMany("liuyanben", { "_id": ObjectId(id) }, function (err, result) {
res.redirect("/");
});
});
app.listen(3000);
settings.js:
module.exports = {
"dburl": 'mongodb://localhost:27017'
}
index.ejs:
<!doctype html>
<html lang="en">
<head>
<!-- Required meta tags -->
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
<!-- Bootstrap CSS -->
<link rel="stylesheet" href="css/bootstrap.min.css">
<style>
.row h4 {
text-align: center;
}
#chenggong,
#shibai {
display: none;
}
.liuyankuai {
padding: 10px 0;
border-bottom: 1px solid #ccc;
}
</style>
<title>Hello, world!</title>
</head>
<body>
<h1>我的留言本</h1>
<div class="container">
<div class="row">
<form class="form-horizontal col-lg-6">
<div class="form-group">
<label for="xingming" class="col-sm-2 control-label">姓名</label>
<div class="col-sm-10">
<input type="text" class="form-control" id="xingming" placeholder="姓名">
</div>
</div>
<div class="form-group">
<label for="inputPassword3" class="col-sm-2 control-label">留言</label>
<div class="col-sm-10">
<textarea style="resize:none;" name="liuyan" id="liuyan" class="form-control" rows="3"></textarea>
</div>
</div>
<div class="form-group">
<div class="col-sm-offset-2 col-sm-10">
<button type="button" id="tijiao" class="btn btn-success">提交</button>
</div>
</div>
<div id="chenggong" class="alert alert-success" role="alert">
<a href="#" class="alert-link">表单已经成功提交</a>
</div>
<div class="alert alert-danger" id="shibai" role="alert">
<a href="#" class="alert-link">表单提交失败</a>
</div>
</form>
</div>
<nav aria-label="Page navigation">
<ul class="pagination">
<% for(var i =1;i<=pageamount; i++){ %>
<li data-page="<%=i%>" class="yemaanniu">
<a href="#">
<%=i%>
</a>
</li>
<% } %>
</ul>
</nav>
<div id="quanbuliuyan">
</div>
</div>
<script type="text/template" id="moban">
<div class="liuyankuai">
<p>[_id]{{=id}}</p>
<p>[姓名]{{=xingming}}</p>
<p>[留言]{{=liuyan}}</p>
<p>[时间]{{=shijian}}</p>
<p><a href="/shanchu?id={{=id}}" class="shanchu" >删除</a></p>
</div>
</script>
<script src="js/underscore.js"></script>
<script src="js/jquery.min.js"></script>
<script>
var nowpage = 1;
//删除
//给第一个页面,补一个active
$(".pagination").find("li").eq(0).addClass("active");
//给所有的页码按钮,添加监听
$(".yemaanniu").click(function () {
nowpage = parseInt($(this).attr("data-page"));
//重新发起请求即可
getData(nowpage);
$(this).addClass("active").siblings().removeClass("active");
});
$("#nextbtn").click(function () {
nowpage++;
if (nowpage)
getData(nowpage);
});
//默认请求第一页数据
getData(1);
//Ajax请求数据
function getData(page) {
$.get("/du?page=" + (page - 1), function (result) {
//这里接收时result，但是这个json里面有一个key叫做result。
//得到模板，弄成模板函数
var compiled = _.template($("#moban").html());
//清空全部留言中的所有节点
$("#quanbuliuyan").html("");
for (var i = 0; i < result.result.length; i++) {
//数据绑定
var html = compiled({
liuyan: result.result[i].liuyan,
xingming: result.result[i].xingming,
shijian: result.result[i].shijian,
id: result.result[i]._id,
});
//DOM操作，添加节点
$("#quanbuliuyan").append($(html));
}
});
}
//Ajax提交表单
$("#tijiao").click(function () {
$("#shibai").hide();
$("#chenggong").hide();
//Ajax提交表单
$.post("/tijiao", {
"xingming": $("#xingming").val(),
"liuyan": $("#liuyan").val()
}, function (result) {
if (result.result == -1) {
$("#shibai").fadeIn();
} else if (result.result == 1) {
//提交成功
$("#chenggong").fadeIn();
//数据库真的存储了，但是当前页面无法显示，这是因为需要刷新
//才能用ajax从/du中得到新的。所以我们先用一个假盒子凑出来
var compiled = _.template($("#moban").html());
var html = compiled(
{
liuyan: $("#liuyan").val(),
xingming: $("#xingming").val(),
shijian: new Date()
}
);
console.log($("#quanbuliuyan"));
$(html).insertBefore($("#quanbuliuyan"));
}
});
});
</script>
</body>
</html>
db.js:
//这个模块封装了所有对数据库的常用操作。
const MongoClient = require('mongodb').MongoClient;
const settings = require('../settings');
//不管数据库什么操作，都是先连接数据库，所以我们可以把连接数据库
//封装成内部函数
function __connectDB(callback) {
var url = settings.dburl; //从settings文件中读数据库地址
MongoClient.connect(url, function (err, client) {
const db = client.db('huha');
//这里是新增加的
if (err) {
callback(err, db);
return;
}
callback(err, db, client);
});
};
//插入数据
exports.insertOne = function (collectionName, json, callback) {
__connectDB(function (err, db, client) {
if (err) {
callback(err, null);
return;
}
db.collection(collectionName).insertOne(json, function (err, result) {
callback(err, result);
client.close();//关闭数据库
});
})
};
//查找数据,找到所有数据
exports.find = function (collectionName, json, C, D) {
var result = [];//结果数组
if (arguments.length == 3) {
// console.log("有三个参数");
//那么参数C就是callback，参数D没有传。
var callback = C;
var skipnumber = 0;
//数目限制
var limit = 0;
} else if (arguments.length == 4) {
// console.log("有四个参数");
var callback = D;
var args = C;
//应该省略的条数
var skipnumber = args.pageamount * args.page || 0;
//数目限制
var limit = args.pageamount || 0;
//排序方式
var sort = args.sort || {};
} else {
throw new Error("find函数的参数个数，必须是3个，或者4个");
}
//连接数据库，连接之后查找所有
__connectDB(function (err, db, client) {
var cursor = db.collection(collectionName).find(json).skip(skipnumber).limit(limit).sort(sort);
cursor.each(function (err, doc) {
if (err) {
callback(err, null);
return;
}
if (doc != null) {
result.push(doc); //放入结果数组
} else {
//遍历结束，没有更多的文档了
callback(null, result);
}
});
client.close();
});
}
//删除
exports.deleteMany = function (collectionName, json, callback) {
__connectDB(function (err, db, client) {
if (err) {
callback(err, null);
return;
}
//删除
db.collection(collectionName).deleteMany(
json,
function (err, results) {
console.log(results);
callback(null,results);
client.close();
}
);
});
}
//修改
exports.updateMany = function (collectionName, json1, json2, callback) {
__connectDB(function (err, db, client) {
db.collection(collectionName).updateMany(
json1,
json2,
function (err, results) {
callback(err, results);
//这里可能会有错误
client.close();
});
});
}
//得到文件总数
exports.getAllCount = function (collectionName, callback) {
__connectDB(function (err, db, client) {
var a = db.collection(collectionName).count({}).then(function (count) {
// console.log(count);
callback(count);
client.close();
});
});
}
二、Cookie和Session
HTTP是无状态协议。简单地说，当你浏览了一个页面，然后转到同一个网站的另一个页面，服务器无法认识到，这是同一个浏览器在访问同一个页面。每一次的访问，都是没有关系的。
那么世界就乱套了，比如说我上一次访问，登陆了，下一次访问，又让我登录，不存在登录着事儿了。
第一次访问一个服务器，不可能携带cookie。必须是服务器得到这次请求，在下行的响应报头中携带cookie信息，此后每一次浏览器往这个服务器发出的请求，都会携带这个cookie。
·cookie是不加密的，用户可以自由看到;
·用户可以删除cookie，或者禁用它
·cookie可以被篡改
·cookie可以用于攻击
·cookie存储量很小。未来实际上要被localStorage干掉。
express中的cookie，你肯定能想到。res负责设置cookie，req负责识别cookie。
Express中的Cookie
·Express中，使用cookie-parser中间件来设置cookie.
·主要设置选项:domain、path、maxAge、signed
1.js:
var express = require('express');
var cookieParser = require('cookie-parser');
var app = express();
app.use(cookieParser());
app.get('/', function (req, res) {
res.cookie('xihao', 'tfboys', { maxAge: 900000, httpOnly: true })
res.send();
});
app.listen(3000);
这个图是服务器发给浏览器的cookie，是明码:
再次请求的时候可以看到浏览器携带的cookie，是明码。
test.js:
var express = require('express');
var cookieParser = require('cookie-parser');
var app = express();
//使用cookie必须要使用cookie-parser中间件
app.use(cookieParser());
app.get('/', function (req, res) {
//maxAge在Express中毫秒为单位
// res.cookie('xihao', 'tfboys', { maxAge: 900000, httpOnly: true })
res.send("猜你喜欢" + JSON.stringify(req.cookies));
});
app.get("/gonglue", function (req, res) {
//得到get请求,用户查询的目的地
var mudidi = req.query.mudidi;
//记录用户喜好
//先读取用户的喜好,然后把新的数据push进入数组,设置新的数据
var mudidiarray = req.cookies.mudidi || [];
mudidiarray.push(mudidi);
res.cookie("mudidi", mudidiarray, { maxAge: 900000, httpOnly: true });
res.send(mudidi + '旅游攻略');
});
app.listen(3000);
4.2 Session
Session不是天生就有的，是依赖于cookie。
cookie是明码传输的，
浏览器通过给服务器发送一段”乱码”cookie，让服务器进行对比，看看这个客户端是谁。
session依赖cookie，当一个浏览器禁用cookie的时候，登陆效果消失;或者用户清除了cookie，登录也消失。
session比cookie不一样在哪里呢? session下发的是乱码，并且服务器自己缓存一些东西，下次浏览器的请求带着乱码上来，此时与缓存进行比较，看看是谁。
所以，一个乱码，可以对应无限大的数据。
任何语言中，session的使用，是”机理透明”的，他是帮你设置cookie的，但是足够方便，让你感觉不到这事儿和cookie有关。
session中乱码和存储数据比对的这个库是存储在服务器的内存中的，一旦服务器关机了，就会消失了。
nodejs中的session:
express中使用express-session来使用session。
05.js:
var express = require('express');
var app = express();
var session = require('express-session');
app.use(session({
secret: 'keyboard cat',
resave: false,
saveUninitialized: true,
}));
app.get('/', function (req, res) {
if (req.session.login == "1") {
res.send("欢迎你");
} else {
res.send('你没有登陆!!');
}
})
app.get('/login', function (req, res) {
req.session.login = "1"; //设置这个session
res.send('你已经成功登陆');
});
app.listen(3000);
看看这段被加密的cookie:
做一个利用session的登陆界面:
var express = require('express');
var app = express();
var db = require('./model/db.js');
var session = require('express-session');
app.use(session({
secret: 'keyboard cat',
resave: false,
saveUninitialized: true,
}));
app.set('view engine', 'ejs');
app.get('/', function (req, res) {
if (req.session.login == "1") {
res.send("欢迎" + req.session.username);
} else {
res.send("没有成功登录");
}
});
app.get('/login', function (req, res) {
res.render('denglu');
});
app.get('/checklogin', function (req, res) {
var tianxiedeusername = req.query.username;
var tianxiepassword = req.query.password;
//根据用户填写的姓名,去数据库里面找这个文档,读出密码
//如果读取的密码,和填写的密码一样,那么登录成功了
//如果读取的密码和填写的密码不一样,登陆失败.
//如果根本没有找到这个记录,那么就说明用户名填写错了
db.find("users", { "username": tianxiedeusername }, function (err, result) {
console.log(result);
if (result.length == 0) {
res.send('你的登录名写错了,没有这个注册用户');
return;
}
var shujukuzhongdepassword = result[0].password;
if (shujukuzhongdepassword == tianxiepassword) {
req.session.login = "1";
req.session.username = result[0].username;
res.send('成功登录!你是' + result[0].username);
} else {
res.send('用户名对了密码错误');
}
});
});
app.listen(3000);
加密使用的是MD5加密。
加密’1’:
md5(1,32) = c4ca4238a0b923820dcc509a6f75849b
md5(1,16) = a0b923820dcc509a
加密’2’:
md5(2,32) = c81e728d9d4c2f636f067f89cc14862c
md5(2,16) = 9d4c2f636f067f89
不管你加密多大的东西，哪怕10M的文字，都会加密为32位的字符串，就是密码。并且神奇的，数学上能够保证，哪怕你更改一个文字，都能大变。
MD5是数学上，不能破解的。不能反向破解。
也就是说，c4ca4238a0b923820dcc509a6f75849b 没有一个函数，能够翻译成为1的。
但是，有的人做数据库就是把1~999999所有数字都用MD5加密了，然后进行了列表，所以有破解的可能。
