🌡️ ⚪️ 👶🏾 Aplicativo CLI + Dependency Injector - guia de injeção de dependência + FAQ 😌 🤴🏾 🔫

Olá,

sou o criador do injetor de dependência . Esta é uma estrutura de injeção de dependência para Python.

Este é o guia definitivo para criar aplicativos com o injetor de dependência. Tutoriais anteriores cobrem como construir um aplicativo da web com Flask , API REST com Aiohttp e monitorar um daemon com Asyncio usando injeção de dependência.

Hoje eu quero mostrar como você pode construir um aplicativo de console (CLI).

Além disso, preparei respostas para as perguntas mais frequentes e publicarei seu pós-escrito.

O manual consiste nas seguintes partes:

O projeto concluído pode ser encontrado no Github .

Para começar você deve ter:

Python 3.5+
Ambiente virtual

E é desejável ter uma compreensão geral do princípio da injeção de dependência.

O que vamos construir?

Estaremos construindo um aplicativo CLI (console) que procura filmes. Vamos chamá-lo de Movie Lister.

Como funciona o Movie Lister?

Temos um banco de dados de filmes
As seguintes informações são conhecidas sobre cada filme:
- Nome
- Ano de emissão
- Nome do diretor
O banco de dados é distribuído em dois formatos:
- Arquivo csv
- Banco de dados Sqlite
O aplicativo pesquisa o banco de dados usando os seguintes critérios:
- Nome do diretor
- Ano de emissão
Outros formatos de banco de dados podem ser adicionados no futuro

Movie Lister é um aplicativo de amostra usado no artigo de Martin Fowler sobre injeção de dependência e inversão de controle.

Esta é a aparência do diagrama de classes do aplicativo Movie Lister:

As responsabilidades entre as classes são distribuídas da seguinte forma:

MovieLister - responsável pela busca
MovieFinder - responsável por extrair dados do banco de dados
Movie - classe de entidade "filme"

Preparando o ambiente

Vamos começar preparando o ambiente.

Em primeiro lugar, precisamos criar uma pasta de projeto e um ambiente virtual:

mkdir movie-lister-tutorial
cd movie-lister-tutorial
python3 -m venv venv

Agora vamos ativar o ambiente virtual:

. venv/bin/activate

O ambiente está pronto. Agora vamos entrar na estrutura do projeto.

Estrutura do projeto

Nesta seção, vamos organizar a estrutura do projeto.

Vamos criar a seguinte estrutura na pasta atual. Deixe todos os arquivos vazios por enquanto.

Estrutura inicial:

./
├── movies/
│   ├── __init__.py
│   ├── __main__.py
│   └── containers.py
├── venv/
├── config.yml
└── requirements.txt

Instalando dependências

É hora de instalar as dependências. Usaremos pacotes como este:

dependency-injector - framework de injeção de dependência
pyyaml - biblioteca para analisar arquivos YAML, usada para ler a configuração
pytest - estrutura de teste
pytest-cov - biblioteca auxiliar para medir a cobertura de código por testes

Vamos adicionar as seguintes linhas ao arquivo requirements.txt:

dependency-injector
pyyaml
pytest
pytest-cov

E execute no terminal:

pip install -r requirements.txt

A instalação das dependências foi concluída. Passando para os acessórios.

Luminárias

Nesta seção, adicionaremos acessórios. Os dados de teste são chamados de acessórios.

Criaremos um script que criará bancos de dados de teste.

Adicione um diretório data/à raiz do projeto e adicione um arquivo dentro de fixtures.py:

./
├── data/
│   └── fixtures.py
├── movies/
│   ├── __init__.py
│   ├── __main__.py
│   └── containers.py
├── venv/
├── config.yml
└── requirements.txt

A seguir, edite fixtures.py:

"""Fixtures module."""

import csv
import sqlite3
import pathlib


SAMPLE_DATA = [
    ('The Hunger Games: Mockingjay - Part 2', 2015, 'Francis Lawrence'),
    ('Rogue One: A Star Wars Story', 2016, 'Gareth Edwards'),
    ('The Jungle Book', 2016, 'Jon Favreau'),
]

