ABE Framework Development Guide

Framework Overview

Core Features

• Modular Architecture: Loose-coupling design implemented based on dependency injection
• Routes and Controllers: Standardized controller pattern and route registration mechanism
• Middleware Management: Flexible global and route-level middleware system
• Internationalization Support: Built-in multi-language i18n support
• Access Control: Integrated Casbin access control
• Event-Driven: Asynchronous event bus based on Watermill
• Goroutine Pool Management: Efficient concurrent task processing
• Plugin Mechanism: Extensible plugin system

Quick Start

1. Initialize Engine

package main

import "github.com/otzgo/abe"

func main() {
    // 创建引擎实例
    engine := abe.NewEngine()
    
    // 配置和注册组件
    // ...
    
    // 启动服务
    engine.Run(abe.WithBasePath("/api/v1"))
}

2. Core Concepts

• Engine: Main application container that coordinates all components
• Controller: Business logic controller that implements standardized interfaces
• Middleware: HTTP middleware that handles cross-cutting concerns
• UseCase: Business use case pattern that encapsulates specific business logic
• Plugin: Pluggable extension module

Development Process

1. Engine Core Features - Learn about Engine instance creation and service acquisition
2. Controller Development - Master standardized controller design and route registration
3. Middleware System - Grasp middleware development and usage skills
4. Dependency Injection - Understand container management and dependency injection patterns
5. Plugin Mechanism - Develop plugins to extend framework functionality

Best Practices

Recommended Project Structure

project/
├── cmd/app/           # 应用入口
├── internal/
│   ├── controllers/   # 控制器层
│   ├── usecases/      # 业务用例层
│   ├── dtos/          # 数据传输对象
│   └── models/        # 数据模型
├── configs/           # 配置文件
└── docs/              # 文档

Code Organization Principles

• Controllers only handle route registration and parameter processing
• Business logic is placed in UseCase
• Dependencies are injected via constructors
• Use standardized error handling and response formats

Detailed Reference Materials

Core Features

• Engine Core Feature Details - Engine instance management, service accessor, lifecycle management
• Controller Development Guide - Controller interface implementation, route registration, RESTful design
• Dependency Injection Container - Global and request-level dependency injection, UseCase pattern

System Integration

• Configuration Management System - Multi-layer configuration, environment variables, command-line parameters
• Database Integration - GORM usage, model definition, query optimization
• Logging System Usage - Structured logging, context management, performance monitoring

Functional Features

• Middleware System Usage - Global middleware, route-level middleware, custom middleware development
• CORS Middleware Configuration - Cross-origin resource sharing, security configuration, common issues
• Form Validation System - Data validation, multi-language support, custom rules
• Multi-Language Internationalization - Translation files, language switching, template usage

Security & Operations

• Access Control Mechanism - JWT authentication, Casbin permissions, middleware usage
• Event-Driven System - Message publish/subscribe, asynchronous processing, event bus
• Scheduled Task Scheduling - Cron expressions, task management, monitoring and alerting
• Plugin Mechanism Details - Plugin interfaces, lifecycle hooks, plugin development examples

Goroutines & Performance

• Goroutine Pool Management - Performance optimization, resource management, task scheduling