这是在 Django 中进行依赖注入的正确方法吗？

我正在尝试将依赖项注入到我的 Django 视图（控制器？）中。这是一些背景知识。

通常情况下，urls.py文件是处理路由的。通常是这样的：

 urlpatterns = [
     path("", views.get_all_posts, name="get_all_posts"),
     path("<int:post_id>", views.get_post, name="get_post"),
     path("create", views.create_post, name="create_post"),
 ]

问题在于，一旦你到达create_post例如，您可能依赖于创建帖子的服务：

# views.py
...

def create_post(self):
    svc = PostCreationService()
    svc.create_post()

这种模式很难测试。虽然我知道 python 测试库有工具来模拟此类事情，但我宁愿将依赖项注入视图中。这就是我的想法。

具有静态方法的控制器类，export(deps)它接受依赖项列表并返回 url 模式对象列表：

class ApiController(object):

    @staticmethod
    def export(**deps):
        ctrl = ApiController(**deps)
        return [
            path("", ctrl.get_all_posts, name="get_all_posts"),
            path("<int:post_id>", ctrl.get_post, name="get_post"),
            path("create", ctrl.create_post, name="create_post"),
        ]

    def __init__(self, **deps):
        self.deps = deps

    def get_all_posts():
        pass
    ...

这看起来很笨拙，但我不知道有任何其他方法可以完成我想做的事情。控制器需要返回 url 模式列表，并且还需要接收依赖项列表。使用上述技术，我可以这样做urls.py:

urlpatterns = ApiController.export(foo_service=(lambda x: x))

我现在可以免费使用foo_service在任何方法中ApiController.

Note:

一种替代方法是让构造函数返回 url 列表，但我不认为这是对此的巨大改进。事实上，我觉得这更令人困惑，因为类构造函数将返回一个列表而不是类的实例。

Note 2:

我知道 python 有用于模拟类成员的模拟工具。请不要建议使用它们。我想使用 DI 作为控制和管理依赖项的方式。

关于最好的方法是什么有什么想法吗？

考虑使用装饰器注入：

from functools import wraps

class ServiceInjector:

    def __init__(self):
        self.deps = {}

    def register(self, name=None):

        name = name
        def decorator(thing):
            """
            thing here can be class or function or anything really
            """

            if not name:
                if not hasattr(thing, "__name__"):
                    raise Exception("no name")
                thing_name = thing.__name__
            else:
                thing_name = name
            self.deps[thing_name] = thing
            return thing

        return decorator

    def inject(self, func):

        @wraps(func)
        def decorated(*args, **kwargs):
            new_args = args + (self.deps, )
            return func(*new_args, **kwargs)

        return decorated

# usage:


si = ServiceInjector()

# use func.__name__, registering func
@si.register()
def foo(*args):
    return sum(args)


# we can rename what it's been registered as, here, the class is registered 
# with name `UpperCase` instead of the class name `UpperCaseRepresentation`
@si.register(name="UpperCase")
class UpperCaseRepresentation:
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return self.value.upper()

#register float
si.register(name="PI")(3.141592653)


# inject into functions
@si.inject 
def bar(a, b, c, _deps): # the last one in *args would be receiving the dependencies
    UpperCase, PI, foo = _deps['UpperCase'], _deps['PI'], _deps['foo']
    print(UpperCase('abc')) # ABC
    print(PI) # 3.141592653
    print(foo(a, b, c, 4, 5)) # = 15

bar(1, 2, 3)

# inject into class methods
class Foo:

    @si.inject
    def my_method(self, a, b, _deps, kwarg1=30):
        return _deps['foo'](a, b, kwarg1)

print(Foo().my_method(1, 2, kwarg1=50)) # = 53