Aspect Oriented Programming #

// ANTI-PATTERN: cross-cutting concern scattered across every business method
func (s *OrderService) CreateOrder(req CreateOrderRequest) (*Order, error) {
    // Logging — not part of the order logic
    log.Info("start CreateOrder", "user_id", req.UserID)
    start := time.Now()
    
    // Auth check — not part of the order logic
    if !s.auth.HasPermission(req.UserID, "order:create") {
        log.Warn("unauthorized CreateOrder", "user_id", req.UserID)
        return nil, ErrUnauthorized
    }
    
    // Retry — not part of the order logic
    var order *Order
    var err error
    for attempt := 1; attempt <= 3; attempt++ {
        order, err = s.repo.Save(buildOrder(req))
        if err == nil { break }
        time.Sleep(time.Duration(attempt) * time.Second)
    }
    
    // Metrics — not part of the order logic
    metrics.Histogram("order.create.duration", time.Since(start))
    
    // More logging — still not part of the order logic
    log.Info("end CreateOrder", "order_id", order.ID, "duration", time.Since(start))
    return order, err
}
// The actual business code is only 2 lines — drowned under technical concerns

// CORRECT with AOP — pure business code
type OrderService struct {
    repository OrderRepository
}

func (s *OrderService) CreateOrder(req CreateOrderRequest) *Order {
    // Only business logic — no logging, auth, metrics
    order := buildOrder(req)
    return s.repository.Save(order)
}

// Logging, auth, and metrics are handled by separate middleware/decorators
// and applied automatically without touching the code above

// Go has no AOP aspect — the same concern lives in middleware/decorators
type LoggingAspect struct{}

func (a *LoggingAspect) Wrap(next func(ctx Context) error) func(ctx Context) error {
    // All logging logic collected here
    // Service functions don't need to know this aspect exists
    return func(ctx Context) error {
        return next(ctx)
    }
}

// Pointcut: all handlers registered on the service router
serviceGroup.Use(serviceLayerMiddleware)

// Pointcut: handlers carrying the RequireAdmin annotation
//   (Go has no annotations — use an explicit wrapper instead)
adminRoutes.Use(adminOnlyMiddleware)

// Pointcut: handlers of a specific service
paymentRoutes.Use(paymentServiceMiddleware)

// ANTI-PATTERN: manual logging in every service method
type OrderService struct {
    log Logger
}

func (s *OrderService) CreateOrder(req CreateOrderRequest) *Order {
    s.log.Info("start createOrder userId=%s", req.UserID) // duplicated in every method
    order := s.doCreate(req)
    s.log.Info("end createOrder orderId=%s", order.ID)    // duplicated in every method
    return order
}

// CORRECT: logging centralized in a decorator — all services get logged automatically
type LoggingDecorator struct {
    inner Service
    log   Logger
}

func (d *LoggingDecorator) CreateOrder(req CreateOrderRequest) (*Order, error) {
    method := "CreateOrder"
    d.log.Info("[START] %s", method)
    start := time.Now()

    order, err := d.inner.CreateOrder(req)
    if err != nil {
        d.log.Error("[ERROR] %s failed after %v: %v", method, time.Since(start), err)
        return nil, err
    }
    d.log.Info("[END] %s took %v", method, time.Since(start))
    return order, nil
}

// Annotation equivalent: a helper that guards a function with a role check
//   Go has no annotations — the role check lives in a middleware/decorator
func RequireRole(role string, next func() error) error {
    currentRole := SecurityContext.GetCurrentRole()
    if currentRole != role {
        return fmt.Errorf("role '%s' is required, but the user has '%s'", role, currentRole)
    }
    return next()
}

// Usage — declarative, clean
func (s *AdminService) DeleteUser(userID string) error {
    // The auth check is handled by the wrapper — this function only contains business logic
    return RequireRole("ADMIN", func() error {
        return s.userRepository.Delete(userID)
    })
}

func (s *AdminService) ResetSystem() error {
    return RequireRole("SUPERADMIN", func() error {
        return s.systemRepository.ResetAll()
    })
}

// CORRECT: measure the latency of every service method automatically
//   Go equivalent: a metrics wrapper around the service method
func MeasureLatency(className, methodName string, next func() error) func() error {
    return func() error {
        start := time.Now()

        err := next()
        status := "success"
        if err != nil {
            status = "error"
        }
        metrics.Histogram("method.latency", time.Since(start).Seconds(),
            "class", className, "method", methodName, "status", status)
        return err
    }
}

// CORRECT: cross-cutting concerns as middleware — not inside handlers
func LoggingMiddleware() fiber.Handler {
    return func(c *fiber.Ctx) error {
        start := time.Now()
        method := c.Method()
        path := c.Path()

        // Before: log the incoming request
        log.Infof("[START] %s %s", method, path)

        err := c.Next() // ← run the original handler

        // After: log the result and duration
        log.Infof("[END] %s %s status=%d duration=%v",
            method, path, c.Response().StatusCode(), time.Since(start))

        return err
    }
}

func AuthMiddleware(jwtSecret string) fiber.Handler {
    return func(c *fiber.Ctx) error {
        token := c.Get("Authorization")
        claims, err := validateJWT(token, jwtSecret)
        if err != nil {
            return c.Status(401).JSON(fiber.Map{"error": "unauthorized"})
        }
        c.Locals("user_id", claims.UserID)
        return c.Next()
    }
}

