Koa1 框架

时间：2017-10-05 12:10:49 阅读：307 评论：0 收藏：0 [点我收藏+]

标签：cookie ora ase faq 上下文 method blob blog mysq

Koa是一个类似于Express的Web开发框架，创始人也是同一个人。它的主要特点是，使用了ES6的Generator函数，进行了架构的重新设计。也就是说，Koa的原理和内部结构很像Express，但是语法和内部结构进行了升级。

官方faq有这样一个问题：”为什么koa不是Express 4.0？“，回答是这样的：”Koa与Express有很大差异，整个设计都是不同的，所以如果将Express 3.0按照这种写法升级到4.0，就意味着重写整个程序。所以，我们觉得创造一个新的库，是更合适的做法。“

Koa应用

一个Koa应用就是一个对象，包含了一个middleware数组，这个数组由一组Generator函数组成。这些函数负责对HTTP请求进行各种加工，比如生成缓存、指定代理、请求重定向等等。

1 var koa = require(‘koa‘);
2 var app = koa();
3 
4 app.use(function *(){
5   this.body = ‘Hello World‘;
6 });
7 
8 app.listen(3000);

要安装koa才能测试

上面代码中，变量app就是一个Koa应用。它监听3000端口，返回一个内容为Hello World的网页。

app.use方法用于向middleware数组添加Generator函数。

listen方法指定监听端口，并启动当前应用。它实际上等同于下面的代码

1 var http = require(‘http‘);
2 var koa = require(‘koa‘);
3 var app = koa();
4 http.createServer(app.callback()).listen(3000);

中间件

下面是一个两个中间件级联的例子

1 app.use(function *() {
2   this.body = "header\n";
3   yield saveResults.call(this);
4   this.body += "footer\n";
5 });
6 
7 function *saveResults() {
8   this.body += "Results Saved!\n";
9 }

上面代码中，第一个中间件调用第二个中间件saveResults，它们都向this.body写入内容。最后，this.body的输出如下。

1 header 2 Results Saved! 3 footer

只要有一个中间件缺少yield next语句，后面的中间件都不会执行，这一点要引起注意。

如果想跳过一个中间件，可以直接在该中间件的第一行语句写上return yield next。

1 app.use(function* (next) {
2   if (skip) return yield next;
3 })

路由

可以通过this.path属性，判断用户请求的路径，从而起到路由作用。

 1 app.use(function* (next) {
 2   if (this.path === ‘/‘) {
 3     this.body = ‘we are at home!‘;
 4   } else {
 5     yield next;
 6   }
 7 })
 8 
 9 // 等同于
10 
11 app.use(function* (next) {
12   if (this.path !== ‘/‘) return yield next;
13   this.body = ‘we are at home!‘;
14 })

下面是多路径的例子。

 1 let koa = require(‘koa‘)
 2 
 3 let app = koa()
 4 
 5 // normal route
 6 app.use(function* (next) {
 7   if (this.path !== ‘/‘) {
 8     return yield next
 9   }
10 
11   this.body = ‘hello world‘
12 });
13 
14 // /404 route
15 app.use(function* (next) {
16   if (this.path !== ‘/404‘) {
17     return yield next;
18   }
19 
20   this.body = ‘page not found‘
21 });
22 
23 // /500 route
24 app.use(function* (next) {
25   if (this.path !== ‘/500‘) {
26     return yield next;
27   }
28 
29   this.body = ‘internal server error‘
30 });
31 
32 app.listen(8080)

上面代码中，每一个中间件负责一个路径，如果路径不符合，就传递给下一个中间件。

复杂的路由需要安装koa-router插件。

 1 var app = require(‘koa‘)();
 2 var Router = require(‘koa-router‘);
 3 
 4 var myRouter = new Router();
 5 
 6 myRouter.get(‘/‘, function *(next) {
 7   this.response.body = ‘Hello World!‘;
 8 });
 9 
10 app.use(myRouter.routes());
11 
12 app.listen(3000);

上面代码对根路径设置路由。

Koa-router实例提供一系列动词方法，即一种HTTP动词对应一种方法。典型的动词方法有以下五种。

router.get()
router.post()
router.put()
router.del()
router.patch()

