Inyección de dependencias para código limpio en PHP

Clase 20 de 23 • Curso de Fundamentos de PHP

Contenido del curso

Fundamentos de Programación

Fundamentos profesionales

Proyecto CLI

Resumen

Escribir código limpio y organizado es el pilar principal de un desarrollo profesional en PHP. En esta ocasión, daremos pasos clave que optimizan nuestro proyecto mediante el uso de la inyección de dependencias, buscando un software más sostenible y fácil de mantener.

¿Por qué programar con intención mejora el código?

Programar con intención implica escribir código que refleje claramente su propósito, aún si la solución final no está implementada. Por ejemplo, al contemplar una función para iniciar un chat con diferentes servicios, conviene imaginar primero cómo sería nuestra solución ideal.

Al definir:

$app = new Chat(new OpenAI());
$app->start();

se muestra claramente la intención del código: deseamos inicializar un chat y comenzar a usarlo inmediatamente. Esto es programar con intención, definir claramente lo que queremos antes de incluso implementarlo.

¿Cómo utilizar correctamente la inyección de dependencias en PHP?

La inyección de dependencias permite desacoplar nuestras clases y facilita que podamos cambiar partes del sistema sin afectar otras secciones del programa. Para implementarla adecuadamente puedes seguir estos pasos:

Crear una clase que use dependencias externas.
Definir en el constructor de esta clase las dependencias que necesita en forma explícita.
Usar esas dependencias a través de variables internas.

Un ejemplo básico según lo revisado es crear la clase Chat:

namespace TuProyecto;

class Chat {
    private $servicio;

    public function __construct($servicio) {
        $this->servicio = $servicio;
    }

    public function start() {
        // Aquí iría el algoritmo del chat original.
    }
}

En este caso estamos pasando el servicio OpenAI al constructor.

¿Dónde y cómo iniciar correctamente tu aplicación PHP con esta metodología?

La correcta configuración y utilización de la inyección de dependencias comienza en nuestra entrada principal de la aplicación, por ejemplo en Bootstrap.php. Aquí indicamos explícitamente el servicio requerido:

// En Bootstrap.php
$app = new Chat(new OpenAI());
$app->start();

Este objeto Chat, ahora bien parametrizado, se utiliza luego desde un archivo ejecutable donde el start() inicia el flujo de la aplicación. ¿Qué logramos así? Mayor claridad del código, facilidad de mantenimiento y escalabilidad.

¿De qué otras maneras puedes mejorar aún más tu código PHP? ¿Has intentado otras técnicas alternativas a ésta? Comparte tus experiencias en los comentarios.

Andres Silva Vega

student•

La implementación de ollama la hice con polimorfismo implementando una interfaz a ambos servicios (ollama y OpenAI). La clase Chat espera la interfaz.

ModelServiceInterface.php

<?php
namespace Platzi\Interfaces;
interface ModelServiceInterface {
    public function getResponse(string $question) : string;
}
```OpenAiService.php

```js
<?php
namespace Platzi;
use Platzi\Interfaces\ModelServiceInterface;
use OpenAi;
class OpenAIService implements ModelServiceInterface{
    protected $client;
    public function __construct(){
        $this->client = OpenAI::client($_ENV['OPENAI_KEY']);
    }
    public function getResponse (string $question) : string {
        ...
    }
}
```OllamaService.php

```js
<?php
namespace Platzi;
use Platzi\Interfaces\ModelServiceInterface;
use ArdaGnsrn\Ollama\Ollama;
use ArdaGnsrn\Ollama\Responses\StreamResponse;
class OllamaAiService implements ModelServiceInterface{
    protected $client;
    public function __construct(){
        $this->client = Ollama::client('http://ollama:11434');
    }
    public function getResponse (string $question) : string {
        ...
    }
}
```Chat.php

```js
<?php
namespace Platzi;
use Platzi\Interfaces\ModelServiceInterface;
class Chat {
    public function __construct(
        private ModelServiceInterface $aiService
    ){}
    public function start(){
        echo "Pregunta cualquier cosa a la IA: " . PHP_EOL;
        while(true){
            $input = readline("> ");
            if($input == 'exit' || $input === ''){
                break;
            }  
            echo "..." . PHP_EOL;
            $responses = $this->aiService->getResponse($input);
            echo "AI: " . $responses;
            echo PHP_EOL;
        }
    }
}
```bootstrap.php

```js
<?php 
require __DIR__ . "/vendor/autoload.php";
$dotenv = Dotenv\Dotenv::createImmutable(__DIR__);
$dotenv->load();
use Platzi\OllamaAiService;
use Platzi\OpenAiService;
return new Platzi\Chat(new OllamaAiService());
```bin/ia

```js
#!/usr/bin/env php
<?php
$chat = require __DIR__ . "/../bootstrap.php";
$chat->start();

Inyección de dependencias para código limpio en PHP

Fundamentos de Programación

Por qué PHP sigue siendo relevante en el desarrollo web actual

Creación y uso de variables en PHP

Condicionales en PHP para mostrar información dinámica

Arreglos en PHP: almacenar múltiples valores en una sola variable

Ciclo forEach en PHP para recorrer arreglos automáticamente

Arreglos asociativos en PHP para organizar datos

Creación de clases y objetos en PHP

Organización de clases PHP para código limpio y seguro

Métodos mágicos en PHP para acceso dinámico a propiedades

Fundamentos profesionales

Estructura profesional de archivos en proyectos PHP

Autocarga de clases en PHP con Composer

Proyecto CLI

Creación de un bot interactivo en PHP desde terminal

Creación de clases de servicio para organizar lógica en PHP

Instalación de Olama para inteligencia artificial local

Integración de Olama con PHP usando Composer

Configuración de API Key de OpenAI en PHP

Configuración de variables de entorno en PHP con dotenv

Organización de proyectos PHP con archivo Bootstrap

Diseño de prompts para asistentes especializados en PHP

Inyección de dependencias para código limpio en PHP

Interfaces en PHP para reducir acoplamiento entre clases

Refactorización de código para mejor legibilidad y mantenimiento

Adaptación de código PHP de terminal a navegador web