vlambda博客
学习文章列表

在Python的世界里，将一个对象以json格式进行序列化或反序列化一直是一个问题。Python标准库里面提供了json序列化的工具，我们可以简单的用json.dumps来将一个对象序列化。但是这种序列化仅支持python内置的基本类型，对于自定义的类，我们将得到Object of type A is not JSON serializable的错误。

有很多种方法可以用来支持这种序列化，这里（https://stackoverflow.com/questions/3768895/how-to-make-a-class-json-serializable）有一个很长的关于这个问题的讨论。总结起来，基本上有两种还不错的思路：

• 利用标准库的接口：从python标准json库中的 JSONDecoder 继承，然后自定义实现一个 default 方法用来自定义序列化过程
• 利用第三方库实现：如 jsonpickle   jsonweb   json-tricks 等

利用标准库的接口的问题在于，我们需要对每一个自定义类都实现一个JSONDecoder.default接口，难以实现代码复用。

利用第三方库，对我们的代码倒是没有任何侵入性，特别是jsonpickle，由于它是基于pickle标准序列化库实现，可以实现像pickle一样序列化任何对象，一行代码都不需要修改。

但是我们观察这类第三方库的输出的时候，会发现所有的这些类库都会在输出的json中增加一个特殊的标明对象类型的属性。这是为什么呢？Python是一门动态类型的语言，我们无法在对象还没有开始构建的时候知道对象的某一属性的类型信息，为了对反序列化提供支持，看起来确实是不得不这么做。

有人可能觉得这也无可厚非，似乎不影响使用。但是在跨语言通信的时候，这就成为了一个比较麻烦的问题。比如我们有一个Python实现的API，客户端发送了一个json请求过来，我们想在统一的一个地方将json反序列化为我们Python代码的对象。由于客户端不知道服务器端的类型信息，json请求里面就没法加入这样的类型信息，这也就导致这样的类库在反序列化的时候遇到问题。

能不能有一个相对完美的实现呢？先看一下我们理想的json序列化库的需求：

• 我们希望能简单的序列化任意自定义对象，只添加一行代码，或者不加入任何代码。

• 我们希望序列化的结果不加入任何非预期的属性。

• 我们希望能按照指定的类型进行反序列化，能自动处理嵌套的自定义类，只需要自定义类提供非常简单的支持，或者不需要提供任何支持。

• 我们希望反序列化的时候能很好的处理属性不存在的情况，以便在我们加入某一属性的时候，可以设置默认值，使得旧版本的序列化结果可以正确的反序列化出来。

如果有一个json库能支持上面的四点，那就基本是比较好用的库了。下面我们来尝试实现一下这个类库。

对于我们想要实现的几个需求，我们可以建立下面这样的测试来表达我们所期望的库的API设计：

 
class A(JsonSerializable):

  def __init__(self, a, b):
    super().__init__()
    self.a = a
    self.b = b if b is not None else B(0)

  @property
  def id(self):
  return self.a

  def _deserialize_prop(self, name, deserialized):
  if name == 'b':
    self.b = B.deserialize(deserialized)
      return
    super()._deserialize_prop(name, deserialized)

class B(JsonSerializable):
 
  def__init__(self,b):
 super().__init__()
    self.b = b

class JsonSerializableTest(unittest.TestCase):
 
 def test_model_should_serialize_correctly(self):
    self.assertEqual(json.dumps({'a': 1, 'b': {'b': 2}}), A(1, B(2)).serialize())
   
 def test_model_should_deserialize_correctly(self):
    a = A.deserialize(json.dumps({'a': 1, 'b': {'b': 2}}))
    self.assertEqual(1, a.a)
 self.assertEqual(2,a.b.b)
       
  def test_model_should_deserialize_with_default_value_correctly(self):
    a = A.deserialize(json.dumps({'a': 1}))
    self.assertEqual(1, a.a)
    self.assertEqual(0, a.b.b)

def is_normal_prop(obj, key):
  is_prop = isinstance(getattr(type(obj), key, None), property)
  is_func_attr = callable(getattr(obj, key))
  is_private_attr = key.startswith('__')
  return not (is_func_attr or is_prop or is_private_attr)

def is_basic_type(value):
 return value is None or type(value) in [int, float, str, bool]
 
class JsonSerializable:

  def _serialize_prop(self, name):
 return getattr(self, name)
                 
 def _as_dict(self):
    props = {}
    for key in dir(self):
    if not is_normal_prop(self, key):
      continue
      value = self._serialize_prop(key)
      if not (is_basic_type(value) or isinstance(value, JsonSerializable)):
      raise Exception('unknown value to serialize to dict: key={}, value={}'.format(key, value))
      props[key] = value if is_basic_type(value) else value._as_dict()
    return props

 def serialize(self):
  return json.dumps(self._as_dict(), ensure_ascii=False)

  def _deserialize_prop(self, name, deserialized):
    setattr(self, name, deserialized)

  @classmethod
  def deserialize(cls, json_encoded):
    if json_encoded is None:
    return None

  args = inspect.getfullargspec(cls)
  args_without_self = args.args[1:]
  obj = cls(*([None] * len(args_without_self)))

  data = json.loads(json_encoded, encoding='utf8') if type(json_encoded) is str else json_encoded
  for key in dir(obj):
    if not is_normal_prop(obj, key):
    continue
    if key in data:
    obj._deserialize_prop(key, data[key])
    return obj