FILE = pathlib.Path(__file__)
DIR = FILE.parent
CSV_FILE = DIR / 'movies.csv'
SQLITE_FILE = DIR / 'movies.db'


def create_csv(movies_data, path):
    with open(path, 'w') as opened_file:
        writer = csv.writer(opened_file)
        for row in movies_data:
            writer.writerow(row)


def create_sqlite(movies_data, path):
    with sqlite3.connect(path) as db:
        db.execute(
            'CREATE TABLE IF NOT EXISTS movies '
            '(title text, year int, director text)'
        )
        db.execute('DELETE FROM movies')
        db.executemany('INSERT INTO movies VALUES (?,?,?)', movies_data)


def main():
    create_csv(SAMPLE_DATA, CSV_FILE)
    create_sqlite(SAMPLE_DATA, SQLITE_FILE)
    print('OK')


if __name__ == '__main__':
    main()

Agora vamos executar no terminal:

python data/fixtures.py

O script deve sair OKcom sucesso.

Verificamos se os arquivos movies.csve movies.dbapareceram no diretório data/:

./
├── data/
│   ├── fixtures.py
│   ├── movies.csv
│   └── movies.db
├── movies/
│   ├── __init__.py
│   ├── __main__.py
│   └── containers.py
├── venv/
├── config.yml
└── requirements.txt

Jogos são criados. Vamos continuar.

Recipiente

Nesta seção, adicionaremos a parte principal de nosso aplicativo - o contêiner.

O contêiner permite que você descreva a estrutura do aplicativo em um estilo declarativo. Ele conterá todos os componentes do aplicativo e suas dependências. Todas as dependências serão especificadas explicitamente. Os provedores são usados para adicionar componentes do aplicativo ao contêiner. Os provedores controlam a vida útil dos componentes. Ao criar um provedor, nenhum componente é criado. Dizemos ao provedor como criar o objeto e ele o criará assim que necessário. Se a dependência de um provedor for de outro provedor, ele será chamado e assim por diante ao longo da cadeia de dependências.

Vamos editar containers.py:

"""Containers module."""

from dependency_injector import containers


class ApplicationContainer(containers.DeclarativeContainer):
    ...

O recipiente ainda está vazio. Adicionaremos provedores nas próximas seções.

Vamos adicionar outra função main(). Sua responsabilidade é executar o aplicativo. Por enquanto, ela criará apenas um container.

Vamos editar __main__.py:

"""Main module."""

from .containers import ApplicationContainer


def main():
    container = ApplicationContainer()


if __name__ == '__main__':
    main()

O contêiner é o primeiro objeto do aplicativo. É usado para obter todos os outros objetos.

Trabalhando com csv

Agora vamos adicionar tudo o que precisamos para trabalhar com arquivos csv.

Nós precisamos:

A essência Movie
Classe base MovieFinder
Sua implementação CsvMovieFinder
Classe MovieLister

Após adicionar cada componente, iremos adicioná-lo ao contêiner.

Crie um arquivo entities.pyem um pacote movies:

./
├── data/
│   ├── fixtures.py
│   ├── movies.csv
│   └── movies.db
├── movies/
│   ├── __init__.py
│   ├── __main__.py
│   ├── containers.py
│   └── entities.py
├── venv/
├── config.yml
└── requirements.txt

e adicione as seguintes linhas dentro:

"""Movie entities module."""


class Movie:

    def __init__(self, title: str, year: int, director: str):
        self.title = str(title)
        self.year = int(year)
        self.director = str(director)

    def __repr__(self):
        return '{0}(title={1}, year={2}, director={3})'.format(
            self.__class__.__name__,
            repr(self.title),
            repr(self.year),
            repr(self.director),
        )

Agora precisamos adicionar uma fábrica Movieao contêiner. Para isso, precisamos de um módulo providersde dependency_injector.

Vamos editar containers.py:

