最近使用Mongoose进行数据库连接。使用postman进行测试非法的id长度时报了如下错误。

刚开始我是不明白这个报的是什么错，经过查找后发现错误在这句代码。

 const user=await User.findById(ctx.params.id);

也就是会把传进来的id在数据库中查询。这个findByid默认就是查询_id字段。而_id是mongoose.Types.ObjectId类型

ObjectId 是一个12字节 BSON 类型数据，有以下格式：

• 前4个字节表示时间戳
• 接下来的3个字节是机器标识码
• 紧接的两个字节由进程id组成（PID）
• 最后三个字节是随机数。

MongoDB中存储的文档必须有一个”_id”键。这个键的值可以是任何类型的，默认是个ObjectId对象。

在一个集合里面，每个文档都有唯一的”_id”值，来确保集合里面每个文档都能被唯一标识。

_id的长度是24位，上面那个报错是因为长度不正确导致查询的时候无法转化成ObjectId类型。这里加一个长度判断就可以了！

 async checkUserExist(ctx,next){
        if(ctx.params.id.length!=24){
            ctx.throw(404,"没有此用户,id长度不匹配");
        }
        const user=await User.findById(ctx.params.id);//数据库查询必须使用await，否则不等到查询完成就执行下面语句
    
      
        if(!user){
            ctx.throw(404,"没有此用户");
        }
        await next();
    }

我们使用jsonwebtoken来生成和验证token，然后手写一个登录和授权的逻辑。使用koa-jwt中间件。

参考文章：JSON Web Token 入门教程

JWT原理

JWT 的原理是，服务器认证以后，生成一个 JSON 对象，发回给用户，就像下面这样。

{
  "姓名": "张三",
  "角色": "管理员",
  "到期时间": "2018年7月1日0点0分"
}

以后，用户与服务端通信的时候，都要发回这个 JSON 对象。服务器完全只靠这个对象认定用户身份。为了防止用户篡改数据，服务器在生成这个对象的时候，会加上签名。

JWT 的三个部分

使用JWT使用token作为验证信息，比如下面这个就是一个token

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJfaWQiOiI1ZjMwMDE4OTg1NzcxYTUwNjQwOWU1MjQiLCJuYW1lIjoid3d3IiwiaWF0IjoxNTk2OTgxNjc4LCJleHAiOjE1OTcwNjgwNzh9.3wM-YYxZ2ccAzCwvC4jUVQUSkaeMRuEjuAdZocQAyWA

这个长的字符串由两个小数点分割成三个部分

• Header（头部）
• Payload（负载）
• Signature（签名）

Header

Header 部分是一个 JSON 对象，描述 JWT 的元数据，通常是下面的样子。

{
  "alg": "HS256",
  "typ": "JWT"
}

上面代码中，alg属性表示签名的算法（algorithm），默认是 HMAC SHA256（写成 HS256）；typ属性表示这个令牌（token）的类型（type），JWT 令牌统一写为JWT。

最后，将上面的 JSON 对象使用 Base64URL 算法转成字符串。

Payload

Payload 部分也是一个 JSON 对象，用来存放实际需要传递的数据。JWT 规定了7个官方字段供选用。Payload就是有效载荷，传递的主要内容放置在这里。

• iss (issuer)：签发人
• exp (expiration time)：过期时间
• sub (subject)：主题
• aud (audience)：受众
• nbf (Not Before)：生效时间
• iat (Issued At)：签发时间
• jti (JWT ID)：编号

除了官方字段，你还可以在这个部分定义私有字段，下面就是一个例子。

{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true
}

注意，JWT 默认是不加密的，任何人都可以读到，任何放在token里面的信息，如果被截获了，对任何人别人是可读的。因此，我们不应该在Payload里面存放任何黑客可以利用的用户信息。但是可以使用RSA加密算法得到加密。

这个 JSON 对象也要使用 Base64URL 算法转成字符串。

Signature

Signature 部分是对前两部分的签名，防止数据篡改。

首先，需要指定一个密钥（secret）。这个密钥只有服务器才知道，不能泄露给用户。然后，使用 Header 里面指定的签名算法（默认是 HMAC SHA256），按照下面的公式产生签名。

HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret)

