Mongoose

是一个将JavaScript对象与数据库产生关系的一个框架，object related model。操作对象，就是操作数据库了；对象产生了，同时也持久化了。

这个思路是Java三大框架SSH中Hibernate框架的思路。彻底改变了人们使用数据库的方式。'

1   //引包，并不需要引用mongodb这个包
2   var mongoose = require('mongoose');
3   //链接数据库,haha是数据库名字
4   mongoose.connect('mongodb://localhost/haha');
5   
6   //创建了一个模型。猫的模型。所有的猫，都有名字，是字符串。“类”。
7   var Cat = mongoose.model('Cat', { name: String });
8   //实例化一只猫
9   var kitty = new Cat({ name: 'Zildjian' });
10  //调用这只猫的save方法，保存这只猫
11  kitty.save(function (err) {
12    console.log('喵喵喵');
13  });
14  
15  var tom = new Cat({"name":"汤姆"});
16  tom.save(function(){
17      console.log('喵喵喵');
18  });

上面的代码中，没有一个语句是明显的操作数据库，感觉都在创建类、实例化类、调用类的方法。都在操作对象，但是数据库同步被持久了。

创建一个模型

1   mongoose.model("Cat",{"name" : String , "age" : Integer}); 

就可以被实例化

1   var kitty = new Cat({ name: 'Zildjian' });

然后这个实例就可以被save。

mongoose首先要想明白一件事儿，所有的操作都不是对数据库进行的。所有的操作都是对类、实例进行的。但是数据库的持久化自动完成了。

2.1 数据库连接

公式：

1   var mongoose = require('mongoose');
2   //创建数据库连接
3   var db      = mongoose.createConnection('mongodb://127.0.0.1:27017/haha');
4   //监听open事件
5   db.once('open', function (callback) {
6       console.log("数据库成功连接");
7   });

2.2 定义模型

创造schema → 定义一些schema的静态方法 → 创造模型
创造schema用什么语句？ new mongoose.schema({});
创造模型用什么语句？ db.model(“Student”,schema名字);

//创建了一个schema结构。
var studentSchema = new mongoose.Schema({
    name     :  {type : String},
    age      :  {type : Number},
    sex      :  {type : String}
});
//创建静态方法
studentSchema.statics.zhaoren = function(name, callback) {
    this.model('Student').find({name: name}, callback);   //this.model('Student')指的是当前这个类
};
//创建修改的静态方法
studentSchema.statics.xiugai = function(conditions,update,options,callback){
    this.model("Student").update(conditions, update, options, callback);
}
//创建了一个模型，就是学生模型，就是学生类。
//类是基于schema创建的。
var studentModel = db.model('Student', studentSchema);

解释一下，什么是静态方法，什么是类方法：

1   //类
2   function Student(){
3       
4   }
5   
6   //实例化一个学生
7   var xiaoming = new Student();
8   //实例方法，因为这个sleep方法的执行者是类的实例
9   xiaoming.sleep();
10  
11  
12  //静态方法（类方法），这个方法的执行者是这个类，不是这个类的实例。
13  Student.findAllBuJiGe();

前台界面：不操作数据库，只操作类！

实例

db.js

//引包
var mongoose = require('mongoose');
//创建数据库连接
var db      = mongoose.createConnection('mongodb://127.0.0.1:27017/haha');
//监听open事件
db.once('open', function (callback) {
    console.log("数据库成功连接");
});
//向外暴露这个db对象
module.exports = db;

Student.js

var mongoose = require('mongoose');
var db = require("./db.js");

//创建了一个schema结构。
var studentSchema = new mongoose.Schema({
    name     :  {type : String},
    age      :  {type : Number},
    sex      :  {type : String}
});
//创建静态方法
studentSchema.statics.zhaoren = function(name, callback) {
    this.model('Student').find({name: name}, callback);
};
//创建修改的静态方法
studentSchema.statics.xiugai = function(conditions,update,options,callback){
    this.model("Student").update(conditions, update, options, callback);
}
//创建了一个模型，就是学生模型，就是学生类。
//类是基于schema创建的。
var studentModel = db.model('Student', studentSchema);
//向外暴露
module.exports = studentModel;

app.js

//定义了一个模型，学生模型，“学生类”
var Student = require("./models/Student.js");
////实例化了一个学生类
//var xiaoming = new Student({"name":"小明","age":12,"sex":"男"});
////保存这个学生类
//xiaoming.save(function(){
//    console.log("存储成功");
//});

//用类来创建一个对象（工厂）
Student.create({"name":"小红","age":13,"sex":"女"},function(error){
   console.log("保存成功");
})
//
Student.zhaoren("小明",function(err,result){
    console.log(result);
});

Student.xiugai({"name":"小明"},{$set : {"age":30}},{},function(){
    console.log("改年龄成功");
});