Saltar a contenido

ADS · S10 · Patrones GoF y GRASP en el módulo cobranza

SGE-JD · JD Refrigeración S.A.C. · Equipo CherryTree · Yoel Wagner Chambi Sirena · 10/11/2026

Trabajo autónomo de la sesión 10 (Patrones de diseño GoF y GRASP). Usa el módulo diseñado en S8 y animado en S9. Cada patrón se marca como real (está en el código de hoy, con su archivo), hueco (debería estar y no está) o previsto (diseñado, no implementado). Este trabajo diseña los cambios: no modifica el código de LP2. Así se corrige lo que anuncié en S3, donde dije que el refactor de VentaService "se aplica en S10". La guía pide diseñarlo, y aplicarlo queda para la integración final, con las 217 pruebas como red.

1. Patrones GoF

Patrón Estado Dónde, en cobranza Justificación
Factory Method / Creator Hueco CobranzaService.registrar hace cobro.agregarDetalle(new DetalleCobro(venta, monto)): el servicio crea el abono y la entidad solo lo recibe Quien contiene y registra los abonos es Cobro; él debería crearlos: Cobro.abonar(venta, monto) (sección 3)
Facade Real (con defecto) VentaService es la fachada de ventas para cobranza (obtenerParaCobro, marcarComoPagada, volverAPendiente); ClienteService la de clientes Cobranza no toca repositorios ajenos (ModularityTests). Defecto: la fachada de ventas tiene 25 métodos (S3); el diseño de S8 la reduce a VentasParaCobranza
Proxy Real, de framework (no escrito por nadie del equipo) (1) @Service @Transactional en CobranzaService (líneas 37–38): Spring inyecta un proxy que abre y confirma la transacción alrededor de cada método. (2) @ManyToOne(fetch = LAZY) en Cobro.cliente, DetalleCobro.cobro y DetalleCobro.venta: Hibernate pone un proxy que carga la fila recién cuando se usa Por el proxy transaccional, registrar es todo-o-nada (RN7 de S8). Por el proxy LAZY, el historial no carga cada venta completa
Singleton Real, de framework CobranzaService, CobroRepository, DevolucionService: un solo bean por contexto de Spring Sin estado entre peticiones (S4: stateless), así que compartir una instancia es seguro
Abstract Factory Real, de framework EntityManagerFactory (JPA, configurado por Spring Boot) fabrica la familia EntityManager, Transaction y Query para Oracle El código de cobranza no conoce a Hibernate ni a Oracle: pide un repositorio
Adapter Real CobroResponseDTO.desdeEntidad(Cobro) adapta la entidad a la forma que espera la SPA En S8 se diseñó como CobroMapper (Pure Fabrication); hoy es un método estático en el DTO
Bridge Previsto El recibo de cobro en dos formatos (PDF para el cliente, Excel para el contador): Recibo (abstracción: qué se informa) × FormatoSalida (implementación: cómo se escribe) Sin Bridge serían 2 × 2 clases (ReciboPdf, ReciboExcel, EstadoCuentaPdf…). Hoy hay ExcelBuilder en config/exportacion, que sería un lado del puente
Strategy Real porCobrar ordena con Comparator.comparing(CuentaPorCobrarDTO::fechaLimitePago, nullsLast(naturalOrder())) (línea 90): el criterio de orden es un objeto intercambiable Ordenar por cliente o por monto es cambiar el Comparator, no el algoritmo
Chain of Responsibility Real (framework) y previsto Real: la cadena de filtros de Spring Security decide quién puede anular un cobro (hasAnyRole(conPermiso(Permiso.ANULAR_COBROS)), SecurityConfig:129): si falla un eslabón, 401 o 403 sin llegar al controlador. Previsto: las validaciones de un abono (sección 1.1) Hoy las reglas del abono son una secuencia de if dentro de validarAbono y validarDeduccion
Observer Real ventas publica VentaAnuladaEvent; DevolucionService.alAnularVenta lo escucha (@EventListener, línea 46) y, si la venta ya estaba cobrada, crea la devolución pendiente ventas no conoce a cobranza: si mañana otro módulo necesita enterarse, se suscribe sin tocar ventas. Se formaliza en S11
State Descartado Cobro.Estado (VIGENTE, ANULADO) y Devolucion.Estado (PENDIENTE, DEVUELTA) Tabla 7: dos estados y una transición cada uno, que no cambian seguido. Un enum con la validación en anular() alcanza. Una clase por estado sería sobreingeniería

