itstarting

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

最近访客更多访客>>

sp42

黑小子

winting

yeyeyeid

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

Ajax框架Buffalo深度研究

博客分类：

Java框架

框架 Ajax DWR .net hprose

Buffalo深度研究

——2010.01.11， IT进行时[MSN:zhengxianquan AT hotmail Dot com]

1. BUFFALO概述 2
1.1. 主要产品特性 2
1.2. 初次印象 5
2. BUFFALO的关键序列图 5
3. BUFFALO的协议分析 6
3.1. 概述 6
3.2. 请求[BUFFALO.CALL]协议定义 8
3.3. 响应[BUFFALO.RESPONSE]协议定义 8
3.3.1. List-数组或列表 8
3.3.1.1. List 8
3.3.1.2. Array 9
3.3.2. Map & POJO 9
3.3.3. Ref对象引用 10
3.4. FAULT异常 11
3.5. 其他 12
3.5.1. java.sql.Date 12
3.5.2. java.math.BigDecimal/ java.math.BigInteger 12
3.5.3. 还不够？ 13
4. 核心类分析 13
4.1. 概述 13
4.2. SERVICE 14
4.2.1. 服务注册与初始化 14
4.2.2. 服务的匹配与调用 18
4.3. PROTOCOL 21
4.3.1. converters（类型转换解析器） 21
4.3.2. io（协议marshal/unmarshal） 22
5. 协议可能需要完善的专题讨论 26
5.1. 深度分析 26
5.2. 可能的解决方案 27
5.2.1. 在ProtocalTag中加入新协议标签 27
5.2.2. 定义两个工具类 28
5.2.2.1. PrimitiveObjectWrapper 28
5.2.2.2. PrimitiveObjectUtil 28
5.2.3. 新增转换器PrimitiveDoubleConverter 29
5.2.4. 修改DoubleConverter的协议标签类型 30
5.2.5. 注册转换器到DefaultConverterLookup 30
5.2.6. 修订FastStreamReader 33
5.2.7. 完善BuffaloCall 33
5.2.8. 客户端buffalo.js 34
5.3. 测试结果 35
6. 参考 36

1. Buffalo概述

Buffalo是一个贯穿前后端的比较完整的Ajax框架，目前最新的版本是2.0.1，其主页是：

http://buffalo.sourceforge.net/，可通过该页面找到下载。

不过该版本自2007年来就没有更新了，有点遗憾，不管怎样，一出来就关注到了，早前通读过代码，是个好作品。

上周开始用了些零碎的时间，重新评估并进行了深入的研究，其目的在于通过深度掌握某个优秀的贯穿前后端的AJAX框架，以提高自己的整体认知感。

1.1. 主要产品特性

略，可参考：http://buffalo.sourceforge.net/features.html

1.2. 初次印象

Buffalo最有价值之处，个人感觉有两点：

1、后端实现了较为完整的基于xml的xml<->object序列化反序列化协议；

2、前端提供了适配协议的调用封装和响应解析机制，并基于回调机制提供编码API。

另，作品受xstream影响颇深，如果看过xstream的代码大家的感觉会更明显，不知道这样说Michael是否有意见：buffalo后端转换器、IO部分的代码，是xstream的lightweight版本：）

分享到：

让Ajax框架Buffalo支持JSON协议而非仅仅自 ... | Hadoop-0.20.1+Ubuntu9.10实战

2010-01-11 14:37
浏览 2240
评论(25)
论坛回复 / 浏览 (24 / 18116)
分类:Web前端
查看更多

25 楼 chenhailong 2010-12-22

了解中，希望能用到。。。谢谢

24 楼 itstarting 2010-12-20

martintree 写道

lz 能否将这些内容做一个文档可以提供下载啊，因为这个排版实在是不整齐，而且图也不清晰。先谢谢了

呵呵，这位老兄，论坛就是用来讨论并加上娓娓道来的咯

如果你真有兴趣学Buffalo，不妨也帮忙整理下？

23 楼 martintree 2010-12-16

lz 能否将这些内容做一个文档可以提供下载啊，因为这个排版实在是不整齐，而且图也不清晰。先谢谢了

22 楼 antipro 2010-07-30

