Spring: diferencia entre la inyección de dependencia y el patrón de fábrica

Dependency Injection y Factory Pattern son casi similares en el sentido de que ambos siguen el enfoque de programación basado en interfaz y crean la instancia de las clases.

A. Patrón de fábrica

En Factory Pattern , la clase de cliente sigue siendo responsable de obtener la instancia de los productos mediante el método class getInstance() de la clase de fábrica, lo que significa que la clase de cliente está directamente acoplada con la clase de fábrica y no se puede probar la unidad sin la clase de fábrica.

Implementación: en este ejemplo, veremos la diferencia entre Factory Pattern y DI con la ayuda de la aplicación ExpenseTracker. En esta aplicación, tenemos una clase dependiente ExpenseTracker que depende de la clase ExpenseCalculator. Aquí usaremos tanto Factory Pattern como Dependency Injection para comprender la diferencia entre ellos.

Ejemplo:

// Java Program to Illustrate Factory Pattern
 
// Dependent class
public class ExpenseTracker {
 
    // Getting instance of ExpenseCalculator class
    // using Factory class method
    private ExpenseCalculator expenseCal
        = ExpenseCalculatorFactory.getInstance();
 
    // Method
    public void add(Transaction transaction)
    {
 
        // Returns the expense amount
        // of ExpenseCalculator class
        int expense
            = expenseCal.getTransactionAmount(transaction);
        add(expense);
    }
}

Explicación del código: en el ejemplo anterior, podemos ver que nuestra clase dependiente ExpenseTracker está directamente acoplada con ExpenseCalculatorFactory , ya que está llamando al método estático getInstance() de la clase ExpenseCalculatorFactory para satisfacer su dependencia. Si queremos probar la clase ExpenseTracker, debemos tener la clase ExpenseCalculatorFactory que no es adecuada para la prueba unitaria de la clase ExpenseTracker y hace que la prueba unitaria sea más difícil.

Por otro lado, si usaremos DI, las dependencias se agregan mediante el marco Spring o el contenedor DI a medida que invertimos las responsabilidades de adquisición de dependencias. Esto hará que el contenedor IOC sea responsable de inyectar las dependencias en lugar de la clase dependiente y convertirá cualquier cliente o clase dependiente en una clase POJO.

B. Inyección de dependencia

En el caso de Inyección de dependencia (DI), el cliente no sabe cómo se crean y administran las dependencias. La clase de cliente solo conoce las dependencias y la mayoría de las dependencias son inyectadas por el contenedor IOC . Por ejemplo, la clase Bean existe sin ninguna dependencia codificada y los contenedores IOC como Spring Framework los inyectan.

Ejemplo:

// Java Program to Illustrate Dependency Injection
 
// Dependent class ExpenseTracker
public class ExpenseTracker {
 
    // Class data member
    private ExpenseCalculator expenseCal;
 
    // Constructor
    // Dependencies are injected
    // using Constructor Dependency Injection
    public ExpenseTracker(
        ExpenseCalculator expenseCalculator)
    {
 
        // This keyword refers to current instance itself
        this.expenseCal = expenseCalculator;
    }
 
    // Method
    public void add(Transaction transaction)
    {
        int expense
            = expenseCal.getTransactionAmount(transaction);
        add(expense);
    }
 
    // Dependencies are injected
    // using Setter Dependency Injection
    public void setExpenseCalculator(
        ExpenseCalculator expenseCalculator)
    {
        this.expenseCal = expenseCalculator;
    }
}

Explicación del Código: Podemos ver que la dependencia de ExpenseCalculator se inyecta en la clase ExpenseTracker usando el constructor de la clase, esto se llama Inyección de Dependencia del Constructor . Además, podemos inyectar la dependencia usando los métodos Setter que también podemos ver en el código anterior, se llama Setter Dependency Injection .

Diferencia entre inyección de dependencia y patrón de fábrica