1.1 Chain of Responsibility previsto: validar un abono

Hoy, registrar mezcla siete reglas con if dentro de dos métodos privados. Diseño:

classDiagram
    class ValidadorAbono {
        <<interface>>
        +validar(Abono, VentaParaCobro, Cobro)
    }
    class VentaVigente
    class MismoClienteYMoneda
    class FechaNoAnteriorALaVenta
    class NoSuperaElSaldo
    class DeduccionCorrespondiente
    ValidadorAbono <|.. VentaVigente
    ValidadorAbono <|.. MismoClienteYMoneda
    ValidadorAbono <|.. FechaNoAnteriorALaVenta
    ValidadorAbono <|.. NoSuperaElSaldo
    ValidadorAbono <|.. DeduccionCorrespondiente
    CobranzaServiceImpl --> "1..*" ValidadorAbono : recorre en orden

Spring inyecta la lista (List<ValidadorAbono>, ordenada con @Order) y el servicio la recorre. ¿Se justifica hoy? Solo a medias. Las reglas no cambian seguido y son siete, así que la secuencia de if se entiende bien. Pasaría a valer la pena si JD agrega reglas por tipo de cliente, por ejemplo un tope de crédito. Se deja previsto, no recomendado para ya.

2. GRASP: los nueve patrones

Patrón GRASP Clase o decisión en cobranza Estado
Information Expert Venta.calcularTotal() (la venta tiene sus líneas); el saldo lo calcula cobranza, que tiene los abonos (total − Σ abonos vigentes) Real. Con huecos en Cobro (sección 3)
Creator Cobro debería crear sus DetalleCobro (los contiene y los registra) Hueco: hoy los crea el servicio
Controller CobranzaController: recibe el evento del sistema "registrar cobro" y delega Real
Low Coupling DTO (CobroRequestDTO, CobroResponseDTO) en el borde; en el diseño de S8, ventaId en lugar de Venta Parcial: hoy DetalleCobro tiene la entidad Venta (S8, B1)
High Cohesion CobroRepository: solo consultas de cobros; DevolucionService separado de CobranzaService Real. CobranzaService (326 líneas) mezcla registrar, anular, cuentas por cobrar y deducciones: es cohesivo, a diferencia de VentaService (S3)
Polymorphism MetodoPago con comportamiento por constante (sección 4) Previsto
Pure Fabrication CobroRepository y CobroMapper (S8): no existen en el negocio, existen para que las entidades no sepan guardarse ni serializarse Real (repositorio) / previsto (mapper)
Indirection VentaService y ClienteService entre cobranza y los otros módulos Real
Protected Variations Interfaces estables frente a los cambios de otros módulos Hueco real (sección 5): se depende de la clase concreta FacturacionService cuando ya existe la interfaz ComprobantesDeVenta

3. Information Expert: ¿Cobro es anémica o rica?

Cobro hoy solo tiene agregarDetalle(detalle), que agrega a la lista y fija la relación. Todo lo demás lo hace el servicio con setters. Diagnóstico por operación:

Operación Información que necesita ¿Quién la tiene? Decisión
Sumar el total del cobro (total = total.add(monto) en el servicio, y después cobro.setMontoTotal(total)) Los abonos del cobro Cobro Mover a la entidad: abonar() acumula el total, y montoTotal deja de tener setter
Anular (estado, fecha, motivo, quién) El estado actual del cobro y el motivo Cobro (más un dato de ventas: si alguna de sus ventas está anulada) Mover a la entidad, recibiendo el dato externo como parámetro
Calcular el saldo de una venta El total de la venta (ventas) y los abonos de todos los cobros vigentes (otros cobros) Ningún Cobro solo Se queda en el servicio: no es información de un cobro
Validar cliente y moneda del abono El cliente y la moneda del cobro, y los de la venta Cobro y VentaParaCobro Puede ir en abonar(): el cobro conoce su cliente y su moneda

Refactor diseñado (sin duplicar la lógica en el servicio):

public class Cobro {
    // montoTotal sin setter: solo cambia al abonar
    public DetalleCobro abonar(VentaParaCobro venta, BigDecimal monto) {          // Creator + Information Expert
        if (!venta.clienteId().equals(this.clienteId) || venta.moneda() != this.moneda)
            throw new IllegalArgumentException("La venta #" + venta.id() + " no es de este cliente o está en otra moneda.");
        DetalleCobro abono = new DetalleCobro(this, venta.id(), venta.documento(), monto);
        detalles.add(abono);
        montoTotal = montoTotal.add(monto);
        return abono;
    }
    public void anular(String motivo, String usuario, boolean algunaVentaAnulada, LocalDate hoy) {
        if (estado == Estado.ANULADO) throw new ReglaNegocioException("El cobro #" + id + " ya fue anulado.");
        if (motivo == null || motivo.trim().length() < 5) throw new IllegalArgumentException("Indique el motivo (al menos 5 caracteres).");
        if (algunaVentaAnulada) throw new ReglaNegocioException("Una de sus ventas está anulada: se resuelve en Devoluciones.");
        estado = Estado.ANULADO; fechaAnulacion = hoy; motivoAnulacion = motivo.trim(); anuladoPor = usuario;
    }
}
// En el servicio, lo que NO es del cobro: saldo, bloqueo de las ventas, voucher, y avisar a ventas.

El servicio queda como orquestador: trae los datos de otros módulos y del repositorio, y le pide al cobro que aplique sus reglas. La validación de cliente y moneda sale de validarAbono y vive solo en abonar(), sin duplicarse.

4. Polymorphism: MetodoPago

Hoy el comportamiento por método de pago está repartido en if:

// CobranzaService
if (dto.metodoPago().esDeduccion() && cobro.getReferencia() == null) { … "Indique el N° de la constancia…" : "…comprobante de retención." }
if (dto.metodoPago().esDeduccion()) validarDeduccion(venta, dto.metodoPago(), monto);
Venta.TipoDeduccion esperado = metodo == Cobro.MetodoPago.DETRACCION ? Venta.TipoDeduccion.DETRACCION : Venta.TipoDeduccion.RETENCION;

El mismo DETRACCION ? … : … se repite tres veces. Con métodos por constante del enum, cada método de pago sabe lo suyo:

public enum MetodoPago {
    EFECTIVO, TRANSFERENCIA, DEPOSITO, YAPE_PLIN, CHEQUE,
    DETRACCION { @Override public Optional<TipoDeduccion> deduccion() { return Optional.of(TipoDeduccion.DETRACCION); }
                 @Override public String documentoExigido() { return "N° de la constancia de depósito de la detracción"; } },
    RETENCION  { @Override public Optional<TipoDeduccion> deduccion() { return Optional.of(TipoDeduccion.RETENCION); }
                 @Override public String documentoExigido() { return "N° del comprobante de retención"; } };

    public Optional<TipoDeduccion> deduccion() { return Optional.empty(); }   // dinero que sí recibe JD
    public String documentoExigido() { return null; }
}

esDeduccion() pasa a ser deduccion().isPresent(), y desaparecen los tres DETRACCION ? … : …. Se elige un enum con métodos y no una jerarquía de clases porque los métodos de pago son un conjunto cerrado que fija SUNAT. Para la jerarquía real del dominio, Producto (S7), el polimorfismo reemplazaría los cuatro métodos con if sobre sector por un método controlaStock() en cada subclase.

