Skip to content

Hprose 中间件

Jump to bottom
小马哥 edited this page Aug 7, 2016 · 18 revisions

简介

Hprose 过滤器的功能虽然比较强大，可以将 Hprose 的功能进行扩展。但是有些功能使用它仍然难以实现，比如缓存。

为此，Hprose 2.0 引入了更加强大的中间件功能。Hprose 中间件不仅可以对输入输出的数据进行操作，它还可以对调用本身的参数和结果进行操作，甚至你可以跳过中间的执行步骤，或者完全由你来接管中间数据的处理。

Hprose 中间件跟普通的 HTTP 服务器中间件有些类似，但又有所不同。

Hprose 中间件分为客户端和服务器端两类。

Hprose 客户端中间件分为三种：

  • 调用中间件
  • 批处理调用中间件
  • 输入输出中间件

Hprose 服务器端中间件分为两种：

  • 调用中间件
  • 输入输出中间件

即客户端比服务器端多了一个批处理调用中间件。

另外，输入输出中间件又可以细分为 beforeFilter 和 afterFilter 两种，但它们本质上没有什么区别，只是在执行顺序上有所区别。

执行顺序

Hprose 中间件的顺序执行是按照添加的前后顺序执行的，假设添加的中间件处理器分别为：handler1, handler2 ... handlerN，那么执行顺序就是 handler1, handler2 ... handlerN。

不同类型的 Hprose 中间件和 Hprose 其它过程的执行流程如下图所示：

+------------------------------------------------------------------+
|                 +-----------------batch invoke----------------+  |
|       +------+  | +-----+   +------+       +------+   +-----+ |  |
|       |invoke|  | |begin|   |invoke|  ...  |invoke|   | end | |  |
|       +------+  | +-----+   +------+       +------+   +-----+ |  |
|           ^     +---------------------------------------------+  |
|           |                            ^                         |
|           |                            |                         |
|           v                            v                         |
| +-------------------+        +------------------+                |
| | invoke middleware |        | batch middleware |                |
| +-------------------+        +------------------+                |
|           ^                            ^                         |
|           |     +---------------+      |                         |
|           +---->| encode/decode |<-----+                         |
|                 +---------------+                                |
|                         ^                                        |
|                         |                                        |
|                         v                                        |
|           +--------------------------+                           |
|           | before filter middleware |                           |
|           +--------------------------+                           |
|                         ^                                        |
|                         |       _  _ ___  ____ ____ ____ ____    |
|                         v       |__| |__] |__/ |  | [__  |___    |
|                    +--------+   |  | |    |  \ |__| ___] |___    |
|                    | filter |                                    |
|                    +--------+     ____ _    _ ____ _  _ ___      |
|                         ^         |    |    | |___ |\ |  |       |
|                         |         |___ |___ | |___ | \|  |       |
|                         v                                        |
|            +-------------------------+                           |
|            | after filter middleware |                           |
|            +-------------------------+                           |
+------------------------------------------------------------------+
                                  ^                                 
                                  |                                 
                                  |                                 
                                  v                                 
+------------------------------------------------------------------+
|           +--------------------------+                           |
|           | before filter middleware |                           |
|           +--------------------------+                           |
|                         ^                                        |
|                         |        _  _ ___  ____ ____ ____ ____   |
|                         v        |__| |__] |__/ |  | [__  |___   |
|                    +--------+    |  | |    |  \ |__| ___] |___   |
|                    | filter |                                    |
|                    +--------+    ____ ____ ____ _  _ ____ ____   |
|                         ^        [__  |___ |__/ |  | |___ |__/   |
|                         |        ___] |___ |  \  \/  |___ |  \   |
|                         v                                        |
|            +-------------------------+                           |
|            | after filter middleware |                           |
|            +-------------------------+                           |
|                         ^                                        |
|                         |                                        |
|                         v                                        |
|                 +---------------+                                |
|    +----------->| encode/decode |<---------------------+         |
|    |            +---------------+                      |         |
|    |                    |                              |         |
|    |                    |                              |         |
|    |                    v                              |         |
|    |            +---------------+                      |         |
|    |            | before invoke |-------------+        |         |
|    |            +---------------+             |        |         |
|    |                    |                     |        |         |
|    |                    |                     |        |         |
|    |                    v                     v        |         |
|    |          +-------------------+    +------------+  |         |
|    |          | invoke middleware |--->| send error |--+         |
|    |          +-------------------+    +------------+            |
|    |                    |                     ^                  |
|    |                    |                     |                  |
|    |                    v                     |                  |
|    |            +--------------+              |                  |
|    |            | after invoke |--------------+                  |
|    |            +--------------+                                 |
|    |                    |                                        |
|    |                    |                                        |
|    +--------------------+                                        |
+------------------------------------------------------------------+

