Cohesión relacional
| Sigla | H; RC en Larman |
| Aspecto | «Cohesión» |
| Se mide en | paquete (en .NET, ensamblado) |
| Tipo de valor | media de relaciones por tipo (decimal, mínimo 0) |
| Dirección | intermedia: un valor muy bajo y uno muy alto son malos |
| Umbrales de referencia | intervalo recomendado de 1,5 a 4,0 (NDepend, JArchitect, CodeQL), con fórmulas que no son idénticas |
| Origen | Craig Larman, Applying UML and Patterns, 2.ª edición, 2001 |
| Stau Metro | no la calcula |
En pocas palabras
Cuenta cuántas relaciones hay entre las clases de un mismo paquete y lo divide entre el número de clases. Si las clases de un paquete apenas se usan unas a otras, el paquete es un cajón de sastre: cosas sin relación metidas en la misma carpeta. Si se usan muchísimo, puede que el paquete esté demasiado enmarañado por dentro.
Qué mide
Mide la cohesión de un paquete: si las clases que agrupa forman un conjunto o solo comparten carpeta. La idea es la misma que la cohesión de una clase, un nivel más arriba: un paquete cohesionado agrupa tipos que colaboran en un mismo propósito, y por tanto cambian y se reutilizan juntos.
Larman la presenta al hablar de cómo organizar los paquetes. Su primera pauta es agrupar por cohesión funcional: juntar los tipos que participan en un mismo propósito, servicio, colaboración o política. Una pista para ver qué tipos van juntos es encontrar un racimo de tipos con mucho acoplamiento interno y poco hacia fuera. La cohesión relacional cuantifica la primera mitad de esa pista, el acoplamiento interno del paquete, que es como él la llama también.
Para quien empieza. Aquí «relación» quiere decir que una clase del paquete usa otra del mismo paquete: tiene un campo de ese tipo, recibe un parámetro de ese tipo, la extiende o la implementa. Las relaciones con clases de otros paquetes no cuentan.
Cómo se calcula
Definición de Larman.
Las relaciones internas incluyen, entre tipos del mismo paquete, las de atributo y de parámetro, la herencia y la implementación de interfaces. Larman da dos ejemplos: un paquete de 6 tipos con 12 relaciones internas tiene , y uno de 6 tipos con 3 relaciones, . Cuanto más alto, más cohesionado o relacionado está el paquete.
Variantes de las herramientas. Las herramientas que la calculan con el nombre H le suman 1 para que un paquete
de un solo tipo no valga 0, pero no en el mismo sitio:
- NDepend y JArchitect: , con el número de relaciones entre tipos internas y el número de tipos.
- CodeQL: , calculado como 1 más la media, sobre los tipos del paquete, del número de tipos del mismo paquete de los que depende cada uno.
Para un paquete grande, la diferencia entre las dos es casi exactamente 1: . El mismo paquete puede quedar dentro del intervalo recomendado con una fórmula y fuera con la otra.
Qué es una relación. Larman cuenta tipos de relación (atributo, parámetro, herencia, implementación). CodeQL cuenta, para cada tipo, a cuántos tipos del paquete depende, sin distinguir de qué forma, y advierte en su documentación de que otras herramientas cuentan las distintas formas en que un tipo depende de otro. En la definición de Larman no queda claro si dos relaciones distintas entre el mismo par de tipos cuentan una o dos veces; en el ejemplo de abajo cada par se cuenta una vez.
Ejemplo
Un paquete de pedidos con seis tipos (cada uno en su fichero):
// Money.java
public record Money(long cents) { } // ninguna relación interna
// OrderStatus.java
public enum OrderStatus { OPEN, PAID, SHIPPED } // ninguna
// OrderLine.java
public record OrderLine(Money price, int quantity) { } // → Money (atributo): 1
// Order.java
import java.util.ArrayList;
import java.util.List;
public class Order {
private final List<OrderLine> lines = new ArrayList<>(); // → OrderLine (atributo): 1
private OrderStatus status = OrderStatus.OPEN; // → OrderStatus (atributo): 1
private long discountCents;
public void add(OrderLine line) { lines.add(line); } // OrderLine otra vez: no suma
public void applyDiscount(Money amount) { discountCents = amount.cents(); } // → Money (parámetro): 1
}
// OrderRepository.java
public interface OrderRepository { void save(Order order); } // → Order (parámetro): 1
// CsvExport.java
public final class CsvExport {
public static String header() { return "id;total"; } // ninguna
}
Hay tipos y relaciones internas (OrderLine → Money; Order → OrderLine,
OrderStatus y Money; OrderRepository → Order). Según la fórmula:
| Definición | Cálculo | Valor |
|---|---|---|
| Larman | 0,83 | |
| NDepend, JArchitect | 1,00 | |
| CodeQL | 1,83 |
Con las dos primeras, el paquete queda por debajo del intervalo de 1,5 a 4,0; con la tercera, dentro. El tipo que
más baja el valor es CsvExport, que no se relaciona con nadie: es una utilidad que probablemente pertenece a otro
paquete. Money y OrderStatus tampoco usan a nadie, pero sí son usados: son tipos hoja, y es normal que no tengan
relaciones de salida.
Cómo interpretarla
NDepend, JArchitect y CodeQL recomiendan el mismo intervalo, de 1,5 a 4,0, aunque con las fórmulas distintas descritas arriba. NDepend y JArchitect consideran que un valor fuera de él podría ser problemático. Larman no da cifras.
Un valor bajo. Según Larman, puede significar tres cosas:
- el paquete contiene cosas sin relación y está mal organizado;
- el paquete contiene cosas sin relación a propósito, como un paquete de utilidades dispares (su ejemplo es
java.util), y entonces el valor no importa; - el paquete contiene uno o más racimos de tipos con un valor alto, aunque el paquete en conjunto no lo tenga.
CodeQL lo resume como el paquete «cajón de sastre» que contiene demasiados tipos sin relación.
Un valor alto. Para NDepend puede indicar exceso de acoplamiento; para CodeQL, un paquete demasiado complejo, con demasiadas dependencias internas.
Ojo. Larman advierte de que la medida se aplica mal a los paquetes formados sobre todo por interfaces, que apenas tienen relaciones entre sí; es más útil en paquetes con clases de implementación.
Qué hacer con un valor bajo. Mira qué tipos no tienen ninguna relación interna, ni de entrada ni de salida: son los que sobran, o los que indican que el paquete agrupa por capa técnica («todos los DTO», «todas las excepciones») en lugar de por función. Si hay racimos, cada racimo es un paquete posible.
Para profundizar
Depende del tamaño. En un paquete de tipos, el número de pares de tipos distintos es si se cuentan las dependencias en los dos sentidos, así que el valor máximo de crece con el tamaño del paquete. Un mismo intervalo recomendado no significa lo mismo para un paquete de 4 tipos que para uno de 60.
Solo mira hacia dentro. La pista de Larman tenía dos mitades: mucho acoplamiento interno y poco externo. La
cohesión relacional solo mide la primera. Un paquete con un H excelente puede depender de medio sistema; para eso
están los «acoplamientos eferentes» (Ce) y
«aferentes» (Ca).
No distingue estructura. Cinco relaciones repartidas entre todos los tipos y cinco relaciones que salen de un
solo tipo dan el mismo valor. Una clase central que usa a todas las demás (un «dios» del paquete) eleva H sin que
el paquete sea más cohesionado.
Cómo falsearla. Añadir dependencias internas artificiales sube el valor; sacar a otro paquete los tipos sin relación también, y eso sí suele ser una mejora real.
Sobre el intervalo de 1,5 a 4,0. Aparece en la documentación de NDepend, JArchitect y CodeQL, pero ninguna de las tres cita de dónde sale, y Larman no lo da.
Relación con otras métricas
- «Acoplamientos eferentes» (
Ce) y «aferentes» (Ca): miden las relaciones del paquete hacia fuera y desde fuera; se leen junto a esta, que mide las de dentro. - «Ratio de encapsulación» (
E_RAT): la proporción de clases del paquete que no se usan desde fuera; otra forma de ver si el paquete forma una unidad. - «Número de clases» (
C): una aproximación al denominador de la fórmula, el número de tipos; con muchos tipos, el valor máximo posible deHcrece. - «Inestabilidad» (
I) y «abstracción» (A): las métricas de paquetes de Martin, que NDepend y JArchitect presentan junto a esta. - «Falta de cohesión de los métodos» (
LCOM): la misma pregunta («¿forman una unidad?») un nivel más abajo, entre los métodos de una clase.
En las herramientas
Stau Metro no calcula ninguna métrica de cohesión de paquete. Las más cercanas miran otra cosa:
- «
AfferentCoupling» y «EfferentCoupling» cuentan las clases de fuera que dependen del paquete y las del paquete que dependen de fuera; son la otra mitad de la pista de Larman, no la cohesión interna. - «
EncapsulationRatioPackage» es la proporción de clases del paquete que nunca se usan desde fuera de él, salvo desde los tests. Un paquete puede tener un valor alto y, aun así, clases sin relación entre sí: una clase a la que nadie referencia también cuenta como interna.
NDepend (.NET) la calcula por ensamblado como , con las relaciones entre tipos internas al ensamblado y el número de tipos. Da como intervalo bueno de 1,5 a 4,0 y considera que los ensamblados fuera de él podrían ser problemáticos.
JArchitect (Java) la documenta igual, a nivel de proyecto, con la misma fórmula y el mismo intervalo.
CodeQL (biblioteca para Java) la define por paquete, como 1 más la media, sobre los tipos del paquete, del número de tipos del mismo paquete de los que depende cada uno. Recomienda el mismo intervalo de 1,5 a 4,0.
Referencias
- Larman, C. (2001). Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and the Unified Process, 2.ª ed. Prentice Hall. Sección «Package Organization Guidelines».
- NDepend, definición de métricas: https://www.ndepend.com/docs/code-metrics
- JArchitect, definición de métricas: https://www.jarchitect.com/metrics
- CodeQL, biblioteca estándar para Java,
MetricPackage.relationalCohesion: https://codeql.github.com/codeql-standard-libraries/java/semmle/code/java/metrics/MetricPackage.qll/predicate.MetricPackage$MetricPackage$relationalCohesion.0.html