patterns - php the right way

Implementación simple de Dependency Injection

Question

Después de leer esta pregunta, me pregunto si alguien puede ayudarme a comprender cómo implementar Inyección de Dependencia correctamente con estas Clases de PHP:

class DBClass
{
private $mMysqli;
function __construct(mysqli $database)
{
$this->mMysqli=$database;
}
function __destruct()
{
$this->mMysqli->close();
}
public function listUsers()
{
$query=''SELECT * FROM Utente;'';
$resultset=$this->mMysqli->query($query);
while($row = $resultset->fetch_array(MYSQLI_ASSOC)) {
echo $row[''username''];
echo $row[''pwd''];
echo "<br />/n";
}
}
public function runQuery($query)
{
return $resultset=$this->mMysqli->query($query);
}
public function getConnection()
{
return $this->mMysqli;
}
}

Clase de sesión:

class Session
{
private $_session;
public $maxTime;
private $database;
public function __construct(DBClass $database)
{
$this->database=$database;
$this->maxTime[''access''] = time();
$this->maxTime[''gc''] = get_cfg_var(''session.gc_maxlifetime'');
session_set_save_handler(array($this,''_open''),
array($this,''_close''),
array($this,''_read''),
array($this,''_write''),
array($this,''_destroy''),
array($this,''_clean'')
);
register_shutdown_function(''session_write_close'');
session_start();
...
}
} 

Clase de usuario (para detalles sobre el usuario actualmente conectado):

class User
{
private $username;
private $role;
private $session;
function __construct($session)
{
$this->session=$session;
...
}
}

Externamente:

$connection=new mysqli(DB_HOST, DB_USER, DB_PASSWORD, DB_DATABASE);
$database=new DBClass($connection);
$session=new Session($database);
$user=new User($session);

¿Es esta la manera correcta?

Answer 1

Sí. Ahora está inyectando las dependencias a través del constructor que proporciona menos acoplamiento. Ahora puede cambiar más fácilmente estas dependencias, por ejemplo, cuando UnitTesting puede reemplazarlas con Mocks.

Sin embargo, todavía tiene algo que ver con el uso de la DBClass concreta como TypeHint en lugar de una interfaz . Entonces, cuando quiera usar un DBClass diferente, debería llamarse DBClass. Podría lograr un acoplamiento más flexible codificando contra una interfaz que las clases concretas deben implementar en su lugar.

Para crear solo instancias únicas de una clase (como se solicita en los comentarios), puede usar un Singleton (como sugirió Kevin Peno) o una fábrica para crear y realizar un seguimiento de si la instancia se ha creado aún. O use un contenedor de servicio DI, que es similar a una fábrica, pero no es lo mismo. Crea y administra objetos para usted.

La biblioteca de componentes de Symfony tiene un contenedor de inyección de dependencias con una excelente documentación e introducción al tema sobre cómo mejorar aún más la DI con los contenedores de servicio. Los contenedores también se pueden usar para limitar instancias. Echale un vistazo.