其实最喜欢buffalo的数据绑定功能，其他倒没觉得什么。

21 楼 andot 2010-01-22

如果只关注RPC，还是PHPRPC和Hprose好，不但可以Java和Js互通，还可以在各种其它常用语言之间进行互通。而且使用更高效的序列化格式，运行和开发效率都很高。

20 楼 itstarting 2010-01-22

类似

但从两者的使用经历来看，如果仅关注RPC，还是Buffalo好：
1、DWR由于是通过动态生成js stub，不支持同服务类下的同名方法；
2、DWR的js stub，感觉很不好，性能上应该有一定的影响

当然，Buffalo目前功能还相对单一，提升的空间还不少啊

19 楼 cuixiping 2010-01-22

功能应该是类似于DWR吧

18 楼 taochenpfj 2010-01-13

ding!这么多，支持！

17 楼 itstarting 2010-01-13

xinnn 写道

Buffalo有js内存泄漏，1.2有2.0好像也没有改过来，但我们自己做了一些小的修正问题不大，很不错的框架

客户端反倒研究不多，可否不吝赐教？

16 楼 xinnn 2010-01-12

Buffalo有js内存泄漏，1.2有2.0好像也没有改过来，但我们自己做了一些小的修正问题不大，很不错的框架

15 楼 itstarting 2010-01-12

mootools我不了解，刚刚好奇看了一下，感觉这是一个纯客户端的框架，感觉是又一个prototype or jquery

Buffalo在定位上不一样，我的理解是：有完善XML自定义协议的贯穿前后的Ajax框架。

其客户端是基于prototype做了简单的自我封装

当然，其扩展性现在还有问题，应该也是作者努力的方向之一吧

14 楼 mycybyb 2010-01-12

我在项目中用mootools写了20行代码，模拟了一下Buffalo的接口，然后把它扔了

13 楼 kimmking 2010-01-12

这样一个框架，大概做的就是
定义一套交互的协议报文，调用接口的约定，
然后就是对象的序列化，反序列化，基本类型和bean的协议转换，
包装成其他格式生成stub或代理
都是些细致的工作

12 楼 itstarting 2010-01-11

Michael，看到你的回帖还真有点激动，群里喊话了两次都毫无反应，心里还真咯噔了下

对primitive的尝试，可能是对DWR积怨过深所致：）无非也是一种学习研究的方法

有时间，我会考虑下实现基于json的协议，前端尝试下用jQuery（主要是前段时间翻了翻jquery in action，觉得也还不错）

还请多指导！

11 楼 mechiland 2010-01-11

感谢itstarting的精辟分析。

对于原子类型、包装类型的处理，主要的考虑在于是不是实用。从系统边界的角度来说，你不会希望看到同一个service中同时存在divide(double, double)和divide(Double, Double)吧。

PS. 看了一下，近3年前你在分析，现在又捡起来分析了……算算自从你那时到现在，buffalo也没怎么更新了

10 楼 itstarting 2010-01-11

DWR我2.0.3用在了两个项目，一个是基于internet的项目tuanzi.com，一个是企业内部产品研发项目

这个版本对于后端不能重名方法调用比较忌惮，开始不明白，等搞清楚机制后就知道怎么回事了，其push部分也尝试过，还好。

但在不少地方，感觉还不如Buffalo精致，但文档、包装什么的，却是更胜一筹，不知道新版本如何。

国内人员维护的开源代码，往往难以善终，跟国内开发人员的生存发展环境有关，前几天看了看Michael的blog，对他所提到的困惑深有同感

这篇研究文档，本来想跟他进行必要的沟通确认后再发布的，但发了两封邮件都无法联系到，也不知道他是在忙还是邮箱地址有误了。

9 楼 kimmking 2010-01-11

第一次了解Buffalo，
跟我的rpcfx很像，不过我的还没有成型，
最近一次大的改动，已经跑不起来了
：）
http://code.google.com/p/rpcfx/

旧的版本实现了java .net服务器、客户端的互相调用

都有dwr的影子。

8 楼 golddragon 2010-01-11

我们的应用中用到了buffalo，不错，国产的ajax框架，只是2.0之后就不再更新了

7 楼 itstarting 2010-01-11

