Número de dependencias cíclicas

Actualizado el 15 de noviembre de 2026

Sigla Cyclic
Aspecto «Acoplamiento»
Se mide en clase, interfaz, paquete
Tipo de valor entero, mínimo 0
Dirección más alto es peor
Umbrales de referencia en paquetes, error por encima de 0 (Stau Metro); en clases e interfaces, ninguno
Origen el principio de dependencias acíclicas es de Robert C. Martin, 1996
Familia «Métricas de paquetes de Martin»
Stau Metro NumCyclicDependenciesClass, NumCyclicDependenciesInterface, NumCyclicDependenciesPackage

En pocas palabras

Dice si un elemento está metido en un ciclo de dependencias y con cuántos otros. Si el paquete a usa b, b usa c y c vuelve a usar a, los tres forman un ciclo y cada uno vale 2. Un elemento que no está en ningún ciclo vale 0, que es lo deseable.

Qué mide

Un ciclo de dependencias es un grupo de elementos en el que cada uno depende, directa o indirectamente, de todos los demás. Dentro de un ciclo no hay un orden: no se puede entender, compilar, probar ni publicar ninguno de los miembros sin los otros. A efectos prácticos, el ciclo es una sola pieza grande, aunque el código la presente como varias.

Los ciclos importan sobre todo entre paquetes:

  • Cambios. Un cambio en cualquier miembro puede afectar a todos los demás, y a través de ellos volver al punto de partida.
  • Separación. Ningún paquete del ciclo se puede extraer a un módulo o a una librería sin llevarse los demás.
  • Orden de construcción y pruebas. Sin ciclos, el sistema se puede ordenar por capas («orden de nivel») y probar de abajo arriba. Con ciclos, ese orden no existe para los miembros.

Martin lo formuló como el principio de dependencias acíclicas (ADP): el grafo de dependencias entre paquetes no debe tener ciclos.

Entre clases el criterio es más laxo. Dos clases muy relacionadas que se usan mutuamente (un árbol y sus nodos, un padre y sus hijos) son frecuentes y a menudo razonables, siempre que estén en el mismo paquete.

Cómo se calcula

Se calculan las componentes fuertemente conexas del grafo de dependencias: los grupos máximos de elementos en los que desde cualquiera se llega a cualquier otro siguiendo flechas. Cada elemento pertenece a exactamente una componente; si no está en ningún ciclo, la suya tiene un solo miembro. El valor es:

Cyclic(x)=∣ SCC(x) ∣−1\mathit{Cyclic}(x) = |\,\mathrm{SCC}(x)\,| - 1

donde SCC(x)\mathrm{SCC}(x) es la componente de xx. Todos los miembros de un mismo ciclo tienen el mismo valor.

Para quien empieza. Un ciclo no tiene por qué ser directo. a → b → a es un ciclo de dos; a → b → c → d → a es un ciclo de cuatro, aunque ningún par de paquetes se use mutuamente.

Si dos ciclos se tocan (comparten un elemento, o hay un camino de ida y vuelta entre ellos), forman una sola componente, y el valor es el tamaño del grupo entero, no el de cada ciclo por separado.

Ejemplo

Entre paquetes:

// fichero a/A.java
package a;
public class A { b.B b; }              // a -> b

// fichero b/B.java
package b;
public class B { c.C c; }              // b -> c

// fichero c/C.java
package c;
public class C { a.A a; d.D d; }       // c -> a (cierra el ciclo), c -> d

// fichero d/D.java
package d;
public class D {}
Paquete Componente Cyclic
a {a, b, c} 3 - 1 = 2
b {a, b, c} 3 - 1 = 2
c {a, b, c} 3 - 1 = 2
d {d} 1 - 1 = 0

d está debajo del ciclo pero no dentro: c depende de él, pero él no depende de nadie del ciclo.

Entre clases, con una clase anidada:

class A { void m(Outer.Inner i) {} }       // A -> Outer.Inner, es decir, A -> Outer
class Outer { static class Inner { A a; } } // Outer.Inner -> A, es decir, Outer -> A

A y Outer forman un ciclo de dos, y los tres (A, Outer y Outer.Inner) valen 1 en Stau Metro, que trata la clase anidada como parte de su clase de primer nivel.

Cómo interpretarla

