Python自定义实现JSON解码器的完整指南_Python

大家好，在之前的文章中，我们系统性地讲解了自定义 json 编码器（jsonencoder）的实现。今天我们将聚焦于它的"逆向工程"——通过继承 jsondecoder 并重写 decode() 方法来实现自定义 json 反序列化，将 json 字符串精准还原为 python 对象。同时，我们还会结合多继承的案例，展示如何将序列化能力灵活组合到类体系中。

一、jsondecoder 与 decode 方法概述

1.1 为什么需要自定义解码器

json.loads() 默认将 json 解析为字典、列表等基础类型，无法自动还原为自定义类实例：

import json
json_str = '{"name": "张三", "age": 25}'
data = json.loads(json_str)
print(type(data))   # <class 'dict'>

我们期望的是：

# 自动还原为 person 对象
person = json.loads(json_str, cls=persondecoder)
print(person.name)   # 张三

1.2 jsondecoder 的核心方法

方法	说明
`__init__()`	构造方法，可传入 `object_hook`、`parse_float` 等参数
`decode(s)`	核心方法：将 json 字符串解析为 python 对象
`raw_decode(s)`	底层解析方法，返回 `(对象, 索引)` 元组

自定义解码器的实现方式：

重写 decode() 方法 —— 完全控制解析流程

二、重写 decode 方法

2.1 基础实现

import json
from datetime import datetime
from typing import any

class person:
    def __init__(self, name: str, age: int, created_at: datetime = none):
        self.name = name
        self.age = age
        self.created_at = created_at or datetime.now()
    
    def __repr__(self):
        return f"person(name={self.name}, age={self.age}, created_at={self.created_at})"


class personencoder(json.jsonencoder):
    """序列化编码器"""
    def default(self, obj):
        if isinstance(obj, person):
            return {
                "__type__": "person",
                "name": obj.name,
                "age": obj.age,
                "created_at": obj.created_at.isoformat()
            }
        if isinstance(obj, datetime):
            return {"__type__": "datetime", "value": obj.isoformat()}
        return super().default(obj)


class persondecoder(json.jsondecoder):
    """自定义解码器：重写 decode 方法"""
    
    def decode(self, s: str) -> any:
        """解析 json 字符串，还原为 person 对象"""
        # 先调用父类方法解析为 python 字典
        data = super().decode(s)
        return self._convert(data)
    
    def _convert(self, data):
        """递归转换数据"""
        if isinstance(data, dict):
            # 检查类型标识
            if data.get("__type__") == "person":
                created_at = data.get("created_at")
                if created_at:
                    created_at = datetime.fromisoformat(created_at)
                return person(
                    name=data["name"],
                    age=data["age"],
                    created_at=created_at
                )
            if data.get("__type__") == "datetime":
                return datetime.fromisoformat(data["value"])
            # 递归处理字典中的每个值
            return {k: self._convert(v) for k, v in data.items()}
        
        elif isinstance(data, list):
            # 递归处理列表中的每个元素
            return [self._convert(item) for item in data]
        
        return data


# 测试
p = person("张三", 25)
json_str = json.dumps(p, cls=personencoder, ensure_ascii=false)
print("序列化:", json_str)

restored = json.loads(json_str, cls=persondecoder)
print("还原:", restored)
print("类型:", type(restored))
print("姓名:", restored.name)
print("创建时间类型:", type(restored.created_at))

输出：

序列化: {"__type__": "person", "name": "张三", "age": 25, "created_at": "2024-01-15t10:30:00.123456"}
还原: person(name=张三, age=25, created_at=2024-01-15 10:30:00.123456)
类型: <class '__main__.person'>
姓名: 张三
创建时间类型: <class 'datetime.datetime'>

2.2 支持多种类型

class address:
    def __init__(self, city: str, district: str):
        self.city = city
        self.district = district
    
    def __repr__(self):
        return f"address(city={self.city}, district={self.district})"

class student:
    def __init__(self, name: str, age: int, address: address = none):
        self.name = name
        self.age = age
        self.address = address
    
    def __repr__(self):
        return f"student(name={self.name}, age={self.age}, address={self.address})"