算出签名以后，把 Header、Payload、Signature 三个部分拼成一个字符串，每个部分之间用”点”（.）分隔，就可以返回给用户。

验证过程

1. 用户向认证服务器提交用户名和密码，认证服务器也可以和应用服务器部署在一起，但往往是独立的居多；
2. 认证服务器校验用户名和密码组合，然后创建一个JWT token，token的Payload里面包含用户的身份信息，以及过期时间戳；
3. 认证服务器使用密钥对Header和Payload进行签名，然后发送给客户浏览器；
4. 浏览器获取到经过签名的JWT token，然后在之后的每个HTTP请求中附带着发送给应用服务器。经过签名的JWT就像一个临时的用户凭证，代替了用户名和密码组合，之后都是JWT token和应用服务器打交道了；
5. 应用服务器检查JWT签名，确认Payload确实是由密钥拥有者签过名的；
6. Payload身份信息代表了某个用户；
7. 只有认证服务器拥有私钥，并且认证服务器只把token发给提供了正确密码的用户；
8. 因此应用服务器可以认为这个token是由认证服务器颁发的也是安全的，因为该用户具有了正确的密码；
9. 应用服务器继续完成HTTP请求，并认为这些请求确实属于这个用户；

这样的话，黑客假扮合法用户的办法要么是盗到了用户名和密码组合，要么盗到了认证服务器上的签名私钥。

操作步骤

实现登录

写一个登录逻辑，首先验证传进来的数据类型是否正确，然后在数据库中查询这个用户。如果找到了就把user中的id和name取出。使用jsonwebtoken模块加密。secret是提前保存的密钥，就是一个string。

 async login(ctx) {
        ctx.verifyParams({
            name: {type: `string`, required: true}, //默认require也是true
            password: {type: `string`, required: true},
        })
        const user = await User.findOne(ctx.request.body);
        if (!user) {
            ctx.throw(401, "账号密码不正确");
        }
        const {_id, name} = user;
        const token = jsonwebtoken.sign({_id, name}, secret, {expiresIn: `1d`});//有效时间1d
        ctx.body = {token};
   }

这样登陆成功就会返回一个token

账号密码不正确，也会报错。

实现授权

首先写一个授权中间件，目的是当请求某个特定的操作时，比如delete和update。需要识别这个用户，并将验证信息解码保存到ctx.state.user

const auth=async (ctx,next)=>{
    const {authorization=''}=ctx.request.header;
    const token=authorization.replace("Bearer ",'');//token默认有一个Bearer头
    try {
        const user=jsonwebtoken.verify(token,secret);
        ctx.state.user=user;  //约定
    }catch (err){
        ctx.throw(401,err.message);//401验证不符合
    }
    await next();
}

然后写一个验证中间件，上一个中间件会把用户请求附带的token解码成用户信息，验证中间件可以根据这个信息判断用户是不是有这个权限来进行操作。

   async checkOwner(ctx, next) {
        if (ctx.params.id != ctx.state.users._id) {
            ctx.throw(4.3, "没有权限");
        }
        await next();
    }

这样在进行敏感操作时，就可以保证用户只能修改自己的信息了

router.patch(`/:id`,auth,checkOwner,update)  //put是整体替换
router.delete(`/:id`,auth,checkOwner,deleteByid)

使用koa-jwt中间件

koa-jwt中间件为我们写好了auth逻辑，只需要简单传递secret即可

const jwt=require("koa-jwt");
const auth=jwt({secret});

效果和

const auth=async (ctx,next)=>{
    const {authorization=''}=ctx.request.header;
    const token=authorization.replace("Bearer ",'');//token默认有一个Bearer头
    try {
        const user=jsonwebtoken.verify(token,secret);
        ctx.state.user=user;  //约定
    }catch (err){
        ctx.throw(401,err.message);//401验证不符合
    }
    await next();
}

一样，其它不需要任何改动。

使用postman验证接口

postman如果手动输入token很麻烦，这里写了一段程序可以方便的帮助我们添加token。

var jsonData=pm.response.json();
pm.globals.set("token",jsonData.token);

在需要输入token的地方，使用这个全局变量即可

一般我们不直接用MongoDB的函数来操作MongoDB数据库 Mongose就是一套操作MongoDB数据库的接口。

配置mongoose

链接mongoDB，这里我使用的是mongoDB Atlas免费服务。

