Inyección de Dependencias.

¿Qué es la inyección de dependencias y para qué sirve?.

El patrón de inyección de dependencia siempre ha sido uno de los conceptos que cuesta entender en el mundo del desarrollo de software sobre todo a la gente que esta empezando. ¿Para qué sirve este patrón de diseño y cuál es su utilidad?. Normalmente cuando nosotros programamos en el día a día con la programación orientada a objeto nos encontramos construyendo objetos y relacionando objetos utilizando dependencias.

La inyección de dependencias (DI, por sus siglas en inglés) es un patrón usado en el diseño orientado a objetos de una aplicación. Es parte de uno de los cinco principios de diseño de clases conocido como S.O.L.I.D. Como todo patrón de diseño, DI tiene como finalidad solucionar un problema común que los programadores encuentran en la construcción de aplicaciones. Este es, mantener los componentes o capas de una aplicación lo más desacopladas posible. Busca que sea mucho más sencillo reemplazar la implementación de un componente por otro. Así, evitar un gran cambio o impacto en la aplicación que pudiera originar que deje de funcionar por completo.

Los patrones de diseño son una opción, no un requerimiento.

Para cumplir con dicho objetivo, DI nos permite inyectar comportamientos a componentes haciendo que nuestras piezas de software sean independientes y se comuniquen únicamente a través de una interface. Esto extrae responsabilidades a un componente para delegarlas en otro, establecimiento un mecanismo a través del cual el nuevo componente puede ser cambiado en tiempo de ejecución. Para lograr esta tarea DI se basa en un patrón mas genérico llamado inversión de Conrtol (Inversion of Control).

La inyección de dependencias involucra 4 roles:

• Las interfaces que definen las operaciones de los servicios - no necesariamente tienen que ser interfaces, sino que puede ser una clase abstracta.
• Los servicios, que implementan las interfaces anteriores, que se van a inyectar.
• Los clientes que usarán los servicios.
• El inyector, que es el encargado de construir e inyectar los servicios en los clientes.

Tipos de inyección de dependencias

La inyección de dependencias por constructor es cuando la creación de la instancia no depende de la clase.

                public class TextEditor {
                   private SpellChecker spellChecker;

                   public TextEditor(SpellChecker spellChecker) {

                      this.spellChecker = spellChecker;
                   }

                   public void spellCheck() {
                      spellChecker.checkSpelling();
                   }
                }
                

La inyección de dependencias mediante setters lo que permite mayor flexibilidad. El cliente expone un método set que utiliza el inyector para inyectar la dependencia.

                public class TextEditor {
                    private SpellChecker spellChecker;

                    public void setSpellChecker(SpellChecker spellChecker) {
                       this.spellChecker = spellChecker;
                    }
                }
                

La inyección de dependencias a través de una interfaz

                // Interfaz servicio Setter.
                public interface ServiceSetter {
                    public void setService(Service service);
                }

                // Clase cliente 
                public class Client implements ServiceSetter {
                    private Service service;

                    @Override
                    public void setService(Service service) {
                        this.service = service;
                    }
                }
                

Frameworks

Para implementar la DI hay muchos frameworks que realizan la tarea del inyector. Sin embargo, a estos frameworks usualmente se les conoce como Contenedores de DI, porque implementan una especie de contenedor o almacén en donde se guardan las dependencias para cuando necesiten ser resueltas en tiempo de ejecución.

Ejemplo usando Spring-Framework

                public class Injector {
                  public static void main(String[] args) {
                    BeanFactory beanfactory = new ClassPathXmlApplicationContext("Beans.xml");
                    Client client = (Client) beanfactory.getBean("client");
                    System.out.println(client.greet());
                  }
                }
                
                    <?xml version="1.0" encoding="UTF-8"?>
                        <beans xmlns="http://www.springframework.org/schema/beans"
                            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                            xsi:schemaLocation="http://www.springframework.org/schema/beans
                            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

                            <bean id="service" class="ExampleService">
                            </bean>

                            <bean id="client" class="Client">
                                <constructor-arg value="service" />        
                            </bean>
                        </beans>
                
                

Post Tags DI Inyección Dependencias IOC