1. Injeção de dependência
A injeção de dependência (DI) é um padrão de design de software que lida com a forma como o código obtém os recursos depende.
Para uma discussão mais profunda sobre DI, você pode visitar a injeção de dependência (http://en.wikipedia.org/wiki/dependency_injection), Inversão do controle (http://martinfowler.com/articles/injection.html) ou você pode visitar o livro sobre padrões de software.
1. Di em poucas palavras (simplesmente falando di)
Objeto ou função só pode obter os recursos de que dependem das três maneiras a seguir:
1) Você pode criar recursos dependentes através do novo operador.
2) Você pode encontrar recursos dependentes por meio de variáveis globais.
3) Os recursos dependentes podem ser passados através de parâmetros.
Os dois métodos 1 e 2 não são os melhores, porque codificam as dependências, o que não torna impossível modificar as dependências, mas se tornará mais complicado. Isso é especialmente um problema para testar e, geralmente, ao testar de forma independente, é desejado fornecer dependências simuladas.
O terceiro método é relativamente o mais viável porque remove a responsabilidade de localizar dependências dos componentes. A dependência é entregue aos componentes.
função someclass (cumprimentador) {this.greeter = greeter} someclass.prototype.dosomething = function (name) {this.greeter.greet (nome);}No exemplo acima, o SOMECLASS não precisa se preocupar em localizar a dependência do cumprimento, ele só passa o cumprimento no tempo de execução.
Isso é mais apropriado, mas deixa a responsabilidade de obter os recursos de dependência para o código responsável pela construção de Someclass.
Para gerenciar a responsabilidade pela criação de dependências, cada aplicativo angular possui um injetor (http://code.angularjs.org/1.0.2/docs/api/angular.injector). O Injetor é um localizador de serviço responsável pela localização e criação de recursos dependentes.
Solicite dependências, resolve o problema do código duro, mas isso significa que o injetor precisa executar todo o aplicativo. O injetor de aprovação destruirá a lei do Demeter (http://baike.baidu.com/view/823220.htm). Para corrigir esse problema, transferimos a responsabilidade pelas pesquisas de dependência para o injetor.
Eu disse muito acima. Veja os exemplos que modifiquei abaixo. Mescrei dois exemplos do texto original, usando injeção dentro e fora do Angular:
<! Doctype html> <html lang = "zh-cn" ng-app = "mainApp"> <head> <meta charset = "utf-8"> <title> injetor </title> </botão> <body> <div ng-controller = "mycontroller"> <butt> <blot> " src = "../ angular-1.0.1.js" type = "text/javascript"> </script> <script type = "text/javascript"> // Crie o módulo Othermodule, que é equivalente ao módulo externo var de outro módulo = angular.módulo ("outro módulo",]; // Ensine o injetor como criar "cumprimentador" // Observe que o próprio cumprimento precisa contar com $ window OtherModule.Factory ("GreeTer", function ($ window) {// Este é um método de fábrica, responsável pela criação de serviços de retorno de cumprimento {Greet: function (text) {$ window.alert (text);}};}; // O seguinte mostra que, em um módulo não circulante, chame o método Greet através do injetor: // Crie um novo injetor do módulo // Esta etapa geralmente é feita automaticamente quando o angular é iniciado. // O 'ng', as coisas angulares devem ser introduzidas // a ordem é deliberadamente revertida e é temporariamente confirmado que a ordem dessa coisa não importa. . var injector = angular.injector (['Othermodule', 'ng']); // Solicite a dependência do cumprimentador. var g = injetor.get ("cumprimentador"); // Chame diretamente ~ G.Greet ("Hi ~ meu pequeno dada ~"); // Este é o aplicativo principal atual e você precisa confiar no outro módulo var mainApp = angular.module ("mainApp", ["OtherModule"]); // preste atenção aos parâmetros da função de definição do controlador e injete diretamente $ scope e cumprimentador aqui. // O serviço Greeter é MainApp.Controller ("MyController", Function myController ($ SCOPE, GERETER) {$ SCOPE.SAYHELLO = function () {greeter.greet ("hello kitty ~~");};}); // Ng-Controller fez isso silenciosamente nos bastidores //injector.instantiate(myController); </script> </body> </html>Observe que, como existe um controlador de NG, o MyController é inicializado, ele pode atender a todas as dependências do MyController, para que o MyController não precise conhecer a existência do injetor. Este é o melhor resultado. O código do aplicativo simplesmente solicita as dependências necessárias sem lidar com o injetor. Esse cenário não violará a lei do Demeter.
2. Anotação de dependência (comentários de dependência, explicando o modo de dependências)
Como o injetor sabe que serviço precisa ser injetado?
Os desenvolvedores de aplicativos precisam fornecer informações de anotação usadas pelo Injetor como uma solução para as dependências. Todas as funções da API existentes no Angular referem -se ao injetor, e esse é o caso da API mencionada em cada documento. Aqui estão três maneiras equivalentes de anotar nosso código com informações sobre o nome do serviço.
1. Inferindo dependências
Essa é a maneira mais fácil de obter um recurso dependente, mas é necessário assumir que o nome do parâmetro da função é consistente com o nome do recurso dependente.
função myController ($ scope, cumprimentador) {...}O injetor de uma função pode adivinhar o nome do serviço que precisa ser injetado (functionName.toString (), regexp), verificando a definição da função e extraindo o nome da função. No exemplo acima, $ SCOPE e GEARTER são dois serviços que precisam ser injetados na função (os nomes também são os mesmos).
Embora isso seja simples, esse método não funcionará após a compactação de ofuscação JavaScript, porque o nome do parâmetro será alterado. Isso torna esse método útil apenas para pretotipagem (método de teste de simulação de protótipo de usabilidade do produto, http://www.pretotyping.org/, http://tech.qq.com/a/20120217/000320.htm) e aplicações de demonstração.
2.
Para permitir que o compressor de script renomeie o método da função e ainda possa injetar o serviço correto, a função deve comentar a dependência por meio da propriedade $ inject. A propriedade $ inject é uma matriz dos nomes dos serviços que precisam ser injetados.
var myController = function (renomeado $ scope, renomeadogereter) {...} // Se a coisa que depende aqui não estiver no módulo atual, ele ainda não o reconhece. // Você precisa primeiro confiar no módulo correspondente no módulo atual. É semelhante ao exemplo anterior. Mas não sei se esse é o caminho certo.
MyController. $ Inject = ['$ SCOPE', 'GERETER'];
Deveria tomar cuidado para que a ordem de $ injeção precise ser consistente com a ordem dos argumentos declarados pela função.
Esse método de anotação é útil para declarações do controlador porque especifica informações de anotação com a função.
3. Anotação em linha (comentários embutidos)
Às vezes, não é conveniente usar o método de anotação de injeção $, como ao comentar diretamente.
Por exemplo:
Somemodule.Factory ('Greeter', função ($ Window) {...;});Como as variáveis temporárias são necessárias (impedem que não consiga ser usado após a compressão), o código inchará como:
var greeterFFactory = function (renomeado $ window) {...;}; GERETERFACTORY. $ inject = ['$ window']; somemodule.Factory ('cumprimentador', cumprimentador);Por causa disso (Code Bloat), o Angular também fornece um terceiro estilo de comentário:
SOMEMODULE.FACTORY ('GERETER', ['$ WANDEN', function (renomeado $ window) {...;}]);Lembre -se de que todos os estilos de comentários são equivalentes e podem ser usados em qualquer lugar em um angular que suporta injeção.
3. Onde posso usar o DI?
Di está em todo o angular. Geralmente é usado em métodos controladores e de fábrica.
1. DI em controladores
O controlador é a classe responsável (descrevendo) o comportamento do aplicativo. O método de declaração do controlador recomendado é:
var myController = function (dep1, dep2) {...} myController. $ inject = ['dep1', 'dep2']; myController.prototype.amethod = function () {...}2. Métodos de fábrica
O método da fábrica é responsável por criar a maioria dos objetos angulares. Por exemplo, diretiva, serviço, filtro. O método da fábrica está registrado no módulo. O método recomendado de declaração de fábrica é:
angualar.module ('mymodule', []). config (['Depprovider', função (Depprovider) {...}]). Factory ('ServiceId', ['DePService', function (DePService) {...}]). Diretiva ('DirectiveName', ['DePService', function (DePService) {...}]). filtro ('filterame', ['depService', function (depService) {...}]);O exposto acima é o resumo das informações de injeção de dependência do AngularJS. Obrigado pelo seu apoio a este site!