Explicação detalhada de como implementar a estrutura de injeção de dependência para 200 linhas de código Java

Introdução à injeção de dependência

Vamos primeiro revisar o conceito de injeção de dependência:

Injeção de dependência e inversão de controle, que muitas vezes mencionamos são o mesmo conceito. O significado específico é: quando uma função (talvez uma instância Java, chamador) precisa da assistência de outra função (outra instância do Java, chamador), no processo de programação tradicional, o chamador é geralmente criado pelo chamador. Mas na primavera, o trabalho de criar o callee não é mais feito pelo chamador, por isso é chamado de inversão de controle; O trabalho de criar a instância da Callee geralmente é feito pelo recipiente de mola e depois injetado no chamador, por isso também é chamado de injeção de dependência.

De fato, basta colocar, o papel da injeção de dependência é dissociar as dependências entre os objetos do código original e adicionar o processamento da estrutura da mola para nos permitir gerenciar dependências de maneira flexível e central.

Estrutura de injeção de dependência

A estrutura de injeção de dependência não é misteriosa, é realmente uma coisa muito simples. Não olhe para o código -fonte da injeção de dependência da primavera, porque enquanto você for, isso significa que você nunca mais escreverá e não ousará começar por si mesmo. Sua função é muito poderosa, portanto o design é muito complicado. Os programadores comuns só podem suspirar ao vê -lo.

Eu não li o código -fonte da primavera com cuidado. Mesmo assim, levou apenas meio dia para aplicar um pequeno iockids-estrutura que basicamente atenda ao padrão de injeção de dependência padrão "JSR-330". Essa pequena estrutura possui apenas um injetor de classe principal, com cerca de 200 linhas de código, e possui as seguintes funções.

1. Injeção Singleton/Non Singleton
2. Injeção de construtor
3. Injeção de campo
4. Injeção de dependência circular
5. Injeção de qualificador

Vejamos um exemplo um pouco mais complicado de uso

 importar javax.inject.inject; importar javax.inject.Named; importar javax.inject.singleton; importar iockids.injector; @singletoNClass root {@inject @Named ("a") nó a; @Inject @Named ("B") Nó B; @Override public string tostring () {return string.format ("root ( %s, %s)", a.name (), b.Name ()); }} nó de interface {string name ();}@singleton@nomeado ("a") nodea implementa nó {@inject folha folha; @Inject @Named ("B") Nó B; @Override public string name () {if (b == null) return string.format ("nodea (%s)", folha); caso contrário, return string.format ("nodeawithb (%s)", folha); }}@Singleton@nomeado ("b") classe nodeb implementa o nó {folha folha; @Inject @Named ("A") Nó A; @Inject public NodeB (folha folha) {this.leaf = folha; } @Override public string name () {if (a == null) return string.format ("nodeb (%s)", folha); else Return string.format ("nodeBwitha (%s)", folha); }} classe folha {@inject root root; índice int; sequência estática int; public leaf () {index = sequência ++; } public string tostring () {if (root == null) retorna "folha" + index; else Retornar "LeafWithroot" + índice; }} public classe Demo {public static void main (string [] args) {var injector = new injector (); injetor.ReGisterQualifiedClass (node.class, nodea.class); injetor.ReGisterQualifiedClass (Node.class, nodeb.class); var root = injetor.getInstance (root.class); System.out.println (root); }}

O código acima usa todas as funções fornecidas pelos iockids.

1. A classe raiz/nodea/nodeb é uma aula de singleton
2. A aula de folhas é uma aula não singlear
3. Todos eles usam injeção de campo
4. O NodeB usa injeção de construtor
5. Nodea e NodeB também usam injeção de nomes de qualificador
6. Existem campos do tipo de raiz na classe foliar, que é uma dependência circular
7. Existe um campo de nodeb no campo Nodea e Nodea no NodeB, que também é uma dependência circular

Para facilitar a compreensão do código acima, desenhei um diagrama de dependência

A saída de código acima é a seguinte

 raiz (nodeawithb (leafwithroot0), nodebwitha (leafwithroot1))

A partir dessa saída, também podemos imaginar aproximadamente a estrutura de dependência.

O IockIDS fornece relatórios de exceção de erro de injeção ricos para evitar erros de configuração de injeção de usuário.

Por exemplo, se configurarmos os nomes de Nodea e NodeB acima para o mesmo a, a pilha de erros abaixo será exposta.

 iockids.injectException: Javax.inject qualificado duplicado. iockids.demo.demo.main (Demo.java:106)

Se adicionarmos um parâmetro ao construtor de nodeb à vontade

 @Inject public NodeB (folha de folha, int k) {this.leaf = folha; }

O seguinte erro será lançado ao executar

 iockids.injectException: nenhum construtor acessível para aula de injeção int em iockids.injector.createnew (injector.java:120) em iockids.injector.createnew (injetor.java:94) em iockids.injector.crerefromepart (injava.java:94) iockids.Injector.createFromConstructor(Injector.java:145) at iockids.Injector.createNew(Injector.java:123) at iockids.Injector.createFromQualified(Injector.java:216) at iockids.Injector.createFromField(Injector.java:173) at iockids.Injector.injectMembers(Injector.java:233) at iockids.Injector.createNew(Injector.java:136) at iockids.Injector.createFromQualified(Injector.java:216) at iockids.Injector.createFromField(Injector.java:173) at iockids.injector.injectmembers (injetor.java:233) em iockids.injector.createnew (injector.java:136) em iockids.injector.GreateNew (injector.java:94) em iockids.injector.Gereate (Informor.Java:94) em iockids.gest. iockids.demo.demo.main (Demo.java:107)

Endereço de código aberto do projeto: https://github.com/pyloque/iockids (download local)

Resumir

O acima é o conteúdo inteiro deste artigo. Espero que o conteúdo deste artigo tenha certo valor de referência para o estudo ou trabalho de todos. Se você tiver alguma dúvida, pode deixar uma mensagem para se comunicar. Obrigado pelo seu apoio ao wulin.com.