Blog de Gonzalo

El acoplamiento de código se refiere al grado de dependencia entre diferentes módulos, componentes o clases en un sistema de software. Un alto acoplamiento implica que los módulos están muy interconectados, lo que puede dificultar la reutilización y escalabilidad del código. Por el contrario, un bajo acoplamiento promueve la independencia entre módulos, facilitando cambios y pruebas.

Tipos de acoplamiento

• Acoplamiento fuerte (alto):
  • Los módulos dependen directamente de los detalles internos de otros.
  • Ejemplo: Una clase que accede directamente a los atributos privados de otra.
  • Problemas: Cambios en un módulo pueden romper otros; difícil de testar.
  • Ejemplo:
    
    

    
    class Database {
        public function connect() {
            return "Conexión a MySQL establecida";
        }
    }
    
    class UserManager {
        private $db;
    
        public function __construct() {
            $this->db = new Database(); // Alto acoplamiento: UserManager depende directamente de Database
        }
    
        public function getUser($id) {
            echo $this->db->connect();
            return "Usuario con ID: $id";
        }
    }
    $userManager = new UserManager();
    echo $userManager->getUser(1);
    

• Acoplamiento débil (bajo):
  • Los módulos interactúan a través de interfaces o APIs bien definidas.
  • Ejemplo: Uso de inyección de dependencias o patrones como el observador.
  • Ventajas: Mayor flexibilidad, facilidad para reemplazar o modificar módulos.
  • Ejemplo:
    
    

    
    // Interfaz para desacoplar la implementación de la base de datos
    interface DatabaseConnection {
        public function connect();
    }
    
    // Implementación concreta de la interfaz
    class MySQLDatabase implements DatabaseConnection {
        public function connect() {
            return "Conexión a MySQL establecida";
        }
    }
    
    // Clase que usa la interfaz, no la implementación concreta
    class UserManager {
        private $db;
    
        // Inyección de dependencias a través del constructor
        public function __construct(DatabaseConnection $db) {
            $this->db = $db;
        }
    
        public function getUser($id) {
            echo $this->db->connect();
            return "Usuario con ID: $id";
        }
    }
    // Uso
    $db = new MySQLDatabase();
    $userManager = new UserManager($db);
    echo $userManager->getUser(1);
    

Estrategias para reducir el acoplamiento

• Usar interfaces o abstracciones: Depender de contratos (interfaces) en lugar de implementaciones concretas.
• Inyección de dependencias: Pasar dependencias externas en lugar de crearlas internamente.
• Patrones de diseño: Aplicar patrones como MVC, mediador o fachada para encapsular interacciones.
• Encapsulación: Limitar el acceso a los detalles internos de un módulo (usar modificadores como
private).
• Mensajería o eventos: Usar sistemas de eventos para comunicación indirecta entre módulos.

Explicación del Acoplamiento en los Ejemplos

• Alto acoplamiento: En el primer ejemplo, UserManager está "atado" a Database. Si Database cambia (por ejemplo, el método connect se renombra), UserManager debe ajustarse.
• Bajo acoplamiento: En el segundo ejemplo, UserManager solo conoce la interfaz DatabaseConnection. Puedes crear nuevas implementaciones (como PostgreSQLDatabase) sin tocar UserManager.

Compartir en twitter