feat: hessian2 optimize codec (#97)

Author: denghongcai

README.md

@@ -401,6 +401,9 @@ xd8 - xef    # one-octet compact long (-x8 to xf, xe0 is 0)
 xf0 - xff    # two-octet compact long (-x800 to x7ff, xf8 is 0)
 ```
 
+## About Hessian 2.0 Optimized Decoder
+Hessian 2.0 introduced [ref](http://hessian.caucho.com/doc/hessian-serialization.html##ref) to avoid sending duplicated class definition in the same context. Actully, the `context` can promote to `connection` level in some RPC framework. For example, [EADS](https://www.aliyun.com/product/edas), Requests using the same connection will not change their class definition.
+
 ## Licences
 
 [MIT](LICENSE)

lib/v2/encoder.js

@@ -41,6 +41,7 @@ var proto = Encoder.prototype;
 proto.reset = proto.clean = function () {
   EncoderV1.prototype.clean.call(this);
   this._classRefs = [];
+  this._classRefFields = {};
   this._typeRefs = [];
   return this;
 };

lib/v2_optimize/decoder.js

@@ -0,0 +1,38 @@
+/**
+ * hessian.js - lib/v2_optimize/decoder.js
+ *
+ * Copyright(c)
+ * MIT Licensed
+ *
+ * Authors:
+ *   fengmk2 <fengmk2@gmail.com> (http://fengmk2.github.com)
+ *   denghongcai <admin@dhcouse.com> (https://www.dhc.house)
+ *
+ */
+
+"use strict";
+
+/**
+ * Module dependencies.
+ */ 
+
+var util = require('util');
+var DecoderV2 = require('../v2/decoder');
+var DecoderV1 = require('../v1/decoder');
+
+function Decoder(buf, classRefs) {
+  DecoderV2.call(this, buf);
+  this.classes = classRefs; // using passed in ref array
+}
+
+util.inherits(Decoder, DecoderV2);
+
+var proto = Decoder.prototype;
+
+proto.clean = function () {
+  DecoderV1.prototype.clean.call(this); // can not clean `this.classes`
+  this.types = [];
+  return this;
+};
+
+module.exports = Decoder;

lib/v2_optimize/encoder.js

@@ -0,0 +1,45 @@
+/**
+ * hessian.js - lib/v2/encoder.js
+ *
+ * Copyright(c)
+ * MIT Licensed
+ *
+ * Authors:
+ *   fengmk2 <fengmk2@gmail.com> (http://fengmk2.github.com)
+ *   denghongcai <admin@dhcouse.com> (https://www.dhc.house)
+ * 
+ */
+
+"use strict";
+
+/**
+ * Module dependencies.
+ */
+
+var debug = require('debug')('hessian:v2_optimize:encoder');
+var util = require('util');
+var EncoderV2 = require('../v2/encoder');
+var EncoderV1 = require('../v1/encoder');
+
+function Encoder(options) {
+  EncoderV2.call(this, options);
+
+  this._classRefs = options.classRefs;
+  this._classRefFields = options.classRefFields;
+  this._typeRefs = [];
+}
+
+util.inherits(Encoder, EncoderV2);
+
+var proto = Encoder.prototype;
+
+/**
+ * clean the buf
+ */
+proto.reset = proto.clean = function () {
+  EncoderV1.prototype.clean.call(this);
+  this._typeRefs = [];
+  return this;
+};
+
+module.exports = Encoder;

test/v2.optimize.endecode.test.js

@@ -0,0 +1,78 @@
+'use strict';
+
+var assert = require('assert');
+var hessian = require('../');
+var utils = require('./utils');
+var supportES6Map = require('../lib/utils').supportES6Map;
+var DecoderV2 = require('../lib/v2_optimize/decoder');
+var EncoderV2 = require('../lib/v2_optimize/encoder');
+
+var cache = [];
+
+describe('v2.optimize.endecode.test.js', function () {
+  var decode = hessian.decode;
+  var encode = hessian.encode;
+  var encoder = new EncoderV2({
+    size: 1024 * 1024,
+    classRefs: [],
+    classRefFields: {},
+  });
+  before(function() {
+    hessian.decode = function(buf, version, withType) {
+      return new DecoderV2(buf, cache).read(withType);
+    };
+
+    hessian.encode = function(obj) {
+      encoder.reset();
+      return encoder.write(obj).get();
+    };
+  });
+
+  // reset and check cache
+  after(function() {
+    assert(cache.length);
+    hessian.decode = decode;
+    hessian.encode = encode;
+  });
+
+  describe('encode/decode', function () {
+    it('should encode/decode class and match ref', function () {
+      var obj = {
+        $class: 'hessian.test.demo.Car',
+        $: { a: 1, b: 'map' }
+      };
+      var buf = hessian.encode(obj);
+      assert(buf[0] === 0x43);
+      assert.deepEqual(hessian.decode(buf), obj.$);
+      assert.deepEqual(hessian.decode(buf, '2.0', true), obj);
+
+      buf = hessian.encode(obj);
+      assert(buf[0] === 0x60);
+      assert.deepEqual(hessian.decode(buf), obj.$);
+      assert.deepEqual(hessian.decode(buf, '2.0', true), obj);
+    });
+
+    it('should reset encoder ok', function () {
+      encoder.byteBuffer.putChar('o');
+      encoder.objects.ok = true;
+      encoder._typeRefs.push('ok');
+      encoder.reset();
+      assert.equal(encoder.byteBuffer._offset, 0);
+      assert.equal(Object.keys(encoder.objects).length, 0);
+      assert.equal(encoder._typeRefs.length, 0);
+    });
+
+    it('should clean decoder ok', function () {
+      var decoder = new DecoderV2([], []);
+      var byteBuffer = decoder.byteBuffer;
+      decoder.refId = 1;
+      decoder.refMap = {a: 1};
+      decoder.types.push(1);
+      decoder.clean();
+      assert.notEqual(byteBuffer, decoder.byteBuffer);
+      assert.equal(decoder.refId, 0);
+      assert.equal(Object.keys(decoder.refMap).length, 0);
+      assert.equal(decoder.types.length, 0);
+    });
+  });
+});