Use is_a() to implement a simple dependency injection check mechanism

M66 2025-05-31

In modern PHP development, Dependency Injection is a commonly used design pattern, which helps decouple code and improves the maintainability and testability of code. Dependency injection usually involves passing one object to another, thus allowing the passed object to assume specific responsibilities.

To ensure that the injected dependencies meet the expected types, PHP provides a variety of type checking methods, where the is_a() function is a simple and practical tool. This article will explain how to use the is_a() function to implement a basic dependency injection checking mechanism.

What is the is_a() function?

is_a() is a built-in function in PHP, which is used to determine whether an object is an instance of a class or its subclass. The function prototype is as follows:

 is_a(object $object, string $class_name, bool $allow_string = false): bool

$object : The object or class name string to be checked (when $allow_string is true).
$class_name : target class name.
$allow_string (PHP 5.3.9+): Whether to allow incoming class names in string form.

If $object is an instance of $class_name or an instance of its subclass, the function returns true , otherwise false .

Implement dependency injection checking using is_a()

Suppose we have a simple service interface LoggerInterface and an implementation class FileLogger , and a simple class ServiceConsumer that injects the container. We hope that when injecting dependencies, we can use the is_a() function to verify whether the injected object implements the specified interface.

 <?php

interface LoggerInterface {
    public function log(string $message);
}

class FileLogger implements LoggerInterface {
    public function log(string $message) {
        echo "Logging message to file: $message\n";
    }
}

class ServiceConsumer {
    private $logger;

    public function setLogger($logger) {
        // pass is_a() Check if it is implemented LoggerInterface
        if (is_a($logger, 'LoggerInterface')) {
            $this->logger = $logger;
        } else {
            throw new InvalidArgumentException("Logger must implement LoggerInterface");
        }
    }

    public function doSomething() {
        $this->logger->log("Doing something important");
    }
}

// Example of usage
$consumer = new ServiceConsumer();
$logger = new FileLogger();

$consumer->setLogger($logger);
$consumer->doSomething();

In the above code:

The ServiceConsumer class has a setLogger() method, which is used to inject log services.
During injection, use the is_a() function to determine whether $logger implements LoggerInterface .
If the judgment fails, an exception is thrown, ensuring the correctness of the dependency type.

Support for string class names

The is_a() function supports the third parameter $allow_string since PHP 5.3.9, allowing the class name of the string type to be passed in for judgment. For example:

 if (is_a($logger, 'LoggerInterface', true)) {
    // ...
}

This parameter can also be used if the dependency in your code is a class name string (such as is common in factory mode).

Examples of combining namespaces

If your project uses namespace, don't forget to write the full class name when calling is_a() :

 if (is_a($logger, '\\MyApp\\Logger\\LoggerInterface')) {
    // ...
}

Summarize

is_a() is an easy way to determine whether the object type meets expectations.
When in dependency injection, using is_a() can effectively verify the injection object to avoid runtime type errors.
Combined with exception handling can make the code more robust.
For different versions of PHP, pay attention to the differences in the parameters of is_a() .

Dependency injection is an important part of modern PHP design. The rational use of is_a() function can help us quickly implement type-safe dependency injection checks and improve code quality.

 <?php
interface LoggerInterface {
    public function log(string $message);
}

class FileLogger implements LoggerInterface {
    public function log(string $message) {
        echo "Logging message to file: $message\n";
    }
}

class ServiceConsumer {
    private $logger;

    public function setLogger($logger) {
        if (is_a($logger, 'LoggerInterface')) {
            $this->logger = $logger;
        } else {
            throw new InvalidArgumentException("Logger must implement LoggerInterface");
        }
    }

    public function doSomething() {
        $this->logger->log("Doing something important");
    }
}

// Example usage
$consumer = new ServiceConsumer();
$logger = new FileLogger();

$consumer->setLogger($logger);
$consumer->doSomething();

is_a