Nel post di ieri, ho parlato di un costruttore di plugin per WordPress e del motivo per cui gli hook non dovrebbero essere nel costruttore.
Anche se ho menzionato diversi modi per gestire la registrazione degli hook, non mi sono preoccupato di entrare nei dettagli per ciascuna di queste strategie. Per quanto mi riguarda, si meritano un proprio articolo per fornire quanti più dettagli possibili su come impostare qualcosa.
Ad esempio, uno dei metodi che ho condiviso affermava:
- È possibile creare una classe che mantenga un registro degli oggetti e degli hook con WordPress.
In altre parole, si tratta di registrare gli hook di WordPress utilizzando un approccio orientato agli oggetti per ridurre l’accoppiamento e aumentare la coesione tra i componenti del plug-in.
Ma cosa significa? Quali sono i vantaggi che porta, come è impostato e come viene utilizzato?
Registrazione di WordPress Hooks
Se stai leggendo questo, probabilmente hai familiarità con il sistema di hook di WordPress, l’ordine in cui vengono attivati e come una funzione o una classe può registrare le sue funzioni con WordPress in modo che possano eseguire qualsiasi lavoro devono gestire.
E spesso vediamo le classi farlo da sole. A seconda del progetto, lo faccio da solo. Per coloro che non hanno familiarità, generalmente assomiglia a questo :
<?php
add_action( 'plugins_loaded', 'acme_start' );
/**
* Start the machine.
* https://www.youtube.com/watch?v=ysoMOefPyRs
*/
function acme_start() {
$plugin = new AcmeColumn();
}
Ma tutto questo può essere suddiviso in classi più coese per dare loro ancora meno responsabilità (una buona cosa) e per diminuire l’accoppiamento tra una classe o un insieme di classi con WordPress.
Un esempio di un design che analizzerò in questo post.
La natura controintuitiva di questo, tuttavia, è che richiederà almeno un’altra classe. Ma ecco come funziona.
Configurarlo
Ai fini di questo esempio, useremo solo una semplice classe che registrerà un tipo di azione con WordPress. L’idea per l’architettura funziona in questo modo:
- C’è la classe principale che ha la funzione che vogliamo agganciare a WordPress.
- C’è una classe responsabile dell’orchestrazione dell’aggancio della funzione della classe a WordPress.
Abbastanza facile, giusto? Ma ecco il problema: la classe responsabile della registrazione delle funzioni di una determinata classe con WordPress è il punto che richiede una decisione di progettazione.
Per prima cosa, chiamiamo la classe HookRegistry in modo da potervi riferire correttamente. Successivamente, chiamiamo la classe con le funzioni che vogliamo agganciare ad AcmeColumn semplicemente per rappresentare una classe che aggiunge una nuova colonna alla dashboard della Pagina nell’area di amministrazione di WordPress.
Con questo in atto, la decisione progettuale si riduce a questo:
- L’ HookRegistery dovrebbe sapere di AcmeColumn?
- AcmeColumn dovrebbe conoscere HookRegistry?
So che ci sono altri modi per organizzare questo e ci sono anche strategie su come gestirlo (come l’ inversione del controllo) e questi sono argomenti che vale la pena esplorare, ma per mantenere questa idea iniziale il più semplice possibile, lo mostrerò per un post futuro.
Usando la classe
Date le opzioni precedenti, passeremo un’istanza di AcmeColumn in HookRegistry quando le classi vengono istanziate durante il processo di avvio iniziale del plugin di WordPress. Questo potrebbe assomigliare a questo :
<?php
add_action( 'plugins_loaded', 'acme_start' );
/**
* Start the machine.
* https://www.youtube.com/watch?v=ysoMOefPyRs
*/
function acme_start() {
$registry = new HookRegistry();
$acme_column = new AcmeColumn( $registry );
$acme_column->start();
}
Successivamente, ogni volta che è il momento di fare in modo che AcmeColumn registri la sua funzione con WordPress, chiameremo HookRegistry e gli indicheremo di farlo.
Innanzitutto, AcmeColumn :
<?php
class AcmeColumn {
private $registry;
public function __construct( $registry) {
$this->registry = $registry;
}
public function start() {
$registry->add_hook( 'filter', 'manage_edit-page_columns', $this, 'add_page_column' );
}
public function add_page_column( $page_columns) {
$page_columns['template'] = 'Acme Column';
return $page_columns;
}
}
Quindi HookRegistry :
<?php
class HookRegistry {
public add_hook( $type, $name, $object, $method) {
$type = strtolower( $type );
if ('filter' !== $type || 'action' !== $type) {
return new WP_Error( '1', 'No proper hook type defined.' );
}
}
private function add_filter( $name, $object, $method) {
add_filter( $name, array( $object, $method) );
}
private function add_action( $name, $object, $method) {
add_action( $name, array( $object, $method) );
}
}
Facoltativamente, possiamo anche mantenere un elenco delle varie classi e hook che sono stati registrati. Questo potrebbe essere utile o meno a seconda della tua implementazione, quindi lo condivido esclusivamente come "ecco qualcosa che potresti voler fare".
E potrebbe assomigliare a questo (usando un semplice array associativo):
<?php
class HookRegistry {
private $registry;
public function __construct() {
$this->registery = array();
}
public add_hook( $id, $type, $name, $object, $method) {
$type = strtolower( $type );
if ('filter' !== $type || 'action' !== $type) {
return new WP_Error( '1', 'No proper hook type defined.' );
}
if ('filter' === $type) {
$this->add_filter( $name, $object, $method );
} else {
$this->add_action( $name, $object, $method );
}
$hook_info = array(
$type,
$name,
$object,
$method,
);
$this->registry[ $id ] = $hook_info;
}
private function add_filter( $name, $object, $method) {
add_filter( $name, array( $object, $method) );
}
private function add_action( $name, $object, $method) {
add_action( $name, array( $object, $method) );
}
}
Si noti che nella classe sopra, ora accetta un $id come parametro. Esistono diversi modi per identificare le informazioni che stanno entrando in un registro, il più semplice dei quali è creare l’ID da soli.
Tuttavia, se volessi usare qualcosa come il nome dell’hook o il nome della classe, funzionerebbe anche questo. Tieni presente che poiché si tratta di un array associativo, può mantenere un solo valore per chiave, quindi puoi finire per eliminare i dati precedenti se non stai attento.
Indipendentemente da ciò, questo è qualcosa che considero facoltativo, ma se è implementato, è importante assicurarsi di disporre delle funzioni appropriate per recuperare un’istanza dell’oggetto tramite una chiave.
Uno dei tanti
Come per qualsiasi cosa relativa a questo tipo di lavoro, è possibile riprogettarlo o riorientarlo in un modo che funzioni in modo diverso o che si adatti alle tue esigenze. Lo scopo non è mostrare il modello definitivo su come fare qualcosa, ma un modo per avvicinarlo e adattarlo (proprio come qualsiasi modello di progettazione).
Inoltre, ha lo scopo di assicurarsi che le nostre classi mantengano le responsabilità per le quali sono state create per tutto il tempo consentendo loro di registrarsi con WordPress secondo necessità. Questa volta, però, la classe non deve farlo da sola.
Invece, passa la responsabilità a una classe che ha la responsabilità esclusiva di registrare detti hook. Quindi, sebbene introduca più classi, aumenta la coesione e diminuisce l’accoppiamento.
Ciò offre vantaggi in termini di manutenzione, test e progettazione generale.