"""Containers module."""

from dependency_injector import containers, providers

from . import entities

class ApplicationContainer(containers.DeclarativeContainer):

    movie = providers.Factory(entities.Movie)

Não se esqueça de remover as reticências ( ...). O container já tem provedores e não é mais necessário.

Vamos prosseguir para a criação finders.

Crie um arquivo finders.pyem um pacote movies:

./
├── data/
│   ├── fixtures.py
│   ├── movies.csv
│   └── movies.db
├── movies/
│   ├── __init__.py
│   ├── __main__.py
│   ├── containers.py
│   ├── entities.py
│   └── finders.py
├── venv/
├── config.yml
└── requirements.txt

e adicione as seguintes linhas dentro:

"""Movie finders module."""

import csv
from typing import Callable, List

from .entities import Movie


class MovieFinder:

    def __init__(self, movie_factory: Callable[..., Movie]) -> None:
        self._movie_factory = movie_factory

    def find_all(self) -> List[Movie]:
        raise NotImplementedError()


class CsvMovieFinder(MovieFinder):

    def __init__(
            self,
            movie_factory: Callable[..., Movie],
            path: str,
            delimiter: str,
    ) -> None:
        self._csv_file_path = path
        self._delimiter = delimiter
        super().__init__(movie_factory)

    def find_all(self) -> List[Movie]:
        with open(self._csv_file_path) as csv_file:
            csv_reader = csv.reader(csv_file, delimiter=self._delimiter)
            return [self._movie_factory(*row) for row in csv_reader]

Agora vamos adicionar CsvMovieFinderao contêiner.

Vamos editar containers.py:

"""Containers module."""

from dependency_injector import containers, providers

from . import finders, entities

class ApplicationContainer(containers.DeclarativeContainer):

    config = providers.Configuration()

    movie = providers.Factory(entities.Movie)

    csv_finder = providers.Singleton(
        finders.CsvMovieFinder,
        movie_factory=movie.provider,
        path=config.finder.csv.path,
        delimiter=config.finder.csv.delimiter,
    )

Você CsvMovieFindertem uma dependência da fábrica Movie. CsvMovieFinderprecisa de uma fábrica, pois criará objetos Movieao ler os dados de um arquivo. Para passar de fábrica, usamos o atributo .provider. Isso é chamado de delegação do provedor. Se especificarmos uma fábrica moviecomo dependência, ela será chamada quando csv_finderfor criada CsvMovieFindere um objeto será passado como uma injeção Movie. O uso do atributo .providercomo uma injeção será passado pelo próprio provedor.

Ele csv_findertambém depende de várias opções de configuração. Adicionamos um provedor onfigurationpara passar essas dependências.

Usamos os parâmetros de configuração antes de definir seus valores. Este é o princípio pelo qual o provedor trabalha Configuration.

Primeiro usamos, depois definimos os valores.

Agora vamos adicionar os valores de configuração.

Vamos editar config.yml:

finder:

  csv:
    path: "data/movies.csv"
    delimiter: ","

Os valores são definidos para o arquivo de configuração. Vamos atualizar a função main()para indicar sua localização.

Vamos editar __main__.py:

"""Main module."""

from .containers import ApplicationContainer


def main():
    container = ApplicationContainer()

    container.config.from_yaml('config.yml')


if __name__ == '__main__':
    main()

Vamos para listers.

Crie um arquivo listers.pyem um pacote movies:

./
├── data/
│   ├── fixtures.py
│   ├── movies.csv
│   └── movies.db
├── movies/
│   ├── __init__.py
│   ├── __main__.py
│   ├── containers.py
│   ├── entities.py
│   ├── finders.py
│   └── listers.py
├── venv/
├── config.yml
└── requirements.txt

e adicione as seguintes linhas dentro:

"""Movie listers module."""

from .finders import MovieFinder


