O que é a integração dependente e que benefícios…

A injeção de dependências (Dependency Injection, DI) é um padrão de projeto em que os componentes recebem as suas dependências de fora, em vez de as criarem por si próprios. É um dos princípios da inversão de controlo (Inversion of Control, IoC).

Vantagens do DI:

Melhoria da testabilidade: É mais fácil substituir dependências por mocks ou stubs durante testes unitários.
Redução do acoplamento (Loose Coupling): Os componentes dependem menos de implementações específicas de dependências.
Maior flexibilidade e extensibilidade: É fácil alterar as implementações de dependências sem modificar o código principal do componente.
Melhoria da legibilidade e manutenção: É claro quais dependências um componente necessita.

Exemplo sem DI vs com DI:

Sem DI:

// Classe que cria uma dependência internamente
public class ServiceA {
    private DatabaseConnection dbConnection;

    public ServiceA() {
        // Forte acoplamento: cria uma implementação concreta
        this.dbConnection = new OracleConnection(); 
    }

    public void doSomething() {
        dbConnection.connect();
        // ...
    }
}

Com DI (através do construtor):

// Interface da dependência
public interface DatabaseConnection {
    void connect();
    void disconnect();
}

// Diferentes implementações
public class OracleConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Conectando ao Oracle...");
    }
    @Override
    public void disconnect() {
        System.out.println("Desconectando do Oracle...");
    }
}

public class MySQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Conectando ao MySQL...");
    }
    @Override
    public void disconnect() {
        System.out.println("Desconectando do MySQL...");
    }
}

// Classe que recebe a dependência de fora
public class ServiceB {
    private DatabaseConnection dbConnection;

    // Injeção de dependência via construtor
    public ServiceB(DatabaseConnection dbConnection) {
        this.dbConnection = dbConnection;
    }

    public void doSomething() {
        dbConnection.connect();
        // ...
    }

    public void setDbConnection(DatabaseConnection dbConnection) {
        this.dbConnection = dbConnection;
    }
}

// Código que realiza a injeção (configuração)
public class Application {
    public static void main(String[] args) {
        // Criar a dependência
        DatabaseConnection connection = new MySQLConnection(); 
        // Injetar a dependência em ServiceB
        ServiceB service = new ServiceB(connection); 
        service.doSomething();

        // Ou mudar a dependência sem alterar ServiceB
        DatabaseConnection anotherConnection = new OracleConnection();
        ServiceB anotherService  = new ServiceB(anotherConnection);
        anotherService.doSomething();
    }
}

Formas de injeção:

Através do construtor (Constructor Injection): Dependências fornecidas através do construtor da classe. Preferido para dependências obrigatórias.
Através do setter (Setter Injection): Dependências fornecidas através de métodos setters. Adequado para dependências opcionais.
Através do campo (Field Injection): Dependências injetadas diretamente nos campos da classe (geralmente com frameworks, requer reflexão). Não recomendado sem frameworks de DI devido à dificuldade de testes e ocultação de dependências.

A DI é frequentemente implementada com containers/frameworks de DI, como Spring, Guice, Dagger, que gerenciam o ciclo de vida dos objetos e automatizam o processo de injeção.

O que é a integração dependente e que benefícios traz?