从源代码角度看Struts2返回JSON数据的原理（转）

前面一篇文章其实只是介绍了如何在Struts2中返回JSON数据到客户端的具体范例而无关其原理，内容与标题不符惹来标题党嫌疑确实是笔者发文 不够严谨，目前已修改标题，与内容匹配。本文将从struts2-json插件的源码角度出发，结合之前的应用范例来说明struts2-json插件返 回JSON数据的原理。

 

用winrar打开struts2-json-plugin-xx.jar(笔者使用版本为2.1.8.1)，根目录下有一个struts-plugin.xml，这个文件想必大家都很了解，不做过多介绍了。打开该文件，内容非常简答，如下：

 

<?
xml
 
version
=
"1.0"
 
encoding
=
"UTF-8"
 
?>

<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
        "http://struts.apache.org/dtds/struts-2.0.dtd">

<
struts
>
    <
package
 
name
=
"json-default"
 
extends
=
"struts-default"
>
        <
result-types
>
            <
result-type
 
name
=
"json"
 
class
=
"org.apache.struts2.json.JSONResult"
/>
        </
result-types
>
        <
interceptors
>
            <
interceptor
 
name
=
"json"
 
class
=
"org.apache.struts2.json.JSONInterceptor"
/>
        </
interceptors
>
    </
package
>
</
struts
>

 

 

前文提到，如果要使用Struts2返回JSON数据到客户端，那么action所在的package必须继承自json-default包，原因 就在上边的配置文件中:这里的配置文件指定了该插件的包名为json-default，所以要使用该插件的功能，就必须继承自该包——json- default。

 

上面的配置文件中，配置了两个类：org.apache.struts2.json.JSONResult和 org.apache.struts2.json.JSONInterceptor，前者是结果类型，后者是一个拦截器。简单说一 下，org.apache.struts2.json.JSONResult负责将action中的“某些”(通过相关参数可以指定，前文已有详述)或 action中所有"可获取"(有getter方法的属性或一个有返回值的getter方法的返回值)数据序列化成JSON字符串，然后发送给客户 端；org.apache.struts2.json.JSONInterceptor负责拦截客户端到json-default包下的所有请求，并检查 客户端提交的数据是否是JSON类型，如果是则根据指定配置来反序列化JSON数据到action中的bean中(说的有点简单，其实该拦截器内部对数据 做了很多判断)，拦截器不是本文的重点，介绍到此为止。看一张图，或许能够更加清晰明了的说明JSON插件执行的流程:

 

 

 

 

下面重点说说org.apache.struts2.json.JSONResult。

 

首先看一下org.apache.struts2.json.JSONResult源码的核心部分:

 

部分属性

 

private
 String defaultEncoding = 
"ISO-8859-1"
;
//默认的编码
private
 List<Pattern> includeProperties;
//被包含的属性的正则表达式，这些属性的值将被序列化为JSON字符串，传送到客户端
private
 List<Pattern> excludeProperties;
//被排除的属性的正则表达式，这些属性的值在对象序列化时将被忽略
private
 String root;
//根对象，即要被序列化的对象，如不指定，将序列化action中所有可被序列化的数据
private
 
boolean
 wrapWithComments;
//是否包装成注释
private
 
boolean
 prefix;
//前缀
private
 
boolean
 enableGZIP = 
false
;
//是否压缩
private
 
boolean
 ignoreHierarchy = 
true
;
//是否忽略层次关系，即是否序列化对象父类中的属性
private
 
boolean
 ignoreInterfaces = 
true
;
//是否忽略接口
private
 
boolean
 enumAsBean = 
false
;
//是否将枚举类型作为一个bean处理
private
 
boolean
 excludeNullProperties = 
false
;
//是否排除空的属性，即是否不序列化空值属性
private
 
int
 statusCode;
//HTTP状态码
private
 
int
 errorCode;
//HTTP错误码
private
 String contentType;
//内容类型，通常为application/json，在IE浏览器中会提示下载，可以通过参数配置<param name="contentType">text/html</param>，则不提示下载
private
 String wrapPrefix;
//包装前缀
private
 String wrapSuffix;
//包装后缀

 

 

看一下上一篇文章中的相关参数配置:

 

<
package
 
name
=
"json"
 
extends
=
"json-default"
 
namespace
=
"/test"
>
    <
action
 
name
=
"testByAction"
            class
=
"cn.ysh.studio.struts2.json.demo.action.UserAction"
 
method
=
"testByAction"
>
        <
result
 
type
=
"json"
>
                <!-- 这里指定将被Struts2序列化的属性，该属性在action中必须有对应的getter方法 -->
                <!-- 默认将会序列所有有返回值的getter方法的值，而无论该方法是否有对应属性 -->
                <
