实战：一、使用mongo做一个注册的小demo

思路：
1、使用mongoose 进行 数据库的链接
2、使用Schema来进行传输字段的定义
3、安装koa-router进行数据处理
4、安装koa-bodyparser 进行post数据交互
5、解决跨域
6、前端传递值
7、在router.pot里面 处理 前端传递过来的值。

一、连接数据库
（1）建立一个项目文件夹: service ， npm init
（2）安装 mongoose连接数据库，Mongoose是一个开源的封装好的实现node和MongoDB数据通讯的数据建模库 ，npm i mongoose -S
（3）建立一个database的文件夹，来存放和数据库相关的文件，init.js 代码如下：

const mongoose = require('mongoose');	//引入mongoose插件
const db = "mongodb://localhost/demo1" 	//建立链接的地址，如果数据库里面没有这个数据表则自动建立

exports.connect = ()=>{	//把connect 这个函数暴露出去，并且在此函数里面做一下操作。
    //连接数据库
    mongoose.connect(db)
    //如果数据库连接失败，自动重新连接，连接3次以上放弃连接，设置变量，来保存连接的次数
    let maxConnectTimes = 0
    //先确保数据库连接成功，在做其他的事情，这里使用Promise做一个异步操作
    return new Promise((resolve,reject)=>{
        //增加数据库检听事件
        mongoose.connection.on('disconnected',()=>{
            if(maxConnectTimes<3){
                maxConnectTimes++
                mongoose.connect(db)
                console.log("******重新连接数据库*****")
            }else{
                reject()
                    throw new Error("数据库有问题，请人为修改以后在连接")
            }
        })
        //连接报错以后
        mongoose.connection.on('error',err=>{
        console.log('***********数据库错误***********')
        if(maxConnectTimes<3){
            maxConnectTimes++
            mongoose.connect(db)
        　 }else{
        　　　　eject(err)
            throw new Error('数据库出现问题，程序无法搞定，请人为修理......')
        　　}
        })
        //连接打开时
        mongoose.connection.once('open',()=>{
        　　console.log("MongoDB success")
        　　resolve()
        })
    })
}

二、使用Schema进行数据建模
（1）数据库连接成功以后，使用Schema进行数据建模，定义好传输的字段和模型，Schema是一种以文件形式存储的数据库模型骨架，无法直接通往数据库端，也就是说它不具备对数据库的操作能力。Schema是以key-value形式Json格式的数据。
（2）Schema中的数据类型：
1、String ：字符串类型
2、Number ：数字类型
3、Date ： 日期类型
4、Boolean： 布尔类型
5、Buffer ： NodeJS buffer 类型
6、ObjectID ： 主键,一种特殊而且非常重要的类型
7、Mixed ：混合类型
8、Array ：集合类型
（3）Mongoose中的三个概念：
1、schema ：用来定义表的模版，实现和MongoDB数据库的映射。用来实现每个字段的类型，长度，映射的字段，不具备表的操作能力。
2、model ：具备某张表操作能力的一个集合，是mongoose的核心能力。我们说的模型就是这个Mondel。
3、entity ：类似记录，由Model创建的实体，也具有影响数据库的操作能力。
（4）新建一个为schema.js的文件夹。并且执行代码：

const mongoose = require('mongoose')		//声明mongoose
const Schema = mongoose.Schema  		//引入Schema
let ObjectId = Schema.Types.ObjectId    //声明Object类型

//创建自己的用户Schema
const userSchema = new Schema({
    UserId : ObjectId,   //固定写法
    username : {unique:true,type:String},  //设置用户名不允许重复，字符串格式
    password : String,
    createAt:{type:Date,default:Date.now()},
    lastLoginAt:{type:Date,default:Date.now()}
})
//发布模型   user为写入数据表的名称，userSchema 为发布模型的标准
mongoose.model('user',userSchema )

（5）载入Schema
1、Schema建立好以后，需要载入它。在init.js里面做事件。然后在index.js里面执行。
2、要载入Schema必须先引入：一个glob和一个resolve
npm install glob --save //安装glob
const glob = require('glob')
const {resolve} = require('path')
3、说明：
glob：node的glob模块允许你使用 * 等符号，来写一个glob规则，像在shell里一样，获取匹配对应规则文件。
resolve: 将一系列路径或路径段解析为绝对路径。
4、了解两个引入的模块用法后，我们就可以一次性引入所有的Schema文件了。
exports.initSchemas = () =>{
//引入Schema的所有文件，根据文件夹的不同自己去调整
glob.sync(resolve(__dirname,'./schema/','**/*.js')).forEach(require)
}

三、插入一条数据进行调试
实际上一开始我们就应该先建立一个 index.js的文件。这个是主要的文件。来启动项目的。
插入数据调试 代码：

