O padrão de injeção de dependência sempre foi um dos conceitos que custa entender no mundo do desenvolvimento de software, especialmente para as pessoas que estão começando. O que é esse padrão de design para qual é o seu uso? Normalmente, quando programamos no dia a dia com programação orientada a objetos, encontramos objetos de construção e relacionando objetos usando dependências.
Por exemplo, podemos ter um programa principal que use um serviço de impressão simples para imprimir um documento.
package com.arquitecturajava;public class ServicioImpresion {public void imprimir() {System.out.println("enviando el documento a imprimir");System.out.println("imprimiendo el documento en formato pdf");}}
usamos um programa principal do programa E
package com.arquitecturajava;public class Principal {public static void main(String args) {ServicioImpresion miServicio= new ServicioImpresion();miServicio.imprimir();}}
Não há nada de especial e vamos ver O resultado impresso no console:
injeção de dependência
No entanto, a coisa lógica é que este programa divide suas responsabilidades um pouco mais e este composto de vários serviços algo como o seguinte:
até agora tudo é bastante razoável e o que recebemos é que nosso serviço de impressão Depende de outros serviços e responsabilidades são mais claros. Acabamos de gerar dependências para o serviço de impressão. O código seria algo como o seguinte.
public class ServicioImpresion {ServicioEnvio servicioA;ServicioPDF servicioB; public ServicioImpresion() {this.servicioA= new ServicioEnvio();this.servicioB= new ServicioPDF();}public void imprimir() {servicioA.enviar();servicioB.pdf();}}
public class ServicioEnvio {public void enviar() {System.out.println("enviando el documento a imprimir");}}
public class ServicioPDF {public void pdf() {System.out.println("imprimiendo el documento en formato pdf");}}
O resultado no console será o mesmo apenas que dividimos melhor.
A mesma operação pode ser realizada injetando as dependências ao serviço e que não é aquele que tem que defini-los no construtor.
Isso parece em Princípio Uma mudança sem importância, o código seria:
package com.arquitecturajava.parte3;public class ServicioImpresion {ServicioEnvio servicioA;ServicioPDF servicioB;public ServicioImpresion(ServicioEnvio servicioA,ServicioPDF servicioB) {this.servicioA= servicioA;this.servicioB= servicioB;}public void imprimir() {servicioA.enviar();servicioB.pdf();}}
public class Principal {public static void main(String args) { ServicioImpresion miServicio= new ServicioImpresion(new ServicioEnvio(),new ServicioPDF());miServicio.imprimir();}}
O resultado ainda é o mesmo. Acabamos de injetar as dependências no serviço do nosso programa principal. Quais vantagens isso contribui? . A realidade é que, em princípio, parece que nenhum. Mas há algo que mudou não é mais o serviço próprio responsável pela definição de suas dependências, mas é o principal programa. Isso abre as portas para extensibilidade. Ou seja, sempre temos que injetar as mesmas dependências em serviço? A resposta parece óbvia … é claro que eles já estão definidos. No entanto, a resposta é não, podemos alterar o tipo de dependência que injetamos, simplesmente estendendo uma de nossas classes e mudando o comportamento, vamos vê-lo.
public class ServicioEnvioAspecto extends ServicioEnvio {@Overridepublic void enviar() {System.out.println("haciendo log del correo que vamos a enviar");super.enviar();}}
Acabamos de criar uma classe que estende a ServiceenVius e adiciona uma funcionalidade de log adicional que faz um “log” do e-mail que enviamos. Agora é tão simples quanto dizendo o programa principal que, ao injetar a dependência, não injetamos o formulário do Serviceenvi. terá mudado consideravelmente o comportamento.
public class Principal {public static void main(String args) {ServicioImpresion miServicio= new ServicioImpresion(new ServicioEnvioAspecto(),new ServicioPDF());miServicio.imprimir();}}
O resultado no console será:
Nós apenas modificamos o comportamento do nosso programa significativamente graças ao uso do conceito injeção de dependência.
A injeção de dependência nos permite injetar outras classes e adicionar funcionalidade transversal personalizada. Este padrão de design é o que abre a porta para as estruturas como primavera usando o conceito de injeção de dependência de uma maneira mais avançada. Nestes estrutura, os aspectos que são adicionados às nossas aulas são múltiplos e altos complexidade.
A importância do padrão de injeção de dependência é hoje na maioria dos frameworks.
Outros artigos relacionados
- mola @qualifier usando @Autowired
- @Import, organizando framework de mola
- java 8 padrão de fábrica e sua implementação
Itens externos
- injeção de dependência