class MovieLister:

    def __init__(self, movie_finder: MovieFinder):
        self._movie_finder = movie_finder

    def movies_directed_by(self, director):
        return [
            movie for movie in self._movie_finder.find_all()
            if movie.director == director
        ]

    def movies_released_in(self, year):
        return [
            movie for movie in self._movie_finder.find_all()
            if movie.year == year
        ]

Nós atualizamos containers.py:

"""Containers module."""

from dependency_injector import containers, providers

from . import finders, listers, entities

class ApplicationContainer(containers.DeclarativeContainer):

    config = providers.Configuration()

    movie = providers.Factory(entities.Movie)

    csv_finder = providers.Singleton(
        finders.CsvMovieFinder,
        movie_factory=movie.provider,
        path=config.finder.csv.path,
        delimiter=config.finder.csv.delimiter,
    )

    lister = providers.Factory(
        listers.MovieLister,
        movie_finder=csv_finder,
    )

Todos os componentes são criados e adicionados ao contêiner.

Finalmente, atualizamos a função main().

Vamos editar __main__.py:

"""Main module."""

from .containers import ApplicationContainer


def main():
    container = ApplicationContainer()

    container.config.from_yaml('config.yml')

    lister = container.lister()

    print(
        'Francis Lawrence movies:',
        lister.movies_directed_by('Francis Lawrence'),
    )
    print(
        '2016 movies:',
        lister.movies_released_in(2016),
    )


if __name__ == '__main__':
    main()

Tudo está pronto. Agora vamos iniciar o aplicativo.

Vamos executar no terminal:

python -m movies

Você verá:

Francis Lawrence movies: [Movie(title='The Hunger Games: Mockingjay - Part 2', year=2015, director='Francis Lawrence')]
2016 movies: [Movie(title='Rogue One: A Star Wars Story', year=2016, director='Gareth Edwards'), Movie(title='The Jungle Book', year=2016, director='Jon Favreau')]

Nosso aplicativo funciona com um banco de dados de filmes em csv. Também precisamos adicionar suporte de formato sqlite. Trataremos disso na próxima seção.

Trabalhando com sqlite

Nesta seção, adicionaremos outro tipo MovieFinder- SqliteMovieFinder.

Vamos editar finders.py:

"""Movie finders module."""

import csv
import sqlite3
from typing import Callable, List

from .entities import Movie


class MovieFinder:

    def __init__(self, movie_factory: Callable[..., Movie]) -> None:
        self._movie_factory = movie_factory

    def find_all(self) -> List[Movie]:
        raise NotImplementedError()


class CsvMovieFinder(MovieFinder):

    def __init__(
            self,
            movie_factory: Callable[..., Movie],
            path: str,
            delimiter: str,
    ) -> None:
        self._csv_file_path = path
        self._delimiter = delimiter
        super().__init__(movie_factory)

    def find_all(self) -> List[Movie]:
        with open(self._csv_file_path) as csv_file:
            csv_reader = csv.reader(csv_file, delimiter=self._delimiter)
            return [self._movie_factory(*row) for row in csv_reader]


class SqliteMovieFinder(MovieFinder):

    def __init__(
            self,
            movie_factory: Callable[..., Movie],
            path: str,
    ) -> None:
        self._database = sqlite3.connect(path)
        super().__init__(movie_factory)

    def find_all(self) -> List[Movie]:
        with self._database as db:
            rows = db.execute('SELECT title, year, director FROM movies')
            return [self._movie_factory(*row) for row in rows]

Adicione o provedor sqlite_finderao contêiner e especifique-o como uma dependência para o provedor lister.

Vamos editar containers.py:

"""Containers module."""

from dependency_injector import containers, providers

from . import finders, listers, entities

class ApplicationContainer(containers.DeclarativeContainer):

    config = providers.Configuration()

    movie = providers.Factory(entities.Movie)

    csv_finder = providers.Singleton(
        finders.CsvMovieFinder,
        movie_factory=movie.provider,
        path=config.finder.csv.path,
        delimiter=config.finder.csv.delimiter,
    )

    sqlite_finder = providers.Singleton(
        finders.SqliteMovieFinder,
        movie_factory=movie.provider,
        path=config.finder.sqlite.path,
    )

    lister = providers.Factory(
        listers.MovieLister,
        movie_finder=sqlite_finder,
    )

