Aspect Oriented Programming #

// ANTI-PATTERN: cross-cutting concern tersebar di setiap method bisnis
func (s *OrderService) CreateOrder(req CreateOrderRequest) (*Order, error) {
    // Logging — bukan bagian dari logika order
    log.Info("start CreateOrder", "user_id", req.UserID)
    start := time.Now()
    
    // Auth check — bukan bagian dari logika order
    if !s.auth.HasPermission(req.UserID, "order:create") {
        log.Warn("unauthorized CreateOrder", "user_id", req.UserID)
        return nil, ErrUnauthorized
    }
    
    // Retry — bukan bagian dari logika order
    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 — bukan bagian dari logika order
    metrics.Histogram("order.create.duration", time.Since(start))
    
    // Logging lagi — masih bukan bagian dari logika order
    log.Info("end CreateOrder", "order_id", order.ID, "duration", time.Since(start))
    return order, err
}
// Kode bisnis sebenarnya hanya 2 baris — tenggelam di bawah concern teknis

// BENAR dengan AOP — kode bisnis murni (di Go: middleware/decorator)
type OrderService struct {
    repository OrderRepository
}

func (s *OrderService) CreateOrder(req CreateOrderRequest) (*Order, error) {
    // Hanya logika bisnis — tidak ada logging, auth, metrics
    order := buildOrder(req)
    return s.repository.Save(order)
}

// Logging, auth, metrics ditangani oleh middleware/decorator terpisah
// dan diterapkan secara otomatis tanpa menyentuh kode di atas

// Aspect setara di Go: middleware — semua logika logging dikumpulkan di sini
func LoggingMiddleware() fiber.Handler {
    // Semua logika logging dikumpulkan di sini
    // Handler tidak perlu tahu middleware ini ada
    return func(c *fiber.Ctx) error { return c.Next() }
}

// Pointcut di Go: predicate pemilih method — dipakai oleh middleware/decorator
// Pointcut: semua method di package service
var serviceLayer = func(method string) bool {
    return strings.HasPrefix(method, "service.")
}

// Pointcut: method dengan annotation/tag tertentu
var adminOnly = func(hasTag bool) bool { return hasTag }

// Pointcut: method di struct/type tertentu
var paymentService = func(typeName string) bool {
    return typeName == "PaymentService"
}

// ANTI-PATTERN: logging manual di setiap method service
func (s *OrderService) createOrder(req CreateOrderRequest) (*Order, error) {
    log.Infof("start createOrder userId=%v", req.UserID) // duplikat di setiap method
    order, err := s.doCreate(req)
    log.Infof("end createOrder orderId=%v", order.ID)    // duplikat di setiap method
    return order, err
}

// BENAR: logging terpusat di middleware — semua handler otomatis ter-log
func LoggingMiddleware() fiber.Handler {
    return func(c *fiber.Ctx) error {
        method := c.Method()
        log.Infof("[START] %s", method)
        start := time.Now()

        err := c.Next() // ← jalankan handler asli
        if err != nil {
            log.Errorf("[ERROR] %s failed after %v: %v", method, time.Since(start), err)
            return err
        }
        log.Infof("[END] %s took %v", method, time.Since(start))
        return nil
    }
}

// Definisi "annotation" di Go: struct marker sederhana
type RequireRole struct {
    Role string // role yang dibutuhkan
}

// Aspect yang menerapkan check — middleware/auth wrapper
func RequireRoleMiddleware(requiredRole string, getCurrentRole func() string, next fiber.Handler) fiber.Handler {
    return func(c *fiber.Ctx) error {
        currentRole := getCurrentRole()

        if currentRole != requiredRole {
            return c.Status(403).JSON(fiber.Map{
                "error": "Role '" + requiredRole + "' diperlukan, tapi user punya '" + currentRole + "'",
            })
        }
        return next(c)
    }
}

// Penggunaan — deklaratif, bersih
func (s *AdminService) DeleteUser(userID string) {
    // Auth check ditangani middleware — method ini hanya berisi logika bisnis
    s.userRepository.Delete(userID)
}

func (s *AdminService) ResetSystem() {
    s.systemRepository.ResetAll()
}

// BENAR: ukur latency setiap method handler secara otomatis
type MetricsMiddleware struct {
    registry *MetricsRegistry
}

func NewMetricsMiddleware(registry *MetricsRegistry) *MetricsMiddleware {
    return &MetricsMiddleware{registry: registry}
}

func (m *MetricsMiddleware) Wrap(handler fiber.Handler) fiber.Handler {
    return func(c *fiber.Ctx) error {
        methodName := c.Route().Name
        className := "handler"

        sample := m.registry.StartTimer("method.latency")
        err := handler(c)

        status := "success"
        if err != nil {
            status = "error"
        }
        sample.Stop(map[string]string{
            "class":  className,
            "method": methodName,
            "status": status,
        })
        return err
    }
}

// BENAR: cross-cutting concern sebagai middleware — tidak masuk ke handler
func LoggingMiddleware() fiber.Handler {
    return func(c *fiber.Ctx) error {
        start := time.Now()
        method := c.Method()
        path := c.Path()

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

        err := c.Next() // ← jalankan handler asli

        // After: catat hasil dan durasi
        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()
    }
}

