Dependency Injection vs Dependency Inversion vs IoC

//DependencyWiring.java
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Supplier;

public class DependencyWiring {

  record Employee(String name, String email, double netPay) {}

  // ---------- 1. Hard-wired: no DIP, no DI ----------
  static class SmtpMailerV1 {
    void send(String to, String body) {
      System.out.println("SMTP -> " + to + ": " + body);
    }
  }

  static class PayslipServiceV1 {
    private final SmtpMailerV1 mailer = new SmtpMailerV1();   // creates its own detail
    void sendPayslip(Employee e) { mailer.send(e.email(), "Net pay " + e.netPay()); }
  }

  // ---------- 2. DIP: the policy owns an abstraction... ----------
  interface Mailer { void send(String to, String body); }

  static class PayslipService {
    private final Mailer mailer;

    PayslipService(Mailer mailer) { this.mailer = mailer; }  // ...and DI: it is handed in

    void sendPayslip(Employee e) {
      mailer.send(e.email(), String.format("Net pay for %s: %.2f", e.name(), e.netPay()));
    }
  }

  static class SmtpMailer implements Mailer {
    public void send(String to, String body) {
      System.out.println("SMTP -> " + to + ": " + body);
    }
  }

  // A test double: records messages instead of sending them
  static class RecordingMailer implements Mailer {
    final List<String> sent = new ArrayList<>();
    public void send(String to, String body) { sent.add(to + " | " + body); }
  }

  // ---------- 3. A tiny IoC container ----------
  static class Container {
    private final Map<Class<?>, Supplier<?>> providers = new HashMap<>();

    <T> void register(Class<T> type, Supplier<? extends T> provider) {
      providers.put(type, provider);
    }

    <T> T get(Class<T> type) { return type.cast(providers.get(type).get()); }
  }

  public static void main(String[] args) {
    Employee tom = new Employee("Tom Jones", "tom.jones@example.com", 4310.50);

    System.out.println("1. Hard-wired:");
    new PayslipServiceV1().sendPayslip(tom);

    System.out.println("2. Injected by hand in main(), the composition root:");
    new PayslipService(new SmtpMailer()).sendPayslip(tom);

    System.out.println("   The same service with a test double:");
    RecordingMailer recorder = new RecordingMailer();
    new PayslipService(recorder).sendPayslip(tom);
    System.out.println("   recorded: " + recorder.sent);

    System.out.println("3. Wired by a container:");
    Container container = new Container();
    container.register(Mailer.class, SmtpMailer::new);
    container.register(PayslipService.class,
        () -> new PayslipService(container.get(Mailer.class)));
    container.get(PayslipService.class).sendPayslip(tom);
  }
}

// You never call compare(); List.sort() calls it, as often and in the order it chooses
employees.sort(Comparator.comparing(Employee::name));

// You never call run(); the executor calls it, on a thread it chooses
executor.submit(() -> sendPayslip(tom));

// You never call actionPerformed(); the Swing event loop calls it when a button is clicked
button.addActionListener(event -> refreshReport());

// Constructor injection - preferred
class PayslipService {
  private final Mailer mailer;
  PayslipService(Mailer mailer) { this.mailer = Objects.requireNonNull(mailer); }
}

// Setter injection - for optional dependencies that have a sensible default
class ReportService {
  private Clock clock = Clock.systemUTC();
  void setClock(Clock clock) { this.clock = clock; }
}

// Field injection - a framework sets a private field by reflection
class AuditService {
  @Autowired private Mailer mailer;   // hidden dependency; hard to set in a plain unit test
}

public interface Mailer { void send(String to, String body); }

@Component
public class SmtpMailer implements Mailer { ... }

@Service
public class PayslipService {
  private final Mailer mailer;

  public PayslipService(Mailer mailer) {   // Spring finds the Mailer bean and passes it in
    this.mailer = mailer;
  }
}