O provedor sqlite_finderdepende de opções de configuração que ainda não definimos. Vamos atualizar o arquivo de configuração:

Editar config.yml:

finder:

  csv:
    path: "data/movies.csv"
    delimiter: ","

  sqlite:
    path: "data/movies.db"

Feito. Vamos checar.

Executamos no terminal:

python -m movies

Você verá:

Francis Lawrence movies: [Movie(title='The Hunger Games: Mockingjay - Part 2', year=2015, director='Francis Lawrence')]
2016 movies: [Movie(title='Rogue One: A Star Wars Story', year=2016, director='Gareth Edwards'), Movie(title='The Jungle Book', year=2016, director='Jon Favreau')]

Nosso aplicativo suporta os dois formatos de banco de dados: csve sqlite. Cada vez que precisamos mudar o formato, temos que mudar o código no container. Vamos melhorar isso na próxima seção.

Provider Selector

Nesta seção, tornaremos nosso aplicativo mais flexível.

Você não precisará mais fazer alterações no código para alternar entre os formatos csve sqlite. Implementaremos um switch com base em uma variável de ambiente MOVIE_FINDER_TYPE:

Quando um MOVIE_FINDER_TYPE=csvaplicativo usa o csv.
Quando um MOVIE_FINDER_TYPE=sqliteaplicativo usa o sqlite.

O provedor vai nos ajudar com isso Selector. Ele escolhe um provedor com base na opção de configuração ( documentação ).

Vamos editar containers.py:

"""Containers module."""

from dependency_injector import containers, providers

from . import finders, listers, entities


class ApplicationContainer(containers.DeclarativeContainer):

    config = providers.Configuration()

    movie = providers.Factory(entities.Movie)

    csv_finder = providers.Singleton(
        finders.CsvMovieFinder,
        movie_factory=movie.provider,
        path=config.finder.csv.path,
        delimiter=config.finder.csv.delimiter,
    )

    sqlite_finder = providers.Singleton(
        finders.SqliteMovieFinder,
        movie_factory=movie.provider,
        path=config.finder.sqlite.path,
    )

    finder = providers.Selector(
        config.finder.type,
        csv=csv_finder,
        sqlite=sqlite_finder,
    )

    lister = providers.Factory(
        listers.MovieLister,
        movie_finder=finder,
    )

Criamos um provedor findere o especificamos como uma dependência para o provedor lister. O provedor finderescolhe entre provedores csv_findere sqlite_finderem tempo de execução. A escolha depende do valor do switch.

O switch é a opção de configuração config.finder.type. Quando seu valor é csvusado pelo provedor da chave csv. Da mesma forma para sqlite.

Agora precisamos ler o valor config.finder.typeda variável de ambiente MOVIE_FINDER_TYPE.

Vamos editar __main__.py:

"""Main module."""

from .containers import ApplicationContainer


def main():
    container = ApplicationContainer()

    container.config.from_yaml('config.yml')
    container.config.finder.type.from_env('MOVIE_FINDER_TYPE')

    lister = container.lister()

    print(
        'Francis Lawrence movies:',
        lister.movies_directed_by('Francis Lawrence'),
    )
    print(
        '2016 movies:',
        lister.movies_released_in(2016),
    )


if __name__ == '__main__':
    main()

Feito.

Execute os seguintes comandos no terminal:

MOVIE_FINDER_TYPE=csv python -m movies
MOVIE_FINDER_TYPE=sqlite python -m movies

A saída de cada comando será assim:

Francis Lawrence movies: [Movie(title='The Hunger Games: Mockingjay - Part 2', year=2015, director='Francis Lawrence')]
2016 movies: [Movie(title='Rogue One: A Star Wars Story', year=2016, director='Gareth Edwards'), Movie(title='The Jungle Book', year=2016, director='Jon Favreau')]