param
 
name
=
"root"
>
dataMap
</
param
>
                <!-- 指定是否序列化空的属性 -->
                <
param
 
name
=
"excludeNullProperties"
>
true
</
param
>
                <!-- 这里指定将序列化dataMap中的那些属性 -->
                <
param
 
name
=
"includeProperties"
>
                    user.*
                </
param
>
                <!-- 指定内容类型，默认为application/json，IE浏览器会提示下载 -->
                <
param
 
name
=
"contentType"
>
text/html
</
param
>
                <!-- 这里指定将要从dataMap中排除那些属性，这些排除的属性将不被序列化，一半不与上边的参数配置同时出现 -->
                <
param
 
name
=
"excludeProperties"
>
                    SUCCESS
                </
param
>
        </
result
>
    </
action
>
</
package
>

 

配置中出现了JSONResult的部分属性名，是的，JSONResult中的属性都可以根据需要在struts.xml中配置对应参数以改变默认值来满足我们的需要。

 

 

接下来看看它的两个核心方法:

 

 

public
 
void
 execute(ActionInvocation invocation) 
throws
 Exception {
        ActionContext actionContext = invocation.getInvocationContext();
        HttpServletRequest request = (HttpServletRequest) actionContext.get(StrutsStatics.HTTP_REQUEST);
        HttpServletResponse response = (HttpServletResponse) actionContext.get(StrutsStatics.HTTP_RESPONSE);

        try
 {
            String json;
            Object rootObject;
            //查找指定的需要序列化的对象，否则序列化整个action(上文包括前一篇文章中一提到过多次)
            if
 (
this
.enableSMD) {
                // generate SMD
                rootObject = this
.writeSMD(invocation);
            } else
 {
                // generate JSON
                if
 (
this
.root != 
null
) {
                    ValueStack stack = invocation.getStack();
                    rootObject = stack.findValue(this
.root);
                } else
 {
                    rootObject = invocation.getAction();
                }
            }
            //这是最核心的一行代码，包括了如何从rootObject抽取"可以"被序列化的属性的值，然后包装称JSON字符串并返回
            json = JSONUtil.serialize(rootObject, excludeProperties, includeProperties, ignoreHierarchy,
                    enumAsBean, excludeNullProperties);
            //针对JSONP的一个成员方法
            json = addCallbackIfApplicable(request, json);

            boolean
 writeGzip = enableGZIP && JSONUtil.isGzipInRequest(request);

            //该方法是org.apache.struts2.json.JSONResult的一个成员方法，用于将JSON字符串根据指定参数包装后发送到客户端
            writeToResponse(response, json, writeGzip);

        } catch
 (IOException exception) {
            LOG.error(exception.getMessage(), exception);
            throw
 exception;
        }
    }

    /**
     * 负责根据相关参数配置，将制定JSON字符串发送到客户端
     * @param response
     * @param json
     * @param gzip
     * @throws IOException
     */
    protected
 
void
 writeToResponse(HttpServletResponse response, String json, 
boolean
 gzip)
            throws
 IOException {
        JSONUtil.writeJSONToResponse(new
 SerializationParams(response, getEncoding(), isWrapWithComments(),
                json, false
, gzip, noCache, statusCode, errorCode, prefix, contentType, wrapPrefix,
                wrapSuffix));
    }

 

恕笔者愚钝，找了好多资料，始终不明白这里的"SMD"是个什么意思，所在这里包括下文，都将忽略"SMD"。

 

 

可以看到，Struts2序列化对象为JSON字符串的整个过程都被JSONUtil的serialize方法包办了，所以有必要跟入这个方法一探究竟:

 

/**
 * Serializes an object into JSON, excluding any properties matching any of
 * the regular expressions in the given collection.
 *
 * @param object
 *            to be serialized
 * @param excludeProperties
 *            Patterns matching properties to exclude
 * @param ignoreHierarchy
 *            whether to ignore properties defined on base classes of the
 *            root object
 * @param enumAsBean
 *            whether to serialized enums a Bean or name=value pair
 * @return JSON string
 * @throws JSONException
 */
public
 
static
 String serialize(Object object, Collection<Pattern> excludeProperties,
        Collection<Pattern> includeProperties, boolean
 ignoreHierarchy, 
boolean
 enumAsBean,
        boolean
 excludeNullProperties) 
throws
 JSONException {
    JSONWriter writer = new
 JSONWriter();
    writer.setIgnoreHierarchy(ignoreHierarchy);
    writer.setEnumAsBean(enumAsBean);
    return
 writer.write(object, excludeProperties, includeProperties, excludeNullProperties);
}

 

 