这些动词方法可以接受两个参数，第一个是路径模式，第二个是对应的控制器方法（中间件），定义用户请求该路径时服务器行为。

1 router.get(‘/‘, function *(next) {
2   this.body = ‘Hello World!‘;
3 });

上面代码中，router.get方法的第一个参数是根路径，第二个参数是对应的函数方法。

注意，路径匹配的时候，不会把查询字符串考虑在内。比如，/index?param=xyz匹配路径/index。

有些路径模式比较复杂，Koa-router允许为路径模式起别名。起名时，别名要添加为动词方法的第一个参数，这时动词方法变成接受三个参数。

1 router.get(‘user‘, ‘/users/:id‘, function *(next) {
2  // ...
3 });

上面代码中，路径模式\users\:id的名字就是user。路径的名称，可以用来引用对应的具体路径，比如url方法可以根据路径名称，
结合给定的参数，生成具体的路径。

Koa-router允许为路径统一添加前缀。

1 var router = new Router({
2   prefix: ‘/users‘
3 });
4 
5 router.get(‘/‘, ...); // 等同于"/users"
6 router.get(‘/:id‘, ...); // 等同于"/users/:id"

路径的参数通过this.params属性获取，该属性返回一个对象，所有路径参数都是该对象的成员。

// 访问 /programming/how-to-node
router.get(‘/:category/:title‘, function *(next) {
  console.log(this.params);
  // => { category: ‘programming‘, title: ‘how-to-node‘ }
});

param方法可以针对命名参数，设置验证条件。

 1 router
 2   .get(‘/users/:user‘, function *(next) {
 3     this.body = this.user;
 4   })
 5   .param(‘user‘, function *(id, next) {
 6     var users = [ ‘0号用户‘, ‘1号用户‘, ‘2号用户‘];
 7     this.user = users[id];
 8     if (!this.user) return this.status = 404;
 9     yield next;
10   })

上面代码中，如果/users/:user的参数user对应的不是有效用户（比如访问/users/3），param方法注册的中间件会查到，就会返回404错误。

redirect方法会将某个路径的请求，重定向到另一个路径，并返回301状态码。

1 router.redirect(‘/login‘, ‘sign-in‘);
2 
3 // 等同于
4 router.all(‘/login‘, function *() {
5   this.redirect(‘/sign-in‘);
6   this.status = 301;
7 });

redirect方法的第一个参数是请求来源，第二个参数是目的地，两者都可以用路径模式的别名代替。

错误处理机制

1 app.use(function *() {
2   try {
3     yield saveResults();
4   } catch (err) {
5     this.throw(400, ‘数据无效‘);
6   }
7 });

上面代码自行部署了try…catch代码块，一旦产生错误，就用this.throw方法抛出。该方法可以将指定的状态码和错误信息，返回给客户端。

对于未捕获错误，可以设置error事件的监听函数。

1 app.on(‘error‘, function(err){
2   log.error(‘server error‘, err);
3 });

this.throw方法用于向客户端抛出一个错误。

 1 this.throw(403);
 2 this.throw(‘name required‘, 400);
 3 this.throw(400, ‘name required‘);
 4 this.throw(‘something exploded‘);
 5 
 6 this.throw(‘name required‘, 400)
 7 // 等同于
 8 var err = new Error(‘name required‘);
 9 err.status = 400;
10 throw err;

this.throw方法的两个参数，一个是错误码，另一个是报错信息。如果省略状态码，默认是500错误。

this.assert方法用于在中间件之中断言，用法类似于Node的assert模块

1 this.assert(this.user, 401, ‘User not found. Please login!‘);

上面代码中，如果this.user属性不存在，会抛出一个401错误。

cookie的读取和设置。

1 this.cookies.get(‘view‘);
2 this.cookies.set(‘view‘, n);

get和set方法都可以接受第三个参数，表示配置参数。其中的signed参数，用于指定cookie是否加密。如果指定加密的话，必须用app.keys指定加密短语。

1 app.keys = [‘secret1‘, ‘secret2‘];
2 this.cookies.set(‘name‘, ‘张三‘, { signed: true });

this.cookie的配置对象的属性如下。

signed：cookie是否加密。
expires：cookie何时过期
path：cookie的路径，默认是“/”。
domain：cookie的域名。
secure：cookie是否只有https请求下才发送。
httpOnly：是否只有服务器可以取到cookie，默认为true。