Nesta seção, conhecemos o provedor Selector. Com esse provedor, você pode tornar seu aplicativo mais flexível. O valor da chave pode ser definido a partir de qualquer fonte: arquivo de configuração, dicionário, outro provedor.

Dica:

Substituir um valor de configuração de outro provedor permite que você implemente a sobrecarga de configuração em seu aplicativo sem uma reinicialização a quente.

Para fazer isso, você precisa usar a delegação de provedor e o .override().

Na próxima seção, adicionaremos alguns testes.

Testes

Finalmente, vamos adicionar alguns testes.

Crie um arquivo tests.pyem um pacote movies:

./
├── data/
│   ├── fixtures.py
│   ├── movies.csv
│   └── movies.db
├── movies/
│   ├── __init__.py
│   ├── __main__.py
│   ├── containers.py
│   ├── entities.py
│   ├── finders.py
│   ├── listers.py
│   └── tests.py
├── venv/
├── config.yml
└── requirements.txt

e adicione as seguintes linhas a ele:

"""Tests module."""

from unittest import mock

import pytest

from .containers import ApplicationContainer


@pytest.fixture
def container():
    container = ApplicationContainer()
    container.config.from_dict({
        'finder': {
            'type': 'csv',
            'csv': {
                'path': '/fake-movies.csv',
                'delimiter': ',',
            },
            'sqlite': {
                'path': '/fake-movies.db',
            },
        },
    })
    return container


def test_movies_directed_by(container):
    finder_mock = mock.Mock()
    finder_mock.find_all.return_value = [
        container.movie('The 33', 2015, 'Patricia Riggen'),
        container.movie('The Jungle Book', 2016, 'Jon Favreau'),
    ]

    with container.finder.override(finder_mock):
        lister = container.lister()
        movies = lister.movies_directed_by('Jon Favreau')

    assert len(movies) == 1
    assert movies[0].title == 'The Jungle Book'


def test_movies_released_in(container):
    finder_mock = mock.Mock()
    finder_mock.find_all.return_value = [
        container.movie('The 33', 2015, 'Patricia Riggen'),
        container.movie('The Jungle Book', 2016, 'Jon Favreau'),
    ]

    with container.finder.override(finder_mock):
        lister = container.lister()
        movies = lister.movies_released_in(2015)

    assert len(movies) == 1
    assert movies[0].title == 'The 33'

Agora vamos começar a testar e verificar a cobertura:

pytest movies/tests.py --cov=movies

Você verá:

platform darwin -- Python 3.8.3, pytest-5.4.3, py-1.9.0, pluggy-0.13.1
plugins: cov-2.10.0
collected 2 items

movies/tests.py ..                                              [100%]

---------- coverage: platform darwin, python 3.8.3-final-0 -----------
Name                   Stmts   Miss  Cover
------------------------------------------
movies/__init__.py         0      0   100%
movies/__main__.py        10     10     0%
movies/containers.py       9      0   100%
movies/entities.py         7      1    86%
movies/finders.py         26     13    50%
movies/listers.py          8      0   100%
movies/tests.py           24      0   100%
------------------------------------------
TOTAL                     84     24    71%

Usamos o método do .override()provedor finder. O provedor é substituído por mock. Ao entrar em contato com o provedor, a findersimulação de substituição agora será retornada.

O trabalho está feito. Agora vamos resumir.

Conclusão

Construímos um aplicativo CLI usando o princípio de injeção de dependência. Usamos o Dependency Injector como uma estrutura de injeção de dependência.

A vantagem que você obtém com o Dependency Injector é o contêiner.

O contêiner começa a pagar quando você precisa entender ou alterar a estrutura do seu aplicativo. Com um contêiner, isso é fácil, porque todos os componentes do aplicativo e suas dependências são explicitamente definidos em um só lugar:

"""Containers module."""

from dependency_injector import containers, providers

from . import finders, listers, entities


