目前，我们以及大多数 Web 框架的序列化工作方式是使用某种类型的方法调用将模型转储为某种类型的格式。在我们的例子中，我们在每个模型上都有一个 to_dict() 方法，它构造并返回一个键值字典，键是字段名称，值是实例变量。

在我们的所有代码中，我们都有如下代码片段:json.dumps(**some_model_object.to_dict()) 会将 some_model_object 序列化为 json。最近，我们决定向我们的用户公开一些内部资源，但其中一些资源具有特定的私有(private)实例值，如果请求用户不是 super 用户，我们不想在序列化期间传回这些值。

我正在尝试提出一个简洁的设计，让序列化更容易，并允许我们序列化为 json 以外的格式。我认为这是面向方面的设计/编程的一个很好的用例，其中方面尊重请求访问控制并根据请求用户的权限序列化对象。

这是与我现在拥有的类似的东西:

from framework import current_request


class User(SQLAlchemyDeclarativeModel):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True)
    first_name = Column(Unicode(255))
    last_name = Column(Unicode(255))
    private_token = Column(Unicode(4096))

    def to_dict(self):
        serialized = dict((column_name, getattr(self, column_name))
                          for column_name in self.__table__.c.keys())

        # current request might not be bound yet, could be in a unit test etc.
        if current_request and not current_request.user.is_superuser():
            # we explicitly define the allowed items because if we accidentally add
            # a private variable to the User table, then it might be exposed.
            allowed = ['id', 'first_name', 'last_name']
            serialized = dict((k, v) for k, v in serialized.iteritems() if k in allowed)

        return serialized

如您所见，这不太理想，因为现在我必须将数据库模型与当前请求相结合。虽然这是非常明确的，但请求耦合是一种代码味道，我正在尝试看看如何干净利落地做到这一点。

我考虑过的一种方法是像这样在模型上注册一些字段:

class User(SQLAlchemyDeclarativeModel):
    __tablename__ = 'users'
    __public__ = ['id', 'first_name', 'last_name']
    __internal__ = User.__exposed__ + ['private_token']

    id = Column(Integer, primary_key=True)
    first_name = Column(Unicode(255))
    last_name = Column(Unicode(255))
    private_token = Column(Unicode(4096))

然后，我会有一个序列化器类，它与每个 WSGI 调用的当前请求绑定(bind)，该请求将采用所需的序列化器。例如:

import simplejson

from framework import JSONSerializer  # json serialization strategy
from framework import serializer

# assume response format was requested as json
serializer.register_serializer(JSONSerializer(simplejson.dumps))
serializer.bind(current_request)

然后在我看来某个地方，我会这样做:

from framework import Response

user = session.query(User).first()
return Response(code=200, serializer.serialize(user))

serialize 将按如下方式实现:

def serialize(self, db_model_obj):
    attributes = '__public__'
    if self.current_request.user.is_superuser():
        attributes = '__private__'

    payload = dict((c, getattr(db_model_obj, c)) 
                   for c in getattr(db_model_obj, attributes))

    return self.serialization_strategy.execute(payload)

关于这种方法的可读性和清晰度的想法？这是解决问题的 Pythonic 方法吗？

提前致谢。

最佳答案

通过mixin建立“序列化”契约:

class Serializer(object):
    __public__ = None
    "Must be implemented by implementors"

    __internal__ = None
    "Must be implemented by implementors"

    def to_serializable_dict(self):
        # do stuff with __public__, __internal__
        # ...

通过 WSGI 集成保持简单。 “注册”，JSONSerializer 作为一个对象，所有这些都是某种 Java/Spring 的东西，不需要那么大张旗鼓。下面是我的 pylons 1.0 风格的解决方案，我还没有在金字塔上:

def my_controller(self):
   # ...

   return to_response(request, response, myobject)


# elsewhere
def to_response(req, resp, obj):
    # this would be more robust, look in
    # req, resp, catch key errors, whatever.
    # xxx_serialize are just functions.  don't need state
    serializer = {
       'application/json':json_serialize,
       'application/xml':xml_serialize,
       # ...
    }[req.headers['content-type']]

    return serializer(obj)

关于python - 在尊重访问控制的同时为 REST API 序列化 SQLAlchemy 模型？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/5232461/