const mongoose=require("mongoose");
const {connectionStr}=require("./config");

mongoose.connect(connectionStr,{ useNewUrlParser: true,useUnifiedTopology: true },()=>{
    console.log("数据库链接成功");
});
mongoose.connection.on(`error`,console.error);
mongoose.set('useFindAndModify', false);

把数据库链接String放到config配置文件中去了。

创建Schema和model

Schema是一个骨架，里面定义着数据类型。

const mongoose=require("mongoose");

const {Schema,model}=mongoose;

const userSchema=new Schema({
    name:{type: String,required:true}, //默认require也是true
    age:{type: Number,required: false}
})

module.exports=model('User',userSchema); //模型的别名，模型就是模式的实例化

增删改查举例

还是很清晰的，就不一一解释了，注意数据库查询要使用异步方式，否则会阻塞进程。

const User = require("../models/users.js");

class UserRoute {
    async create(ctx) {
        ctx.verifyParams({
            name: {type: `string`, required: true}, //默认require也是true
            age: {type: `number`, required: false}
        })
        const user=await new User(ctx.request.body).save();
        ctx.body=user;
    }

    async update(ctx) {
        ctx.verifyParams({
            name: {type: `string`, required: true}, //默认require也是true
            age: {type: `number`, required: false}
        })
        const user=await User.findByIdAndUpdate(ctx.params.id,ctx.request.body,{new:true});
        if (!user)
            ctx.throw(404, "用户不存在");
        ctx.body=user;
    }

    async deleteByid(ctx) {
       const user=await User.findByIdAndRemove(ctx.params.id);
        if (!user)
            ctx.throw(404, "用户不存在");
        ctx.status = 204;
    }

    async findByid(ctx) {
        const user = await User.findById(ctx.params.id);
        if (!user)
            ctx.throw(404, "用户不存在");
        ctx.body = user;
    }

    async getAll(ctx) {
        ctx.body = await User.find();
    }
}

module.exports = new UserRoute();

koa-parameter是一个校验参数内容合法性的中间件。

使用时放在koa-body-parser后面。校验request.body，传入参数app使这个中间件可以作为全局使用。

使用时，只需要在需要获取request内容时校验对应的数据类型即可。

不合法时返回422错误。

在写接口时，返回json格式且易读的错误提示是有必要的，koa-json-error中间件帮我们做到了。

412错误 先决条件出错

// code 
ctx.throw(412, '先决条件失败：id大于数据长度')
复制代码

返回错误信息

{
    "message":"先决条件失败：id大于数据长度",
    "name":"PreconditionFailedError",
    "status":412
}

比如我们请求了一个不存在的数据，自动返回412和错误信息。

可以看到，返回了对栈信息，但很多时候我们并不想告诉别人内部是哪里出错。

这里使用环境变量来配置，如果为生产环境，不返回stack的信息。如果为调试环境则全返回。

app.use(error({
    postFormat: (e,{stack,...rest})=>process.env.NODE_ENV===`production`?rest:{stack,...rest}
}));

在intellij中，可以方便的添加环境变量

这样获得请求的信息就是安全的了

koa-generator：koa-生成器是一个npm。

    1.打开cmd进入npm install -g koa-generator安装。

    2.进入想要放项目的文件位置koa projectname。

使用上面的方法可以自动生成一个目录结构，为了一步一步讲解。我们手动生成，因为我们暂时不需要自动生成的结构中的一些文件夹。

控制器和路由

主要分两个部分，下面是设置好后的结构。

控制器

控制器用来对链接进行操作，这里没链接数据库举了一个例子。user.js文件

let db=[];

class UserRoute{
    create(ctx){
        db.push(ctx.request.body);
        ctx.body=ctx.request.body;
    }
    update(ctx){
        db[ctx.params.id]=ctx.request.body;
        ctx.status=200;
    }
    deleteByid(ctx){
        db.splice(+ctx.params.id,1);
        ctx.status=204;
    }
    findByid(ctx){
        if(+ctx.params.id>=db.length){
            ctx.throw(412);
        }
        ctx.body = db[+ctx.params.id];
    }
    getAll(ctx){
        ctx.body=db;
    }
}

module.exports=new UserRoute();

