蟒蛇的依赖注射框架

StackOverflow https://stackoverflow.com/questions/156230

  •  03-07-2019
  •  | 
  •  

题

有一个框架，相当于题之一，因(http://code.google.com/p/google-guice)为蟒蛇?

有帮助吗？

解决方案

我没有使用它，但 Spring Python 框架基于Spring并实现反转控制。

Python项目中似乎还有一个Guice： snake-guice

其他提示

弹簧蟒蛇 是的一个分支的基于Java弹框架和春季安全、有针对性的对蟒蛇。这个项目目前包含以下特点：

  • 反转的控制(依赖注射) -使用经典XML，或python@对象装饰(类似的弹簧JavaConfig次级项目)到丝的东西合在一起。而@目的格式不完全相同题之一，因的风格(集中线与接线信息，在每个类别)，它是一个有价值的方式丝你蟒蛇的应用程序。
  • 面向方面的编程 -申请的拦截在一个水平编程模式(而不是垂直的面向对象的继承)等事务、安全和缓存。
  • DatabaseTemplate-读取的数据库需要一个单调周期的开口光标、读取行，并关闭游标，随着例外处理程序。用这个模板类，所有你需要的是SQL query和行处理的功能。弹簧蟒蛇不会休息。
  • 数据库的交易，包装多个数据库话与交易可以让你的代码。这个模块提供了多种方法来定义的交易，而不会使事情复杂化。
  • 安插的安全拦截器锁定访问，以你的方法，利用认证和域的授权。
  • 远程处理-它很容易转换成当地应用程序的成分之一。如果你已经建立了你的客户和服务器件使用国际奥委会的容器内，然后从当地分布式只是一个配置变化。
  • 样本，以帮助展示各种特征的弹簧蟒蛇，一些样本应用程序已经建立：
    • 命令行下执行命令-弹簧框架的样品网的应用程序已经重建，从地面上使用python网的容器，包括： CherryPy.去检查它如何使用这一框架。(注：其他python框架将被添加到这个清单在未来).
    • 弹簧维基百科是强有力的方式来存储和管理的内容，因此，我们创建了一个简单的一个，作为一个演示！
    • 春季机器人使用的弹簧Python建立一个小机器人来管理因诺琴蒂研究中心的通道的开放源项目。

我喜欢这个简单而整洁的框架。

http://pypi.python.org/pypi/injector/

  

作为正式模式的依赖注入在Python中不太有用   在其他语言中，主要是由于它支持关键字   参数，可以轻松模拟对象及其动态   性质。

     

也就是说，协助这个过程的框架可以消除很多   大型应用的锅炉板。这就是Injector所能做到的   救命。它自动且可传递地提供关键字参数   与他们的价值观。作为额外的好处，Injector很好地鼓励   通过使用Module s来划分代码。

     

虽然受到了Guice的启发，但它并没有盲目地复制它   API。提供Pythonic API胜过忠诚。

作为monkeypatching的替代品，我喜欢DI。一个新生项目，例如 http://code.google.com/p/snake-guice/ 可能适合该法案。

或者看博客文章 Dennis Kempin撰写的“Python中的依赖注入”（08年8月）。

pinject（ https://github.com/google/pinject ）是一种新的替代方案。它似乎由Google维护并遵循与Guice类似的模式（ https://code.google.com/p/ google-guice / ），它是Java对手。

有点Guicey python-inject 项目。它非常活跃，并且比Spring-python少了很多代码，但是再一次，我还没有找到使用它的理由。

如果您只想在Python中进行依赖注入，则不需要框架。看一下 Python方式的依赖注入 。这真的很快捷，而且只有c。 50行代码。

这将留下我的5美分：）

https://pypi.python.org/pypi/dependency_injector 

"""Pythonic way for Dependency Injection."""

from dependency_injector import providers
from dependency_injector import injections


@providers.DelegatedCallable
def get_user_info(user_id):
    """Return user info."""
    raise NotImplementedError()


@providers.Factory
@injections.inject(get_user_info=get_user_info)
class AuthComponent(object):
    """Some authentication component."""

    def __init__(self, get_user_info):
        """Initializer."""
        self.get_user_info = get_user_info

    def authenticate_user(self, token):
        """Authenticate user by token."""
        user_info = self.get_user_info(user_id=token + '1')
        return user_info


print AuthComponent
print get_user_info


@providers.override(get_user_info)
@providers.DelegatedCallable
def get_user_info(user_id):
    """Return user info."""
    return {'user_id': user_id}


print AuthComponent().authenticate_user(token='abc')
# {'user_id': 'abc1'}

更新

一段时间过去了，Dependency Injector现在有点不同了。最好从Dependency Injector GitHub页面开始获取实际示例 - https：// github。 COM / ETS-实验室/蟒依赖性注射器

以下是依赖注入容器的一个小示例，该容器根据构造函数参数名称执行构造函数注入：

http://code.activestate.com/recipes/576609 - 壬侵入依赖性注入/

我做了一个lib来做这件事 https://github.com/ettoreleandrotognoli/python-cdi 我希望有帮助

可在pypi上找到： https://pypi.python.org/pypi/pycdi

有了它，你可以使用python2进行注射

import logging
from logging import Logger

from pycdi import Inject, Singleton, Producer
from pycdi.shortcuts import call


@Producer(str, _context='app_name')
def get_app_name():
    return 'PyCDI'


@Singleton(produce_type=Logger)
@Inject(app_name=str, _context='app_name')
def get_logger(app_name):
    return logging.getLogger(app_name)


@Inject(name=(str, 'app_name'), logger=Logger)
def main(name, logger):
    logger.info('I\'m starting...')
    print('Hello World!!!\nI\'m a example of %s' % name)
    logger.debug('I\'m finishing...')


call(main)

使用python3的类型提示

import logging
from logging import Logger

from pycdi import Inject, Singleton, Producer
from pycdi.shortcuts import call


@Producer(_context='app_name')
def get_app_name() -> str:
    return 'PyCDI'


@Singleton()
@Inject(logger_name='app_name')
def get_logger(logger_name: str) -> Logger:
    return logging.getLogger(logger_name)


@Inject(name='app_name')
def main(name: str, logger: Logger):
    logger.info('I\'m starting...')
    print('Hello World!!!\nI\'m a example of %s' % name)
    logger.debug('I\'m finishing...')


call(main)

比框架更简单的是 @autowired decorator 。

这个装饰器提供了干净的依赖注入和延迟初始化支持。

它变成了这样的代码：

def __init__(self, *, model: Model = None, service: Service = None):
    if model is None:
        model = Model()

    if service is None:
        service = Service()

    self.model = model
    self.service = service
    # actual code

进入这个：

@autowired
def __init__(self, *, model: Model, service: Service):
    self.model = model
    self.service = service
    # actual code

它不是一个框架，因此您没有设置和强制执行的工作流程，但它不提供注入上下文操作。

披露：我是项目维护者。

如果你更喜欢一个非常小的解决方案，那就是一个小功能，它只是一个依赖设置器。

https://github.com/liuggio/Ultra-Lightweight-Dependency-喷射器的Python

有一个dyject（ http://dyject.com ），一个用于Python 2和Python 3的轻量级框架，它使用内置的ConfigParser

如果你想要一个像他们所说的那样的新东西，我最近在Python 3中做了一些非常适合我对副项目的简单需求的东西。

您需要的是方法上的 @inject （当然包括__init__）。 其余的是通过注释完成的。

from py3njection import inject
from some_package import ClassToInject

class Demo:
    @inject
    def __init__(self, object_to_use: ClassToInject):
        self.dependency = object_to_use

demo = Demo()

https://pypi.python.org/pypi/py3njection

我最近在python中发布了一个用于DI的简洁（IMHO）微型库：

https://github.com/suned/serum

Enterprython 是一个提供依赖注入的小框架，基于输入提示。

许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top