该方法还有一个重载的兄弟方法，只是少了boolean enumAsBean这个参数，我们并不关心它，这里不讨论它。可以看到，这个方法更简单:构建一个JSONWriter实例，注入两个参数，然后调用该 实例的write方法。我们进入JSONWriter，查看write方法的源码:

 

 

/**
 * @param object
 *            Object to be serialized into JSON
 * @return JSON string for object
 * @throws JSONException
 */
public
 String write(Object object, Collection<Pattern> excludeProperties,
        Collection<Pattern> includeProperties, boolean
 excludeNullProperties) 
throws
 JSONException {
    this
.excludeNullProperties = excludeNullProperties;
    this
.buf.setLength(
0
);
    this
.root = object;
    this
.exprStack = 
""
;
    this
.buildExpr = ((excludeProperties != 
null
) && !excludeProperties.isEmpty())
            || ((includeProperties != null
) && !includeProperties.isEmpty());
    this
.excludeProperties = excludeProperties;
    this
.includeProperties = includeProperties;
    this
.value(object, 
null
);

    return
 
this
.buf.toString();
}

 

 

它同样有一个重载的方法，我们同样不关心，浏览整个方法，不难发现，它只是所做了一些赋值操作，然后将对象的序列化工作交给了value成员方法，那么我们进入value方法看一看: 

 

 

/**
 * Detect cyclic references
 */
private
 
void
 value(Object object, Method method) 
throws
 JSONException {
    if
 (object == 
null
) {
        this
.add(
"null"
);

        return
;
    }

    if
 (
this
.stack.contains(object)) {
        Class clazz = object.getClass();

        // cyclic reference
        if
 (clazz.isPrimitive() || clazz.equals(String.
class
)) {
            this
.process(object, method);
        } else
 {
            if
 (LOG.isDebugEnabled()) {
                LOG.debug("Cyclic reference detected on "
 + object);
            }

            this
.add(
"null"
);
        }

        return
;
    }

    this
.process(object, method);
}

 

 

很简洁，进入process方法

 

 

/**
 * Serialize object into json
 */
private
 
void
 process(Object object, Method method) 
throws
 JSONException {
    this
.stack.push(object);

    if
 (object 
instanceof
 Class) {
        this
.string(object);
    } else
 
if
 (object 
instanceof
 Boolean) {
        this
.bool(((Boolean) object).booleanValue());
    } else
 
if
 (object 
instanceof
 Number) {
        this
.add(object);
    } else
 
if
 (object 
instanceof
 String) {
        this
.string(object);
    } else
 
if
 (object 
instanceof
 Character) {
        this
.string(object);
    } else
 
if
 (object 
instanceof
 Map) {
        this
.map((Map) object, method);
    } else
 
if
 (object.getClass().isArray()) {
        this
.array(object, method);
    } else
 
if
 (object 
instanceof
 Iterable) {
        this
.array(((Iterable) object).iterator(), method);
    } else
 
if
 (object 
instanceof
 Date) {
        this
.date((Date) object, method);
    } else
 
if
 (object 
instanceof
 Calendar) {
        this
.date(((Calendar) object).getTime(), method);
    } else
 
if
 (object 
instanceof
 Locale) {
        this
.string(object);
    } else
 
if
 (object 
instanceof
 Enum) {
        this
.enumeration((Enum) object);
    } else
 {
        this
.bean(object);
    }

    this
.stack.pop();
}

 

 

发现它做了很多判断，并结合不同的方法来支持不同的数据类型，那么从这里我们可以知道Struts-json-plugin支持哪些数据类型了。对 于每一种支持的数据类型，Struts-json-plugin都有相应的方法来从从对象中抽取数据并封装成JSON字符串，以Map为例，我们看一下 map方法的源码:

 

 

 
/**
  * Add map to buffer
  */
 private
 
void
 map(Map map, Method method) 
