Injeção de dependência

sem injeção de dependência

no exemplo Java a seguir, A classe cliente contém uma variável de membro de serviço que é inicializada pelo construtor do cliente. O cliente controla a implementação do serviço e controla a sua construção. Nesta situação, diz-se que o cliente tem uma dependência em código rígido do serviço de examples.

// An example without dependency injectionpublic class Client { // Internal reference to the service used by this client private ExampleService service; // Constructor Client() { // Specify a specific implementation in the constructor instead of using dependency injection service = new ExampleService(); } // Method within this client that uses the services public String greet() { return "Hello " + service.getName(); }}

injeção de dependência é uma técnica alternativa para inicializar a variável membro ao invés de explicitamente criar um objeto de serviço como mostrado acima., Podemos ajustar este exemplo usando as várias técnicas descritas e ilustradas nas subsecções abaixo.

tipos de dependência injectionEdit

Existem pelo menos três formas de um objecto cliente receber uma referência a um módulo externo:

injecção Construtora as dependências são fornecidas através de um construtor de classe do cliente. setter injeção o cliente expõe um método setter que o injector usa para injetar a dependência. injeção de interface a interface de dependência fornece um método de injeção que irá injetar a dependência em qualquer cliente passado a ele., Os clientes devem implementar uma interface que expõe um método setter que aceita a dependência. é possível que outros tipos de injecção para além dos acima apresentados.os quadros de ensaio podem também utilizar outros tipos. Alguns quadros de testes modernos nem sequer exigem que os clientes aceitem ativamente a injeção de dependência, tornando assim o código legacy testável. Em particular, na Linguagem Java, é possível usar a reflexão para tornar públicos atributos privados ao testar e, assim, aceitar injeções por atribuição.,

algumas tentativas de inversão do controle não fornecem a remoção completa da dependência, mas simplesmente substituir uma forma de dependência por outra. Como regra geral, se um programador pode olhar para nada além do Código do cliente e dizer que framework está sendo usado, então o cliente tem uma dependência hard-coded no framework.

Constructor injectionEdit

este método requer que o cliente forneça um parâmetro em um construtor para a dependência.

Setter injectionEdit

este método requer que o cliente forneça um método setter para a dependência.,

Interface injectionEdit

isto é simplesmente o cliente publicando uma interface de papel para os métodos setter das dependências do cliente. Pode ser usado para estabelecer como o injector deve falar com o cliente quando injectar dependências.

// Service setter interface.public interface ServiceSetter { public void setService(Service service);}// Client classpublic class Client implements ServiceSetter { // Internal reference to the service used by this client. private Service service; // Set the service that this client is to use. @Override public void setService(Service service) { this.service = service; }}

Construtor de injeção comparisonEdit

o Preferido quando todas as dependências podem ser construídos em primeiro lugar, porque ele pode ser usado para garantir que o objeto cliente está sempre em um estado válido, ao contrário de ter alguns dos seus dependência referências de ser nulo (não definido)., No entanto, por si só, falta-lhe flexibilidade para que as suas dependências sejam alteradas mais tarde. Este pode ser um primeiro passo para tornar o cliente imutável e, portanto, thread seguro.

Setter injection comparisonEdit

requer que o cliente forneça um método setter para cada dependência. Isto dá a liberdade de manipular o estado das referências de dependência a qualquer momento. Isso oferece flexibilidade, mas se houver mais de uma dependência a ser injetada, é difícil para o cliente garantir que todas as dependências sejam injetadas antes que o cliente possa ser fornecido para uso.,como estas injecções acontecem de forma independente, não há maneira de saber quando o injector termina a ligação ao cliente. Uma dependência pode ser deixada nula simplesmente pelo injetor não chamando seu setter. Isto obriga a verificar se a injecção foi concluída a partir do momento em que o cliente é montado para sempre que é utilizada.

Interface injection comparisonEdit

a vantagem da interface injection é que as dependências podem ser completamente ignorantes dos seus clientes, mas ainda podem receber uma referência a um novo cliente e, usando-o, enviar uma referência a si mesmo de volta para o cliente., Desta forma, as dependências tornam-se injetores. A chave é que o método de injeção (que pode ser apenas um método clássico de setter) é fornecido através de uma interface.

