让Ajax框架Buffalo支持JSON协议而非仅仅自定义的XML协议[JS前端及单元测试完成]

itstarting

浏览: 146857 次
性别:
来自: 杭州

最近访客更多访客>>

sp42

黑小子

winting

yeyeyeid

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

Java框架

单元测试 json XML 框架 Ajax

Buffalo默认实现了一套很棒的自定义XML协议（具体请参考拙作《Ajax框架Buffalo深度研究》）。

然而在崇尚“标准”的当下，很多人对这种“非标准”的自定义的协议并不感冒，哪怕它再好。

在这种情况下，本人也是本着对Buffalo的继续研究、提升自我的态度，尝试基于org.json的“正宗”JSON参考实现RI，让Buffalo完全支持JSON标准协议。

本来打算自己默默研究，等完全成型之后再发布出来，然而自《Ajax框架Buffalo深度研究》发布后，在社区所凝聚的人气之旺，让我有些震惊（或者说惊喜），继而灵机一动：何不利用社区的强大平台，在线开展此项工作呢？

不能保证每天甚至每周都有让人惊喜的进展，仅希望通过这种方式，鞭策自己的同时，也获得更多社区高手的批评斧正，快速提升，少走弯路。

接下来的工作，欢迎各位踊跃拍砖，谢谢！

2010-02-08，状态简述：

1）前端js已经编写完成：充分结合XML协议和JSON协议，完成了代码的重构

2）单元测试已经完成，并提供了完整的参考XML协议的js单一测试用例（同样基于script.aculo.us 的unittest.js）

3）升级prototype.js到最新的1.6.1（其实buffalo对prototype.js依赖不大）

接下来的工作：

1、完成前后端集成测试，并完善demo

2、适时开展RC

2010-01-25，状态简述：

1）后端代码重构完成，并已纳入buffalo SVN, 建立了新的branch，位于branches/json/；

2）接下来工作的重点是：a.着手编写前台js; c.并结合demo完成集成测试。

分享到：

Maven+Jetty免静态文件死锁的处理 | Ajax框架Buffalo深度研究

2010-01-14 16:01
浏览 2756
评论(27)
论坛回复 / 浏览 (27 / 7849)
分类:Web前端
查看更多

27 楼 itstarting 2010-03-10

Bug-fixed:net.buffalo.protocal.BuffaloProtocal.java
 
原先也提到取得BuffaloProtocal单例的时候会产生线程安全问题，其实能看的出来，为了慎重起见，还特意写了测试代码验证并得到确认。
 
最后进行了修复：
 
<pre name="code" class="java">……
private static Map instanceMap = new HashMap();

……

public static BuffaloProtocal getInstance(String p){
BuffaloProtocal instance = (BuffaloProtocal) instanceMap.get(p);
if (instance == null) {
instance = new BuffaloProtocal();
instance.protocol = p;
instanceMap.put(p, instance);
}
return instance;
}</pre>
 
 
其实也很简单，用了一个Map，对XML和JSON各放了一个实例。

26 楼 itstarting 2010-02-08

<h2 style="margin: 12pt 0cm; text-indent: 0cm;">
 前端JS
</h2>
其实服务端的重构是前段时间的事，也放到了SVN的分支(buffalo/branches/json)上了
近期杂事太多，耽搁了一下,但终于还是回到了前端。

<h3 style="margin: 12pt 0cm; text-indent: 0cm;">说在开发前端前的话</h3>
老实说，我的前端架构、设计和开发能力要打折扣，但还是要硬着头皮上。
同样前端还是采用了TDD，基于script.aculo.us所提供的unittest.js做，还真的不错，不过实话说，咱还没干过js TDD，顺道学一把。
重点说说目标：
1、 平滑的实现兼容JSON协议的客户端；
2、 重构客户端脚本。
 
 
<h3 style="margin: 12pt 0cm; text-indent: 0cm;">开发的重点</h3>
要说重点，主要还是一去一回：协议的封装和返回的解析。
 

<h4 style="margin: 12pt 0cm; text-indent: 0cm;">call.js</h4>

call我的思路是：对外提供一致的接口，用类似于Factory模式的机制来做具体实现的生产和封装——js的OOP其实也是不错的，但我不是太会用，将就着先出一个beta版吧。

 

 
<pre name="code" class="js">Buffalo.Call = Class.create();
Buffalo.Call.prototype = {
initialize: function(methodname,protocol){
this.method = methodname;
this.params = [];
this.protocol = (protocol!=null && (protocol=='XML' || protocol=='JSON'))
? protocol
: Buffalo.DefaultProtocol;
},

addParameter: function(data){
if (typeof(data) == 'undefined') return;
this.params[this.params.length] = data;
},

toCall: function(){
return (this.protocol == 'JSON')
? this._json()
: this._xml();
},

_xml: function(){
var s = "<buffalo-call>\n";
s += "<method>" + this.method+ "</method>\n";
for (var i = 0; i < this.params.length; i++) {
var data = this.params[i];
var p = new Buffalo.XML(this, data);
s += p.parseValue(data) + "\n";
}
s += "</buffalo-call>";
return s;
},

_json: function(){
//demo:[{'buffalo-call':[{'method':'divide'},{'double':1},{'double':2}]]
var s = "[{'buffalo-call':[\n";
s += "{'method':'" + this.method+ "'}\n";
for (var i = 0; i < this.params.length; i++) {
var data = this.params[i];
var p = new Buffalo.JSON(this, data);
s += p.parseValue(data) + "\n";
}
s += "]";
return s;
},

getProtocol : function() {
return this.protocol;
}
}
</pre>
 
把原先在这里面的一些方法一分为二：一部分变成了具体的XML实现，一部分新建了一个Utils的Class。这些就略了，有兴趣自己down下来看。
 
<h4 style="margin: 12pt 0cm; text-indent: 0cm;">json.js</h4>
 
下面是json.js的实现：