session

 1 var session = require(‘koa-session‘);
 2 var koa = require(‘koa‘);
 3 var app = koa();
 4 
 5 app.keys = [‘some secret hurr‘];
 6 app.use(session(app));
 7 
 8 app.use(function *(){
 9   var n = this.session.views || 0;
10   this.session.views = ++n;
11   this.body = n + ‘ views‘;
12 })
13 
14 app.listen(3000);
15 console.log(‘listening on port 3000‘);

 1 可以把session存到mysql中
 2 安装npm install koa-generic-session --save-dev
 3 2.app.js中
 4 var session = require(‘koa-generic-session‘);
 5 
 6 app.keys = [‘my secret key‘];  // needed for cookie-signing,设置一个签名 Cookie 的密钥
 7 app.use(session());
 8 
 9 3.
10 this.session.loginbean
11 
12 方法二:
13 session映射到mysql
14 1.加安装
15 npm install mysql --save-dev
16 npm install koa-mysql-session --save-dev
17 
18 app.js中:
19 var session = require(‘koa-generic-session‘);
20 const mysql = require(‘mysql‘);
21 const MysqlStore = require(‘koa-mysql-session‘);
22 
23 app.keys = [‘my secret key‘];  // needed for cookie-signing,设置一个签名 Cookie 的密钥
24 app.use(session({store:new MysqlStore({
25   host: ‘localhost‘,       //主机  
26   user: ‘root‘,               //MySQL认证用户名  
27   password: ‘root‘,        //MySQL认证用户密码  
28   database: ‘kameng‘,  
29   port: ‘3306‘,                   //端口号 
30   acquireTimeout:0
31 })}));

Request对象

Request对象表示HTTP请求。

（1）this.request.header

返回一个对象，包含所有HTTP请求的头信息。它也可以写成this.request.headers。

（2）this.request.method

返回HTTP请求的方法，该属性可读写。

（3）this.request.length

返回HTTP请求的Content-Length属性，取不到值，则返回undefined。

（4）this.request.path

返回HTTP请求的路径，该属性可读写。

（5）this.request.href

返回HTTP请求的完整路径，包括协议、端口和url。

1 this.request.href
2 // http://example.com/foo/bar?q=1

（6）this.request.querystring

返回HTTP请求的查询字符串，不含问号。该属性可读写。

（7）this.request.search

返回HTTP请求的查询字符串，含问号。该属性可读写。

（8）this.request.host

返回HTTP请求的主机（含端口号）。

（9）this.request.hostname

返回HTTP的主机名（不含端口号）。

（10）this.request.type

返回HTTP请求的Content-Type属性

1 var ct = this.request.type;
2 // "image/png"

（11）this.request.charset

返回HTTP请求的字符集。

1 this.request.charset
2 // "utf-8"

JavaScript 标准参考教程（alpha）

GitHub
TOP

Koa 框架

来自《JavaScript 标准参考教程（alpha）》，by 阮一峰

Koa应用

var koa = require(‘koa‘);
var app = koa();

app.use(function *(){
  this.body = ‘Hello World‘;
});

app.listen(3000);

上面代码中，变量app就是一个Koa应用。它监听3000端口，返回一个内容为Hello World的网页。

app.use方法用于向middleware数组添加Generator函数。

listen方法指定监听端口，并启动当前应用。它实际上等同于下面的代码。

var http = require(‘http‘);
var koa = require(‘koa‘);
var app = koa();
http.createServer(app.callback()).listen(3000);

中间件

Koa的中间件很像Express的中间件，也是对HTTP请求进行处理的函数，但是必须是一个Generator函数。而且，Koa的中间件是一个级联式（Cascading）的结构，也就是说，属于是层层调用，第一个中间件调用第二个中间件，第二个调用第三个，以此类推。上游的中间件必须等到下游的中间件返回结果，才会继续执行，这点很像递归。

中间件通过当前应用的use方法注册。

app.use(function* (next){
  var start = new Date; // （1）
  yield next;  // （2）
  var ms = new Date - start; // （3）
  console.log(‘%s %s - %s‘, this.method, this.url, ms); // （4）
});