<h2 style="margin: 12pt 0cm; text-indent: 0cm;"><a name="_Toc250983422">5.3. 测试结果</a></h2>
输入：

 <img src="http://dl.iteye.com/upload/attachment/191470/ced4ea83-a24f-35b1-a38e-f34c63332426.jpg" alt=""> 
提交：
<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">
<buffalo-call>
<method>divide</method>
<double>1.1</double>
<double>2.2</double>
</buffalo-call>
</td>
</tr></tbody></table>
结果：
1）日志：
<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">
2010-1-11 13:25:40 net.buffalo.demo.simple.SimpleService divide
信息: Calling Divide in divide(double a, double b),a=1.1, b=2.2
</td>
</tr></tbody></table>
2）界面：
 
 <img src="http://dl.iteye.com/upload/attachment/191469/248a49e8-5063-3b91-82a9-4f8325ce83df.png" alt=""> 
OK，正是我们想要的。
当然了，还有两点需要说明：
1）其他的诸如Float等Primitive类型的处理，照葫芦画瓢即可；
2）客户端buffalo.js还应该有少量的完善工作，重点在于类型的处理上，应该考虑的更周全些。
<h1 style="margin: 24pt 0cm; text-indent: 0cm;"><a name="_Toc250983423">6. 参考</a></h1>
一、Buffalo官方网站：
<a href="http://buffalo.sourceforge.net/">http://buffalo.sourceforge.net</a>
 
二、buffalo.jar 包分析：
http://blog.csdn.net/jianglike18/archive/2009/04/11/4062630.aspx
<a href="http://blog.csdn.net/jianglike18/archive/2009/05/05/4151558.aspx">http://blog.csdn.net/jianglike18/archive/2009/05/05/4151558.aspx</a>

6 楼 itstarting 2010-01-11

<h1 style="margin: 24pt 0cm; text-indent: 0cm;">5<a name="_Toc250983409">. 协议可能需要完善的专题讨论</a>
</h1>
<h2 style="margin: 12pt 0cm; text-indent: 0cm;">5<a name="_Toc250983410">.1. 深度分析</a>
</h2>
首先声明：在未与Michael充分沟通交流前，一切都只是个人的想法，未必正确。
本人在“服务的匹配与调用”章节，曾经提出过服务方法匹配的问题，Michael在buffalo.js的310行提到过“Guess the type of an javascript object”，但光完善客户端，只怕于事无补。
就如我做的实验那样，客户端可以提供divide(double a, double b)的请求，此时的xml为：
<pre name="code" class="xml"><buffalo-call>
<method>divide</method>
<double>1.1</double>
<double>2.1</double>
</buffalo-call>
</pre>
 
此时调用的是divide(Double a, Double b)而不是divide(double a, double b)。
虽然已经相差无几，但依然无法到达准确制导，主要还是primitive及其Wrapper之间容易造成误会。
首先我们还是仔细来看看匹配权重的代码，在相同服务下，同名称同参数长度下，下一步就考虑到了参数的匹配权重问题（这里我加了注释）：

<pre name="code" class="java">private int parameterAssignable(Class targetType, Class sourceType) {
if (targetType.equals(sourceType)) return 6;//如果类型相等，匹配度为6
if (targetType.isAssignableFrom(sourceType)) return 5;//同源，为5
if (targetType.isPrimitive()) {//如果是primitive，则获取Wrapper类
targetType = ClassUtil.getWrapperClass(targetType);
}
if (targetType.equals(sourceType)) {
return 4; //此时肯定是经过处理的匹配，只能为4
} else if (Number.class.isAssignableFrom(targetType) &&
Number.class.isAssignableFrom(sourceType)) {
return 3; //如果两边都是Number型的，马虎匹配了，为3
}
return 0; //0就是没啥匹配度了
}
</pre>
 
 
题外话：注意下后面的if/else代码稍微有些逻辑交待不清。
同时，需要结合所涉及到的Converter，此时为DoubleConverter。同样我们看看代码：

 

 
<pre name="code" class="java">public class DoubleConverter extends AbstractBasicConverter implements Converter{
public boolean canConvert(Class value) {
if (value == null) return false;
return value.equals(double.class) ||
value.equals(Double.class) ||
value.equals(float.class) ||
value.equals(Float.class);
}
protected String getType() {
return ProtocalTag.TAG_DOUBLE;
}
public Object fromString(String string) {
return Double.valueOf(string);
}
}
</pre>
 
