Go est un langage de programmation open source développé par Google et conçu pour aider à construire des systèmes logiciels simples et fiables. La force principale de Go réside dans ses mécanismes de concurrence qui simplifient l’écriture de logiciels et l’exploitation d’architectures multicœurs..

C'est un langage compilé, fortement typé statiquement, simultané et non ordonné..

C'est une langue moderne très intéressante en raison de certains des choix qui ont été faits lors de sa conception. Par exemple, le système de types, bien que Go possède des méthodes et également un style de programmation OO, il n’existe pas de hiérarchie de types. Le seul moyen d'y parvenir est d'utiliser des interfaces.

Comment aller diffère des autres

Il convient de lire la spécification du langage pour mieux comprendre les éléments de conception du langage. C'est très concis et permet de faire ressortir des détails vraiment intéressants. Go se distingue des autres langages de programmation classiques par le fait qu’il présente des fonctionnalités différentes de celles des autres langages OO:

• Pas d'héritage de type
• Pas de surcharge des méthodes et des opérateurs
• Des primitives de concurrence intégrées, qui le distinguent vraiment des autres. Il partage la mémoire en communiquant et non l'inverse.
• Une chaîne d'outils qui utilise un modèle traditionnel de compilation et de liaison pour générer des fichiers binaires sans dépendances externes.
• Les cartes sont intégrées.

Organisation du code

Le code Go est conservé sous les espaces de travail. C'est juste une hiérarchie de répertoires, comme suit:

• src - contient les fichiers source Go sous forme de packages
• pkg - contient des objets de package
• poubelle - contient des exécutables

L’outil Aller construit les packages source et installe les fichiers binaires résultants dans poubelle et pkg des annuaires.

Une application Web simple utilisant Go

Construisons un site statique, puis l’améliorons afin qu’il se comporte beaucoup plus dynamiquement, en fonction des entrées de l’utilisateur..

Le site statique

La structure de code pour le site statique ressemble à ceci:

Donc, vous voudriez essentiellement créer une structure similaire à l’image ci-dessus ou telle que présentée dans le référentiel. Cette structure de pension se situerait elle-même sous le espace de travail . Lisez à propos de la structure de code Go pour plus d'informations.

Maintenant, ce que nous voulons faire est de servir un fichier HTML résidant dans le répertoire public.

le index.html le contenu est comme suit:

       
Développer un site web avec Go
 
Je suis une page statique, étant servie à vous avec l'aide de Go lang.
   

Et voici le programme Go pour servir les fichiers de manière statique à partir du dossier public:

package main import ("net / http") func main () fs: = http.FileServer (http.Dir ("public")) http.ListenAndServe (": 8080", fs)

Permettez-moi de vous expliquer:

• net / http - ce paquet fournit les implémentations client et serveur HTTP.
• FileServer - cette fonction renvoie un gestionnaire qui sert les requêtes HTTP avec le contenu du système de fichiers.

C'est tout. Vraiment simple et au point. Vous pouvez exécuter le code en utilisant les éléments suivants: aller courir gostatic.go.

Une meilleure solution

Cependant, cette solution ne sépare pas clairement les problèmes d'acheminement et de desserte et, par conséquent, une meilleure solution consisterait en:

package main import ("net / http" "log") func main () fs: = http.FileServer (http.Dir ("public")) http.Handle ("/", fs) log.Println ("Écoute … ") Err: = http.ListenAndServe (": 8080 ", nil) si err! = Nil log.Fatal (" ListenAndServe: ", err) 

ListenAndServe démarre un serveur HTTP sur l'adresse TCP donnée, puis appelle Serve avec un gestionnaire. Ce gestionnaire est généralement nul, de sorte que le routeur par défaut (dans le cas de Go, le DefaultServerMux peut prendre la relève).

Maintenant en ce qui concerne DefaultServeMux - Faisons un petit détour pour comprendre comment Go traite le traitement HTTP. Il le fait avec l'aide de deux choses principales.

• ServerMuxes - (Routeur) C'est un multiplexeur - essentiellement un routeur HTTP, qui compare les demandes entrantes à la liste définie et appelle ensuite le gestionnaire associé..
• Manutentionnaires - Ceux-ci sont responsables de la gestion de la requête, comme de répondre avec les en-têtes, corps, etc. appropriés. Tout objet obéissant à l'interface Handler peut agir de la sorte..

Allez de l'avant et exécutez l'exemple d'application Web comme vous l'avez fait précédemment. Vous devriez voir le résultat!

Sites dynamiques - Ajout d'un horodatage à chaque actualisation

Ensuite, écrivons l’application pour qu’elle imprime l’heure actuelle, ce qui implique qu’à chaque actualisation, vous obtenez une sortie différente. Le code Go ressemblerait à ceci:

package main import ("fmt" "net / http" "heure") func main () http.HandleFunc ("/", gestionnaire) log.Println ("listening ...") err: = http.ListenAndServe (": 8080) ", nil) if err! = nil panic (err) gestionnaire func (w http.ResponseWriter, r * http.Request) fmt.Fprintf (w," Bonjour. L'heure est la suivante: "+ heure.Maintenant (maintenant ) .Format (heure.RFC850)) 

Ici nous avons importé fmt travailler avec certaines fonctions d'impression. Le fmt implémente des fonctions d’E / S formatées le long des lignes de C stdio bibliothèque.

Nous avons également utilisé HandleFunc qui enregistre le chemin d’URL avec la fonction de gestionnaire dans le DefaultServeMux. Le gestionnaire de fonctions est du type http.HandlerFunc. Il faut un http.ResponseWriter et http.Request comme ses arguments. Les personnes familières avec les servlets Java se rappelleraient de l'avoir fait.!