上面代码中，app.use方法的参数就是中间件，它是一个Generator函数，最大的特征就是function命令与参数之间，必须有一个星号。Generator函数的参数next，表示下一个中间件。

Generator函数内部使用yield命令，将程序的执行权转交给下一个中间件，即yield next，要等到下一个中间件返回结果，才会继续往下执行。上面代码中，Generator函数体内部，第一行赋值语句首先执行，开始计时，第二行yield语句将执行权交给下一个中间件，当前中间件就暂停执行。等到后面的中间件全部执行完成，执行权就回到原来暂停的地方，继续往下执行，这时才会执行第三行，计算这个过程一共花了多少时间，第四行将这个时间打印出来。

下面是一个两个中间件级联的例子。

app.use(function *() {
  this.body = "header\n";
  yield saveResults.call(this);
  this.body += "footer\n";
});

function *saveResults() {
  this.body += "Results Saved!\n";
}

上面代码中，第一个中间件调用第二个中间件saveResults，它们都向this.body写入内容。最后，this.body的输出如下。

header
Results Saved!
footer

只要有一个中间件缺少yield next语句，后面的中间件都不会执行，这一点要引起注意。

app.use(function *(next){
  console.log(‘>> one‘);
  yield next;
  console.log(‘<< one‘);
});

app.use(function *(next){
  console.log(‘>> two‘);
  this.body = ‘two‘;
  console.log(‘<< two‘);
});

app.use(function *(next){
  console.log(‘>> three‘);
  yield next;
  console.log(‘<< three‘);
});

上面代码中，因为第二个中间件少了yield next语句，第三个中间件并不会执行。

如果想跳过一个中间件，可以直接在该中间件的第一行语句写上return yield next。

app.use(function* (next) {
  if (skip) return yield next;
})

由于Koa要求中间件唯一的参数就是next，导致如果要传入其他参数，必须另外写一个返回Generator函数的函数。

function logger(format) {
  return function *(next){
    var str = format
      .replace(‘:method‘, this.method)
      .replace(‘:url‘, this.url);

    console.log(str);

    yield next;
  }
}

app.use(logger(‘:method :url‘));

上面代码中，真正的中间件是logger函数的返回值，而logger函数是可以接受参数的。

多个中间件的合并

由于中间件的参数统一为next（意为下一个中间件），因此可以使用.call(this, next)，将多个中间件进行合并。

function *random(next) {
  if (‘/random‘ == this.path) {
    this.body = Math.floor(Math.random()*10);
  } else {
    yield next;
  }
};

function *backwards(next) {
  if (‘/backwards‘ == this.path) {
    this.body = ‘sdrawkcab‘;
  } else {
    yield next;
  }
}

function *pi(next) {
  if (‘/pi‘ == this.path) {
    this.body = String(Math.PI);
  } else {
    yield next;
  }
}

function *all(next) {
  yield random.call(this, backwards.call(this, pi.call(this, next)));
}

app.use(all);

上面代码中，中间件all内部，就是依次调用random、backwards、pi，后一个中间件就是前一个中间件的参数。

Koa内部使用koa-compose模块，进行同样的操作，下面是它的源码。

function compose(middleware){
  return function *(next){
    if (!next) next = noop();

    var i = middleware.length;

    while (i--) {
      next = middleware[i].call(this, next);
    }

    yield *next;
  }
}

function *noop(){}

上面代码中，middleware是中间件数组。前一个中间件的参数是后一个中间件，依次类推。如果最后一个中间件没有next参数，则传入一个空函数。

路由

可以通过this.path属性，判断用户请求的路径，从而起到路由作用。

app.use(function* (next) {
  if (this.path === ‘/‘) {
    this.body = ‘we are at home!‘;
  } else {
    yield next;
  }
})

// 等同于

app.use(function* (next) {
  if (this.path !== ‘/‘) return yield next;
  this.body = ‘we are at home!‘;
})

下面是多路径的例子。

let koa = require(‘koa‘)

let app = koa()

// normal route
app.use(function* (next) {
  if (this.path !== ‘/‘) {
    return yield next
  }

  this.body = ‘hello world‘
});

// /404 route
app.use(function* (next) {
  if (this.path !== ‘/404‘) {
    return yield next;
  }

  this.body = ‘page not found‘
});