throws
 JSONException {
     //这是一个对象，按照JSON语法，应该以"{}"括起来
his.add("{"
);

     Iterator it = map.entrySet().iterator();

     boolean
 warnedNonString = 
false
; 
// one report per map
     boolean
 hasData = 
false
;
     while
 (it.hasNext()) {
         Map.Entry entry = (Map.Entry) it.next();
//如果key不是String类型，将发出警告
         Object key = entry.getKey();
//当前属性的OGNL表达式
         String expr = null
;
         if
 (
this
.buildExpr) {
             if
 (key == 
null
) {
                 LOG.error("Cannot build expression for null key in "
 + 
this
.exprStack);
                 continue
;
             } else
 {
        //获取完整的OGNL表达式
                 expr = this
.expandExpr(key.toString());
        //是否是被排除的属性
        //如果你对上边生成的OGNL表达式的格式有所了解，那么includeProperties和excludeProperties的正则配置绝对不是问题
                 if
 (
this
.shouldExcludeProperty(expr)) {
                     continue
;
                 }
        //如果不被排除，则将当前属性名压入表达式栈(其实就是一个String而非传统意义上的栈，此处是模拟，非常精巧的算法)
        //该方法返回原来的表达式，稍后还将恢复该表达式到"栈"中
                 expr = this
.setExprStack(expr);
             }
         }
//如果还有数据，则以","风格，这是JSON的语法格式
         if
 (hasData) {
             this
.add(
','
);
         }
         hasData = true
;
//如果key不是String类型，将发出警告，且只警告一次
         if
 (!warnedNonString && !(key 
instanceof
 String)) {
             LOG.warn("JavaScript doesn't support non-String keys, using toString() on "
                     + key.getClass().getName());
             warnedNonString = true
;
         }
         this
.value(key.toString(), method);
         this
.add(
":"
);
//递归抽取数据
         this
.value(entry.getValue(), method);
//下一层的数据递归完成后，恢复表达式栈值为当前层的属性名
         if
 (
this
.buildExpr) {
             this
.setExprStack(expr);
         }
     }

     this
.add(
"}"
);
 }

 

这个方法中比较重要的几行代码都做了注释，不再赘述。过滤某些属性，以使其不被序列化时struts2-JSON应用中非常常见的，比如在序列化一 个用户对象的时候，密码信息时不应该被传送到客户端的，所以要排除掉。了解shouldExcludeProperty方法的过滤规则，可以帮助我们更好 的使用此功能。源码如下:

 

private
 
boolean
 shouldExcludeProperty(String expr) {
        if
 (
this
.excludeProperties != 
null
) {
            for
 (Pattern pattern : 
this
.excludeProperties) {
                if
 (pattern.matcher(expr).matches()) {
                    if
 (LOG.isDebugEnabled())
                        LOG.debug("Ignoring property because of exclude rule: "
 + expr);
                    return
 
true
;
                }
            }
        }

        if
 (
this
.includeProperties != 
null
) {
            for
 (Pattern pattern : 
this
.includeProperties) {
                if
 (pattern.matcher(expr).matches()) {
                    return
 
false
;
                }
            }

            if
 (LOG.isDebugEnabled())
                LOG.debug("Ignoring property because of include rule:  "
 + expr);
            return
 
true
;
        }

        return
 
false
;
    }

 

非常简单，就是简单的正则匹配，如果有排除配置，则先判断当前属性是否被排除，如果没有被排除，且有包含配置则检查是否被包含，如果没有被包含，则不序列化该属性，如果没有被排除且没有包含配置，则将序列化该属性。

源码跟踪到这里，已经没有继续下去的必要了，因为我们已经很清楚Struts2是如何将一个对象转换成JSON字符串并返回客户端的:

1、收集用户配置；
2、JSONWriter通过判断对象的类型来有针对性的抽取其中的属性值，对于嵌套的对象则采用递归的方式来抽取，抽取的同时，包装成符合JSON语法规范的字符串；
3、JSONUtil.writeJSONToResponse将序列化的JSON字符串按照相关配置发送到客户端；  
  
不难看出，代码逻辑清晰，简单，朴素，没有半点花巧和卖弄，但确实是非常的精巧，表现出作者扎实的编程功底和过人的逻辑思维能力。尤其是递归抽取嵌套对象的属性值和获取当前属性的OGNL表达式的算法，堪称经典！

 

通过以上的源码跟踪，我们很清楚的了解Struts2序列化对象的原理和过程，并对相关参数的配置有了深刻的体会。只是令人感到奇怪的是，他并没有 使用json-lib.xx.jar中的API接口，而是以字符串拼接的方式手动构建JSON字符串，我想原因可能是因为它要用正则表达式包含或排除某些 属性的原因吧，仅作猜测，还望高人指点。

 

有很多人说不知道includeProperties和excludeProperties的正则表达式该怎么配置，我想说其实很简单，除了正则知 识外，就是"对象名.属性名"，数组稍微不同，以为它有下标，所以是"数组对象名\[\d+\]\.属性名"。如果这里觉得说的不清楚，可以阅读以下 JSONWriter中关于OGNL表达式是如何获取的部分代码，就会明白正则该如何写了。

 

 

纯属个人理解，如有错误，烦请指正，不胜荣幸！

 

 

 

 

原创文章，转载请注明出处:http://yshjava.iteye.com/blog/1333602