class multidecoder(json.jsondecoder):
    """支持多种类型的解码器"""
    
    def decode(self, s: str) -> any:
        data = super().decode(s)
        return self._convert(data)
    
    def _convert(self, data):
        if isinstance(data, dict):
            obj_type = data.get("__type__")
            
            if obj_type == "person":
                return person(
                    name=data["name"],
                    age=data["age"],
                    created_at=self._convert(data.get("created_at"))
                )
            
            if obj_type == "student":
                return student(
                    name=data["name"],
                    age=data["age"],
                    address=self._convert(data.get("address"))
                )
            
            if obj_type == "address":
                return address(
                    city=data["city"],
                    district=data["district"]
                )
            
            if obj_type == "datetime":
                return datetime.fromisoformat(data["value"])
            
            # 递归处理
            return {k: self._convert(v) for k, v in data.items()}
        
        elif isinstance(data, list):
            return [self._convert(item) for item in data]
        
        return data


class multiencoder(json.jsonencoder):
    def default(self, obj):
        if isinstance(obj, person):
            return {"__type__": "person", "name": obj.name, "age": obj.age, "created_at": obj.created_at}
        if isinstance(obj, student):
            return {"__type__": "student", "name": obj.name, "age": obj.age, "address": obj.address}
        if isinstance(obj, address):
            return {"__type__": "address", "city": obj.city, "district": obj.district}
        if isinstance(obj, datetime):
            return {"__type__": "datetime", "value": obj.isoformat()}
        return super().default(obj)


# 测试
addr = address("北京", "朝阳区")
student = student("李四", 20, addr)
json_str = json.dumps(student, cls=multiencoder, ensure_ascii=false, indent=2)
print("序列化:")
print(json_str)

restored = json.loads(json_str, cls=multidecoder)
print("\n还原:")
print(restored)
print(restored.address.city)

三、继承序列化类 + 多继承实战

将序列化能力封装到基类中，通过多继承组合到业务类。

序列化基类与混合类

class life:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"name:{self.name},age:{self.age}"

class animal(life):
    def __init__(self,name,age,speed):
        super().__init__(name,age)
        self.speed = speed

    def __str__(self):
        return f"{super().__str__()},speed:{self.speed}"

class flyable:
    def fly(self):
        return f"{self.name}正在飞行,速度为{self.speed}"

class swimable:
    def swim(self):
        return f"{self.name}正在游泳,速度为{self.speed}"
class attackable:
    def attack(self):
        return f"{self.name}会攻击,破坏力强大"

class bird(flyable,animal,life,attackable):
    def __init__(self,name,age,speed):
        super().__init__(name,age,speed)

    def speek(self):
        return f"{self.name}正在喳喳喳"

class dog(animal,life,swimable,attackable):
    def __init__(self,name,age,speed):
        super().__init__(name,age,speed)

    def speek(self):
        return f"{self.name}正在汪汪汪"

class bigswan(animal,life,swimable,flyable,attackable):
    def __init__(self,name,age,speed):
        super().__init__(name,age,speed)

    def speek(self):
        return f"{self.name}发出鹅鹅鹅的声音"

l0 = life("张飞",18)
print(l0)
a0 = animal("陈军",18,30)
print(a0)
b1 = bird("刘振阳",18,100)
print(b1,b1.speek(),b1.fly(),b1.attack())
d1 = dog("陈军",18,30)
print(d1,d1.speek(),d1.swim(),d1.attack())
bs = bigswan("张怡飞",20,50)
print(bs,bs.speek(),bs.swim(),bs.fly(),bs.attack())

四、总结

知识点	核心要点
jsondecoder	自定义解码器的基类，通过继承实现定制
decode() 方法	重写后可完全控制解析流程，实现递归转换
类型标识 __type__	标记对象的原始类型，便于反序列化还原
递归转换	处理嵌套对象时需要递归调用转换逻辑
类型注册表	集中管理类型映射，使解码器可扩展
多继承组合	通过 serializablemixin + deserializablemixin 组合序列化能力