// /500 route
app.use(function* (next) {
  if (this.path !== ‘/500‘) {
    return yield next;
  }

  this.body = ‘internal server error‘
});

app.listen(8080)

上面代码中，每一个中间件负责一个路径，如果路径不符合，就传递给下一个中间件。

复杂的路由需要安装koa-router插件。

var app = require(‘koa‘)();
var Router = require(‘koa-router‘);

var myRouter = new Router();

myRouter.get(‘/‘, function *(next) {
  this.response.body = ‘Hello World!‘;
});

app.use(myRouter.routes());

app.listen(3000);

上面代码对根路径设置路由。

Koa-router实例提供一系列动词方法，即一种HTTP动词对应一种方法。典型的动词方法有以下五种。

router.get()
router.post()
router.put()
router.del()
router.patch()

这些动词方法可以接受两个参数，第一个是路径模式，第二个是对应的控制器方法（中间件），定义用户请求该路径时服务器行为。

router.get(‘/‘, function *(next) {
  this.body = ‘Hello World!‘;
});

上面代码中，router.get方法的第一个参数是根路径，第二个参数是对应的函数方法。

注意，路径匹配的时候，不会把查询字符串考虑在内。比如，/index?param=xyz匹配路径/index。

有些路径模式比较复杂，Koa-router允许为路径模式起别名。起名时，别名要添加为动词方法的第一个参数，这时动词方法变成接受三个参数。

router.get(‘user‘, ‘/users/:id‘, function *(next) {
 // ...
});

上面代码中，路径模式\users\:id的名字就是user。路径的名称，可以用来引用对应的具体路径，比如url方法可以根据路径名称，结合给定的参数，生成具体的路径。

router.url(‘user‘, 3);
// => "/users/3"

router.url(‘user‘, { id: 3 });
// => "/users/3"

上面代码中，user就是路径模式的名称，对应具体路径/users/:id。url方法的第二个参数3，表示给定id的值是3，因此最后生成的路径是/users/3。

Koa-router允许为路径统一添加前缀。

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

router.get(‘/‘, ...); // 等同于"/users"
router.get(‘/:id‘, ...); // 等同于"/users/:id"

路径的参数通过this.params属性获取，该属性返回一个对象，所有路径参数都是该对象的成员。

// 访问 /programming/how-to-node
router.get(‘/:category/:title‘, function *(next) {
  console.log(this.params);
  // => { category: ‘programming‘, title: ‘how-to-node‘ }
});

param方法可以针对命名参数，设置验证条件。

router
  .get(‘/users/:user‘, function *(next) {
    this.body = this.user;
  })
  .param(‘user‘, function *(id, next) {
    var users = [ ‘0号用户‘, ‘1号用户‘, ‘2号用户‘];
    this.user = users[id];
    if (!this.user) return this.status = 404;
    yield next;
  })

上面代码中，如果/users/:user的参数user对应的不是有效用户（比如访问/users/3），param方法注册的中间件会查到，就会返回404错误。

redirect方法会将某个路径的请求，重定向到另一个路径，并返回301状态码。

router.redirect(‘/login‘, ‘sign-in‘);

// 等同于
router.all(‘/login‘, function *() {
  this.redirect(‘/sign-in‘);
  this.status = 301;
});

redirect方法的第一个参数是请求来源，第二个参数是目的地，两者都可以用路径模式的别名代替。

context对象

中间件当中的this表示上下文对象context，代表一次HTTP请求和回应，即一次访问/回应的所有信息，都可以从上下文对象获得。context对象封装了request和response对象，并且提供了一些辅助方法。每次HTTP请求，就会创建一个新的context对象。

app.use(function *(){
  this; // is the Context
  this.request; // is a koa Request
  this.response; // is a koa Response
});

context对象的很多方法，其实是定义在ctx.request对象或ctx.response对象上面，比如，ctx.type和ctx.length对应于ctx.response.type和ctx.response.length，ctx.path和ctx.method对应于ctx.request.path和ctx.request.method。

context对象的全局属性。

request：指向Request对象
response：指向Response对象
req：指向Node的request对象
res：指向Node的response对象
app：指向App对象
state：用于在中间件传递信息。