um montador ainda é necessário para introduzir o cliente e suas dependências. O montador tomaria uma referência ao cliente, lançá-la-ia para a interface setter que define essa dependência, e passá-la-ia para aquele objeto de dependência que daria a volta e passaria uma referência a si mesmo de volta para o cliente.,

para que a injecção de interface tenha valor, a dependência deve fazer algo além de simplesmente passar para trás uma referência a si mesma. Isto poderia estar agindo como uma fábrica ou sub-montador para resolver outras dependências, abstraindo alguns detalhes do montador principal. Pode ser a contagem de referência para que a dependência saiba quantos clientes estão a usá-la. Se a dependência mantiver uma coleção de clientes, ele poderia mais tarde injectá-los todos com uma instância diferente de si mesmo.,

montar examplesEdit

montar manualmente, principalmente à mão, é uma forma de implementar a injecção de dependência.

o exemplo acima constrói o gráfico de objetos manualmente e então invoca-o em um ponto para começar a funcionar. É importante notar que este injector não é puro. Usa um dos objectos que constrói. Ele tem uma relação puramente de construção-apenas com ExampleService, mas mistura a construção e uso do cliente. Isto não deve ser comum. No entanto, é inevitável., Assim como o software orientado a objetos precisa de um método estático não orientado a objetos como main() para começar, um grafo de objeto injectado dependência precisa de pelo menos um (de preferência apenas um) ponto de entrada para começar a coisa toda.

a construção Manual no método principal pode não ser esta reta para a frente e pode envolver construtores de chamadas, fábricas, ou outros padrões de construção também. Isto pode ser bastante avançado e abstrato., A linha é cruzada da injeção manual de dependências para a injeção de dependências de framework uma vez que o código de construção não é mais personalizado para a aplicação e é, em vez disso, universal.Frameworks como o Spring podem construir esses mesmos objetos e conectá-los antes de retornar uma referência ao cliente. Toda a Menção do concreto ExampleService pode ser movida do código para os dados de configuração.Frameworks como a Primavera permitem externalizar os detalhes da montagem em arquivos de configuração.Este código (acima) constrói objetos e os fios juntos de acordo com o feijão.xml (abaixo)., ExampleService ainda é construído, apesar de apenas ser mencionado abaixo. Um grafo objeto longo e complexo pode ser definido desta forma e a única classe mencionada no código seria aquela com o método do ponto de entrada, que neste caso é greet().

no exemplo acima cliente e serviço não tiveram que passar por quaisquer alterações a serem fornecidas até a Primavera. Eles são autorizados a permanecer simples POJOs. Isto mostra como a primavera pode conectar serviços e clientes que são completamente ignorantes de sua existência. Isto não poderia ser dito se as anotações da Primavera fossem adicionadas às classes., Ao manter anotações específicas de primavera e chamadas de se espalhar entre muitas classes, o sistema permanece vagamente dependente da Primavera. Isto pode ser importante se o sistema pretende sobreviver à Primavera.

a escolha de manter POJOs puros não vem sem custo. Ao invés de gastar o esforço para desenvolver e manter arquivos de configuração complexos, é possível simplesmente usar anotações para marcar classes e deixar a Primavera fazer o resto do trabalho. Resolver dependências pode ser simples se elas seguem uma convenção como a correspondência por tipo ou pelo nome. Isto é escolher convenção em vez de configuração., É também discutível que, ao refactorar outro quadro, remover anotações específicas de framework seria uma parte trivial da tarefa e muitas anotações de injeção são agora padronizadas.

@Componentpublic class ExampleService { public String getName() { return "World!"; }}

var injector = angular.injector();var greeter = injector.get('greeter');

<div ng-controller="MyController"> <button ng-click="sayHello()">Hello</button></div>

function MyController($scope, greeter) { $scope.sayHello = function() { greeter.greet('Hello World'); };}

injector.instantiate(MyController);