js 服务器

这是为了方便使用javascript进行web开发准备的。

它与nodejs的不同在于它使用duktape引擎。虽然该引擎的执行效率比不上v8引擎，但是它是轻量级的，效率虽不够好，但也不太差。其执行效率方面的劣势可通过多进程化服务器、开启lru缓存等多种途径来弥补。压测显示，多进程化后，其并发性能高于nodejs。

duktapeVSnode

上图是一个简单的hello,world测试，node在8888端口,js_server在9090端口。第一次压测js_server为单进程，第三次压测时采用多进程化js_server。

特别需要说明的是，在测试比较中发现，nodejs(v11)完成上述测试通常需要很多的内存消耗——50MB-120MB,与并发数量正相关。而js_server的内存消耗近通常不会超过1.8MB，与并发数量没什么关系。

来看例子：

  2. #include <mongols/js_server.hpp>
  4. int main(int, char**) {
  5.     int port = 9090;
  6.     const char* host = "127.0.0.1";
  7.     mongols::js_server
  8.     server(host, port, 5000, 8096, 0/*2*/);
  9.     server.set_root_path("html/js");
  10.     server.set_enable_bootstrap(true);
  11.     server.run("html/js/package", "html/js/package");
  12. }

run方法的第一个参数表示js模块的搜索路径，第二个参数则表示c/c++模块的搜索路径。

  1. //index.js
  3. /*
  4. var foo = require('foo')
  5. mongols_res.header('Content-Type','text/plain;charset=UTF-8')
  6. mongols_res.content(foo.hello())
  7. mongols_res.status(200)
  8. */
  10. /*
  11. var math = require('math/math')
  12. var v=math.minus(1,3)/math.add(100,3)
  13. mongols_res.header('Content-Type','text/plain;charset=UTF-8')
  14. mongols_res.content(v.toString())
  15. mongols_res.status(200)
  16. */
  19. /*
  20. var loaded = mongols_module.require('adder/libadder','adder')
  21. mongols_res.header('Content-Type','text/plain;charset=UTF-8')
  22. mongols_res.content(loaded?adder(1,2).toString():'failed load c module.')
  23. mongols_res.status(200)
  24. */
  26. /*
  27. var loaded = mongols_module.require('concat/libconcat','concat')
  28. mongols_res.header('Content-Type','text/plain;charset=UTF-8')
  29. mongols_res.content(loaded?concat('Hello,','world'):'failed load c module.')
  30. mongols_res.status(200)
  31. */
  35. ///*
  36. mongols_res.header('Content-Type','text/plain;charset=UTF-8')
  37. mongols_res.content('hello,world')
  38. mongols_res.status(200)
  39. //*/

模块

js 模块

用require加载

c/c++ 模块

动态库模块

动态库可以用mongols_module.require加载:

  1. #include <mongols/lib/dukglue/duktape.h>
  3. #ifdef __cplusplus
  4. extern "C" {
  5. #endif
  7.     duk_ret_t adder(duk_context *ctx) {
  8.         int i;
  9.         int n = duk_get_top(ctx); /* #args */
  10.         double res = 0.0;
  12.         for (i = 0; i < n; i++) {
  13.             res += duk_to_number(ctx, i);
  14.         }
  16.         duk_push_number(ctx, res);
  17.         return 1; /* one return value */
  18.     }
  21. #ifdef __cplusplus
  22. }
  23. #endif

编译为libadder.so——编译时需使用pkg-config —libs —cflags mongols，然后使用：

  2.  var loaded = mongols_module.require('adder/libadder','adder')
  3.  mongols_res.header('Content-Type','text/plain;charset=UTF-8')
  4.  mongols_res.content(loaded?adder(1,2).toString():'failed load c module.')
  5.  mongols_res.status(200)

mongols_module.require方法的第一个参数加载路径，第二个参数是函数名。返回布尔值。

