Ejemplo
Encontré un código monolítico que hace "todo" en un solo lugar: cargar datos de la base de datos, mostrar el código HTML, actuar como un enrutador / controlador / acción. Comencé a aplicar SRP moviendo el código de la base de datos a su propio archivo, proporcionando una mejor nomenclatura para las cosas, y todo se veía bien, pero luego empecé a tener dudas sobre por qué hago esto.
¿Por qué refactorizar? ¿Cuál es el propósito? ¿Es inútil? ¿Cuál es el beneficio? Tenga en cuenta que, en su mayoría, dejé el archivo monolítico tal como está, pero que solo reproduje la parte más pequeña que era relevante para el área en la que necesitaba trabajar.
Código original:
Para dar un ejemplo concreto, encontré este fragmento de código: carga las especificaciones del producto ya sea por un ID de producto conocido o por un ID de versión seleccionado por el usuario:
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 */
Refactorización:
Ya que estoy haciendo un trabajo que me obliga a cambiar las cosas en esta parte específica del código, lo cambié para usar el patrón de repositorio y lo actualicé para usar las instalaciones de MySQL orientadas a objetos:
//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();
}
}
¿Debo hacer esto?
Mirando hacia atrás a los cambios, el código sigue ahí, código con la misma funcionalidad, pero en diferentes archivos, diferentes nombres, lugares, utilizando un estilo más orientado a objetos en lugar de procedimientos. En realidad, es gracioso observar que el código refactorizado se ve mucho más abultado a pesar de tener la misma funcionalidad.
Preveo algunas respuestas que dicen "si no sabes las razones por las que te refieres, no lo hagas", y tal vez esté de acuerdo. Mis razones son mejorar la calidad del código con el tiempo (y mi esperanza es que lo haré siguiendo el SRP y otros principios).
¿Son esas razones lo suficientemente buenas o estoy perdiendo el tiempo en "reorganizar el código" de esta manera? En general, refactorizar esto se siente un poco como pisar el agua para ser honesto: toma tiempo y se vuelve más "separado" en lo que respecta a SRP, pero a pesar de mis buenas intenciones, no siento que esté haciendo mejoras sorprendentes. Por lo tanto, debatir si es mejor dejar el código como antes y no refactorizar.
¿Por qué me refactoricé en primer lugar?
En mi caso, estoy agregando una nueva funcionalidad para una nueva línea de productos, por lo que debo seguir la estructura de código existente para líneas de productos similares o escribir la mía.