这个文件处理用户的操作，可以看到CRUD。通过一个类中不同的方法实现操作，传入ctx参数得到数据。

路由

user.js的路由，包含进控制器的user.js。也很好理解。

const Router = require("koa-router");

const router = new Router({prefix: `/users`});
const {create,update,deleteByid,findByid,getAll}=require("../controllers/users.js");

router.get('/:id',findByid)
router.post(`/`,create)
router.put(`/:id`,update)
router.delete(`/:id`,deleteByid)
router.get('/',getAll);

module.exports=router;

如果我们有很多路由，将每个路由文件都添加到app.js中就太麻烦了，这里写一个自动化脚本帮我们导入。 index.js：

const fs = require("fs");
module.exports = (app) => {
    fs.readdirSync(__dirname).forEach(file => {
        if (file === "index.js")
            return;
        const route = require(`./${file}`);
        app .use(route.routes()).use(route.allowedMethods());
    })
}

app.js

在app.js中，集成我们需要的模块，注意模块之间是有顺序关系的，如果下一个模块使用了上一个模块，则排在后面。

"use strict"

const Koa = require("koa");
const bodyparser=require("koa-body-parser");
const routing=require('./routes/index.js');
const error=require("koa-json-error");
const app = new Koa();
 
app.use(error());//中间件加入有顺序
app.use(bodyparser());
routing(app);
app.listen(3000,()=>{console.log("成功启动")});

OPTIONS请求方法的主要用途有两个：

1. 获取服务器支持的HTTP请求方法。
2. 用来检查服务器的性能。例如：AJAX进行跨域请求时的预检，需要向另外一个域名的资源发送一个HTTP OPTIONS请求头，用以判断实际发送的请求是否安全。

在koa-router中相应option请求

获取返回的类型

在koa-router方法中，使用router.allowedMethods() 为某个router开启option请求。

var Koa = require('koa');
var Router = require('koa-router');

var app = new Koa();
var router = new Router();

app.use(router.routes());
app.use(router.allowedMethods());

这样当我们访问时，就可以使用option方式来查看这个链接支持哪些请求。支持的类型在Header中

usersRouter.get(`/`,(ctx)=>{
    ctx.body="users"
})
app.use(usersRouter.routes());
app.use(usersRouter.allowedMethods());

可以看到，users路由支持get请求。

405和501状态码

405

405是说，这个请求方法（GET、PUT、DELETE）我们api server认识，但是对于你请求的资源（URI），你使用的方法我们不支持，这叫做方法不允许，同时response要包含一个Allow头，返回支持的HTTP请求方法。

比如上面的链接只支持get方法，但如果我们请求了post方法就会返回405.

501

501是说，你的请求方法（例如PROPFIND方法），我们api server不认识（无法进行匹配），因此叫做未实现。 返回501主要是受限制于API Server实现。

请求Link方法就会得到501，因为koa-router只支持常用的方法，不支持这个方法。

koa-router可以很方便的写出路由跳转的代码。

安装koa                   cnpm install koa --save 

安装koa-router         cnpm install koa-router --save

放个api文档，不过我有一点补充鉴权的部分。

https://github.com/ZijianHe/koa-router

koa-router源码详解

简单示例

我们先写一个get请求，

"use strict"

const Koa = require("koa");
const  Router=require("koa-router");
const app = new Koa();
const router=new Router();

router.get('/',(ctx)=>{
    ctx.body="主页";
})

app.use(router.routes());//将中间件加入app中
app.listen(3000);

使用postman验证api

使用前缀

比如像这段代码，在创建router时就可以带上前缀

var router = new Router({
  prefix: '/users'
});

router.get('/', ...); // responds to "/users"
router.get('/:id', ...); // responds to "/users/:id"

获取URL参数

router的参数存放在ctx.params中

router.get('/:category/:title', (ctx, next) => {
  console.log(ctx.params);
  // => { category: 'programming', title: 'how-to-node' }
});

实际举一个例子

"use strict"

const Koa = require("koa");
const  Router=require("koa-router");
const app = new Koa();
const router=new Router();


router.get('/',(ctx)=>{
    ctx.body="主页";
})
router.get('/users/:id',(ctx)=>{
    ctx.body=`${ctx.params.id}`; //这个id就是上面冒号后id的内容
})
app.use(router.routes());
app.listen(3000)c

