Qué es el patrón de diseño Observer y cómo se implementa en

Vista previa del material en texto

¿Qué es el patrón de diseño Observer y cómo se implementa en PHP? 
 
El patrón de diseño Observer es un patrón de comportamiento que se utiliza para establecer 
una relación de uno a muchos entre objetos. En este patrón, un objeto, conocido como el 
"sujeto" (subject), mantiene una lista de dependientes llamados "observadores" 
(observers). Cuando el estado del sujeto cambia, todos los observadores registrados son 
notificados y actualizados automáticamente. 
 
El patrón Observer es útil cuando deseas que varios objetos estén informados 
automáticamente cuando ocurra un cambio en el estado de un objeto principal, sin que el 
sujeto tenga que conocer o estar acoplado con los observadores específicos. 
 
**Componentes del patrón Observer:** 
- Sujeto (Subject): Mantiene una lista de observadores y notifica a los observadores cuando 
cambia su estado. 
- Observador (Observer): Define una interfaz que debe ser implementada por todos los 
observadores. Esta interfaz proporciona un método de actualización que se invoca cuando 
el sujeto cambia su estado. 
- Observadores concretos (Concrete Observers): Implementan la interfaz del observador y 
se registran con el sujeto para recibir notificaciones sobre cambios de estado. 
 
**Implementación del patrón Observer en PHP:** 
Veamos cómo implementar el patrón Observer en PHP mediante un ejemplo sencillo: 
 
Supongamos que tienes un objeto "Usuario" que tiene un nombre, y deseas que varios 
objetos "Log" y "Estadísticas" se actualicen automáticamente cada vez que cambie el 
nombre del usuario. 
 
1. **Definir la interfaz del Observador:** 
 
```php 
interface Observer { 
 public function update($data); 
} 
``` 
 
2. **Definir la clase del Sujeto (Usuario):** 
 
```php 
class Usuario { 
 private $nombre; 
 private $observadores = []; 
 
 public function setNombre($nombre) { 
 $this->nombre = $nombre; 
 $this->notificarObservadores(); 
 } 
 
 public function registrarObservador(Observer $observador) { 
 $this->observadores[] = $observador; 
 } 
 
 public function notificarObservadores() { 
 foreach ($this->observadores as $observador) { 
 $observador->update($this->nombre); 
 } 
 } 
} 
``` 
 
3. **Implementar los Observadores (Log y Estadísticas):** 
 
```php 
class Log implements Observer { 
 public function update($data) { 
 echo "Usuario cambiado a: " . $data . " - Registro en el log\n"; 
 } 
} 
 
class Estadisticas implements Observer { 
 public function update($data) { 
 echo "Usuario cambiado a: " . $data . " - Actualización de estadísticas\n"; 
 } 
} 
``` 
 
4. **Utilizar el patrón Observer:** 
 
```php 
// Crear el sujeto (Usuario) 
$usuario = new Usuario(); 
 
// Crear los observadores (Log y Estadísticas) 
$log = new Log(); 
$estadisticas = new Estadisticas(); 
 
// Registrar los observadores con el sujeto 
$usuario->registrarObservador($log); 
$usuario->registrarObservador($estadisticas); 
 
// Cambiar el nombre del usuario (esto notificará a los observadores) 
$usuario->setNombre("John Doe"); 
``` 
 
En este ejemplo, cada vez que se cambia el nombre del usuario mediante el método 
`setNombre()`, se notifica automáticamente a todos los observadores registrados (Log y 
Estadísticas) mediante el método `update()`, y cada observador realiza una acción específica 
en función del cambio de estado del sujeto. 
 
El patrón Observer es útil cuando necesitas mantener varios objetos sincronizados con el 
estado de un objeto principal, y es especialmente útil en situaciones en las que se requiere 
desacoplar los objetos para mantener un diseño más flexible y extensible.