this.state.user = yield User.find(id);

上面代码中，user属性存放在this.state对象上面，可以被另一个中间件读取。

context对象的全局方法。

throw()：抛出错误，直接决定了HTTP回应的状态码。
assert()：如果一个表达式为false，则抛出一个错误。

this.throw(403);
this.throw(‘name required‘, 400);
this.throw(‘something exploded‘);

this.throw(400, ‘name required‘);
// 等同于
var err = new Error(‘name required‘);
err.status = 400;
throw err;

assert方法的例子。

// 格式
ctx.assert(value, [msg], [status], [properties])

// 例子
this.assert(this.user, 401, ‘User not found. Please login!‘);

以下模块解析POST请求的数据。

co-body
https://github.com/koajs/body-parser
https://github.com/koajs/body-parsers

var parse = require(‘co-body‘);

// in Koa handler
var body = yield parse(this);

错误处理机制

Koa提供内置的错误处理机制，任何中间件抛出的错误都会被捕捉到，引发向客户端返回一个500错误，而不会导致进程停止，因此也就不需要forever这样的模块重启进程。

app.use(function *() {
  throw new Error();
});

上面代码中，中间件内部抛出一个错误，并不会导致Koa应用挂掉。Koa内置的错误处理机制，会捕捉到这个错误。

当然，也可以额外部署自己的错误处理机制。

app.use(function *() {
  try {
    yield saveResults();
  } catch (err) {
    this.throw(400, ‘数据无效‘);
  }
});

上面代码自行部署了try…catch代码块，一旦产生错误，就用this.throw方法抛出。该方法可以将指定的状态码和错误信息，返回给客户端。

对于未捕获错误，可以设置error事件的监听函数。

app.on(‘error‘, function(err){
  log.error(‘server error‘, err);
});

error事件的监听函数还可以接受上下文对象，作为第二个参数。

app.on(‘error‘, function(err, ctx){
  log.error(‘server error‘, err, ctx);
});

如果一个错误没有被捕获，koa会向客户端返回一个500错误“Internal Server Error”。

this.throw方法用于向客户端抛出一个错误。

this.throw(403);
this.throw(‘name required‘, 400);
this.throw(400, ‘name required‘);
this.throw(‘something exploded‘);

this.throw(‘name required‘, 400)
// 等同于
var err = new Error(‘name required‘);
err.status = 400;
throw err;

this.throw方法的两个参数，一个是错误码，另一个是报错信息。如果省略状态码，默认是500错误。

this.assert方法用于在中间件之中断言，用法类似于Node的assert模块。

this.assert(this.user, 401, ‘User not found. Please login!‘);

上面代码中，如果this.user属性不存在，会抛出一个401错误。

由于中间件是层级式调用，所以可以把try { yield next }当成第一个中间件。

app.use(function *(next) {
  try {
    yield next;
  } catch (err) {
    this.status = err.status || 500;
    this.body = err.message;
    this.app.emit(‘error‘, err, this);
  }
});

app.use(function *(next) {
  throw new Error(‘some error‘);
})

cookie的读取和设置。

this.cookies.get(‘view‘);
this.cookies.set(‘view‘, n);

get和set方法都可以接受第三个参数，表示配置参数。其中的signed参数，用于指定cookie是否加密。如果指定加密的话，必须用app.keys指定加密短语。

app.keys = [‘secret1‘, ‘secret2‘];
this.cookies.set(‘name‘, ‘张三‘, { signed: true });

this.cookie的配置对象的属性如下。

signed：cookie是否加密。
expires：cookie何时过期
path：cookie的路径，默认是“/”。
domain：cookie的域名。
secure：cookie是否只有https请求下才发送。
httpOnly：是否只有服务器可以取到cookie，默认为true。

session

var session = require(‘koa-session‘);
var koa = require(‘koa‘);
var app = koa();

app.keys = [‘some secret hurr‘];
app.use(session(app));

app.use(function *(){
  var n = this.session.views || 0;
  this.session.views = ++n;
  this.body = n + ‘ views‘;
})

app.listen(3000);
console.log(‘listening on port 3000‘);

Request对象

Request对象表示HTTP请求。

（1）this.request.header

返回一个对象，包含所有HTTP请求的头信息。它也可以写成this.request.headers。