调用中间件

调用中间件的形式为：

function(name, args, context, next) {
    ...
    var result = next(name, args, context);
    ...
    return result;
}

name 是调用的远程函数/方法名。

args 是调用参数。

context 是调用上下文对象。

next 表示下一个中间件。通过调用 next 将各个中间件串联起来。

在调用 next 之前的操作在调用发生前执行，在调用 next 之后的操作在调用发生后执行，如果你不想修改返回结果，你应该将 next 的返回值作为该中间件的返回值返回。

跟踪调试

我们来看一个例子：

loghandler.js

module.exports = function(name, args, context, next) {
    console.log("before invoke:", name, args);
    var result = next(name, args, context);
    result.then(function(result) {
        console.log("after invoke:", name, args, result);
    });
    return result;
};

client.js

var hprose = require("hprose");
var loghandler = require("./loghandler.js");
var client = hprose.Client.create("http://127.0.0.1:8080/", ['hello']);
client.use(loghandler);
client.hello("world", function(result) {
    console.log(result);
});

server.js

var hprose = require("hprose");
var loghandler = require("./loghandler.js");
function hello(name) {
    return "Hello " + name + "!";
}
var server = hprose.Server.create("http://0.0.0.0:8080");
server.use(loghandler);
server.add(hello);
server.start();

然后分别启动服务器和客户端，就会看到如下输出：

服务器输出

before invoke: hello [ 'world' ]
after invoke: hello [ 'world' ] Hello world!

客户端输出

before invoke: hello [ 'world' ]
after invoke: hello [ 'world' ] Hello world!
Hello world!

通过上面的输出，我们会发现结果 result 是个 promise 对象。但参数值 args 在 loghandler 里并不包含 Promise 的值，原因是 Hprose 内部已经对参数值处理过了。这样对于中间件编写就方便了很多，只需要处理异步结果就可以了。

缓存调用

我们再来看一个实现缓存调用的例子，在这个例子中我们也使用了上面的日志中间件，用来观察我们的缓存是否真的有效。

cachehandler.js

var cache = {};
module.exports = function(name, args, context, next) {
    if (context.userdata.cache) {
        var key = JSON.stringify(args);
        if (name in cache) {
            if (key in cache[name]) {
                return cache[name][key];
            }
        }
        else {
            cache[name] = {};
        }
        var result = next(name, args, context);
        cache[name][key] = result;
        return result;
    }
    return next(name, args, context);
};

client.js

var hprose = require("hprose");
var loghandler = require("./loghandler.js");
var cachehandler = require("./cachehandler.js");
var client = hprose.Client.create("http://127.0.0.1:8080/", ['hello']);
client.use(cachehandler)
      .use(loghandler);
client.hello("cache world", function(result) {
    console.log(result);
}, { userdata: { cache: true } });
client.hello("cache world", function(result) {
    console.log(result);
}, { userdata: { cache: true } });
client.hello("no cache world", function(result) {
    console.log(result);
});
client.hello("no cache world", function(result) {
    console.log(result);
});

我们的服务器仍然使用上面例子中的服务器。在确保服务器已启动的情况下，我们运行客户端，可以看到它们分别输出以下结果：

服务器输出

before invoke: hello [ 'cache world' ]
after invoke: hello [ 'cache world' ] Hello cache world!
before invoke: hello [ 'no cache world' ]
before invoke: hello [ 'no cache world' ]
after invoke: hello [ 'no cache world' ] Hello no cache world!
after invoke: hello [ 'no cache world' ] Hello no cache world!

客户端输出

before invoke: hello [ 'cache world' ]
before invoke: hello [ 'no cache world' ]
before invoke: hello [ 'no cache world' ]
after invoke: hello [ 'cache world' ] Hello cache world!
after invoke: hello [ 'no cache world' ] Hello no cache world!
after invoke: hello [ 'no cache world' ] Hello no cache world!
Hello cache world!
Hello cache world!
Hello no cache world!
Hello no cache world!

我们看到输出结果中 'cache world' 的日志只被打印了一次，而 'no cache world' 的日志被打印了两次。这说明 'cache world' 确实被缓存了。