多级嵌套时，直接在参数中写我们需要的值就可以取出

鉴权

这里举个简单的例子，鉴权可以用于过滤掉一些不合法的请求，首先写一个函数。当不符合时返回401.

const auth = async (ctx, next) => {
    if (ctx.url !== `/users`) {
        ctx.throw(401).catch();
    }
    await next();
}

注意，这时url必须为http://localhost:3000/users。

usersRouter.get('/:id', auth, (ctx) => {
    ctx.body = `${ctx.params.id}`;
})
usersRouter.get(`/`,auth,(ctx)=>{
    ctx.body="users"
})

访问其它链接即为无效

如果想访问动态链接，可以使用正则表达式

const auth = async (ctx, next) => {
    if (ctx.url !== ctx.url.match(/\/users\/\d+/).toString()) {
        ctx.throw(401).catch();
    }
    await next();
}

这里我写了几个常用的方法，注意delete方法约定返回的状态码是204

其它方法可以去上面给的链接里找到

模拟请求演示

这里我使用数组模拟数据库请求。

使用koa-body-parser模块来获取post中request的body。

"use strict"

const Koa = require("koa");
const Router = require("koa-router");
const bodyparser=require("koa-body-parser");
const app = new Koa();
const router = new Router();
const usersRouter = new Router({prefix: `/users`})

let db=[];
router.get('/', (ctx) => {
    ctx.body = "主页";
});

usersRouter.get('/:id', (ctx) => {
    ctx.body = db[+ctx.params.id];
})

usersRouter.post(`/`,(ctx)=>{
    db.push(ctx.request.body);
    ctx.body=ctx.request.body;//request的body
})
usersRouter.put(`/:id`,(ctx)=>{
    db[ctx.params.id]=ctx.request.body;
    ctx.status=200;
})
usersRouter.delete(`/:id`,(ctx)=>{
    db.splice(+ctx.params.id,1);
    ctx.status=204;
})
app.use(router.routes());
app.use(bodyparser());
app.use(usersRouter.routes());
app.use(usersRouter.allowedMethods());
app.listen(3000)

这里直接可以使用postman进行相应的请求方法测试。

本篇文章介绍Koa，RESTful概念，并搭建一个Koa Demo。

什么是RESTfulAPI？

RESTful 是目前最流行的 API 设计规范，用于 Web 数据接口的设计。用通俗的话讲

• 看Url就知道要什么
• 看http method就知道干什么
• 看http status code就知道结果如何

具体详细介绍参见：怎样用通俗的语言解释REST，以及RESTful？

什么是Koa？

Koa 是一个新的 web 框架，由 Express 幕后的原班人马打造， 致力于成为 web 应用和 API 开发领域中的一个更小、更富有表现力、更健壮的基石。 通过利用 async 函数，Koa 帮你丢弃回调函数，并有力地增强错误处理。 Koa 并没有捆绑任何中间件， 而是提供了一套优雅的方法，帮助您快速而愉快地编写服务端应用程序。

也就是说，koa是最新的开发node.js服务端的框架。很高兴我们能使用最新的技术。

搭建Koa

我比较习惯idea，就使用intellij unlimited 版本了。实际上也确实比vscode方便，可以省去一些指令步骤。

首先创建一个node.js项目。然后使用npm导入koa包，这里可以直接在设置中导入。

点击加号后输入koa，勾选版本即可导入。

为了能够快速重启node.js模块，我们还需要导入nodemon包。注意标记为dev模式，这意味着在工作环境中是不会导入这个包的。

创建一个新文件，并写入hello world程序。

在终端中输入nodemon 文件名

然后在浏览器中打开链接

demo就完成了，这里暂时没有用到RESTful，因为没有设计复杂的链接，后续会继续更新。

首先下载node.js插件，这个我安装IDEA的时候就已经安装好了。

新建node文件，很简单，找到node.js选项

我们首先创建一个js文件

var http=require("http");

var server=http.createServer(function (req,res) {
    res.writeHead(200,{"Content-type":"text/html;charset=UTF-8"});
    res.end("hello world");
});

server.listen(3000,"127.0.0.1");

添加运行配置

设置浏览器启动

点击运行直接弹出结果

这个简单实例就完成了。