// Daftarkan sekali, berlaku ke semua route di bawahnya
app := fiber.New()
app.Use(LoggingMiddleware())  // apply ke semua route
app.Use(AuthMiddleware(secret)) // apply ke semua route

app.Get("/orders", getOrders)        // otomatis ter-log dan ter-auth
app.Post("/orders", createOrder)     // otomatis ter-log dan ter-auth
app.Delete("/orders/:id", deleteOrder)

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

// ANTI-PATTERN: logging di dalam implementasi — mencemari repository
type MySQLOrderRepository struct{ db *sql.DB }

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

// BENAR: logging sebagai decorator — wraps repository tanpa mengubahnya
type LoggingOrderRepository struct {
    inner  OrderRepository // ← bungkus implementasi asli
    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) // delegasi ke implementasi asli
    
    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 di main() — transparansi penuh
func main() {
    mysqlRepo    := repository.NewMySQLOrderRepository(db)
    loggingRepo  := NewLoggingOrderRepository(mysqlRepo, logger)  // decorator
    cachingRepo  := NewCachingOrderRepository(loggingRepo, redis) // decorator di atas decorator
    
    service := service.NewOrderService(cachingRepo) // service tidak tahu ada logging/caching
}

@Service
public class OrderService {
    
    @Transactional // ← Aspect yang mengelola transaction
    public void createOrder(CreateOrderRequest req) {
        Order order = repository.save(req);
        
        // ANTI-PATTERN: memanggil method @Transactional dari dalam class yang sama
        // Spring AOP menggunakan proxy — this.processOrder() tidak melalui proxy!
        this.processOrder(order); // ← @Transactional di sini TIDAK akan bekerja
    }
    
    @Transactional(propagation = REQUIRES_NEW)
    public void processOrder(Order order) {
        // Kira-kira dalam transaction baru — tapi tidak, karena dipanggil via this
    }
}

// BENAR: pisahkan ke bean terpisah agar melalui proxy
@Service
public class OrderService {
    private final OrderProcessor processor; // ← bean terpisah
    
    @Transactional
    public void createOrder(CreateOrderRequest req) {
        Order order = repository.save(req);
        processor.processOrder(order); // ← melalui proxy, @Transactional bekerja
    }
}

// ANTI-PATTERN: business logic di dalam middleware — salah tempat
func handleOrder(next fiber.Handler) fiber.Handler {
    return func(c *fiber.Ctx) error {
        // ← ini seharusnya di OrderService, bukan di middleware!
        req := c.Locals("req").(CreateOrderRequest)
        if req.Amount <= 0 {
            return fiber.NewError(400, "Amount must be positive")
        }
        return next(c)
    }
}

// BENAR: business logic di service, aspect hanya concern teknis
func logAndMeasure(next fiber.Handler) fiber.Handler {
    return func(c *fiber.Ctx) error {
        start := time.Now()
        err := next(c) // ← tidak modifikasi args atau result
        log.Infof("%v took %v", c.Route().Path, time.Since(start))
        return err
    }
}

// ANTI-PATTERN: pointcut terlalu luas — intercept semua method di seluruh aplikasi
var logAll = func(method string) bool { return true } // ← semua method!
// Intercept method internal framework, library pihak ketiga, dsb.

// BENAR: spesifik ke package dan layer yang memang butuh
var logServiceLayer = func(method string) bool {
    return strings.HasPrefix(method, "com.example.service.")
}

// Atau gunakan marker-based pointcut — lebih eksplisit
var auditMethod = func(hasTag bool) bool { return hasTag }

// ✗ Business logic di Aspect — aspect menjadi "controller" terselubung
func handle(next fiber.Handler) fiber.Handler {
    return func(c *fiber.Ctx) error {
        if !hasEnoughStock() {
            return fiber.NewError(400, "out of stock") // ← logika bisnis!
        }
        return next(c)
    }
}
// ✓ Validasi stok di dalam service, bukan di aspect

// ✗ Pointcut terlalu luas — performa terdampak, debugging sulit
var intercept = func(next fiber.Handler) fiber.Handler { return next } // ← semua method
// ✓ Batasi ke layer spesifik: execution(* com.example.service..*(..))

// ✗ Terlalu banyak aspect bertumpuk — alur eksekusi tidak jelas
// LoggingMiddleware → MetricsMiddleware → RetryMiddleware → CachingMiddleware → AuthMiddleware
// Tidak ada yang tahu aspek mana yang jalan duluan
// ✓ Gunakan urutan pendaftaran eksplisit (app.Use urut)
app.Use(AuthMiddleware())     // paling awal
app.Use(LoggingMiddleware())
app.Use(MetricsMiddleware())  // paling akhir

// ✗ Tidak mendokumentasikan aspect — engineer baru tidak tahu kenapa method tiba-tiba ter-log
// ✓ Tambahkan komentar di middleware dan di method yang di-intercept
// ✓ Catat di README atau internal wiki: "semua handler otomatis di-log oleh LoggingMiddleware"