Paquetes. El valor deseable es 0, y el umbral de referencia de Stau Metro lo refleja: cualquier valor por encima de 0 es un error. Ante un ciclo:

  1. Busca las dependencias que van «hacia arriba». Decide qué paquete del ciclo es de más bajo nivel y localiza la flecha que sale de él hacia uno de más alto nivel. A menudo son pocas.
  2. Invierte la dependencia. Define una interfaz en el paquete de bajo nivel y haz que el de alto nivel la implemente (principio de inversión de dependencias).
  3. Extrae lo compartido. Si dos paquetes se usan mutuamente porque comparten unos tipos, mueve esos tipos a un paquete nuevo del que dependan los dos.
  4. Mueve la clase. A veces una sola clase está en el paquete equivocado; cambiarla de sitio rompe el ciclo.

El valor también ayuda a priorizar: un ciclo de 15 paquetes es un problema de arquitectura; uno de 2, a menudo, una clase mal colocada.

Clases e interfaces. No hay umbral. Un ciclo pequeño entre clases del mismo paquete suele ser aceptable; uno que cruza paquetes es el que acaba creando el ciclo entre paquetes. Un ciclo grande entre clases (decenas) indica que buena parte del sistema no se puede probar por piezas.

Ojo. El valor no es el número de ciclos, ni el de dependencias que hay que romper. Es el tamaño del grupo enredado menos uno. Un grupo de 10 paquetes puede desenredarse quitando una sola flecha, o puede necesitar varias.

Para profundizar

El principio. Martin presentó el principio de dependencias acíclicas en su artículo «Granularity» (The C++ Report, 1996) y lo recoge en Agile Software Development: Principles, Patterns, and Practices (2002), junto con el principio de dependencias estables, que es lo que mide la «inestabilidad», y el de abstracciones estables, que es lo que mide la «distancia a la secuencia principal». Las dos técnicas clásicas para romper un ciclo son las que se citan arriba: invertir una dependencia y extraer un paquete nuevo con lo compartido.

Lakos (1996) llega a la misma conclusión desde el diseño físico: un sistema con ciclos no es levelizable, sus componentes no se pueden ordenar por niveles ni probarse de forma incremental.

Algoritmo. Las componentes fuertemente conexas se calculan en tiempo lineal con el algoritmo de Tarjan (1972).

Ciclos de test. En Java los tests suelen vivir en el mismo paquete que el código que prueban, pero en otra raíz de fuentes. Si se cuentan, un test que usa una clase de otro paquete puede crear un ciclo que no existe en el código de producción. Por eso conviene saber si la herramienta los excluye.

Paquetes jerárquicos. En Java com.x.a y com.x.a.b son paquetes independientes: un ciclo entre un paquete y su subpaquete es un ciclo como cualquier otro.

Relación con otras métricas

En las herramientas

Stau Metro (NumCyclicDependenciesClass, NumCyclicDependenciesInterface, NumCyclicDependenciesPackage). Tamaño de la componente fuertemente conexa del elemento menos uno. Reglas:

  • Clases e interfaces comparten un mismo grafo, con los tipos de referencia del «número de dependencias». Una clase anidada cuenta como parte de su clase de primer nivel: toma su valor, y las dependencias entre ellas no forman ciclo. Las anónimas y locales cuentan como parte de la clase que las contiene. Las clases de test sí entran en este grafo. Las interfaces de anotación no tienen valor propio.
  • Paquetes: el grafo del «número de dependencias de paquete». Una dependencia desde o hacia una clase de test no une dos paquetes, así que un test no crea un ciclo entre paquetes. Un paquete se identifica por su nombre, aunque esté en varios módulos. Un paquete que solo contiene tests aparece con valor 0.
  • Las clases de librerías no entran en ningún grafo.
  • Solo se recorre el código Java del ámbito: un ciclo que se cierra a través de código que queda fuera de él no aparece.
  • Umbral de referencia: solo en NumCyclicDependenciesPackage, error por encima de 0.

MetricsReloaded (plugin de IntelliJ IDEA). Tiene la misma métrica, con la misma sigla Cyclic, para clases, interfaces y paquetes: el tamaño de la componente del elemento menos uno. Encuentra la componente comparando los conjuntos de dependencias transitivas de cada elemento, en lugar de con el algoritmo de Tarjan.

JDepend. Detecta y lista los ciclos entre paquetes, con la ruta de los paquetes implicados; sus informes de texto y XML incluyen también los paquetes que dependen de un paquete que está en un ciclo.

NDepend. La regla «Avoid namespaces dependency cycles» lista los ciclos entre namespaces de la aplicación, uno por fila. Aconseja decidir qué namespaces son de bajo nivel y quitar las dependencias que van de ellos hacia los de alto nivel. Su métrica Level no da valor a los elementos de un ciclo.

Referencias