python2.6对json字符串有序的解析成有序的字典

在某些设计不合理的的加密方式下，生成的json字符串，解析成对象的时候，序保证字典key的先后顺序。

Python2.6不支持，采取的办法是：

1. 把Python2.7的json目录复制到工程目录，取名叫jsonx

2. 修改几处import使无语法错误

3. 参考它的encoder，实现如下代码:

import jsonx
from jsonx.encoder import encode_basestring
from collections import OrderedDict


def dumps( orderDict, encoding="utf8" ):
    """
    不支持ensure_ascii=False
    对有序字典有序序列化(不支持null None NaN true/false True/False等js数据类型)
    :param orderDict:
    :param encoding:
    :return:
    """

    def _iter_list( vlst ):
        if not vlst:
            yield '[]'
            return

        buf = "["
        first = True
        for e in vlst:
            if first:
                first = False
            else:
                buf = ','

            if isinstance(e, OrderedDict):
                yield buf
                cs = _iter_dict(e)
                for c in cs:
                    yield c

            elif isinstance(e, (list, tuple)):
                yield buf
                cs = _iter_list(e)
                for c in cs:
                    yield c

            else:
                if isinstance(e, unicode):
                    yield buf + encode_basestring(e.encode(encoding))
                elif isinstance(e, basestring):
                    yield buf + encode_basestring(e)
                elif isinstance(e, (int, long)):
                    yield buf + str(e)
                elif isinstance(e, float):
                    yield buf + repr(e)
                else:
                    yield buf + str(e)
        yield ']'

    def _iter_dict( od ):
        if not od:
            yield '{}'
            return

        yield '{'
        first = True
        for k, v in od.items( ):
            if isinstance(k, unicode):
                key = encode_basestring(k.encode(encoding))
            elif isinstance(k, basestring):
                key = encode_basestring(k)
            elif isinstance(k, (int, long)):
                key = str(k)
            elif isinstance(k, float):
                key = repr(k)
            else:
                key = '"' + str(k) + '"'  # TypeError

            if first:
                first = False
            else:
                yield ","

            yield key
            yield ":"

            if isinstance(v, unicode):
                yield encode_basestring(v.encode(encoding))
            elif isinstance(v, basestring):
                yield encode_basestring(v)
            elif isinstance(v, (int, long)):
                yield str(v)
            elif isinstance(v, float):
                yield repr(v)
            else:
                if isinstance(v, OrderedDict):
                    chunks = _iter_dict(v)
                    for c in chunks:
                        yield c
                elif isinstance(v, list):
                    chunks = _iter_list(v)
                    for c in chunks:
                        yield c
                else:
                    yield '"' + str(v) + '"'
        yield "}"

    if isinstance(orderDict, list):
        it = _iter_list(orderDict)
    elif isinstance(orderDict, OrderedDict):
        it = _iter_dict(orderDict)
    else:
        raise TypeError(orderDict)

    return ''.join(it)


def loads( s, encoding="utf8" ):
    return jsonx.loads(s, encoding=encoding, object_pairs_hook=OrderedDict)