也可以在动态库中注册c++函数或者类。方法是先如上注册普通的c函数，然后在该函数中注册c++函数和类。例如：

  2. #include <string>
  3. #include <mongols/lib/dukglue/dukglue.h>
  4. #include <mongols/lib/dukglue/duktape.h>
  5. #include <mongols/js_server.hpp>
  7. #include "dukglue/duktape.h"
  9. class demo : public mongols::js_object {
  10. public:
  11.     demo() = default;
  12.     virtual~demo() = default;
  14.     std::string echo(const std::string& text) {
  15.         return text;
  16.     }
  18.     static bool loaded;
  19. };
  21. bool demo::loaded = false;
  23. #ifdef __cplusplus
  24. extern "C" {
  25. #endif
  27.     duk_ret_t cpp(duk_context *ctx) {
  28.         if (!demo::loaded) {
  29.             dukglue_register_constructor<demo>(ctx, "demo");
  30.             dukglue_register_method(ctx, &demo::echo, "echo");
  31.             demo::loaded = true;
  32.         }
  33.         if (demo::loaded) {
  34.             duk_push_true(ctx);
  35.         } else {
  36.             duk_push_false(ctx);
  37.         }
  38.         return 1; /* one return value */
  39.     }
  41. #ifdef __cplusplus
  42. }
  43. #endif

调用方法，先用mongols_module.require加载动态库，然后调用c函数注册c++类和函数：

  2. var loaded = mongols_module.require('cpp/libcpp', 'cpp')
  3. var registered = cpp()
  4. if (loaded && registered) {
  5.     var a = new demo()
  6.     mongols_res.header('Content-Type', 'text/plain;charset=UTF-8')
  7.     mongols_res.content(a.echo('hello,cpp class'))
  8.     mongols_res.status(200)
  9.     mongols_module.free(a)
  10. }

类和函数注入

js_server还支持直接注入c/c++函数和类到服务器：

  2. class person : public mongols::js_object {
  3. public:
  5.     person() : mongols::js_object(), name("Tom"), age(0) {
  6.     }
  7.     virtual~person() = default;
  9.     void set_name(const std::string& name) {
  10.         this->name = name;
  11.     }
  13.     void set_age(unsigned int age) {
  14.         this->age = age;
  15.     }
  17.     const std::string& get_name() const {
  18.         return this->name;
  19.     }
  21.     unsigned int get_age() {
  22.         return this->age;
  23.     }
  24. private:
  25.     std::string name;
  26.     unsigned int age;
  27. };
  29. class studest : public person {
  30. public:
  32.     studest() : person() {
  33.     }
  34.     virtual~studest() = default;
  36.     double get_score() {
  37.         return this->score;
  38.     }
  40.     void set_score(double score) {
  41.         this->score = score;
  42.     }
  43. private:
  44.     double score;
  45. };
  46. // some code
  49. server.register_class_constructor<person>("person");
  50. server.register_class_method(&person::set_age, "set_age");
  51. server.register_class_method(&person::get_age, "get_age");
  52. server.register_class_method(&person::set_name, "set_name");
  53. server.register_class_method(&person::get_name, "get_name");
  55. server.register_class_constructor<studest>("studest");
  56. server.register_class_method(&studest::get_score, "get_score");
  57. server.register_class_method(&studest::set_score, "set_score");
  58. server.set_base_class<mongols::js_object, person>();
  59. server.set_base_class<person, studest>();
  61. server.register_function(&mongols::md5, "md5");
  62. server.register_function(&mongols::sha1, "sha1");
  2. var handlebars = require('handlebars')
  3. var s=new studest()
  4. s.set_name("Jerry")
  5. s.set_age(14)
  6. s.set_score(74.6)
  7. var text='hello,world'
  8. var tpl=handlebars.compile('name: {{name}}\nage: {{age}}\nscore: {{score}}\ntext:{{text}}\ntext_md5: {{md5}}\ntext_sha1: {{sha1}}')
  9. var content=tpl({name:s.get_name(),age:s.get_age(),score:s.get_score(),text:text,md5:md5(text),sha1:sha1(text)})
  10. mongols_module.free(s)
  11. mongols_res.header('Content-Type','text/plain;charset=UTF-8')
  12. mongols_res.content(content)
  13. mongols_res.status(200)

就这一点而言，js_server与lua_server是基本一致的。不过，lua的执行效率远高于duktape——如果不开启lru缓存。

特别注意:

  • 所有需要注册的c++类必须继承mongols::js_object类且不允许多重继承。
  • 所有注册的c++类，用new创建、使用完毕后，一定要使用mongols_module.free方法进行垃圾回收，因为duktape不管理c++类实例生命期。

