Ho appena letto del modello di facciata e ho trovato questo esempio in cui un client (utente di un computer) richiama un metodo startComputer() che chiama tutte le cose complesse:
Fonte: wikipedia
/* Complex parts */
class CPU {
public void freeze() { ... }
public void jump(long position) { ... }
public void execute() { ... }
}
class Memory {
public void load(long position, byte[] data) { ... }
}
class HardDrive {
public byte[] read(long lba, int size) { ... }
}
/* Facade */
class Computer {
private CPU cpu;
private Memory memory;
private HardDrive hardDrive;
public Computer() {
this.cpu = new CPU();
this.memory = new Memory();
this.hardDrive = new HardDrive();
}
public void startComputer() {
cpu.freeze();
memory.load(BOOT_ADDRESS, hardDrive.read(BOOT_SECTOR, SECTOR_SIZE));
cpu.jump(BOOT_ADDRESS);
cpu.execute();
}
}
/* Client */
class You {
public static void main(String[] args) {
Computer facade = new Computer();
facade.startComputer();
}
}
Qui possiamo vedere la classe client (tu) che crea una nuova facciata, chiamando il metodo startComputer() . Questo metodo crea un'istanza di diversi oggetti e invoca i loro metodi, incapsulandolo all'interno della classe facade dove 'glues it together' .
Domanda 1:
Ma com'è esattamente diverso dai livelli di astrazione?
Ieri ho eseguito la funzionalità di accesso per un'applicazione web in cui un doLogin($username, $password) ha incapsulato un metodo 'complex' di livello inferiore chiama le informazioni di accesso aggiornate sull'utente, imposta le sessioni per accedere e ha istanziato diversi oggetti ecc. per eseguire questa operazione lavoro.
Questo livello chiamerebbe anche un altro livello ancora più basso che avrebbe a che fare con operazioni di tipo CRUD come il controllo dello stato di attivazione, dell'esistenza dell'account e altre cose come l'elaborazione di stringhe tramite algoritmi di hashing. Questo metodo (a livello di modello, guarda 'panoramica dei livelli' sotto) restituirebbe un array con una chiave 'success' o una chiave 'error_message' , agendo come un booleano di ordinamenti per il livello che lo chiama .
Questo è ciò che capisco è noto come 'abstraction layers' , che nasconde le procedure complesse dall'architettura di livello superiore, ma quando leggo del modello di facciata sembra che lo stia usando da sempre?
Domanda 2:
Il mio approccio all'astrazione del meccanismo di accesso sarebbe una cattiva scelta in un'architettura MVC? (in caso contrario, si prega di fornire esempi perché)
Considerato dovrebbe essere molto facile decidere dove andrà il risultato finale (HTML, AJAX, ecc.), non sarebbe una scelta saggia per evitare un sacco di IF dato che questo può essere affrontato su un livello controller ?
Panoramica dei livelli:
Livello controller: $model->doLogin(POST VARIABLES HERE)
Livello del modello: (si tratta di una facciata?) Imposta sessioni, aggiorna le informazioni di accesso nel database ecc., chiama i componenti indipendenti per informazioni: $user_id = $user->getId(); e $session->sessionExists();
Livello di classe indipendente: ogni classe su questo livello è indipendente e ha un accoppiamento minimo o nullo. Dopo tutto, perché dovrebbe? È il lavoro di cui sopra per creare l'applicazione e prestare un'API per controllarla.
Domanda 3:
Il pattern di facciata è utilizzato solo per instradare le chiamate alle sottoclassi in un modulo simile a API, o forse solo più comunemente?
Con questo intendo: Oggetto A crea un'istanza dell'oggetto B e presta un metodo per controllare i metodi dell'oggetto B attraverso un metodo a sé stante:
<?php
class A {
private $_objectB;
public function __construct()
{
$this->_objectB = new B();
}
public function callMethodB()
{
$this->_objectB->methodB();
}
}
class B {
public function methodB()
{
die('Wuhu!');
}
}
// --------------------------
$objectA->callMethodB(); // Wuhu!
invece di:
$objectA->objectB->methodB(); // Wuhu!