DotWeb est un micro-framework web léger pour le langage Go, conçu pour faciliter et accélérer le développement d'applications web et d'API. Il se distingue par son architecture intuitive, ses performances élevées et son ensemble complet de fonctionnalités intégrées, telles que le routage, les middlewares, la gestion des sessions et la journalisation.

Installation et initialisation

Pour intégrer DotWeb à votre projet, assurez-vous d'utiliser Go 1.24 ou une version ultérieure avec le support des Go Modules. L'installation s'effectue via la commande suivante :

go get github.com/devfeel/dotweb

Voici comment initialiser un serveur web basique. Nous allons configurer un point d'entrée simple qui répond aux requêtes HTTP.

package main

import (
    "log"
    "github.com/devfeel/dotweb"
)

func main() {
    // Création de l'instance principale
    server := dotweb.New()
    
    // Configuration du répertoire des logs
    server.SetLogPath("./app_logs")
    
    // Définition d'une route fondamentale
    server.HttpServer.GET("/api/status", func(c dotweb.Context) error {
        return c.WriteString("Service opérationnel !")
    })
    
    // Lancement du serveur sur le port 8080
    log.Println("Démarrage du serveur sur le port 8080...")
    if err := server.StartServer(8080); err != nil {
        log.Fatalf("Erreur lors du démarrage : %v", err)
    }
}

Système de routage

Le routeur de DotWeb est optimisé pour la rapidité et prend en charge plusieurs modèles de correspondance d'URL.

Routes statiques et dynamiques

Les routes statiques correspondent à des chemins exacts, tandis que les routes dynamiques capturent des segments d'URL variables.

// Route statique
server.HttpServer.GET("/dashboard", func(c dotweb.Context) error {
    return c.WriteString("Tableau de bord principal")
})

// Route dynamique avec paramètre
server.HttpServer.GET("/items/:itemId", func(c dotweb.Context) error {
    identifier := c.GetRouterName("itemId")
    return c.WriteString("Détails de l'article : " + identifier)
})

Groupement de routes

Pour organiser les endpoints, il est possible de regrouper les routes sous un préfixe commun, ce qui simplifie également l'application de middlewares spécifiques.

apiV1 := server.HttpServer.Group("/api/v1")

apiV1.GET("/metrics", func(c dotweb.Context) error {
    return c.WriteString("Métriques système")
})

apiV1.GET("/health", func(c dotweb.Context) error {
    return c.WriteString("Statut de santé : OK")
})

Middleware et interception des requêtes

Les middlewares permettent d'intercepter le cycle de vie d'une requête. Ils peuvent être appliqués de manière globale, à un groupe de routes ou à une route unique. Voici un exemple de middleware qui calcule le temps de traitement d'une requête :

import "time"

type PerformanceMonitor struct {
    dotweb.BaseMiddlware
}

func (pm *PerformanceMonitor) Handle(c dotweb.Context) error {
    startTime := time.Now()
    
    // Exécution du handler suivant
    err := pm.Next(c)
    
    duration := time.Since(startTime)
    log.Printf("Requête %s traitée en %v", c.Request.RequestURI, duration)
    
    return err
}

// Enregistrement global du middleware
server.Use(&PerformanceMonitor{})

Liaison de données (Data Binding)

DotWeb simplifie l'extraction et la validation des données entrantes en les mappant directement sur des structures Go. Cette fonctionnalité supporte les charges utiles JSON, XML et les formulaires URL.

type ProductPayload struct {
    Title string  `json:"title" form:"title"`
    Price float64 `json:"price" form:"price"`
    Stock int     `json:"stock" form:"stock"`
}

server.HttpServer.POST("/products", func(c dotweb.Context) error {
    var payload ProductPayload
    
    // Liaison automatique des données
    if bindErr := c.Bind(&payload); bindErr != nil {
        return c.WriteJson(map[string]string{"error": bindErr.Error()})
    }
    
    // Traitement et réponse
    return c.WriteJson(map[string]interface{}{
        "message": "Produit créé avec succès",
        "data":    payload,
    })
})

Fonctionnalités avancées

Gestion des sessions

Le framework inclut un gestionnaire de sessions natif. Il peut être configuré pour utiliser un stockage en mémoire pour le développement ou Redis pour les environnements de production distribués.

// Activation des sessions
server.HttpServer.EnabledSession = true

// Configuration pour utiliser Redis
server.HttpServer.SessionConfig.StoreType = "redis"
server.HttpServer.SessionConfig.RedisConfig.Addr = "localhost:6379"
server.HttpServer.SessionConfig.RedisConfig.Password = "secret_password"

Service de fichiers statiques

La distribution de ressources statiques (CSS, JS, images) se configure en une seule ligne, avec la possibilité d'activre l'exploration de répertoires si nécessaire.

// Servir le contenu du dossier 'assets' sous l'URL '/public'
server.HttpServer.Static("/public", "./assets")
server.HttpServer.EnabledListDir = false // Désactivé pour des raisons de sécurité

Optimisation et déploiement

Pour tirer le meilleur parti de DotWeb en production, il est recommandé d'appliquer les configurations suivantes :

• Mode production : Activez le mode production via server.SetProductionMode() pour désactiver les fonctionnalités de débogage et optimiser les performances.
• Compression Gzip : Intégrez le middleware Gzip officiel pour réduire la taille des réponses HTTP et diminuer la latence réseau.
• Journalisation structurée : Ajustez le niveau de log pour éviter les opérations d'écriture disque excessives qui pourraient bloquer les goroutines.
• Limitation des middlewares : N'appliquez que les middlewares strictement nécessaires à chaque route pour minimiser la surcharge du pipeline de requêtes.