const Koa = require('koa')
const app = new Koa()
const mongoose = require('mongoose')
const {connect , initSchemas} = require('./database/init.js')
//立即执行函数，执行连接数据库的函数和载入Schema的函数
;(async () =>{
    await connect()
    initSchemas()
    const User = mongoose.model('user')   //user 是发布模型里面使用的表
    let oneUser = new user({userName:'jspang13',password:'123456'})   //插入数据
    oneUser.save().then(()=>{
            console.log('插入成功')
    })
    let  users = await  User.findOne({}).exec()
    console.log('------------------')
    console.log(users)
    console.log('------------------')
})()

app.use(async(ctx)=>{
    ctx.body = '<h1>hello Koa2</h1>'
})
app.listen(3000,()=>{
    console.log('[Server] starting at port 3000')
})

四、使用bcryptjs用户加密处理
1、bcryptjs是一个第三方密码加密库，是对原有bcrypt的优化，优点是不需要安装任何依赖
npm install bcryptjs -S
2、bcryptjs 和 Schema 写在一个文件里面 完整版代码：

const mongoose = require('mongoose') //引入mongoose
const Schema = mongoose.Schema //声明Schema
let ObjectId = Schema.Types.ObjectId //声明Object类型

const bcrypt = require('bcryptjs');

const SALT_WORK_FACTOR = 10

//创建用户的Shema  也就是用来定义 表的模板
const userSchema = new Schema({
    UserId : ObjectId,
    userName : {unique:true,type:String},
    password : String,
    // _id:String,
    createAt:{type:Date,default:Date.now()},
    lastLoginAt:{type:Date,default:Date.now()}
}) 

// 用pre每次进行保存时都进行加盐加密的操作
userSchema.pre('save',function(next){
    let _this = this
    bcrypt.genSalt(SALT_WORK_FACTOR,(err,salt)=>{
        if(err){
            return next(err)
        }
        //把密码传给hash进行加密。成功以后赋值给password属性
        bcrypt.hash(_this.password,salt,(err,hash)=>{
            if(err) return next(err)
            _this.password = hash
            next()
        })
    })
})

mongoose.model('User',userSchema)

五、安装koa-router 并且使路由模块化
1、安装：npm install koa-router --save
2、新建一个sppApi的文件夹，然后在文件夹里面建立 user.js 代码如下：

const Router = require ('koa-router')
let router = new Router()
router.get('/',async(ctx)=>{
    ctx.body="这是用户操作首页"
})
router.get('/register',async(ctx)=>{
    ctx.body="用户注册接口"
})
module.exports=router;

3、让路由模块化，在index.js里面写入
（1）引入 koa-router const Router = require('koa-router')
（2）引入我们的user.js模块 let user = require('./appApi/user.js')
（3）装载所有子路由 let router = new Router(); router.use('/user',user.routes())
（4）加载路由中间件 app.use(router.routes()) app.use(router.allowedMethods())
我们就可以在浏览器中实验一下我们的模块化路由是否起作用了。在浏览器中输入，http://localhost:3000/user，已经可以出现我们设定好的页面了。

六、打通前后端的通讯。
（1）安装koa2-cors中间件 解决前端跨域问题。
（2）安装koa-bodyparser中间件 获取post提交的数据。
（3）数据处理，返回。
操作：index.js 服务端 文件中 优先 引入 koa2-cors 和 koa-bodyparser 代码如下：

//解决跨域
const cors = require('koa2-cors')
app.use(cors());
//链接数据库，前台和后台的通讯 ，接收post数据
const bodyParser = require('koa-bodyparser')
app.use(bodyParser());
数据处理：（在koa-router的页面使用，或者直接使用，现在在koa-router文件夹下面使用）
const Router = require('koa-router')
const router = new Router()
const mongoose = require('mongoose')

router.get('/',async(ctx)=>{
    ctx.body = "用户操作首页"
})

router.post('/register',async(ctx)=>{
    console.log(ctx.request.body)

    //取得Model
    const User = mongoose.model('User');
    //把从前端接收的POST数据封装成一个新的user对象
    let newUser = new User(ctx.request.body)

    //用mongoose的save方法直接储存。然后判断是否成功返回相应的结果。
    await newUser.save().then(()=>{
        ctx.body = {
            code : 200,
            message:'注册成功'
        }
    }).catch((error)=>{
        ctx.body = {
            code:500,
            message:error
        }
    })
})

module.exports = router
（4）前端业务逻辑代码
    axios({
                url: url.registerUser,
                method: 'post',
                data:{
                    userName:this.username,
                    password:this.password ,
                }
            })
            .then(response => {
                console.log(response)
                if(response.data.code==200){
                    Toast.success('注册成功');
                }else{
                    Toast.fail('注册失败');
                }
            })
            .catch((error) => {
                console.log(error)
            })