API

mongols_req

  • uri
  • method
  • client
  • param
  • user_agent
  • has_header
  • get_header
  • has_form
  • get_form
  • has_session
  • get_session
  • has_cookie
  • get_cookie
  • has_cache
  • get_cache

mongols_res

  • status
  • content
  • header
  • session
  • cache

单文件入口

js_server支持单文件入口模式。方法是引入route模块，与lua_server的使用方法类似：

  2. var route = require('route').get_instance()
  4. route.add(['GET'], '^\/(hello|test)?\/?$', function (req, res, param) {
  5.     res.header('Content-Type', 'text/plain;charset=UTF8')
  6.     res.content(param.toString())
  7.     res.status(200)
  8. })
  10. route.add(['POST', 'PUT'], '^\/.*$', function (req, res, param) {
  11.     res.header('Content-Type', 'text/plain;charset=UTF8')
  12.     res.content(req.uri())
  13.     res.status(200)
  14. })
  17. route.run(mongols_req, mongols_res)

其他

mongols_module对象实例下有个read方法，可完整读取文件。

比较

v8比duktape快，这是毫无疑义的。单纯执行复杂一点的代码，前者的效率可能是后者的几倍甚至十几倍。

然而，对web应用而言，承载js引擎的服务器并发性能，具有更大的意义。例如，当js_server和nodejs都使用LRU缓存提升吞吐率时，js_server的吞吐率就会数倍于nodejs。这是由服务器性能决定的。比如：

  2. var http = require('http');
  3. var md5=require('md5')
  4. var sha1=require('sha1')
  5. var studest=require('./studest')
  6. var handlebars = require('./handlebars')
  7. const QuickLRU = require('quick-lru');
  8. const lru = new QuickLRU({maxSize: 1000});
  11. http.createServer(function (request, response) {
  12.     response.writeHead(200, {'Content-Type': 'text/plain;charset=UTF-8'});
  14.     if(lru.has('key')){
  15.         response.end(lru.get('key'));
  16.     }else{
  17.         var s=new studest()
  18.         s.set_name("Jerry")
  19.         s.set_age(14)
  20.         s.set_score(74.6)
  21.         var text='hello,world'
  22.         var tpl=handlebars.compile('name: {{name}}\nage: {{age}}\nscore: {{score}}\ntext:{{text}}\ntext_md5: {{md5}}\ntext_sha1: {{sha1}}')
  23.         var content=tpl({name:s.get_name(),age:s.get_age(),score:s.get_score(),text:text,md5:md5(text),sha1:sha1(text)})
  24.         lru.set('key',content)
  25.         response.end(content)
  26.     }
  27. }).listen(8888);

以上是个略复杂的nodejs例子。开启LRU缓存可使得吞吐率2千多提升至2万多。如果开启多进程模式，nodejs的吞吐率可达到4万多。

但是，同样的逻辑，用js_server实现：

  2. var handlebars = require('handlebars')
  3. var s=new studest()
  4. s.set_name("Jerry")
  5. s.set_age(14)
  6. s.set_score(74.6)
  7. var text='hello,world'
  8. var tpl=handlebars.compile('name: {{name}}\nage: {{age}}\nscore: {{score}}\ntext:{{text}}\ntext_md5: {{md5}}\ntext_sha1: {{sha1}}')
  9. var content=tpl({name:s.get_name(),age:s.get_age(),score:s.get_score(),text:text,md5:md5(text),sha1:sha1(text)})
  10. mongols_module.free(s)
  11. mongols_res.header('Content-Type','text/plain;charset=UTF-8')
  12. mongols_res.content(content)
  13. mongols_res.status(200)

开启LRU缓存（仅仅1秒的缓存期）即可使得吞吐率从3百多提升至8万多——nodejs多进程也没有js_server轻快。如果同时多进程化，吞吐率可高达13万以上。如果再比较内存消耗，则js_server的优势会更加明显：每个nodejs进程都需要40MB+的内存，而js_server每个进程只需3MB+的内存。因此，完全不必纠结于v8与duktape的比较：决定性的因素是承载脚本引擎的服务器，而非脚本引擎本身。

原文: https://mongols.hi-nginx.com/doc/js.html