在这个例子中，我们用到了 userdata 设置项和 context.userdata，通过 userdata 配合 Hprose 中间件，我们就可以实现自定义选项功能了。

另外，我们在这个例子中可以看到，use 方法可以链式调用。

批处理调用中间件

上面的调用中间件对于批处理调用是不起作用的，因为批处理调用是单独处理的。

批处理调用中间件的形式为：

function(batches, context, next) {
    ...
    var result = next(batches, context);
    ...
    return result;
}

batches 是个数组。它的每个元素都是一个对象，该对象表示一个单独的调用，它包含有以下属性：

  • name 是调用的远程函数/方法名。
  • args 是调用的参数。
  • context 是调用的上下文对象。
  • resolve 用于返回成功结果的回调函数。
  • reject 用于返回失败结果（异常）的回调函数。

context 是批处理调用的上下文对象。

next 表示下一个中间件。通过调用 next 将各个中间件串联起来。

在调用 next 之前的操作在批处理调用发生前执行，在调用 next 之后的操作在批处理调用发生后执行，如果你不想修改返回结果，你应该将 next 的返回值作为该中间件的返回值返回。

批处理跟踪调试

batchloghandler.js

module.exports = function(batches, context, next) {
    console.log("before invoke:", batches);
    var result = next(batches, context);
    result.then(function(result) {
        console.log("after invoke:", batches, result);
    });
    return result;
};

client.js

var hprose = require("hprose");
var batchloghandler = require("./batchloghandler.js");
var log = hprose.Future.wrap(console.log, console);
var client = hprose.Client.create("http://127.0.0.1:8080/", ['hello']);
client.batch.use(batchloghandler);
client.batch.begin();
var r1 = client.hello("world 1");
var r2 = client.hello("world 2");
var r3 = client.hello("world 3");
client.batch.end();
log(r1, r2, r3);

服务器端我们不修改，还用上面那个例子中的服务器。先后启动服务器和客户端之后，我们会看到

服务器输出

before invoke: hello [ 'world 1' ]
before invoke: hello [ 'world 2' ]
before invoke: hello [ 'world 3' ]
after invoke: hello [ 'world 1' ] Hello world 1!
after invoke: hello [ 'world 2' ] Hello world 2!
after invoke: hello [ 'world 3' ] Hello world 3!

客户端输出

before invoke: [ { args: [ 'world 1' ],
    name: 'hello',
    context: 
     { mode: 0,
       byref: false,
       simple: false,
       onsuccess: undefined,
       onerror: undefined,
       useHarmonyMap: false,
       client: [Object],
       userdata: {} },
    resolve: [Function: bound ],
    reject: [Function: bound ] },
  { args: [ 'world 2' ],
    name: 'hello',
    context: 
     { mode: 0,
       byref: false,
       simple: false,
       onsuccess: undefined,
       onerror: undefined,
       useHarmonyMap: false,
       client: [Object],
       userdata: {} },
    resolve: [Function: bound ],
    reject: [Function: bound ] },
  { args: [ 'world 3' ],
    name: 'hello',
    context: 
     { mode: 0,
       byref: false,
       simple: false,
       onsuccess: undefined,
       onerror: undefined,
       useHarmonyMap: false,
       client: [Object],
       userdata: {} },
    resolve: [Function: bound ],
    reject: [Function: bound ] } ]