显然，在这个例子上，是这个转换器模糊了double和Double，统统变成了Double。
<h2 style="margin: 12pt 0cm; text-indent: 0cm;"><a name="_Toc250983411">5.2. 可能的解决方案</a></h2>
当然，这里的解决方案是以“需要这么干”为前提假设的。在很大程度上来说，这种“精确制导”没有必要。
我仅以解决上述例子为目标，做出修缮。
<h3 style="margin: 12pt 0cm; text-indent: 0cm;">
<a name="_Toc250983412">5.2.1. 在ProtocalTag</a>中加入新协议标签
</h3>
位置：net.buffalo.protocal.ProtocalTag
需要加入新的标签定义：

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

public interface ProtocalTag {
public static final String TAG_BOOLEAN = "boolean";
public static final String TAG_DATE = "date";
public static final String TAG_INT = "int";
public static final String TAG_LONG = "long";
public static final String TAG_NULL = "null";
public static final String TAG_STRING = "string";
public static final String TAG_LENGTH = "length";
public static final String TAG_TYPE = "type";
public static final String TAG_LIST = "list";
public static final String TAG_MAP = "map";
public static final String TAG_DOUBLE = "double";
public static final String TAG_REPLY = "buffalo-reply";
public static final String TAG_REF = "ref";
public static final String TAG_CALL = "buffalo-call";
public static final String TAG_FAULT = "fault";
public static final String TAG_METHOD = "method";

//加入新的协议标签 by zhengxq
//java.lang.Double
public static final String TAG_DOUBLE_W = "java.lang.Double";
//其他}
</pre>
 
 
<h3 style="margin: 12pt 0cm; text-indent: 0cm;"><a name="_Toc250983413">5.2.2. 定义两个工具类</a></h3>
<h4 style="margin: 12pt 0cm; text-indent: 0cm;"><a name="_Toc250983414">5.2.2.1. PrimitiveObjectWrapper</a></h4>
Primitive对象的包装类：

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

public class PrimitiveObjectWrapper {
private Class clazz;
private Object value;
public PrimitiveObjectWrapper(Object value){
this.clazz = PrimitiveObjectUtil.getPrivitiveType(value);
this.value = value;
}
public Class getClazz() {
return clazz;
}
public void setClazz(Class clazz) {
this.clazz = clazz;
}
public Object getValue() {
return value;
}
public void setValue(Object value) {
this.value = value;
}
}
</pre>
 
 
<h4 style="margin: 12pt 0cm; text-indent: 0cm;">5<a name="_Toc250983415">.2.2.2. PrimitiveObjectUtil</a>
</h4>
一个获取primitive类型的工具：

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

public class PrimitiveObjectUtil {
public static Class getPrivitiveType(Object v){
Class clazz = v instanceof Integer ? int.class :
v instanceof Long ? long.class :
v instanceof Short ? short.class :
v instanceof Byte ? byte.class :
v instanceof Float ? float.class :
v instanceof Double ? double.class :
v instanceof Boolean ? boolean.class :
v.getClass();
return clazz;
}
}
</pre>
 
 
<h3 style="margin: 12pt 0cm; text-indent: 0cm;"><a name="_Toc250983416">5.2.3. 新增转换器PrimitiveDoubleConverter</a></h3>
位置：net.buffalo.protocal.converters.primitive
新增primitive的package，并建立新的转换器PrimitiveDoubleConverter.java：

 

 
<pre name="code" class="java">package net.buffalo.protocal.converters.primitive;

import net.buffalo.protocal.ProtocalTag;
import net.buffalo.protocal.converters.Converter;
import net.buffalo.protocal.converters.basic.AbstractBasicConverter;
import net.buffalo.protocal.util.PrimitiveObjectWrapper;

public class PrimitiveDoubleConverter extends AbstractBasicConverter implements Converter{

public boolean canConvert(Class value) {
if (value == null) return false;
return value.equals(double.class);
}

protected String getType() {
return ProtocalTag.TAG_DOUBLE;
}

public Object fromString(String string) {
//get the custom Wrapper
return new PrimitiveObjectWrapper(Double.valueOf(string));
}
}
</pre>
 
<h3 style="margin: 12pt 0cm; text-indent: 0cm;">
<a name="_Toc250983417">5.2.4. 修改DoubleConverter</a>的协议标签类型
</h3>
位置：net.buffalo.protocal.converters.basic.DoubleConverter.java
不再是ProtocalTag.TAG_DOUBLE了：
<pre name="code" class="java">protected String getType() {
return ProtocalTag.TAG_DOUBLE_W;
}
</pre>
 
<h3 style="margin: 12pt 0cm; text-indent: 0cm;"><a name="_Toc250983418">5.2.5. 注册转换器到DefaultConverterLookup</a></h3>
位置：net.buffalo.protocal.converters.DefaultConverterLookup.java


<pre name="code" class="java">protected void registerDefaultConverters() {
BooleanConverter booleanConverter = new BooleanConverter();
DoubleConverter doubleConverter = new DoubleConverter();
IntegerConverter integerConverter = new IntegerConverter();
LongConverter longConverter = new LongConverter();
StringConverter stringConverter = new StringConverter();
DateConverter dateConverter = new DateConverter();
CollectionConverter collectionConverter = new CollectionConverter();
MapConverter mapConverter = new MapConverter();
ArrayConverter arrayConverter = new ArrayConverter();
SqlDateConverter sqlDateConverter = new SqlDateConverter();
BigNumberConverter bigNumberConverter = new BigNumberConverter();
ExceptionConverter exceptionConverter = new ExceptionConverter();
ObjectConverter objectConverter = new ObjectConverter();

//新增新的转换器定义
PrimitiveDoubleConverter primitiveDoubleConverter = new PrimitiveDoubleConverter();

converters.add(nullConverter);
converters.add(booleanConverter);
converters.add(doubleConverter);
converters.add(integerConverter);
converters.add(longConverter);
converters.add(stringConverter);
converters.add(dateConverter);
converters.add(collectionConverter);
converters.add(mapConverter);
converters.add(arrayConverter);
converters.add(sqlDateConverter);
converters.add(bigNumberConverter);
converters.add(exceptionConverter);
// register new primitiveDoubleConverter
converters.add(primitiveDoubleConverter);
// Should be last one
converters.add(objectConverter);

tagNameConverterCache.put(ProtocalTag.TAG_BOOLEAN, booleanConverter);
tagNameConverterCache.put(ProtocalTag.TAG_STRING, stringConverter);
tagNameConverterCache.put(ProtocalTag.TAG_INT, integerConverter);
tagNameConverterCache.put(ProtocalTag.TAG_LONG, longConverter);
tagNameConverterCache.put(ProtocalTag.TAG_NULL, nullConverter);
tagNameConverterCache.put(ProtocalTag.TAG_DATE, dateConverter);
tagNameConverterCache.put(ProtocalTag.TAG_LIST, collectionConverter);
tagNameConverterCache.put(ProtocalTag.TAG_MAP, mapConverter);
tagNameConverterCache.put(ProtocalTag.TAG_REF, new ReferenceConverter());
// edit the doubleConverter
tagNameConverterCache.put(ProtocalTag.TAG_DOUBLE_W, doubleConverter);
// register new primitiveDoubleConverter
tagNameConverterCache.put(ProtocalTag.TAG_DOUBLE, primitiveDoubleConverter);

converterCache.put(Boolean.class, booleanConverter);
converterCache.put(boolean.class, booleanConverter);
converterCache.put(String.class, stringConverter);
converterCache.put(Integer.class, integerConverter);
converterCache.put(int.class, integerConverter);
converterCache.put(Long.class, longConverter);
converterCache.put(long.class, longConverter);
converterCache.put(Double.class, doubleConverter);
// edit the double converter mapping
//converterCache.put(double.class, doubleConverter);
converterCache.put(double.class, primitiveDoubleConverter);
converterCache.put(Date.class, dateConverter);
converterCache.put(ArrayList.class, collectionConverter);
converterCache.put(LinkedList.class, collectionConverter);
converterCache.put(HashSet.class, collectionConverter);
converterCache.put(Vector.class, collectionConverter);
converterCache.put(TreeSet.class, collectionConverter);
converterCache.put(HashMap.class, mapConverter);
converterCache.put(TreeMap.class, mapConverter);
converterCache.put(java.sql.Date.class, sqlDateConverter);
converterCache.put(java.math.BigDecimal.class, bigNumberConverter);
converterCache.put(java.math.BigInteger.class, bigNumberConverter);
}
</pre>
 
 
<h3 style="margin: 12pt 0cm; text-indent: 0cm;"><a name="_Toc250983419">5.2.6. 修订FastStreamReader</a></h3>
位置：net.buffalo.protocal.io.FastStreamReader
 
<pre name="code" class="java">/* 判断是否有效的标签字符，必须是字母、数字和两个特定字符：':'、'-'
* 又新增了字符'.'
*/
private boolean isTagChar(int ch) {
return (ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z' || ch >= '0'
&& ch <= '9' || ch == ':' || ch == '-' || ch == '.');
}
</pre>
 
<h3 style="margin: 12pt 0cm; text-indent: 0cm;"><a name="_Toc250983420">5.2.7. 完善BuffaloCall</a></h3>
位置：net.buffalo.protocal.BuffaloCall

 


 


 

 
<pre name="code" class="java">public BuffaloCall(String methodName, Object[] arguments) {
this.argumentTypes = new Class[arguments.length];
this.arguments = new Object[arguments.length];
for (int i = 0; i < arguments.length; i++) {
// from code
//types[i] = arguments[i].getClass();
// to - begin
if(arguments[i] instanceof PrimitiveObjectWrapper){
PrimitiveObjectWrapper p = (PrimitiveObjectWrapper)arguments[i];
//the type
this.argumentTypes[i] = PrimitiveObjectUtil.getPrivitiveType(p.getValue());
//the value
this.arguments[i] = p.getValue();
}else{
this.argumentTypes[i] = arguments[i].getClass();
this.arguments[i] = arguments[i];
}
//end
}

this.methodName = methodName;
}
</pre>
 
<h3 style="margin: 12pt 0cm; text-indent: 0cm;"><a name="_Toc250983421">5.2.8. 客户端buffalo.js</a></h3>
需要处理客户端对于java.lang.Double标签的处理，在Buffalo.Reply中（注意红色的部分）：

<pre name="code" class="js">deserialize: function(dataNode) {
var ret;
var type = this._getType(dataNode);
switch (type) {
case "boolean": ret = this.doBoolean(dataNode); break;
case "date": ret = this.doDate(dataNode); break;
case "java.lang.double":;//new add
case "double": ret = this.doDouble(dataNode); break;
case "int":
case "long":
ret = this.doInt(dataNode);
break;
case "list": ret = this.doList(dataNode); break;
case "map": ret = this.doMap(dataNode); break;
case "null": ret = this.doNull(dataNode); break;
case "ref": ret = this.doRef(dataNode); break;
case "string": ret = this.doString(dataNode);break;
case "xml": ret = this.doXML(dataNode); break;
case "fault": ret = this.doFault(dataNode); break;
default: ;
}
return ret;
}
</pre>

发表评论

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

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

Ajax框架Buffalo深度研究

1. Buffalo概述

1.1. 主要产品特性

1.2. 初次印象

评论

发表评论

相关推荐

最近访客 更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

Ajax框架Buffalo深度研究

1. Buffalo概述

1.1. 主要产品特性

1.2. 初次印象

评论

发表评论

相关推荐

Netty + Protobuf 的客户端模式运用和问题探讨

实战：使用JMeter的Java Sampler轻松定制自己的benchmark

如何从零开始编写一个企业级的生物匹配引擎

JBoss在单机下多实例的配置备忘

能不能让log4j跑的“更快”，对业务总体执行时间影响更小？

大家都用什么Maven插件？及本人的几个常用插件分享

JSTL/EL如何方便高效的访问Constants和CodeTable（存储于DB的应用系统变量）

Spring MVC 3.x annotated controller的几点心得体会

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

最近访客更多访客>>