En el patrón de diseño del software Proxy, se incluye una clase intermedia antes de un objeto, para aplicar acciones extra antes de usar el objeto intermediado.
Es decir, es para aplicar acciones como cacheado de la información, de los objetos generados, logs, reenvío de acciones a otros objetos, control de acceso a métodos o datos, etcétera..
Al grano, show me the code
Supongamos que queremos cachear el uso de la clase Something con un Proxy. Una forma es implementar algo parecido a lo siguiente:
Simplemente se delega la creación del objeto Something, y la llamada al método doSomething que es el objetivo para hacer todo esto. Lo siguiente es que se cachea la respuesta al método doSomething dentro del objeto ProxyForSomething, este es el porqué se ha metido el proxy, haciendo que sólo se procese la función del objeto Something una sola vez en vez de tres veces.
El código del cliente que usa el proxy:
<?php
include 'ISomething.php';
include 'Something.php';
include 'ProxyForSomething.php';
(new Client())->main();
class Client
{
public function main()
{
$proxy = new ProxyForSomething('Something');
echo $proxy->doSomething().PHP_EOL;
echo $proxy->doSomething().PHP_EOL;
echo $proxy->doSomething().PHP_EOL;
}
}La implementación de la interfaz que define contrato de uso:
<?php
interface ISomething
{
public function doSomething();
}El objeto cacheado:
<?php
class Something implements ISomething
{
public function doSomething()
{
/*
* Here goes code for something to do..
*/
return 'Say something..';
}
}
Y finalmente el proxy que implementa las mismas funciones que el objeto cacheado:
<?php
class ProxyForSomething implements ISomething
{
private $instance;
private $returnCached;
public function __construct($className)
{
$this->instance = new $className();
}
/**
* For instance, this proxy wants to cache the returned string..
*/
public function doSomething()
{
if (empty($this->returnCached)) {
$this->returnCached = $this->instance->doSomething();
}
return $this->returnCached;
}
}