after invoke: [ { args: [ 'world 1' ],
    name: 'hello',
    context: 
     { mode: 0,
       byref: false,
       simple: false,
       onsuccess: undefined,
       onerror: undefined,
       useHarmonyMap: false,
       client: [Object],
       userdata: {} },
    resolve: [Function: bound ],
    reject: [Function: bound ],
    result: 'Hello world 1!',
    error: null },
  { args: [ 'world 2' ],
    name: 'hello',
    context: 
     { mode: 0,
       byref: false,
       simple: false,
       onsuccess: undefined,
       onerror: undefined,
       useHarmonyMap: false,
       client: [Object],
       userdata: {} },
    resolve: [Function: bound ],
    reject: [Function: bound ],
    result: 'Hello world 2!',
    error: null },
  { args: [ 'world 3' ],
    name: 'hello',
    context: 
     { mode: 0,
       byref: false,
       simple: false,
       onsuccess: undefined,
       onerror: undefined,
       useHarmonyMap: false,
       client: [Object],
       userdata: {} },
    resolve: [Function: bound ],
    reject: [Function: bound ],
    result: 'Hello world 3!',
    error: null } ] [ { args: [ 'world 1' ],
    name: 'hello',
    context: 
     { mode: 0,
       byref: false,
       simple: false,
       onsuccess: undefined,
       onerror: undefined,
       useHarmonyMap: false,
       client: [Object],
       userdata: {} },
    resolve: [Function: bound ],
    reject: [Function: bound ],
    result: 'Hello world 1!',
    error: null },
  { args: [ 'world 2' ],
    name: 'hello',
    context: 
     { mode: 0,
       byref: false,
       simple: false,
       onsuccess: undefined,
       onerror: undefined,
       useHarmonyMap: false,
       client: [Object],
       userdata: {} },
    resolve: [Function: bound ],
    reject: [Function: bound ],
    result: 'Hello world 2!',
    error: null },
  { args: [ 'world 3' ],
    name: 'hello',
    context: 
     { mode: 0,
       byref: false,
       simple: false,
       onsuccess: undefined,
       onerror: undefined,
       useHarmonyMap: false,
       client: [Object],
       userdata: {} },
    resolve: [Function: bound ],
    reject: [Function: bound ],
    result: 'Hello world 3!',
    error: null } ]
Hello world 1! Hello world 2! Hello world 3!

这段输出比较长，这里就不需要解释了。

这里有一点要注意，那就是批处理调用中间件使用：client.batch.use 方法来添加，该方法也支持链式调用，链式调用方式为：

client.batch.use(handler1)
            .use(handler2)
            .use(handler3);

输入输出中间件

输入输出中间件可以完全代替 Hprose 过滤器。使用输入输出中间件还是使用 Hprose 过滤器完全看开发者喜好。

输入输出中间件的形式为：

function(request, context, next) {
    ...
    var response = next(request, context);
    ...
    return response;
}

request 是原始请求数据，对于客户端来说它是输出数据，对于服务器端来说，它是输入数据。该数据的类型为 Uint8Array 类型对象。

context 是调用上下文对象。

next 表示下一个中间件。通过调用 next 将各个中间件串联起来。

next 的返回值 response 是返回的响应数据。对于客户端来说，它是输入数据。对于服务器端来说，它是输出数据。这个 response 必须为 promise 对象，且 promise 对象的成功值必须为 Uint8Array 类型的对象。

跟踪调试

下面我们来看一下 Hprose 过滤器中的跟踪调试的例子在这里如何实现。

loghandler.js

var hprose = require('hprose');
module.exports = function(request, context, next) {
    console.log(hprose.BytesIO.toString(request));
    var response = next(request, context);
    response.then(function(data) {
        console.log(hprose.BytesIO.toString(data));
    });
    return response;
};

server.js

var hprose = require("hprose");
var loghandler = require("./loghandler.js");
function hello(name) {
    return "Hello " + name + "!";
}
var server = hprose.Server.create("http://0.0.0.0:8080");
server.beforeFilter.use(loghandler);
server.add(hello);
server.start();

client.js

var hprose = require("hprose");
var loghandler = require("./loghandler.js");
var client = hprose.Client.create("http://127.0.0.1:8080/", ['hello']);
client.beforeFilter.use(loghandler);
client.hello("world", function(result) {
    console.log(result);
});

然后分别启动服务器和客户端，就会看到如下输出：

服务器输出

Cs5"hello"a1{s5"world"}z
Rs12"Hello world!"z

客户端输出

Cs5"hello"a1{s5"world"}z
Rs12"Hello world!"z
Hello world!

这个结果跟使用 Hprose 过滤器的例子的结果一模一样。

但是我们发现，这里使用 Hprose 中间件要写的代码比起 Hprose 过滤器来要多一些。主要原因是在 Hprose 中间件中，next 的返回值为 Promise 对象，需要异步处理，而 Hprose 过滤器只需要同步处理就可以了。

另外，因为这个例子中，我们没有使用过滤器功能，因此使用 beforeFilter.use 方法或者 afterFilter.use 方法添加中间件处理器效果都是一样的。

但如果我们使用了过滤器的话，那么 beforeFilter.use 添加的中间件处理器的 request 数据是未经过过滤器处理的。过滤器的处理操作在 next 的最后一环中执行。next 返回的响应 response 是经过过滤器处理的。