Pour imprimer l'heure, nous importons 'heure' à partir du paquet standard et nous l'utilisons pour répondre en retour à l'objet auteur de la réponse. En écrivant à http.ResponseWriter objet, nous pouvons envoyer la réponse au client.

http.Request est la structure qui représente la requête HTTP et a donc toutes les données de la requête. Pour accéder au chemin de l'URL que nous faisons r.URL.path.

Lorsque vous exécutez ceci puis accédez à localhost: 8080 vous devriez voir l'heure actuelle à chaque rafraîchissement.

Accepter la saisie de l'utilisateur

Maintenant, écrivons une application qui accepte un Nom d'utilisateur sur la page d'index, puis lorsque le formulaire est soumis, il salue l'utilisateur sur la page suivante.

Voici notre structure de code Go:

Permet de créer d’abord un fichier HTML contenant le formulaire dans le répertoire public.

       
Go Greeter
 
   
   

Ce formulaire, lors de l'envoi, sera redirigé vers /saluer. Écrivons aussi le contenu de la greet.html fichier à l'intérieur du répertoire public, que nous rendrions lorsque la demande arrive /saluer.

       
Bonjour .
   

Le code Go est le suivant:

package principal d'importation ("log" "net / http" "html / template") func main () http.HandleFunc ("/", racine) http.HandleFunc ("/ greet", greeter) log.Println ("Écoute … ") Err: = http.ListenAndServe (": 8080 ", nil) si err! = Nil log.Fatal (" ListenAndServe: ", err) func root (w http.ResponseWriter, r * http.Request) t, _: = template.ParseFiles ("public / index.html") t.Execute (w, nil) func greeter (w http.ResponseWriter, r * http.Request) username: = r.FormValue (" nom d'utilisateur ") t, _: = template.ParseFiles (" public / greeter.html ") err: = t.Execute (w, nom d'utilisateur) si err! = nil http.Error (w, err.Error (), http .StatusInternalServerError) 

Nous avons utilisé html / template conserver le code HTML dans les modèles et les utiliser ensuite pour rendre, sur demande.

Il y a un regard curieux . dans le greeter.html fichier. le html / template package suppose que le texte brut est toujours produit. Il ajoute l'échappement si nécessaire pour intégrer en toute sécurité cette chaîne simple dans un contexte correct. Lorsqu'une valeur de données n'est pas du texte brut, nous pouvons nous assurer qu'elle ne soit pas échappée en spécifiant son type. Donc essentiellement, Hey, .! peut être invoqué en utilisant tmpl.Execute (out, HTML ('Nishant')) produire Hey, Nishant!. Allez-y, essayez ça!

Puisque l'application de base fonctionne maintenant, nous pouvons enfin la déployer sur Heroku..

Déploiement à Heroku

Une fois que vous avez le heroku-toolbelt correctement configuré et le repo géré via Git, nous pouvons le déployer dans ce sens.

Le seul changement que nous aurions à faire dans le code de déploiement pour Heroku est de changer la ligne où écoute sur un port spécifique.

Changement:

 http.ListenAndServe (": 8080",…) 

à:

http.ListenAndServe (":" + os.Getenv ("PORT"),… .

Configuration de Heroku

Pour pouvoir vous déployer sur Heroku, vous aurez besoin d’un compte utilisateur Heroku. Vous aurez également besoin d'un client en ligne de commande Heroku. Obtenez-le en installant le Heroku Toolbelt si ce n'est déjà fait.

Une fois installé, connectez-vous en utilisant le compte Heroku en disant connexion heroku, puis téléchargez votre clé SSH. Avec ces choses en place, vous devriez être prêt à être déployé à Heroku..

Déploiement de l'application

Pour pouvoir être déployé sur Heroku, l'application doit être stockée dans Git..

git init. ajouter git -A. git commit -m 'première application heroku' 

Nous aurons également besoin d'un fichier Procfile pour indiquer à Heroku que la commande dont il a besoin pour exécuter le processus Web est notre application..

echo 'web: gogreeter'> Procfile

Les dépendances de paquets Go sont gérées sur Heroku à l'aide de Godep paquets.

Installez Godep et enregistrez vos dépendances en utilisant les éléments suivants:

allez chercher github.com/kr/godep godep save 

Ajoutez ces nouveaux fichiers à Git:

ajouter git -A. git commit -m 'godep' 

Enfin, créez l'application Heroku. Cela peut être fait comme ça:

heroku create -b https://github.com/kr/heroku-buildpack-go.git 

Cela devrait créer une télécommande Git dans votre référentiel sous le nom de Heroku. Vous êtes prêt à déployer maintenant! Exécutez ce qui suit:

git push maître heroku

Une fois la commande ci-dessus terminée, votre application devrait être opérationnelle.!

Allez visiter l'URL en disant heroku ouvert ou en visitant directement l'URL de l'application que vous voyez dans la console.

C'est tout. Vous avez maintenant une application Go opérationnelle sur Heroku!

Résumé

Dans ce tutoriel, nous avons appris à quel point il est facile de développer une application Web Go et de la déployer également sur Heroku. De nos jours, le développement Web dépend en grande partie des cadres utilisés. Pour explorer certaines de ces options, vous devez absolument vérifier certains de ces projets..

• Hugo
• Martini
• Se délecter
• Gorilla web toolkit
• Hastie - Générateur de site statique à Go