php 65 lines · 9 steps

Building a DI container with reflection in PHP

A dependency injection container that registers factories and auto-wires constructor dependencies using reflection.

Explained by highlit

Advanced dependency-injection reflection autowiring service-container design-patterns

1final class Container
2{
  private array $bindings = [];
  private array $instances = [];
5 
  public function bind(string $abstract, callable $factory): void
  {
      $this->bindings[$abstract] = $factory;
  }
10 
  public function singleton(string $abstract, callable $factory): void
  {
      $this->bindings[$abstract] = function (Container $c) use ($abstract, $factory) {
          return $this->instances[$abstract] ??= $factory($c);
      };
  }
17 
  public function make(string $abstract): object
  {
      if (isset($this->bindings[$abstract])) {
          return ($this->bindings[$abstract])($this);
      }
23 
      return $this->resolve($abstract);
  }
26 
  private function resolve(string $class): object
  {
      $reflector = new ReflectionClass($class);
30 
      if (!$reflector->isInstantiable()) {
          throw new RuntimeException("Cannot instantiate {$class}");
      }
34 
      $constructor = $reflector->getConstructor();
36 
      if ($constructor === null) {
          return new $class();
      }
40 
      $arguments = array_map(
          fn (ReflectionParameter $param) => $this->resolveParameter($param, $class),
          $constructor->getParameters()
      );
45 
      return $reflector->newInstanceArgs($arguments);
  }
48 
  private function resolveParameter(ReflectionParameter $param, string $class): mixed
  {
      $type = $param->getType();
52 
      if ($type instanceof ReflectionNamedType && !$type->isBuiltin()) {
          return $this->make($type->getName());
      }
56 
      if ($param->isDefaultValueAvailable()) {
          return $param->getDefaultValue();
      }
60 
      throw new RuntimeException(
          "Unresolvable dependency \${$param->getName()} in {$class}"
      );
  }
65}

01 / 01

STEP 01

Walkthrough

Space play ←→ step click any line

Three takeaways

1A container decouples object creation from usage by mapping abstract names to factories or reflected classes.
2Reflection lets you inspect constructor signatures and recursively resolve typed dependencies without manual wiring.
3Caching resolved instances behind a closure turns any binding into a lazily-created singleton.

Related explainers

typescript

import { registerLocaleData } from '@angular/common';
import localeFr from '@angular/common/locales/fr';
import localeFrExtra from '@angular/common/locales/extra/fr';
import localeDe from '@angular/common/locales/de';

Locale-aware bootstrapping in Angular

i18n localization dependency-injection

Intermediate 8 steps

php

<?php
 
class NameParser
{

Parsing a full name into components in PHP

string-parsing arrays normalization

Intermediate 8 steps

typescript

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import * as Joi from 'joi';

Validating env config at boot in NestJS

configuration schema-validation environment-variables

Intermediate 8 steps

php

<?php
 
namespace App\Services\Checkout;

Validating coupons with Laravel's Pipeline

pipeline chain of responsibility transactions

Intermediate 7 steps

java

@Component
@Converter
public class EncryptedStringConverter implements AttributeConverter<String, String> {

Transparent column encryption in Spring & JPA

encryption aes-gcm jpa-converter

Advanced 10 steps

typescript

import { Inject, Injectable, Logger } from '@nestjs/common';
import { CACHE_MANAGER } from '@nestjs/cache-manager';
import { Cache } from 'cache-manager';
import { InjectRepository } from '@nestjs/typeorm';