Esempio
Mi sono imbattuto in un codice monolitico che fa "tutto" in un unico punto: il caricamento dei dati dal database, la visualizzazione del markup HTML, il funzionamento come router / controller / azione. Ho iniziato ad applicare il codice del database di spostamento SRP nel proprio file, fornendo una denominazione migliore per le cose, e tutto sembrava buono, ma poi ho iniziato a dubitare del motivo per cui lo sto facendo.
Perché refactoring? Qual è lo scopo? È inutile? Qual è il vantaggio? Nota che per la maggior parte ho lasciato il file monolitico così com'è, ma ho rifattorizzato solo la parte più piccola che era rilevante per l'area in cui avevo bisogno di fare del lavoro.
Codice originale:
Per fare un esempio concreto, mi sono imbattuto in questo snippet di codice: carica le specifiche del prodotto o da un ID prodotto conosciuto o da un id della versione selezionata dall'utente:
if ($verid)
$sql1 = "SELECT * FROM product_spec WHERE id = " . clean_input($verid);
else
$sql1 = "SELECT * FROM product_spec WHERE product_id = " . clean_input($productid) ;
$result1 = query($sql1);
$row1 = fetch_array($result1);
/* html markup follows */
Refactoring:
Dato che sto facendo del lavoro che richiede di cambiare le cose in questa parte specifica del codice, l'ho modificato per usare il pattern di repository e l'ho aggiornato per usare le strutture MySQL orientate agli oggetti:
//some implementation details omitted
$this->repository = new SpecRepository($mysql);
if ($verid)
$row1 = $this->repository->getSpecByVersion($verid);
else
$row1 = $this->repository->getSpecByProductId($productid);
/* html markup follows to be refactored or left alone till another time*/
//added new class:
class SpecRepository extends MySqlRepository
{
function getSpecByVersion(int $verid)
{
return $this->getMySql()->paramQuery("
SELECT * FROM product_spec WHERE id = ?
", $verid)->getSingleArray();
}
function getSpecByProductId(int $productid)
{
return $this->getMySql()->paramQuery("
SELECT * FROM product_spec WHERE product_id = ?
", $productid)->getSingleArray();
}
}
Devo farlo?
Guardando indietro alle modifiche, il codice è ancora lì, codice con la stessa funzionalità, ma in file diversi, nomi diversi, luoghi, usando più stile orientato agli oggetti piuttosto che procedurale. In realtà è divertente notare che il codice refactored sembra molto più gonfio nonostante abbia la stessa funzionalità.
Prevedo alcune risposte che dicono "se non conosci i motivi per cui ti rifatti, non farlo", e forse potrei essere d'accordo. La mia ragione è migliorare la qualità del codice nel tempo (e la mia speranza è che lo farò seguendo SRP e altri principi).
Queste ragioni sono abbastanza buone o sto sprecando il mio tempo per "riorganizzare il codice" in questo modo? Il refactoring generale mi sembra un po 'come calpestare l'acqua per essere onesti - ci vuole tempo e diventa più "separato" per quanto riguarda l'SRP ma, nonostante le mie buone intenzioni, non mi sento di apportare miglioramenti sorprendenti. Quindi, discutendo se è meglio lasciare il codice come prima e non refactoring.
Perché ho fatto il refactoring in primo luogo?
Nel mio caso sto aggiungendo nuove funzionalità per una nuova linea di prodotti, quindi devo seguire la struttura di codice esistente per linee di prodotti simili o scrivere la mia.