如果某个通过 beforeFilter.use 添加的中间件处理器跳过了 next 而直接返回了结果的话，则返回的 response 也是未经过过滤器处理的。而且如果某个 beforeFilter.use 添加的中间件处理器跳过了 next，不但过滤器不会执行，而且在它之后使用 beforeFilter.use 所添加的中间件处理器也不会执行，afterFilter.use 方法所添加的所有中间件处理器也都不会执行。

而 afterFilter.use 添加的处理器所收到的 request 都是经过过滤器处理以后的，但它当中使用 next 方法返回的 response 是未经过过滤器处理的。

下面，我们在来看一个结合了压缩过滤器和输入输出缓存中间件的例子。

压缩、缓存、计时

CompressFilter.js

var hprose = require('hprose');
var compressjs = require('compressjs');
function CompressFilter(algorithmName) {
    this.algorithm = compressjs[algorithmName];
}
CompressFilter.prototype.inputFilter = function(data) {
    return this.algorithm.decompressFile(data);
};
CompressFilter.prototype.outputFilter = function(data) {
    return this.algorithm.compressFile(data);
};
module.exports = CompressFilter;

上面的代码跟 Hprose 过滤器一章的压缩代码完全相同。

sizehandler.js

var hprose = require('hprose');
module.exports = function(message) {
    return function(request, context, next) {
        console.log(message + ' request size: ' + request.length);
        var response = next(request, context);
        response.then(function(data) {
            console.log(message + ' response size: ' + data.length);
        });
        return response;
    };
};

stathandler.js

module.exports = function(message) {
    return function(request, context, next) {
        var start = Date.now();
        var response = next(request, context);
        response.then(function() {
            var end = Date.now();
            console.log(message + ': It takes ' + (end - start) + ' ms.');
        });
        return response;
    };
};

cachehandler.js

var cache = {};
module.exports = function(request, context, next) {
    if (context.userdata.cache) {
        if (request in cache) {
            return cache[request];
        }
        var response = next(request, context);
        cache[request] = response;
        return response;
    }
    return next(request, context);
};

server.js

var hprose = require("hprose");
var CompressFilter = require("./CompressFilter.js");
var sizehandler = require("./sizehandler.js");
var stathandler = require("./stathandler.js");
function echo(value) {
    return value;
}
var server = hprose.Server.create("http://0.0.0.0:8080");
server.beforeFilter.use(stathandler('BeforeFilter'))
                   .use(sizehandler('compressed'));
server.addFilter(new CompressFilter('Lzp3'));
server.afterFilter.use(stathandler('AfterFilter'))
                  .use(sizehandler('Non compressed'));
server.add(echo);
server.start();

client.js

var hprose = require("hprose");
var CompressFilter = require("./CompressFilter.js");
var cachehandler = require("./cachehandler.js");
var sizehandler = require("./sizehandler.js");
var stathandler = require("./stathandler.js");
var client = hprose.Client.create("http://127.0.0.1:8080/", ['echo']);
client.beforeFilter.use(cachehandler)
                   .use(stathandler('BeforeFilter'))
                   .use(sizehandler('Non compressed'));
client.addFilter(new CompressFilter('Lzp3'));
client.afterFilter.use(stathandler('AfterFilter'))
                  .use(sizehandler('compressed'));
var value = [];
for (var i = 0; i < 100000; i++) {
    value[i] = i;
}
client.echo(value, function(result) {
    console.log(result.length);
}, { userdata: { cache: true } });
client.echo(value, function(result) {
    console.log(result.length);
}, { userdata: { cache: true } });

分别启动服务器和客户端，就会看到如下输出：

服务器输出

compressed request size: 127233
Non compressed request size: 688893
Non compressed response size: 688881
AfterFilter: It takes 250 ms.
compressed response size: 127217
BeforeFilter: It takes 434 ms.

客户端输出

Non compressed request size: 688893
compressed request size: 127233
compressed response size: 127217
AfterFilter: It takes 537 ms.
Non compressed response size: 688881
BeforeFilter: It takes 726 ms.
100000
100000

我们可以看到两次的执行结果都出来了，但是中间件的输出内容只有一次。原因就是第二次执行时，cachehandler 将缓存的结果直接返回了。因此后面所有的步骤就都略过了。

通过这个例子，我们可以看出，将 Hprose 中间件和 Hprose 过滤器结合，可以实现非常强大的扩展功能。如果你有什么特殊的需求，直接使用 Hprose 无法实现的话，就考虑一下是否可以添加几个 Hprose 中间件和 Hprose 过滤器吧。

Hprose for Node.js 用户手册
Clone this wiki locally