Importez le package net / http et définissez la fonction de traitement, utilisez http.handlefunc pour enregistrer le processeur du chemin racine, puis appelez http.ListenandServe (": 8080", nil) pour démarrer le serveur; 2. Enregistrez les processeurs indépendants pour différents chemins tels que "/ à propos" via http.handlefunc pour atteindre le multi-roulement; 3. Utilisez http.fileServer pour combiner http.stripprefix et http.handle pour donner accès aux fichiers du répertoire statique / via le / statique / chemin, et définissez éventuellement le maintien d'accueil pour revenir à la page principale; 4. Utilisez HTTP.NewServermux pour créer un multiplexeur de routeur et utilisez des instances HTTP.Server personnalisées pour obtenir des capacités de contr?le de configuration avancées telles que Timeout et TLS; En résumé, un serveur Web léger avec routage, des services de fichiers statiques et une configuration extensible peuvent être construits via la bibliothèque standard GO Bibliothèque NET / HTTP, qui convient à l'apprentissage et aux applications simples, sans avoir besoin de frameworks tiers.

La construction d'un serveur Web simple à Golang est simple grace au package net/http , qui fait partie de la bibliothèque standard de Go. Vous n'avez pas besoin de dépendances externes pour les fonctionnalités de base. Voici comment le faire étape par étape.

? 1. Configurez un serveur HTTP de base

Commencez par importer les packages requis et définissant une fonction de gestionnaire:

 package principal

importer (
    "FMT"
    "net / http"
)

func hellohandler (w http.ResponseWriter, r * http.request) {
    fmt.fprintf (w, "Bonjour, monde! Ceci est un serveur Web simple Go.")
}

func main () {
    http.handlefunc ("/", bonjourhandler)
    fmt.println ("Server à partir de: 8080 ...")
    http.ListenandServe (": 8080", nil)
}

Ce que cela fait:

• http.HandleFunc("/", helloHandler) enregistre la fonction helloHandler pour gérer les demandes du chemin racine / .
• http.ListenAndServe(":8080", nil) démarre le serveur sur le port 8080.
• Le helloHandler écrit une réponse simple au client.

Exécutez-le avec:

 aller courir main.go

Visitez ensuite http://localhost:8080 dans votre navigateur.

? 2. Ajouter plusieurs itinéraires

Vous pouvez définir différents gestionnaires pour différents chemins:

 func abouthandler (w http.ResponseWriter, r * http.request) {
    fmt.fprintf (w, "à propos de la page - Construit avec Go!")
}

func main () {
    http.handlefunc ("/", bonjourhandler)
    http.handlefunc ("/ about", abouthandler)

    fmt.println ("Server en cours d'exécution sur http: // localhost: 8080")
    http.ListenandServe (": 8080", nil)
}

Maintenant:

• GET / → "Bonjour, monde!"
• GET /about → "à propos de la page - Construit avec Go!"

? 3. Servir les fichiers statiques (comme HTML, CSS, JS)

Supposons que vous ayez un dossier static/ avec un fichier index.html .

 func main () {
    fs: = http.fileServer (http.dir ("statique /"))
    http.handle ("/ static /", http.stripprefix ("/ static /", fs)))

    http.handlefunc ("/", HomeHandler) // Facultatif: rendre la page d'accueil

    fmt.println ("serveur sur: 8080")
    http.ListenandServe (": 8080", nil)
}

Avec ceci:

• Les fichiers en static/ sont servis sous /static/...
• Par exemple, static/index.html → accessible à http://localhost:8080/static/index.html

Et votre homeHandler pourrait être:

 Func HomeHandler (W Http.ResponseWriter, R * http.Request) {
    http.servefile (w, r, "static / index.html")
}

? 4. Utilisez un serveur personnalisé pour un meilleur contr?le

Au lieu de http.ListenAndServe , utilisez http.Server pour les délais d'attente et les fermetures gracieuses:

 func main () {
    MUX: = http.newServermux ()
    MUX.HANDLEFUNC ("/", HelloHandler)
    Mux.Handlefunc ("/ About", Abouthandler)

    serveur: = & http.server {
        Addr: ": 8080",
        Handler: Mux,
    }

    fmt.println ("Serveur à démarrer: 8080")
    Si err: = server.ListenandServe (); err! = Nil {
        FMT.PRINTF ("Echec du serveur:% V \ n", ERR)
    }
}

Cela vous donne plus de contr?le sur la configuration (comme les délais d'expiration, TLS, etc.).

Conseils et meilleures pratiques

• Validez toujours l'entrée dans les applications réelles (en-têtes, paramètres de requête, corps).
• évitez nil HANDER dans ListenAndServe si vous utilisez un ServeMux personnalisé.
• Pour la production, envisagez d'utiliser des routeurs comme gorilla/mux ou chi , mais pour l'apprentissage ou les API simples, net/http est parfait.
• Gérer correctement les erreurs (par exemple, fichier non trouvé, mauvaises demandes).

C'est tout - vous avez construit un serveur Web fonctionnel dans Go avec le routage et la prise en charge des fichiers statiques. Il est minime, rapide et n'a pas besoin d'un cadre.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!