حقول التزامن في Go: الأنماط والممارسات المثلى

// تعريف واجهة للمستودع
type UserRepository interface {
    FindByID(id int) (*User, error)
    Save(user *User) error
}

// الخدمة تعتمد على واجهة المستودع
type UserService struct {
    repo UserRepository
}

// الدالة المُنشِّئة تحقن التبعية
func NewUserService(repo UserRepository) *UserService {
    return &UserService{repo: repo}
}

// تستخدم الدوال المُشَغَّلة التبعية المحقونة
func (s *UserService) GetUser(id int) (*User, error) {
    return s.repo.FindByID(id)
}

type EmailService interface {
    Send(to, subject, body string) error
}

type Logger interface {
    Info(msg string)
    Error(msg string, err error)
}

type OrderService struct {
    repo        OrderRepository
    emailSvc    EmailService
    logger      Logger
    paymentSvc  PaymentService
}

func NewOrderService(
    repo OrderRepository,
    emailSvc EmailService,
    logger Logger,
    paymentSvc PaymentService,
) *OrderService {
    return &OrderService{
        repo:       repo,
        emailSvc:   emailSvc,
        logger:     logger,
        paymentSvc: paymentSvc,
    }
}

// جيد: واجهة صغيرة ومُركزَة
type PaymentProcessor interface {
    ProcessPayment(amount float64) error
}

// سيء: واجهة كبيرة مع طرق غير ضرورية
type PaymentService interface {
    ProcessPayment(amount float64) error
    RefundPayment(id string) error
    GetPaymentHistory(userID int) ([]Payment, error)
    UpdatePaymentMethod(userID int, method PaymentMethod) error
    // ... العديد من الطرق
}

// واجهة قاعدة البيانات - تجريد عالي المستوى
type DB interface {
    Query(ctx context.Context, query string, args ...interface{}) (Rows, error)
    Exec(ctx context.Context, query string, args ...interface{}) (Result, error)
    BeginTx(ctx context.Context) (Tx, error)
}

// المستودع يعتمد على التجريد
type UserRepository struct {
    db DB
}

func NewUserRepository(db DB) *UserRepository {
    return &UserRepository{db: db}
}

func (r *UserRepository) FindByID(ctx context.Context, id int) (*User, error) {
    query := "SELECT id, name, email FROM users WHERE id = $1"
    rows, err := r.db.Query(ctx, query, id)
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    
    // ... تحليل الصفوف
}

func main() {
    // تهيئة التبعيات البنية التحتية
    db := initDatabase()
    logger := initLogger()
    
    // تهيئة المستودعات
    userRepo := NewUserRepository(db)
    orderRepo := NewOrderRepository(db)
    
    // تهيئة الخدمات مع التبعيات
    emailSvc := NewEmailService(logger)
    paymentSvc := NewPaymentService(logger)
    userSvc := NewUserService(userRepo, logger)
    orderSvc := NewOrderService(orderRepo, emailSvc, logger, paymentSvc)
    
    // تهيئة مُعالجي HTTP
    userHandler := NewUserHandler(userSvc)
    orderHandler := NewOrderHandler(orderSvc)
    
    // توصيل الطرق
    router := setupRouter(userHandler, orderHandler)
    
    // بدء الخادم
    log.Fatal(http.ListenAndServe(":8080", router))
}

go install github.com/google/wire/cmd/wire@latest

// wire.go
//go:build wireinject
// +build wireinject

package main

import "github.com/google/wire"

func InitializeApp() (*App, error) {
    wire.Build(
        NewDB,
        NewUserRepository,
        NewUserService,
        NewUserHandler,
        NewApp,
    )
    return &App{}, nil
}

import "go.uber.org/dig"

func main() {
    container := dig.New()
    
    // تسجيل مزودي التبعيات
    container.Provide(NewDB)
    container.Provide(NewUserRepository)
    container.Provide(NewUserService)
    container.Provide(NewUserHandler)
    
    // استدعاء دالة تحتاج إلى التبعيات
    err := container.Invoke(func(handler *UserHandler) {
        // استخدام المُعالج
    })
    if err != nil {
        log.Fatal(err)
    }
}

// تنفيذ مُحاكي للاختبار
type mockUserRepository struct {
    users map[int]*User
    err   error
}

func (m *mockUserRepository) FindByID(id int) (*User, error) {
    if m.err != nil {
        return nil, m.err
    }
    return m.users[id], nil
}

func (m *mockUserRepository) Save(user *User) error {
    if m.err != nil {
        return m.err
    }
    m.users[user.ID] = user
    return nil
}

// اختبار باستخدام المُحاكي
func TestUserService_GetUser(t *testing.T) {
    mockRepo := &mockUserRepository{
        users: map[int]*User{
            1: {ID: 1, Name: "John", Email: "john@example.com"},
        },
    }
    
    service := NewUserService(mockRepo)
    
    user, err := service.GetUser(1)
    assert.NoError(t, err)
    assert.Equal(t, "John", user.Name)
}

// جيد: العميل يحتاج فقط لقراءة المستخدمين
type UserReader interface {
    FindByID(id int) (*User, error)
    FindByEmail(email string) (*User, error)
}

// واجهة منفصلة للكتابة
type UserWriter interface {
    Save(user *User) error
    Delete(id int) error
}

func NewUserService(repo UserRepository) (*UserService, error) {
    if repo == nil {
        return nil, errors.New("مستودع المستخدم لا يمكن أن يكون فارغًا")
    }
    return &UserService{repo: repo}, nil
}

type ctxKey string

const dbKey ctxKey = "db"

func WithDB(ctx context.Context, db DB) context.Context {
    return context.WithValue(ctx, dbKey, db)
}

func DBFromContext(ctx context.Context) (DB, bool) {
    db, ok := ctx.Value(dbKey).(DB)
    return db, ok
}

// جيد: المساعد الداخلي لا يحتاج حقن
type UserService struct {
    repo UserRepository
    // التخزين المؤقت الداخلي - لا يحتاج حقن
    cache map[int]*User
}

func NewUserService(repo UserRepository) *UserService {
    return &UserService{
        repo:  repo,
        cache: make(map[int]*User),
    }
}

// UserService يتعامل مع منطق العمل المرتبط بالمستخدمين.
// يحتاج إلى UserRepository للوصول إلى البيانات وLogger لل
// تتبع الأخطاء. يجب أن يكون المستودع آمنًا في السياقات المتزامنة.
func NewUserService(repo UserRepository, logger Logger) *UserService {
    // ...
}

// كائن بسيط - لا حاجة لحقن التبعيات
type Point struct {
    X, Y float64
}

func NewPoint(x, y float64) Point {
    return Point{X: x, Y: y}
}

// أداة بسيطة - لا حاجة لحقن التبعيات
func FormatCurrency(amount float64) string {
    return fmt.Sprintf("$%.2f", amount)
}

type PDFGenerator interface {
    GenerateReport(data ReportData) ([]byte, error)
}

type ReportService struct {
    pdfGen PDFGenerator
    repo   ReportRepository
}

func NewReportService(pdfGen PDFGenerator, repo ReportRepository) *ReportService {
    return &ReportService{
        pdfGen: pdfGen,
        repo:   repo,
    }
}