思路：
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)
})