5. Dependency Injection, Indirection y Protected Variations, con el código real

// cobranza/cobro/service/CobranzaService.java, líneas 47–53
public CobranzaService(CobroRepository cobroRepository, VentaService ventaService,
                       ClienteService clienteService, FacturacionService facturacionService) {
Verificación Resultado
Dependency Injection ✓ Las cuatro dependencias llegan por el constructor, final; ningún new de servicios ni repositorios
Indirection ✓ Cobranza llega a ventas, clientes y facturación por sus servicios públicos, nunca por sus repositorios (ModularityTests)
Protected Variations ✗ Hueco. Las tres dependencias de otros módulos son clases concretas. La de facturación se usa para un solo método: facturacionService.numeroComprobanteDeVenta(v.getId()) (línea 74). Ese método ya está en la interfaz ComprobantesDeVenta, que define ventas y que VentaReporteService ya usa así

Corrección, de una línea: inyectar ComprobantesDeVenta en lugar de FacturacionService. Cobranza dejaría de depender de los 24 métodos públicos y de las 10 dependencias de FacturacionService. Además, en una prueba se podría reemplazar por una implementación falsa de dos métodos.

6. Error o hallazgo

Hallazgo 1: un patrón catalogado mal al principio. Puse Strategy en la validación de detracción y retención, porque "cambia según el método de pago". Al revisarlo, no hay objetos intercambiables: hay un if con el mismo DETRACCION ? … : … repetido tres veces. Es un caso de Polymorphism pendiente (sección 4), no una Strategy. La Strategy real del módulo estaba en otro lado, en el Comparator que ordena las cuentas por cobrar, y no la había notado porque es una línea de la API de Java.

Hallazgo 2: Proxy de framework que no había visto. @Transactional sobre la clase CobranzaService hace que Spring entregue un proxy en lugar del objeto. Por eso, si un método llamara a otro de la misma clase, por ejemplo registrar llamando a un método @Transactional(readOnly = true) de CobranzaService, esa segunda anotación no tendría efecto: la llamada no pasa por el proxy. Hoy no ocurre en cobranza, pero explica por qué las fachadas de otros módulos (ventaService.marcarComoPagada) sí se ejecutan dentro de la misma transacción.

Hallazgo 3: Protected Variations roto con la solución a la vista (sección 5). La interfaz correcta ya existía y otro servicio la usaba, pero CobranzaService inyectaba la clase completa.

Descartado con criterio: el patrón State para Cobro y Devolucion (dos estados, una transición, reglas que no cambian) y la Chain of Responsibility de validaciones ahora (siete reglas estables).

7. Reflexión

¿Qué patrón reconociste sin haberlo diseñado, y qué operación diagnosticaste con Information Expert? Relación con Fowler.

Reconocí tres Proxy que nadie del equipo escribió:

  • el de @Transactional, que hace que un cobro y el cambio de estado de sus ventas se confirmen juntos;
  • los proxies LAZY de Hibernate, que evitan cargar cada venta completa en el historial;
  • la cadena de filtros de Spring Security, que es una Chain of Responsibility.

Con Information Expert, el diagnóstico fue que Cobro es anémica: el servicio suma su total y la anula con setters, aunque el cobro es quien tiene esa información. El refactor mueve abonar() y anular() a la entidad, y deja en el servicio solo lo que no es del cobro: el saldo y el bloqueo de las ventas. Fowler llamó a esto el Anemic Domain Model: objetos con nombres del negocio pero sin comportamiento, con la lógica en servicios que los manipulan desde afuera. Su punto era que así se paga el costo de un modelo de objetos sin recibir su beneficio. En SGE-JD se ve en una pregunta simple: hoy, para saber todas las reglas de un cobro, hay que leer CobranzaService entero. Con el refactor, basta con mirar Cobro.