// Register once, applies to every route below it
app := fiber.New()
app.Use(LoggingMiddleware())  // applies to all routes
app.Use(AuthMiddleware(secret)) // applies to all routes

app.Get("/orders", getOrders)        // automatically logged and authed
app.Post("/orders", createOrder)     // automatically logged and authed
app.Delete("/orders/:id", deleteOrder)

// Business interface
type OrderRepository interface {
    Save(ctx context.Context, order *Order) error
    FindByID(ctx context.Context, id string) (*Order, error)
}

// ANTI-PATTERN: logging inside the implementation — pollutes the repository
type MySQLOrderRepository struct{ db *sql.DB }

func (r *MySQLOrderRepository) Save(ctx context.Context, order *Order) error {
    log.Infof("saving order %s", order.ID) // ← shouldn't be here
    _, err := r.db.ExecContext(ctx, "INSERT INTO orders ...", order)
    log.Infof("saved order %s err=%v", order.ID, err)
    return err
}

// CORRECT: logging as a decorator — wraps the repository without changing it
type LoggingOrderRepository struct {
    inner  OrderRepository // ← wraps the original implementation
    logger Logger
}

func NewLoggingOrderRepository(inner OrderRepository, logger Logger) OrderRepository {
    return &LoggingOrderRepository{inner: inner, logger: logger}
}

func (r *LoggingOrderRepository) Save(ctx context.Context, order *Order) error {
    r.logger.Infof("[REPO] Save order %s", order.ID)
    start := time.Now()
    
    err := r.inner.Save(ctx, order) // delegate to the original implementation
    
    r.logger.Infof("[REPO] Save order %s done in %v err=%v",
        order.ID, time.Since(start), err)
    return err
}

func (r *LoggingOrderRepository) FindByID(ctx context.Context, id string) (*Order, error) {
    r.logger.Infof("[REPO] FindByID %s", id)
    order, err := r.inner.FindByID(ctx, id)
    r.logger.Infof("[REPO] FindByID %s found=%v", id, order != nil)
    return order, err
}

// Wiring in main() — full transparency
func main() {
    mysqlRepo    := repository.NewMySQLOrderRepository(db)
    loggingRepo  := NewLoggingOrderRepository(mysqlRepo, logger)  // decorator
    cachingRepo  := NewCachingOrderRepository(loggingRepo, redis) // decorator on top of decorator
    
    service := service.NewOrderService(cachingRepo) // the service doesn't know about logging/caching
}

@Service
public class OrderService {
    
    @Transactional // ← The aspect managing the transaction
    public void createOrder(CreateOrderRequest req) {
        Order order = repository.save(req);
        
        // ANTI-PATTERN: calling a @Transactional method from within the same class
        // Spring AOP uses proxies — this.processOrder() doesn't go through the proxy!
        this.processOrder(order); // ← @Transactional here will NOT work
    }
    
    @Transactional(propagation = REQUIRES_NEW)
    public void processOrder(Order order) {
        // Supposed to be in a new transaction — but it isn't, because it's called via this
    }
}

// CORRECT: separate into its own bean so it goes through the proxy
@Service
public class OrderService {
    private final OrderProcessor processor; // ← a separate bean
    
    @Transactional
    public void createOrder(CreateOrderRequest req) {
        Order order = repository.save(req);
        processor.processOrder(order); // ← goes through the proxy, @Transactional works
    }
}

// ANTI-PATTERN: business logic inside the middleware — wrong place
func HandleOrder(next func(req CreateOrderRequest) (*Order, error)) func(req CreateOrderRequest) (*Order, error) {
    return func(req CreateOrderRequest) (*Order, error) {
        // ← this should be in OrderService, not in a middleware!
        if req.Amount <= 0 {
            return nil, &ValidationError{msg: "Amount must be positive"}
        }
        return next(req)
    }
}

// CORRECT: business logic in the service, middleware only for technical concerns
func LogAndMeasure(name string, next func() error) func() error {
    return func() error {
        start := time.Now()
        err := next() // ← no modifying args or result
        log.Infof("%s took %v", name, time.Since(start))
        return err
    }
}

// ANTI-PATTERN: middleware applied to every route in the entire application
app.Use(LogAll) // ← intercepts framework internals, third-party libraries, etc.

// CORRECT: scoped to the router (layer) that actually needs it
serviceGroup.Use(LogServiceLayer)

// Or apply explicitly per handler — more explicit
app.Post("/orders", AuditMethod(CreateOrder))

// ✗ Business logic in a wrapper — the wrapper becomes a hidden "controller"
func Handle(next func() (*Order, error)) func() (*Order, error) {
    return func() (*Order, error) {
        if !hasEnoughStock() {
            return nil, ErrOutOfStock // ← business logic!
        }
        return next()
    }
}
// ✓ Stock validation inside the service, not in a wrapper

// ✗ Middleware applied to everything — performance impact, hard debugging
app.Use(Intercept) // ← wraps every route, framework internals included
// ✓ Limit to a specific group: serviceGroup.Use(Intercept)

// ✗ Too many stacked wrappers — execution flow is unclear
// Logging → Metrics → Retry → Caching → Auth
// Nobody knows which wrapper runs first
// ✓ Compose them in an explicit order (outer-most runs first)
service := Auth(Logging(Metrics(NewOrderService()))) // first → last

// ✗ Undocumented wrappers — new engineers don't know why a method suddenly gets logged
// ✓ Add comments to the wrapper and to the wrapped methods
// ✓ Document in the README or internal wiki: "all @Service methods are automatically logged by LoggingDecorator"