（2）this.request.method

返回HTTP请求的方法，该属性可读写。

（3）this.request.length

返回HTTP请求的Content-Length属性，取不到值，则返回undefined。

（4）this.request.path

返回HTTP请求的路径，该属性可读写。

（5）this.request.href

返回HTTP请求的完整路径，包括协议、端口和url。

this.request.href
// http://example.com/foo/bar?q=1

（6）this.request.querystring

返回HTTP请求的查询字符串，不含问号。该属性可读写。

（7）this.request.search

返回HTTP请求的查询字符串，含问号。该属性可读写。

（8）this.request.host

返回HTTP请求的主机（含端口号）。

（9）this.request.hostname

返回HTTP的主机名（不含端口号）。

（10）this.request.type

返回HTTP请求的Content-Type属性。

var ct = this.request.type;
// "image/png"

（11）this.request.charset

返回HTTP请求的字符集。

this.request.charset
// "utf-8"

（12）this.request.query

返回一个对象，包含了HTTP请求的查询字符串。如果没有查询字符串，则返回一个空对象。该属性可读写。

比如，查询字符串color=blue&size=small，会得到以下的对象。

（13）this.request.fresh

返回一个布尔值，表示缓存是否代表了最新内容。通常与If-None-Match、ETag、If-Modified-Since、Last-Modified等缓存头，配合使用。

 1 his.response.set(‘ETag‘, ‘123‘);
 2 
 3 // 检查客户端请求的内容是否有变化
 4 if (this.request.fresh) {
 5   this.response.status = 304;
 6   return;
 7 }
 8 
 9 // 否则就表示客户端的内容陈旧了，
10 // 需要取出新内容
11 this.response.body = yield db.find(‘something‘);

（14）this.request.stale

返回this.request.fresh的相反值。

（15）this.request.protocol

返回HTTP请求的协议，https或者http。

（16）this.request.secure

返回一个布尔值，表示当前协议是否为https。

（17）this.request.ip

返回发出HTTP请求的IP地址。

（18）this.request.subdomains

返回一个数组，表示HTTP请求的子域名。该属性必须与app.subdomainOffset属性搭配使用。app.subdomainOffset属性默认为2，则域名“tobi.ferrets.example.com”返回[“ferrets”, “tobi”]，如果app.subdomainOffset设为3，则返回[“tobi”]。

（19）this.request.is(types…)

返回指定的类型字符串，表示HTTP请求的Content-Type属性是否为指定类型

CSRF攻击

CSRF攻击是指用户的session被劫持，用来冒充用户的攻击。

koa-csrf插件用来防止CSRF攻击。原理是在session之中写入一个秘密的token，用户每次使用POST方法提交数据的时候，必须含有这个token，否则就会抛出错误。

 1 var koa = require(‘koa‘);
 2 var session = require(‘koa-session‘);
 3 var csrf = require(‘koa-csrf‘);
 4 var route = require(‘koa-route‘);
 5 
 6 var app = module.exports = koa();
 7 
 8 app.keys = [‘session key‘, ‘csrf example‘];
 9 app.use(session(app));
10 
11 app.use(csrf());
12 
13 app.use(route.get(‘/token‘, token));
14 app.use(route.post(‘/post‘, post));
15 
16 function* token () {
17   this.body = this.csrf;
18 }
19 
20 function* post() {
21   this.body = {ok: true};
22 }
23 
24 app.listen(3000);

POST请求含有token，可以是以下几种方式之一，koa-csrf插件就能获得token。

表单的_csrf字段
查询字符串的_csrf字段
HTTP请求头信息的x-csrf-token字段
HTTP请求头信息的x-xsrf-token字段

参考链接

Koa Guide
William XING, Is Koa.js right for me?

Koa1 框架

标签：cookie ora ase faq 上下文 method blob blog mysq

原文地址：http://www.cnblogs.com/yu-hailong/p/7628794.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行

Koa1 框架

Koa应用

中间件

路由

错误处理机制

cookie

session

Request对象

JavaScript 标准参考教程（alpha）

Koa 框架

目录

Koa应用

中间件

多个中间件的合并

路由

context对象

错误处理机制

cookie

session

Request对象

CSRF攻击

参考链接