class ApplicationContainer(containers.DeclarativeContainer):

    config = providers.Configuration()

    movie = providers.Factory(entities.Movie)

    csv_finder = providers.Singleton(
        finders.CsvMovieFinder,
        movie_factory=movie.provider,
        path=config.finder.csv.path,
        delimiter=config.finder.csv.delimiter,
    )

    sqlite_finder = providers.Singleton(
        finders.SqliteMovieFinder,
        movie_factory=movie.provider,
        path=config.finder.sqlite.path,
    )

    finder = providers.Selector(
        config.finder.type,
        csv=csv_finder,
        sqlite=sqlite_finder,
    )

    lister = providers.Factory(
        listers.MovieLister,
        movie_finder=finder,
    )

Um contêiner como um mapa de seu aplicativo. Você sempre sabe o que depende do quê.

PS: perguntas e respostas

Nos comentários do tutorial anterior, perguntas interessantes foram feitas: "por que isso é necessário?", "Por que precisamos de um framework?", "Como o framework ajuda na implementação?"

Preparei as respostas:

O que é injeção de dependência?

é o princípio que reduz o acoplamento e aumenta a coesão

Por que devo usar injeção de dependência?

seu código se torna mais flexível, compreensível e melhor testável
você tem menos problemas quando precisa entender como funciona ou alterá-lo

Como começo a aplicar injeção de dependência?

você começa a escrever código seguindo o princípio de injeção de dependência
você registra todos os componentes e suas dependências no contêiner
quando você precisa de um componente, você o obtém do contêiner

Por que preciso de uma estrutura para isso?

você precisa de uma estrutura para não criar a sua própria. O código de criação do objeto será duplicado e difícil de alterar. Para evitar isso, você precisa de um contêiner.
a estrutura fornece um contêiner e provedores
os provedores controlam o tempo de vida dos objetos. Você precisará de fábricas, singletons e objetos de configuração
o contêiner serve como uma coleção de provedores

Que preço estou pagando?

você precisa especificar explicitamente as dependências no contêiner
este é um trabalho adicional
começará a pagar dividendos quando o projeto começar a crescer
ou 2 semanas após sua conclusão (quando você esquecer quais decisões você tomou e qual é a estrutura do projeto)

Conceito de injetor de dependência

Além disso, descreverei o conceito de injetor de dependência como uma estrutura.

O injetor de dependência é baseado em dois princípios:

Explícito é melhor do que implícito (PEP20).
Não faça mágica com seu código.

Como o Dependency Injector é diferente de outras estruturas?

Sem vinculação automática. A estrutura não vincula dependências automaticamente. A introspecção, vinculação por nomes de argumento e / ou tipos não é usada. Porque "explícito é melhor do que implícito (PEP20)".
Não polui o código do seu aplicativo. Seu aplicativo desconhece e é independente do Injetor de Dependências. Sem @injectdecoradores, anotações, remendos ou outros truques de mágica.

O Dependency Injector oferece um contrato simples:

Você mostra ao framework como coletar objetos
A estrutura os coleta

A força do Injetor de Dependência está em sua simplicidade e objetividade. É uma ferramenta simples para implementar um princípio poderoso.

Qual é o próximo?

Se você estiver interessado, mas hesite, minha recomendação é esta:

tente esta abordagem por 2 meses. Ele não é intuitivo. Leva tempo para se acostumar e sentir. Os benefícios se tornam tangíveis quando o projeto cresce para mais de 30 componentes em um contêiner. Se você não gosta, não perca muito. Se você gostar, obtenha uma vantagem significativa.

Saiba mais sobre o Dependency Injector no GitHub
Confira a documentação em Read the Docs

Eu ficaria feliz em receber feedback e responder perguntas nos comentários.

Aplicativo CLI + Dependency Injector - guia de injeção de dependência + FAQ

O que vamos construir?

Preparando o ambiente

Estrutura do projeto

Instalando dependências

Luminárias

Recipiente

Trabalhando com csv

Trabalhando com sqlite

Provider Selector

Testes

Conclusão

PS: perguntas e respostas

Conceito de injetor de dependência

Qual é o próximo?

More articles: