Maison > Article > développement back-end > Comment écrire des API comme un pro en Go avec GopherLight
GopherLIght
Hé les amis, je voudrais d'abord vous remercier d'avoir choisi d'utiliser notre projet. Même s'il est petit, nous l'avons fait avec beaucoup d'enthousiasme ! Pour commencer à l'utiliser, vous devez d'abord avoir installé Go, supposons que vous l'ayez déjà. Installez ensuite les modules principaux du framework, qui sont req et router
go get github.com/BrunoCiccarino/GopherLight/router go get github.com/BrunoCiccarino/GopherLight/req
Déjà téléchargé ? Ouf ! Nous pouvons maintenant créer notre premier bonjour monde.
package main import ( "fmt" "github.com/BrunoCiccarino/GopherLight/router" "github.com/BrunoCiccarino/GopherLight/req" ) func main() { app := router.NewApp() // Define a route that responds to a GET request at "/hello". app.Get("/hello", func(r *req.Request, w *req.Response) { w.Send("Hello, World!") }) fmt.Println("Server listening on port 3333") app.Listen(":3333") }
Assez simple, non ? Et nous pouvons faire bien plus avec GopherLight. Continuez à lire pour une description complète des méthodes HTTP et de nos outils de requête et de réponse.
Méthodes HTTP prises en charge
Voici la liste des méthodes HTTP que vous pouvez utiliser avec router.App. Chacun d’eux vous permet de configurer des itinéraires pour gérer différents types de demandes. Allons-y !
Récupère les données sans rien modifier.
Exemple : récupérer une liste d'éléments ou lire les détails de l'utilisateur.
Envoie des données pour créer une nouvelle ressource.
Exemple : Soumettre un formulaire ou ajouter un nouvel élément à une liste.
Utilisation : app.Put(chemin, gestionnaire)
Mise à jour ou remplace une ressource. C'est une action « écraser ».
Exemple : mise à jour d'un profil utilisateur complet.
Utilisation : app.Delete(chemin, gestionnaire)
Supprime une ressource.
Exemple : Supprimer un utilisateur ou supprimer une publication.
Utilisation : app.Patch(chemin, gestionnaire)
Mise à jour partiellement une ressource sans tout remplacer.
Exemple : Mettre à jour uniquement l'e-mail sur un profil utilisateur.
Utilisation : app.Options(chemin, gestionnaire)
Renvoie les méthodes HTTP autorisées pour une URL, principalement pour les requêtes de contrôle en amont CORS.
Utilisation : app.Head(chemin, gestionnaire)
Comme GET, mais pas de corps de réponse. Utilisez-le pour vérifier si une ressource existe.
Utilisation : app.Connect(chemin, gestionnaire), app.Trace(chemin, gestionnaire)
Méthodes avancées : CONNECT configure un tunnel (pour SSL) et TRACE sert au débogage, en renvoyant la requête.
Maintenant que vous avez vu les itinéraires, parlons des objets Request et Response, vos assistants incontournables pour gérer les demandes entrantes et envoyer des réponses.
Chaque gestionnaire de requêtes reçoit un objet Request chargé d'informations sur la requête entrante. Voici ce que vous pouvez en faire :
go get github.com/BrunoCiccarino/GopherLight/router go get github.com/BrunoCiccarino/GopherLight/req
L'objet Response vous aide à renvoyer une réponse au client. Voici ce que vous pouvez faire :
package main import ( "fmt" "github.com/BrunoCiccarino/GopherLight/router" "github.com/BrunoCiccarino/GopherLight/req" ) func main() { app := router.NewApp() // Define a route that responds to a GET request at "/hello". app.Get("/hello", func(r *req.Request, w *req.Response) { w.Send("Hello, World!") }) fmt.Println("Server listening on port 3333") app.Listen(":3333") }
Nous avons un lot de middlewares prêts à vous permettre d'ajouter des fonctionnalités sérieuses à votre application Web Go. Chacun de ces middlewares apporte sa propre magie : sécurité, journalisation, délais d'attente et bien plus encore ! Décomposons-les un par un. ?
Notre AuthMiddleware vous aide à protéger vos itinéraires avec les jetons Web JSON (JWT). Il est flexible et vous permet de personnaliser la clé secrète, la gestion des erreurs et la méthode d'extraction des jetons.
Configuration
Pour commencer, configurez vos paramètres JWT à l'aide de JWTConfig :
app.Get("/greet", func(r *req.Request, w *req.Response) { name := r.QueryParam("name") if name == "" { name = "stranger" } w.Send("Hello, " + name + "!") })
Besoin d'autoriser les requêtes d'origine croisée ? Aucun problème! Notre CORSMiddleware configure les paramètres de partage de ressources Cross-Origin (CORS) pour rendre votre API accessible depuis d'autres domaines.
Options de configuration
app.Get("/user", func(r *req.Request, w *req.Response) { user := map[string]string{"name": "Gopher", "language": "Go"} w.JSON(user) })
Notre CSRFMiddleware protège contre la falsification de requêtes intersites en validant un jeton CSRF envoyé avec chaque requête. Utilisez GenerateCSRFToken() pour créer un jeton sécurisé, puis validez-le avec votre propre fonction isValidToken.
import ( "github.com/BrunoCiccarino/GopherLight/middleware" ) config := middleware.JWTConfig{ SecretKey: []byte("your_secret_key"), } app.Use(middleware.NewAuthMiddleware(config))
Et n'oubliez pas de générer des jetons avec :
go get github.com/BrunoCiccarino/GopherLight/router go get github.com/BrunoCiccarino/GopherLight/req
Vous voulez suivre ce qui se passe sur votre serveur ? LoggingMiddleware enregistre chaque requête, y compris la méthode, le chemin et le temps nécessaire. C'est un excellent moyen de rester informé des performances de l'application et de toute activité inhabituelle.
package main import ( "fmt" "github.com/BrunoCiccarino/GopherLight/router" "github.com/BrunoCiccarino/GopherLight/req" ) func main() { app := router.NewApp() // Define a route that responds to a GET request at "/hello". app.Get("/hello", func(r *req.Request, w *req.Response) { w.Send("Hello, World!") }) fmt.Println("Server listening on port 3333") app.Listen(":3333") }
Chaque demande sera enregistrée comme ceci :
Évitez ces attentes interminables en fixant des délais de traitement des demandes avec TimeoutMiddleware. Ce middleware annulera la demande si elle ne se termine pas à temps, envoyant un statut 504 Gateway Timeout au client.
app.Get("/greet", func(r *req.Request, w *req.Response) { name := r.QueryParam("name") if name == "" { name = "stranger" } w.Send("Hello, " + name + "!") })
L'interface du plugin est super simple mais super puissante. Il vous propose une seule méthode : vous inscrire. Cela vous permet de vous connecter au système de routage de l'application pour ajouter tous les itinéraires dont vous avez besoin, qu'il s'agisse d'un nouveau point de terminaison d'API, d'un webhook ou de tout ce que vous pouvez imaginer.
La méthode d'enregistrement
Voici la partie magique de l’interface du plugin :
app.Get("/user", func(r *req.Request, w *req.Response) { user := map[string]string{"name": "Gopher", "language": "Go"} w.JSON(user) })
La méthode Register accepte une fonction de route qui vous permet de définir de nouvelles routes dans votre plugin en spécifiant :
Disons que vous souhaitez créer un plugin qui ajoute un simple point de terminaison à /hello-plugin pour saluer les utilisateurs. Voici à quoi ressemblerait le plugin :
import ( "github.com/BrunoCiccarino/GopherLight/middleware" ) config := middleware.JWTConfig{ SecretKey: []byte("your_secret_key"), } app.Use(middleware.NewAuthMiddleware(config))
Pour charger un plugin, créez simplement une instance et appelez Register dans la configuration principale de votre application :
corsOptions := middleware.CORSOptions{ AllowOrigin: "*", AllowMethods: []string{"GET", "POST"}, } app.Use(middleware.CORSMiddleware(corsOptions))
Chaque plugin peut ajouter autant de routes que nécessaire. Appelez simplement route plusieurs fois dans votre fonction Register pour définir des points de terminaison supplémentaires. Utilisez différentes méthodes, chemins et gestionnaires HTTP pour façonner les fonctionnalités de votre plugin comme vous le souhaitez.
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!