<pre name="code" class="js">/** JSON Implementation */
Buffalo.JSON = Class.create();
Buffalo.JSON.prototype = {
initialize : function(call, data) {
this.call = call;
this.data = data;
this._objects = [];
},

parseValue : function(data) {
var s;
var type = Buffalo.Utils.typeOfData(data);
switch (type) {
case "date":
s = this.doDate(data);
break;
case "list":
s = this.doArray(data);
break;
case "map":
s = this.doStruct(data);
break;
case "boolean":
s = this.doBoolean(data);
break;
case "null":
s = this.doNull();
break;
default:
s = this.doValue(type, data);
break;
}
return s;
},

doDate : function(data) {
var s = "{'date':'";
s += Buffalo.Utils.dateToISO8609(data);
s += "'}";
return "," + s;
},

doValue : function(type, data) {
var s;
if (typeof (data) == "string") {
data = data.replace(/&/g, "&amp;");
data = data.replace(/</g, "&lt;");
data = data.replace(/>/g, "&gt;");
data = data.replace(/'/g, "/'");
}
s = "{'" + type + "':'" + data + "'}";

return "," + s;
},

doBoolean : function(data) {
var value = (data == true) ? 1 : 0;
var s = "{'boolean':" + value + "}";
return "," + s;
},

doArray : function(data) {
var ref = this._checkRef(data);
if (ref != -1) return "{'ref':" + ref + "}";
this._objects[this._objects.length] = data;

var s = "{'list':[\n";
var boClass = data[Buffalo.BOCLASS];
var boType = boClass ? boClass : Buffalo.Utils.typeOfArray(data);
s += "{'type':'" + boType + "'}\n";
s += ",{'length':" + data.length + "}\n";
for ( var i = 0; i < data.length; i++) {
s += this.parseValue(data[i]) + "\n";
}
s += "]}\n";
return "," + s;
},

doStruct : function(data) {
var ref = this._checkRef(data);
if (ref != -1)
return "{'ref':" + ref + "}";
this._objects[this._objects.length] = data;

var boType = data[Buffalo.BOCLASS] || "java.util.HashMap";
var s = "{'map':[\n";
s += "{'type':'" + boType + "'}\n";

for ( var i in data) {
if (data[i] != boType) {
if (typeof (data[i]) == "function")
continue; /* the function shouldn't transfered. */
s += this.parseValue(i) + "\n";
s += this.parseValue(data[i]) + "\n";
}
}
s += "]}\n";
return "," + s;
},

doNull : function() {
return "," + "{'null':null}";
},

_checkRef : function(obj) {
var ref = -1;
for ( var i = 0; i < this._objects.length; i++) {
if (obj === this._objects[i]) {
ref = i;
break;
}
}
return ref;
}
};
</pre>
 


 
<pre name="code" class="js">Buffalo.Reply = Class.create();
Buffalo.Reply.prototype = {
initialize: function(xhr,protocol) {
this._isFault = false;
this._type = "null";
this._source = xhr.responseText;
this._impl = (protocol == 'JSON')
? new Buffalo.Reply.JSON(xhr, this._source)
: new Buffalo.Reply.XML(xhr, this._source);
},

/** interface : getType, get the response object type */
getType: function() { return this._impl.getType(); },

/** interface : getResult, deserialize the response and return the javascript object */
getResult : function() { return this._impl.getResult(); },

/** interface : isFault, check response is fault or not */
isFault : function() { return this._impl.isFault(); },

/** interface : isFault, check response is null or not */
isNull: function() { return this._impl.isNull(); },

getSource : function() { return this._source; },
}
</pre>
 
然后分别实现。后面的代码很多，就不贴了。
说实话，js的OOD/OOP也蛮有意思的，但一时半会儿还不顺手。

25 楼 itstarting 2010-02-07

<h2 style="margin: 12pt 0cm; text-indent: 0cm;">服务端的重构</h2>
 
考虑到在纳入SVN前完成重构，挤出点时间完成了重构。
所谓的重构，其实很简单，就是新增了两个抽象类方法，采用Template模式进行了抽象与具体的分离。
1、 AbstractStreamReader.java
2、 AbstractStreamWriter.java
这样，无论是JSON还是XML的IO实现，都变成了很简单，也更聚焦了。
类图如下：
 <img src="http://dl.iteye.com/upload/attachment/204423/70a9f5c8-9036-37df-be7c-43e9584d665a.gif" alt=""> <img src="http://dl.iteye.com/upload/attachment/204425/14a4ceff-46f3-3534-bcd1-dc76472009b2.gif" alt=""> 
OK，很简单的套路，但显然，具体协议实现代码变得非常的简单，可读性大大增加了。以后再出现什么阿猫阿狗协议，只要好的，你都可以遵照实现，难度大大降低咯。

24 楼 itstarting 2010-01-21

为了发布上面的这个回复，我老老实实的提交-》不行（都是缺胳膊少腿的）-》编辑了足足5遍！！

Robbin TX啊，这么牛气哄哄（回帖还需要考试）的网站，可不能被这个破编辑器给砸了呀

23 楼 itstarting 2010-01-21

net.buffalo.protocal.io.json.JsonStreamWriter


接下来就干这个了。
这个相对而言容易些，加上写JsonStreamWriter的经验，自然顺当些了。
原先提供的测试用例明显不足，也顺便完善了这块。
总体而言，花了个把小时开发和调试，整体就比较完善了，测试用例的思考和编写，反倒花费了更多的心思。
<h4 style="margin: 12pt 0cm; text-indent: 0cm;">
 核心方法
</h4>
startNode：


<table class="MsoTableGrid" style="border-collapse: collapse;" border="1" cellspacing="0" cellpadding="0"><tbody><tr style="">
<td style="padding-right: 5.4pt; padding-left: 5.4pt; padding-bottom: 0cm; width: 426.1pt; padding-top: 0cm; background-color: transparent;" width="568" valign="top">
 public void startNode(String name) { 
 if(isStart){
 writer.write("[");
 stack.push("[");
 }else if(depth>0){
 writer.write(",");
 }
 writer.write("{'");
 writer.write(name);
 writer.write("':");
 
 stack.push("{");
 depth++;
 isStart = true;
 }
</td>
</tr></tbody></table>
endNode：


<table class="MsoTableGrid" style="border-collapse: collapse;" border="1" cellspacing="0" cellpadding="0"><tbody><tr style="">
<td style="padding-right: 5.4pt; padding-left: 5.4pt; padding-bottom: 0cm; width: 426.1pt; padding-top: 0cm; background-color: transparent;" width="568" valign="top">
 public void endNode() {
 depth--;
 String beginFlag = (String) stack.pop();
 
 if(beginFlag.equals("[")) write("]");
 if(beginFlag.equals("{")) write("}");
 
 if(depth == 0) {
 while(stack.hasStuff()){
 beginFlag = (String) stack.pop();
 if(beginFlag.equals("[")) write("]");
 if(beginFlag.equals("{")) write("}");
 } 
 flush();
 }
 isStart = false;
 }
</td>
</tr></tbody></table>
 
<h4 style="margin: 12pt 0cm; text-indent: 0cm;">测试用例</h4>
提供更为丰富的测试用例：


<table class="MsoTableGrid" style="margin: auto 6.75pt; border-collapse: collapse;" border="1" cellspacing="0" cellpadding="0" align="left"><tbody>
<tr style="">
<td style="padding-right: 5.4pt; padding-left: 5.4pt; padding-bottom: 0cm; width: 4cm; padding-top: 0cm; background-color: transparent;" width="151" valign="top">
测试用例
</td>
<td style="padding-right: 5.4pt; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #ece9d8; width: 312.7pt; padding-top: 0cm; background-color: transparent;" width="417" valign="top">
说明
</td>
</tr>
<tr style="">
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; width: 4cm; padding-top: 0cm; background-color: transparent;" width="151" valign="top">
testPrimitive
</td>
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #ece9d8; width: 312.7pt; padding-top: 0cm; background-color: transparent;" width="417" valign="top">
测试"boolean","date","double","double","long","string","null","node"等基本对象
</td>
</tr>
<tr style="">
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; width: 4cm; padding-top: 0cm; background-color: transparent;" width="151" valign="top">
testNested
</td>
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #ece9d8; width: 312.7pt; padding-top: 0cm; background-color: transparent;" width="417" valign="top">
测试存在基本嵌套的对象
</td>
</tr>
<tr style="">
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; width: 4cm; padding-top: 0cm; background-color: transparent;" width="151" valign="top">
testList
</td>
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #ece9d8; width: 312.7pt; padding-top: 0cm; background-color: transparent;" width="417" valign="top">
测试列表对象
</td>
</tr>
<tr style="">
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; width: 4cm; padding-top: 0cm; background-color: transparent;" width="151" valign="top">
testMap
</td>
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #ece9d8; width: 312.7pt; padding-top: 0cm; background-color: transparent;" width="417" valign="top">
测试map对象
</td>
</tr>
<tr style="">
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; width: 4cm; padding-top: 0cm; background-color: transparent;" width="151" valign="top">
testfault
</td>
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #ece9d8; width: 312.7pt; padding-top: 0cm; background-color: transparent;" width="417" valign="top">
测试异常对象
</td>
</tr>
<tr style="">
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; width: 4cm; padding-top: 0cm; background-color: transparent;" width="151" valign="top">
testComplex
</td>
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #ece9d8; width: 312.7pt; padding-top: 0cm; background-color: transparent;" width="417" valign="top">
测试最为复杂的多重嵌套对象。List->Map->List
</td>
</tr>
</tbody></table>

22 楼 itstarting 2010-01-21

经过两天的努力，终于攻克了各种难关，成功实现了所有测试用例的验证，核心方法如下：
moveDown：
<pre name="code" class="java"> public void moveDown() {
int tag = parseTag();
switch(tag) {
case TAG_METHOD:
case TAG_INT:
case TAG_LENGTH:
case TAG_TYPE:
case TAG_STRING:
case TAG_BOOLEAN:
case TAG_LONG:
case TAG_DATE:
case TAG_DOUBLE:
case TAG_NULL:
case TAG_REF:
case TAG_LIST:
case TAG_MAP:
case TAG_CALL:
currentTag = new Tag(tag, parseString());
stack.push(currentTag);
depth++;
break;

default: throw new ProtocolException("unexpected tag: " + tagName(tag));
}
}
</pre>
 
moveUp:

<pre name="code" class="java"> public void moveUp() {
int ch = skipWhitespace();
if (ch == '}'){
depth--;
stack.pop();
currentTag = (Tag) stack.get(depth-1);
}else if(ch == ']'){
depth--;
stack.pop();
currentTag = (Tag) stack.get(depth-1);
ch = skipWhitespace();
if (ch != '}') throw expectedChar("'}'", ch);
}else throw expectedChar("'}' or ']'", ch);
}
</pre>
 
 
parseTag:

<pre name="code" class="java"> protected int parseTag() {
int ch = skipWhitespace();

if(ch == '[') {
ch = skipWhitespace();
}else if (ch == ',') {
ch = skipWhitespace();
}else throw expectedChar("'[' or ','", ch);

int endChar;
if (ch != '{') throw expectedChar("'{'", ch);
ch = read();
if (ch != '\'' && ch != '"') throw expectedChar("'\'' or '\"'", ch);
endChar = ch;
ch = read();

if (!isTagChar(ch)) throw expectedChar("tag", ch);
sbuf.setLength(0);
for (; isTagChar(ch); ch = read()) sbuf.append((char) ch);
if (ch != endChar) throw expectedChar("'"+endChar+"'", ch);
Integer value = (Integer) tagCache.get(sbuf.toString());
if (value == null) throw new ProtocolException("Unknown tag '" + sbuf + "'");

return value.intValue();
}
</pre>
 
 
parseString:


<pre name="code" class="java"> protected String parseString() {
sbuf.setLength(0);
int ch = readChar();
if (ch != ':') throw expectedChar("':'", ch);
int endChar = -1;
ch = readChar();
if (ch == '\'' || ch == '"'){
endChar = ch;
ch = readChar();
}else if (ch == '[') {
peekChar = ch;
return "[";
}
if(ch == endChar) return "";
sbuf.append((char) ch);
while ((ch = readChar()) >= 0) sbuf.append((char) ch);
if(endChar>0 && sbuf.charAt(sbuf.length()-1) == endChar){
return sbuf.substring(0, sbuf.length()-1);
}else{
return sbuf.toString();
}
}
</pre>
 
 
<h4 style="margin: 12pt 0cm; text-indent: 0cm;">
 测试用例
</h4>
所提供的测试用例包括标准的buffalo-call请求，以及其他通用的JSON格式，均能有效解析。
所提供的测试用例清单如下：



<table class="MsoTableGrid" style="margin: auto 6.75pt; border-collapse: collapse;" border="1" cellspacing="0" cellpadding="0" align="left"><tbody>
<tr style="">
<td style="padding-right: 5.4pt; padding-left: 5.4pt; padding-bottom: 0cm; width: 149.4pt; padding-top: 0cm; background-color: transparent;" width="199" valign="top">
测试用例
</td>
<td style="padding-right: 5.4pt; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #ece9d8; width: 276.7pt; padding-top: 0cm; background-color: transparent;" width="369" valign="top">
说明
</td>
</tr>
<tr style="">
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; width: 149.4pt; padding-top: 0cm; background-color: transparent;" width="199" valign="top">
testSimpleCall
</td>
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #ece9d8; width: 276.7pt; padding-top: 0cm; background-color: transparent;" width="369" valign="top">
简单的buffalo-call
</td>
</tr>
<tr style="">
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; width: 149.4pt; padding-top: 0cm; background-color: transparent;" width="199" valign="top">
testCallWithMap
</td>
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #ece9d8; width: 276.7pt; padding-top: 0cm; background-color: transparent;" width="369" valign="top">
带map的相对复杂的buffalo-call
</td>
</tr>
<tr style="">
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; width: 149.4pt; padding-top: 0cm; background-color: transparent;" width="199" valign="top">
testHasMoreChildren
</td>
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #ece9d8; width: 276.7pt; padding-top: 0cm; background-color: transparent;" width="369" valign="top">
复杂的用以测试hasMoreChildren方法的buffalo-call
</td>
</tr>
<tr style="">
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; width: 149.4pt; padding-top: 0cm; background-color: transparent;" width="199" valign="top">
testComplexTest
</td>
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #ece9d8; width: 276.7pt; padding-top: 0cm; background-color: transparent;" width="369" valign="top">
最复杂的混杂map/list/primitive的buffalo-call
</td>
</tr>
<tr style="">
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; width: 149.4pt; padding-top: 0cm; background-color: transparent;" width="199" valign="top">
testPrimitive
</td>
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #ece9d8; width: 276.7pt; padding-top: 0cm; background-color: transparent;" width="369" valign="top">
非buffalo-call的标准的primitive格式的JSON
</td>
</tr>
<tr style="">
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; width: 149.4pt; padding-top: 0cm; background-color: transparent;" width="199" valign="top">
testNull
</td>
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #ece9d8; width: 276.7pt; padding-top: 0cm; background-color: transparent;" width="369" valign="top">
非buffalo-call的标准的null格式的JSON
</td>
</tr>
<tr style="">
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; width: 149.4pt; padding-top: 0cm; background-color: transparent;" width="199" valign="top">
testList
</td>
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #ece9d8; width: 276.7pt; padding-top: 0cm; background-color: transparent;" width="369" valign="top">
非buffalo-call的标准的list格式的JSON
</td>
</tr>
<tr style="">
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; width: 149.4pt; padding-top: 0cm; background-color: transparent;" width="199" valign="top">
testChineseChar
</td>
<td style="padding-right: 5.4pt; border-top: #ece9d8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #ece9d8; width: 276.7pt; padding-top: 0cm; background-color: transparent;" width="369" valign="top">
非buffalo-call的标准的带中文字符的JSON
</td>
</tr>
</tbody></table>
 
 
 
 
 
 
 
 
 
 
 

 


 

抱怨一下：javaeye的编辑器一旦带有代码，往往需要反复编辑多次才能成功，否则会被莫名其妙的截掉了，我不得不把所有注释都干掉了——也该改进了！

21 楼 itstarting 2010-01-21

我想到了’[‘字符。
经过努力，以下测试用例通过了：
JSON：

<pre name="code" class="java">private String callWithMap = "[{'buffalo-call':''},{'method':'sum'}," +
"{'int':1}," +
"{'map':[{'type':java.util.HashMap},{'string':'key1'},{'string':'value1'},{'string':'key2'},{'string':'value2'}]}," +
"{'string':test}" +
"]";
</pre>


测试用例代码：



<pre name="code" class="java"> // callWithMap - PASS
public void testShoudReadNested() throws Exception {
StringReader reader = new StringReader(callWithMap);
StreamReader streamReader = new JsonStreamReader(reader);
assertEquals("buffalo-call", streamReader.getNodeName());
streamReader.moveDown();
assertEquals("method", streamReader.getNodeName());
assertEquals("sum", streamReader.getValue());
streamReader.moveUp();
streamReader.moveDown();
assertEquals("int", streamReader.getNodeName());
assertEquals("1", streamReader.getValue());

streamReader.moveUp();
streamReader.moveDown();
assertEquals("map", streamReader.getNodeName());
streamReader.moveDown();
assertEquals("type", streamReader.getNodeName());
assertEquals("java.util.HashMap", streamReader.getValue());
streamReader.moveUp();
streamReader.moveDown();
assertEquals("string", streamReader.getNodeName());
assertEquals("key1", streamReader.getValue());
streamReader.moveUp();
streamReader.moveDown();
assertEquals("string", streamReader.getNodeName());
assertEquals("value1", streamReader.getValue());
streamReader.moveUp();
streamReader.moveDown();
assertEquals("string", streamReader.getNodeName());
assertEquals("key2", streamReader.getValue());
streamReader.moveUp();
streamReader.moveDown();
assertEquals("string", streamReader.getNodeName());
assertEquals("value2", streamReader.getValue());
streamReader.moveUp();

streamReader.moveUp();
streamReader.moveDown();
assertEquals("string", streamReader.getNodeName());
assertEquals("test", streamReader.getValue());

streamReader.moveUp();
}
</pre>


 
到了测试hasMoreChildren的时候，正如JsonStandardStreamReader编写过程中所遇到的困难一样，困难又来了。
如何处理好层级关系，理顺’[‘和’]’字符的关系是重点。
重新审视了JSON表达式，决定再一次改版，如下：
simpleCall：

<pre name="code" class="java">[{'buffalo-call':[{'method':'divide'},{'double':1},{'double':2}]]</pre>


 
callWithMap：

<pre name="code" class="java">[{'buffalo-call':[{'method':'sum'},{'int':1},{'map':[{'type':java.util.HashMap},{'string':'key1'},{'string':'value1'},{'string':'key2'},{'string':'value2'}]},{'string':test}]]</pre>


 
hasMoreChildren：

<pre name="code" class="java">[{'buffalo-call':[{'method':'sum'},{'int':1},{'map':[{'type':java.util.HashMap},{'string':'key1'},{'string':'value1'},{'string':'list1'},{'list':[{'type':'java.util.ArrayList'},{'length':3},{'string':a},{'int':2},{'double':8.88}]},]}]]</pre>


 
简洁多了吧，主要还是考虑JSON的层级关系，通过层级开始字符’[‘和层级关闭字符’]’，应该可以更好的处理hasMoreChildren接口。
还好，这样改动后对simpleCall和callWithMap测试用例没有任何影响，PASS。

20 楼 itstarting 2010-01-19

老实说，也不是没在JSON的表达样式上思考过，我在写测试用例时就推翻了不下两个版本

我现在初步的考虑是：先完成一个解析JSON的版本的解析器，通过不同call请求对不同协议的需求，无缝的实现XML和JSON的输入-》解析-》服务寻址-》调用-》解析-》输出的同样过程。

也就是说，我要求自己写的JSON实现，在相同的测试用例下要一摸一样，同时都能通过

所以在这个角度上说，可能不能发挥JSON的“精炼”的特点，当然这可能更多的针对输入，输出上应该对JSON会更友好些。

但无论如何，对用户都是友好的，透明的

19 楼 mechiland 2010-01-19

这么写实现上没有问题，但感觉丢掉了JSON自带的类型支持。例如，对float, int, string, boolean等原生数据类型的支持，JSON是可以自描述的，而不用写上string:"abc", double: 1.0之类。

例如service.divide(1.0, 2.0), 我期待用JSON写起来应该是这样子的：

{buffalo-call: 'divide', parameters: [1.0, 2.0]}

例如Map的例子：

{buffalo-call: 'somemethod', parameters: [{id: 1, name: "Michael", gendor: true}, count: 2]}

这样写需要对json更加智能的处理。

你的实现仍然是没有问题的；只是这样写出来的协议对于xml没有本质的区别，对于客户端调用而言也没有太多的改善之处。

18 楼 itstarting 2010-01-19

<h3 style="margin: 12pt 0cm; text-indent: 0cm;">net.buffalo.protocal.io.json.JsonStreamReader</h3>

 
 

正式写这个类了。
开始很顺利，对于如下简单的测试用例，很快就PASS了。

 

 
<pre name="code" class="java"> private String simpleCall = "[{'buffalo-call':''},{'method':'divide'},{'double':1},{'double':2}]";

public void testSimpleCall() throws Exception {
StringReader reader = new StringReader(simpleCall);
StreamReader streamReader = new JsonStreamReader(reader);
assertEquals("buffalo-call",streamReader.getNodeName());
streamReader.moveDown();
assertEquals("method",streamReader.getNodeName());
assertEquals("divide", streamReader.getValue());
streamReader.moveUp();
streamReader.moveDown();
assertEquals("double", streamReader.getNodeName());
assertEquals("1", streamReader.getValue());
streamReader.moveUp();
streamReader.moveDown();
assertEquals("double", streamReader.getNodeName());
assertEquals("2", streamReader.getValue());
}
</pre>
 
然而对于复杂的参数，尤其是map和list这种存在复杂嵌套的部分，则暴露出了两个关键问题：
1、moveUp/moveDown对于XML这种有明确封闭标签（如</double>）的，确实支持的非常好，但对于JSON却有些逻辑上的障碍：JSON不是特别方便/合适表达层级关系，也无特别的好用以匹配关闭的标签；
2、JSON表达样式我所提供的是否适合Buffalo？
我所提供的JSON表达样式，可参考JsonStandardStreamReaderTest.java。

17 楼 itstarting 2010-01-18

快速小结

 
 
上面版本的Reader，并非一个符合buffalo SteamReader接口的通用的JSON解析器，充其量只能是一个buffalo-call请求JSON的解析器而已。
另外，还是存在一些明显的问题的，且先不说性能，光就moveDown和moveUp逻辑的严谨性就够喝一壶。
 
其中，已知的BUG有：
1、在单元测试用例testComplexTest中，我注释了两句assertEquals，因为他们测试是不能通过的，主要还是moveUp的逻辑可能还存在不完整不严谨。——当然了，一般人不会那么变态的moveUp后还要看看是啥。
2、存在一些“潜规则”硬编码。比如我假定了第一个JSONObject就是buffalo-call，第二个JSONObject就是method，第三个开始就是call方法的参数——虽然buffalo-call确实如此——这也就是为什么说这个Reader只能是一个buffalo-call请求JSON的解析器的根本原因。
 
但是，通过上面Reader的编写，让我更进一步了解了JSON的同时，也逐步尝试约定了JSON协议表达的约定。
 
总而言之，还是得写正宗的JsonStreamReader，绕不开啊。

16 楼 itstarting 2010-01-18

net.buffalo.protocal.io.json.JsonStandardInputStreamReader
 

同XML协议一样，完全是照葫芦画瓢的写了这个类：
<pre name="code" class="java">package net.buffalo.protocal.io.json;

import java.io.IOException;
import java.io.InputStream;

import org.json.JSONArray;
import org.json.JSONException;

import net.buffalo.protocal.ProtocolException;
import net.buffalo.protocal.io.StreamException;
import net.buffalo.protocal.io.StreamReader;

/**
* The same as FastInputStreamReader
*
* @see FastInputStreamReader.java
*/
public class JsonStandardInputStreamReader extends JsonStandardStreamReader implements StreamReader {

private final InputStream in;

public JsonStandardInputStreamReader(InputStream in) {
this.in = in;
int ch;
try {
ch = readSingleChar();
for (; ch > -1; ch = readSingleChar()) {
sbuf.append((char)ch);
}
} catch (IOException e) {
throw new StreamException(e);
}
try{
all = new JSONArray(sbuf.toString());
len = all.length();
}catch(JSONException e){
throw new ProtocolException("Invalid JSON String.");
}
moveDown();
}

public void close() {
try {
in.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}

protected int readSingleChar() throws IOException {
return in.read();
}
}
</pre>
 
此时可以完整的测试了，且慢，Writer还没写呢，咋测试啊——简单了，我的JsonStreamWriter是拷贝XML协议的过来的，此时：
JSON-> JsonStandardInputStreamReader->调用服务-> JsonStreamWriter，哈哈，回写还是用原来的XML协议，怪是怪了点，但却是可以测试我的JsonStandardInputStreamReader对JSON协议的请求（Buffalo-Call），基本还好用的：
请求界面：
 <img src="http://dl.iteye.com/upload/attachment/195262/0ab23746-d472-386e-ae9e-405436b28272.png" alt=""> 

看日志，用了JSON协议，解析类是刚刚出炉的JsonStandardInputStreamReader：
 <img src="http://dl.iteye.com/upload/attachment/195264/ee01d7ee-5b22-3d4f-895d-e0cd16a8aeca.png" alt=""> 
结果呢：
 <img src="http://dl.iteye.com/upload/attachment/195266/afa9cd13-3728-3062-afc6-dae6ff40a7b6.png" alt=""> 

正确，YEAH!

15 楼 itstarting 2010-01-18

net.buffalo.protocal.io.json.JsonStandardStreamReader
 

第一个版本仅用于解析buffalo-call的JsonStandardStreamReader.java。
<pre name="code" class="java">package net.buffalo.protocal.io.json;

import java.io.IOException;
import java.io.Reader;
import java.util.Stack;

import net.buffalo.protocal.ProtocalTag;
import net.buffalo.protocal.ProtocolException;
import net.buffalo.protocal.io.StreamException;
import net.buffalo.protocal.io.StreamReader;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

/**
* The Implementation is not a general JSON StreamReader,
* just for parsing buffalo-call only.
*
* @author zhengxq
* @see JsonStreamReader.java
*/
public class JsonStandardStreamReader implements StreamReader {
private final Reader in;
protected StringBuffer sbuf = new StringBuffer();
private final JSONArray all;
private final int len;

protected Stack stack = new Stack();
protected int depth = 0;

protected Tag currentTag;
private int pointer = 0;

protected Stack paramStack = new Stack();
private int paramDepth = 0;
private JSONArray param; //temp for map or list
private int innerPointer = 0; //for map or list param

protected JsonStandardStreamReader() {
this.in = null;
this.all = null;
this.len = 0;
}

public JsonStandardStreamReader(Reader in){
this.in = in;
int ch;
try {
ch = readSingleChar();
for (; ch > -1; ch = readSingleChar()) {
sbuf.append((char)ch);
}
} catch (IOException e) {
throw new StreamException(e);
}
try{
all = new JSONArray(sbuf.toString());
len = all.length();
}catch(JSONException e){
throw new ProtocolException("Invalid JSON String.");
}
moveDown();
}

/* move to next, and parse a Tag */
public void moveDown() {
JSONObject o = null;
if(pointer==0){ // buffalo-call
try{
o = all.getJSONObject(pointer);
pointer++;
if(o==null) throw new ProtocolException("The first tag should be 'buffalo-call'");
}catch(JSONException e){
throw new ProtocolException("Invalid JSON String.");
}catch(ProtocolException e){
throw e;
}
}else if(pointer==1){ // method
try{
o = all.getJSONObject(pointer);
pointer++;
if(o==null) throw new ProtocolException("The first tag should be 'method'");
}catch(JSONException e){
throw new ProtocolException("Invalid JSON String.");
}
}else{ // params
try{
//test for map or list
Tag test = (Tag) stack.get(depth - 1);
if(test.tag.equalsIgnoreCase(ProtocalTag.TAG_MAP)
|| test.tag.equalsIgnoreCase(ProtocalTag.TAG_LIST)) {
//it's map, then get the inner object
if(param == null){
// reset it
innerPointer = 0;
//parse it
param = (JSONArray)test.value;
}
if(innerPointer>=param.length()) {
//try to restore
try{
Param p = (Param) paramStack.pop();
param = p.array;
innerPointer = p.pointer;
}catch(Exception e){
throw new ProtocolException("JSONArray in the param is out of bound : len="+len+" but innerPointer="+innerPointer);
}
}

o = (JSONObject) param.get(innerPointer);
innerPointer++;
}else{
// reset it
param = null;
innerPointer = 0;

if(pointer >= len)
throw new ProtocolException("JSONArray is out of bound : len="+len+" but pointer="+pointer);
o = all.getJSONObject(pointer);
pointer++;
}
}catch(JSONException e){
throw new ProtocolException("Unexcepted error.");
}
}
parseTag(o);

stack.push(currentTag);
depth++;

if(currentTag.tag.equalsIgnoreCase(ProtocalTag.TAG_MAP)
|| currentTag.tag.equalsIgnoreCase(ProtocalTag.TAG_LIST)){
paramStack.push(new Param(param,innerPointer));
param = (JSONArray)currentTag.value;
innerPointer = 0;
}
}

public void moveUp() {
depth--;
currentTag = (Tag) stack.pop();

if(currentTag.tag.equalsIgnoreCase(ProtocalTag.TAG_MAP)
|| currentTag.tag.equalsIgnoreCase(ProtocalTag.TAG_LIST)){
currentTag = (Tag) stack.get(depth-1);
//restore it
if(currentTag.tag.equalsIgnoreCase(ProtocalTag.TAG_MAP)
|| currentTag.tag.equalsIgnoreCase(ProtocalTag.TAG_LIST)){
Param p = (Param) paramStack.pop();
param = p.array;
innerPointer = p.pointer;
}
}
}

/* get tag name from currentTag */
public String getNodeName() {
return currentTag.tag;
}

/* get tag value from currentTag */
public String getValue() {
return String.valueOf(currentTag.value);
}

/* test if there has more*/
public boolean hasMoreChildren() {
//test for map or list
Tag test = (Tag) stack.get(depth - 1);
if(test.tag.equalsIgnoreCase(ProtocalTag.TAG_MAP)
|| test.tag.equalsIgnoreCase(ProtocalTag.TAG_LIST)){
//it's map, then get the inner object
if(param == null){
//parse it
param = (JSONArray)test.value;
}
if((innerPointer+1)<param.length()) return true;
}else if(test.tag.equalsIgnoreCase(ProtocalTag.TAG_CALL)
&& pointer<all.length()) return true;
return false;
}

public void close() {
try {
in.close();
} catch (IOException e) {
throw new StreamException(e);
}
}

protected int readSingleChar() throws IOException {
return in.read();
}

// get value from a JSONObject, the key is a standard key
private Tag parseTag(JSONObject o){
Tag t = new Tag();
for(int i=0; i < ProtocalTag.ALL_TYPED_TAGS.length; i++){
try{
t.tag = ProtocalTag.ALL_TYPED_TAGS[i];
t.value = o.get(t.tag);
currentTag = t;
return currentTag;
}catch(JSONException e){}
}
return null;
}

class Tag {
protected String tag;
protected Object value;
public Tag(){}
public Tag(String tag, Object value) {
this.tag = tag;
this.value = value;
}
}

class Param {
protected JSONArray array;
protected int pointer;
public Param(JSONArray ja, int p) {
this.array = ja;
this.pointer = p;
}
}
}
</pre>
 
毋庸置疑：It’s buggy

14 楼 itstarting 2010-01-18

net.buffalo.protocal.io.json.JsonStandardStreamReaderTest.java

第一个版本的测试用例，很长，但对buffalo-call具有较好的覆盖度：


<pre name="code" class="java">package net.buffalo.protocal.io.json;

import java.io.StringReader;

import junit.framework.TestCase;
import net.buffalo.protocal.io.StreamReader;

/**
*
* for json unit test
*
* @author zhengxq
* @see FastStreamReaderTest.java
*/
public class JsonStandardStreamReaderTest extends TestCase {
private String simpleCall = "[{'buffalo-call':''},{'method':'divide'},{'double':1},{'double':2}]";
private String callWithMap = "[{'buffalo-call':''},{'method':'sum'}," +
"{'int':1}," +
"{'map':[{'type':java.util.HashMap},{'string':'key1'},{'string':'value1'},{'string':'key2'},{'string':'value2'}]}," +
"{'string':test}" +
"]";
private String hasMoreChildren = "[{'buffalo-call':''},{'method':'sum'}," +
"{'int':1}," +
"{'map':[" +
" {'type':java.util.HashMap}," +
" {'string':'type'}," +
" {'string':'name'}," +
" {'list':[{'type':'list'},{'length':3}," +
" {'string':a}," +
" {'int':2}," +
" {'double':8.88}]}," +
"]}]";
private String complexTest = "[{'buffalo-call':''},{'method':'fullTypeTest'}," +
"{'boolean':1}," +
"{'date':20100118T154212Z}," +
"{'int':1}," +
"{'double':2.22},"+
"{'string':'Hello world'},"+
"{'list':["+
" {'type':''},"+
" {'length':2},"+
" {'int':100},"+
" {'string':hi}"+
" ]},"+
"{'map':[" +
" {'type':java.util.HashMap}," +
" {'string':key1}," +
" {'string':value1}," +
" {'string':key2}," +
" {'string':value2}," +
" {'string':java.util.ArrayList}," +
" {'list':[" +
" {'type':''}," +
" {'length':3}," +
" {'int':1}," +
" {'string':good}," +
" {'string':baby}" +
" ]}" +
"]}," +
"{'double':3.33}" +
"]";

/* simpleCall */
public void testSimpleCall() throws Exception {
StringReader reader = new StringReader(simpleCall);
StreamReader streamReader = new JsonStandardStreamReader(reader);
assertEquals("buffalo-call",streamReader.getNodeName());
streamReader.moveDown();
assertEquals("method",streamReader.getNodeName());
assertEquals("divide", streamReader.getValue());
streamReader.moveUp();
streamReader.moveDown();
assertEquals("double", streamReader.getNodeName());
assertEquals("1", streamReader.getValue());
streamReader.moveUp();
streamReader.moveDown();
assertEquals("double", streamReader.getNodeName());
assertEquals("2", streamReader.getValue());
}

/* callWithMap */
public void testShoudReadNested() throws Exception {
StringReader reader = new StringReader(callWithMap);
StreamReader streamReader = new JsonStandardStreamReader(reader);
assertEquals("buffalo-call", streamReader.getNodeName());
streamReader.moveDown();
assertEquals("method", streamReader.getNodeName());
assertEquals("sum", streamReader.getValue());
streamReader.moveUp();
streamReader.moveDown();
assertEquals("int", streamReader.getNodeName());
assertEquals("1", streamReader.getValue());

streamReader.moveUp();
streamReader.moveDown();
assertEquals("map", streamReader.getNodeName());
streamReader.moveDown();
assertEquals("type", streamReader.getNodeName());
assertEquals("java.util.HashMap", streamReader.getValue());
streamReader.moveUp();
streamReader.moveDown();
assertEquals("string", streamReader.getNodeName());
assertEquals("key1", streamReader.getValue());
streamReader.moveUp();
streamReader.moveDown();
assertEquals("string", streamReader.getNodeName());
assertEquals("value1", streamReader.getValue());
streamReader.moveUp();
streamReader.moveDown();
assertEquals("string", streamReader.getNodeName());
assertEquals("key2", streamReader.getValue());
streamReader.moveUp();
streamReader.moveDown();
assertEquals("string", streamReader.getNodeName());
assertEquals("value2", streamReader.getValue());

streamReader.moveUp();
streamReader.moveUp();
}

/* hasMoreChildren */
public void testHasMoreChildren() throws Exception {
StringReader reader = new StringReader(hasMoreChildren);
StreamReader streamReader = new JsonStandardStreamReader(reader);
assertTrue(streamReader.hasMoreChildren());
streamReader.moveDown();
//then {'method':'sum'}
assertFalse(streamReader.hasMoreChildren());
streamReader.moveUp();

streamReader.moveDown();
streamReader.moveUp();
streamReader.moveDown();
//then {'map':[...]}
assertEquals("map",streamReader.getNodeName());
assertTrue(streamReader.hasMoreChildren());

streamReader.moveDown();
//then {'type':java.util.HashMap}
streamReader.moveUp();

streamReader.moveDown();
//then {'string':'type'}
streamReader.moveUp();

streamReader.moveDown();
//then {'string':'name'}
streamReader.moveUp();

streamReader.moveDown();
//then {'list':[...]}
assertTrue(streamReader.hasMoreChildren());
assertEquals("list",streamReader.getNodeName());

while(streamReader.hasMoreChildren()) {
streamReader.moveDown();
streamReader.moveUp();
}

streamReader.moveUp();
assertEquals("map",streamReader.getNodeName());

assertFalse(streamReader.hasMoreChildren());
}

/**
* more complex test.
* //boolean、date、int、long、null、string、list、map、double
* var t1 = true;//
* var t2 = new Date();
* var t3 = 1;//int
* var t4 = parseFloat("2.22");
* //var t5 = null;
* var t6 = "Hello world";
* var t7 = [100,"hi"];//list
* var t8 = {'key1':'value1','key2':'value2','java.util.ArrayList':[1,"good","baby"]};//map
* var t9 = parseFloat("3.33");
*
* buffalo.remoteCall("fullTypeService.fullTypeTest",[t1,t2,t3,t4,t6,t7,t8,t9], function(reply) {
* $("result").value = reply.getResult();
* },protocol)
* @author zhengxq
*/
public void testComplexTest() throws Exception {
StringReader reader = new StringReader(complexTest);
StreamReader streamReader = new JsonStandardStreamReader(reader);
assertEquals("buffalo-call",streamReader.getNodeName());
assertTrue(streamReader.hasMoreChildren());
streamReader.moveDown();
//<method>fullTypeTest</method>
assertEquals("method",streamReader.getNodeName());
assertEquals("fullTypeTest",streamReader.getValue());
assertFalse(streamReader.hasMoreChildren());
streamReader.moveUp();

streamReader.moveDown();
//<boolean>1</boolean>
assertEquals("boolean",streamReader.getNodeName());
assertEquals("1",streamReader.getValue());
streamReader.moveUp();

streamReader.moveDown();
//<date>20100118T154212Z</date>
assertEquals("date",streamReader.getNodeName());
assertEquals("20100118T154212Z",streamReader.getValue());
streamReader.moveUp();

streamReader.moveDown();
//<int>1</int>
assertEquals("int",streamReader.getNodeName());
assertEquals("1",streamReader.getValue());
streamReader.moveUp();

streamReader.moveDown();
//<double>2.22</double>
assertEquals("double",streamReader.getNodeName());
assertEquals("2.22",streamReader.getValue());
streamReader.moveUp();

streamReader.moveDown();
//<string>Hello world</string>
assertEquals("string",streamReader.getNodeName());
assertEquals("Hello world",streamReader.getValue());
streamReader.moveUp();

streamReader.moveDown();
//<list>...</list>
assertEquals("list",streamReader.getNodeName());
assertTrue(streamReader.hasMoreChildren());

streamReader.moveDown();
//<type></type>
assertEquals("type",streamReader.getNodeName());
streamReader.moveUp();

streamReader.moveDown();
//<length>2</length>
assertEquals("length",streamReader.getNodeName());
assertEquals("2",streamReader.getValue());
streamReader.moveUp();

streamReader.moveDown();
//<int>100</int>
assertEquals("int",streamReader.getNodeName());
assertEquals("100",streamReader.getValue());
streamReader.moveUp();

streamReader.moveDown();
//<string>hi</string>
assertEquals("string",streamReader.getNodeName());
assertEquals("hi",streamReader.getValue());
streamReader.moveUp();

streamReader.moveUp();//</list>

streamReader.moveDown();
//<map>...</map>
assertEquals("map",streamReader.getNodeName());
assertTrue(streamReader.hasMoreChildren());

streamReader.moveDown();
//<type>java.util.HashMap</type>
assertEquals("type",streamReader.getNodeName());
assertEquals("java.util.HashMap",streamReader.getValue());
streamReader.moveUp();

streamReader.moveDown();
//<string>key1</string>
assertEquals("string",streamReader.getNodeName());
assertEquals("key1",streamReader.getValue());
streamReader.moveUp();

streamReader.moveDown();
//<string>value1</string>
assertEquals("string",streamReader.getNodeName());
assertEquals("value1",streamReader.getValue());
streamReader.moveUp();

streamReader.moveDown();
//<string>key2</string>
assertEquals("string",streamReader.getNodeName());
assertEquals("key2",streamReader.getValue());
streamReader.moveUp();

streamReader.moveDown();
//<string>value2</string>
assertEquals("string",streamReader.getNodeName());
assertEquals("value2",streamReader.getValue());
streamReader.moveUp();

streamReader.moveDown();
//<string>java.util.ArrayList</string>
assertEquals("string",streamReader.getNodeName());
assertEquals("java.util.ArrayList",streamReader.getValue());
streamReader.moveUp();

streamReader.moveDown();
//<list>...</list>
assertEquals("list",streamReader.getNodeName());
assertTrue(streamReader.hasMoreChildren());

streamReader.moveDown();
//<type></type>
assertEquals("type",streamReader.getNodeName());
streamReader.moveUp();

streamReader.moveDown();
//<length>3</length>
assertEquals("length",streamReader.getNodeName());
assertEquals("3",streamReader.getValue());
streamReader.moveUp();

streamReader.moveDown();
//<int>1</int>
assertEquals("int",streamReader.getNodeName());
assertEquals("1",streamReader.getValue());
streamReader.moveUp();

streamReader.moveDown();
//<string>good</string>
assertEquals("string",streamReader.getNodeName());
assertEquals("good",streamReader.getValue());
streamReader.moveUp();

streamReader.moveDown();
//<string>baby</string>
assertEquals("string",streamReader.getNodeName());
assertEquals("baby",streamReader.getValue());
streamReader.moveUp();
//assertEquals("list",streamReader.getNodeName());

streamReader.moveUp();//</list>
assertEquals("map",streamReader.getNodeName());
streamReader.moveUp();//</map>
assertEquals("buffalo-call",streamReader.getNodeName());

streamReader.moveDown();
//<double>3.33</double>
assertEquals("double",streamReader.getNodeName());
assertEquals("3.33",streamReader.getValue());
streamReader.moveUp();

//assertEquals("buffalo-call",streamReader.getNodeName());
assertFalse(streamReader.hasMoreChildren());
}
}
</pre>

13 楼 yvfish 2010-01-18

多年以后，一个贴子，引起我对Buffalo的回忆，感叹时光流逝，物是人非。。。

12 楼 itstarting 2010-01-18

经与Michael沟通，印证了我对于性能的猜想：


<table class="MsoTableGrid" style="border-collapse: collapse;" border="1" cellspacing="0" cellpadding="0"><tbody><tr style="">
<td style="padding-right: 5.4pt; padding-left: 5.4pt; padding-bottom: 0cm; width: 426.1pt; padding-top: 0cm; background-color: transparent;" width="568" valign="top">
没错。如果用dom, 意味着使用通用的xml解析根据我的测试，当时使用最快的xpp3的xml解析器都无法满足我的性能期待。
On 1 16, 2010 7:52 PM, "zhengxianquan" wrote:
Michael： 
我已经开展了JSON协议的相关开发工作。
然而对照XML协议，我有个问题没想明白：为什么StreamReader要一个字符一个字符的解析，何不直接读出来后，直接转化为DOM再处理？
这其中难道有什么考虑吗？性能？ 
对于JSON协议，在表达格式上有什么建议？
</td>
</tr></tbody></table>

但正如我之前的考虑那样，我打算先做一次性读入->解析为JSONObject->再基于现有StreamReader接口实现系列方法的第一个版本，命名为JsonStandardStreamReader.java。
然而，这个JsonStandardStreamReader.java只能是一个buffalo-call的实现，不具有原有XML协议下作为Reader的广泛通用性（可不限制于Buffalo）：The Implementation is not a general JSON StreamReader, just for parsing buffalo-call only.”。
协议的表达格式经过多番测试验证，需要调整一下，举例如下：

<pre name="code" class="java">[{'buffalo-call':''},{'method':'divide'},{'double':1},{'double':2}]</pre>

 
或者：

<pre name="code" class="java">[{'buffalo-call':''},{'method':'sum'},{'int':1},{'map':[{'type':java.util.HashMap},{'string':'key1'},{'string':'value1'},{'string':'key2'},{'string':'value2'}]},{'string':test}]</pre>

 
基于TDD来做。目前的JsonStandardStreamReader已经可以解析上述的协议。
接下来将枚举各种buffalo-call的可能，尽可能的保证单元测试下的覆盖率。

11 楼 itstarting 2010-01-18

非常感谢楼上的推荐，昨天粗略看了下，你的beetle框架确实比较完整，值得学习，但个中的精华还没体会到，你可进一步开贴宣讲。

但我的目标不是简单的用AJAX框架，而是通过与原创作者沟通，结合自己的思考，学习和完善个人觉得比较精到的AJAX框架Buffalo

10 楼 HenryYu 2010-01-17

用不得改造那么累了，用我的beetle框架吧，其中基于web层ajax实现，通信协议用的就是json，可以实现java对象（包括列表等）与javascript对象透明转换，可以随意与当前流行的UI的js库整合。

9 楼 itstarting 2010-01-16

通过进一步学习JSON发现，正如Michael说的“有些需要特殊解决的问题，在JSON中仍然存在，特别是类型的处理。你仍然不得不在JSON中加上类似于type的特殊属性并在后端进行处理”，我决定中庸一些，不寻求绝对精简的JSON，而是要求所有的值，都给我老老实实带上Type。
格式举例：

<pre name="code" class="java">{'buffalo-call':[{'method':divide},{'double':1},{'double':2}]}</pre>
 


 

然而，在编写协议解析的时候，出现了第一个疑问：这个协议需要一个字符一个字符来解析吗，何不直接转化为JSONObject再处理，岂不是更方便？
这个问题同样适用于XML：何不直接读取inputStream后，转化为标准的DOM对象后再处理？
 
难道还有其他什么考虑吗？

8 楼 itstarting 2010-01-15

改造：BuffaloWorker.java
 
根据BuffaloInvoker的调整而微调：
BuffaloInvoker.getInstance()
改为：
BuffaloInvoker.getInstance(getProtocol())
如下：
<pre name="code" class="java">//get the right BuffaloInvoker instance, and invoke it
//BuffaloInvoker.getInstance().invoke(service, inputStream, new OutputStreamWriter(response.getOutputStream(), OUTPUT_ENCODING));
BuffaloInvoker.getInstance(getProtocol()).invoke(service, inputStream, new OutputStreamWriter(response.getOutputStream(), OUTPUT_ENCODING));
</pre>
 
至此，我个人感觉结构性的代码调整已经完成。
下面所做的，就是我们刚才说到的三个重头戏。

但涉及到协议的代码，将非常细节，要求精通Buffalo的XML协议细节，并要求对JSON有较好的把握，所以整体难度也会更大写，从进度上看可能需要点时间了。

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论