Installation et premiers pas sur Beego (Partie 1)

Beego est un framework écrit en Go (diminutif de Golang). Il permet de coder des sites Internet (tout comme Django sur Python, Ruby On Rails sur Ruby, etc…). Dans cette première partie, on va voir comment installer Go et Beego sur une machine Windows, disséquer rapidement le framework, créer une nouvelle page, transférer des données du contrôleur à la vue et mettre en place un formulaire.

Installation de Golang

Dans un premier temps, si vous n'avez pas encore installé Go sur votre machine, allez sur la page de téléchargement : https://golang.org/dl, téléchargez puis installez Golang.
Tapez dans votre console go version.

Puis, dans un second temps, il crééz un dossier qui va recueillir les fichiers sources du framework Beego mais aussi les autres projets sur Golang.
Pour ce faire, allez à la racine de votre disque dur et créez le dossier "gopath".
Créez une nouvelle variable d'environnement que vous nommez "GOPATH" puis dans "Valeur" copier-coller le chemin de votre répertoire "gopath" et validez.

Si vous faites Windows + R et que vous tapez "%gopath%" vous accédez bien à votre répertoire.

Astuce : dans la console Windows, tapez go env.

Téléchargement de Beego

Ouvrez une console Windows et tapez la ligne de commande suivante :
go get github.com/astaxie/beego

Info : avec la commande go get, les fichiers sont téléchargés et placés dans le dossier "%gopath%/src/github.com/astaxie/beego".

NB : Le logiciel Git doit être installé sur votre ordinateur. Si "go get" contient une URL avec "code.google.com/[…]" vous aurez besoin du logiciel Mercurial.

Installation de l'outil "bee tool"

Dans votre dossier "%gopath%", créez un répertoire "bin". Dans la console Windows tapez :
go get github.com/beego/bee

Recréez une variable d'environnement, mais cette fois, à la suite de la variable "Path" :
;%GOPATH%/bin/

Ouvrez une nouvelle console Windows en mode administrateur et tapez "bee".

Création d'un nouveau projet

On va maintenant pouvoir passer aux choses sérieuses. Toujours dans la fenêtre de console en mode administrateur, changez de répertoire :
cd %gopath%/src
bee new myapp

Cela va générer le projet "myapp" dans "%gopath%/src/myapp".

On peut alors lancer le serveur en se plaçant d'abord dans le répertoire de notre application :
cd myapp

Puis, on exécute notre application :
bee run

Cette commande va compiler un exécutable "myapp.exe" qui n'est autre que le serveur Web sur le port 8080 par défaut. Lorsque vous modifierez un fichier de votre projet avec l'extension go, le serveur redémarra automatiquement pour ainsi, recompiler votre application.
Vous pouvez désormais ouvrir votre navigateur Web préféré sur l'adresse locale : http://localhost:8080

Attention : si vous avez un serveur Web traditionnel (Apache, Nginx, IIS, etc...) en cours d'exécution, le port 8080 peut rentrer en conflit. Si ce dernier vous handicape, vous pouvez le changer dans le fichier "conf/app.conf". Editez la valeur contenue dans la variable intitulée "httport" (ligne 2). Vous devez alors relancer votre serveur pour prendre en compte cette modification.

Architecture MVC de l'application

Comment ça marche ?


Comme sur un MVC classique. Le routeur appelle le contrôleur qui à son tour affiche la vue.

Le contrôleur ("controllers/defaut.go") :

package controllers

import (
    "github.com/astaxie/beego"
)

type MainController struct {
    beego.Controller
}

func (this *MainController) Get() {
    this.Data["Website"] = "beego.me"
    this.Data["Email"]   = "astaxie@gmail.com"
    this.TplNames = "index.tpl"
}

La vue (views/index.tpl) :

<h1>Welcome to Beego!</h1>
<p class="description">
    Beego is a simple & powerful Go web framework which is inspired by tornado and sinatra.
<br />
    Official website: <a href="http://{{.Website}}">{{.Website}}</a>
<br />
    Contact me: {{.Email}}
</p>

Beego utilise le moteur de templating natif de Go ("html/template"). Bien entendu, vous pouvez le changer par un autre.

Les données sont bien transmises du contrôleur vers la vue et la page est accessible grâce à la table de routage contenue dans la fonction "init" du fichier de routage par défaut "routers/router.go" :

package routers

import (
    "someone/controllers"
    "github.com/astaxie/beego"
)

func init() {
    beego.Router("/", &controllers.MainController{})
}

La fonction de base du contrôleur appelée par le fichier de routage par défaut est "Get()" (contrairement à "Index()" dans de nombreux frameworks en PHP).

Créons notre première page.

Dans le dossier "controllers" créez un nouveau contrôleur "test.go". A l'intérieur, on reprend le même en-tête que le contrôleur "defaut.go", c'est-à-dire :

package controllers

import (
    "github.com/astaxie/beego"
)

Puis on déclare notre contrôleur en lui attribuant un nom :

type TestController struct {
    beego.Controller
}

Ensuite, on déclare nos variables ainsi que le template que l'on désire charger :

func (this *TestController) About() {
    this.Data["title"]   = "About"
    this.Data["content"] = "Lorem Ipsum"

    this.TplNames = "test/about.tpl"
}

Attention : bien mettre des doubles quotes et non des simples quotes (mauvais réflexe de développeur PHP... et sur Golang, c'est le Mal !).

Dans "routers/router.go" (dans la fonction "init"), à la suite du code actuel, rajoutez cette route :

beego.Router("/about", &controllers.TestController{}, "get:About")

Explications :
En 1er paramètre, on indique l'URI (Uniform Resource Identifier) de notre application ("/about").
En 2nd paramètre, on indique le contrôleur ("TestController").
En 3ème paramètre, on indique la fonction de notre contrôleur concernée ("About").
Bee re-compile comme un grand et relance le serveur.

Si vous vous rendez sur la page dédiée (http://localhost:8080/about), vous aurez droit au message classique :
someone:can't find templatefile in the path:test/about.tpl

En effet, Beego nous signale que le fichier template appelé dans le contrôleur "Test" n'existe pas. Pour régler cela, dans le dossier "views", créez un nouveau dossier "test" puis un nouveau fichier template "about.tpl" :

<h1>{{.title}}</h1>
<p>{{.content}}</p>

Les routes dynamiques

On veut créer une URL du type : http://localhost:8080/author/robert
Dans le contrôleur "test.go", ajoutez la fonction ci-dessous :

func (this *TestController) Author() {
    this.Data["title"] = this.Ctx.Input.Param(":name")

    this.TplNames = "test/about.tpl"
}

Et dans le fichier de routage ("routers/routes.go"), ajoutez la route suivante :

beego.Router("/author/:name", &controllers.TestController{}, "get:Author")

http://localhost:8080/author/robert est accessible.

Formulaire

Allons plus loin avec les formulaires. Après la déclaration de notre contrôleur "test.go", mettez en place la structure suivante :

type user struct {
    Id      int     `form:"-"`
    Name  string    `form:"username"`
    Email string    `form:"email,email"`
}

Puis, créez une nouvelle fonction dans le contrôleur :

func (this *TestController) User() {
    this.Data["Form"] = &user{}
    this.TplNames     = "test/add_user.tpl"
}

Dans le répertoire "views/test", créez un nouveau fichier template que vous nommez "add_user.tpl".

<form id="user" action="" method="POST">
    {{.Form | renderform}}
</form>

Ensuite, dans le fichier route :

beego.Router("/user", &controllers.TestController{}, "get:User")

En vous rendant sur la page du formulaire, http://localhost:8080/user, Beego a créé automatiquement un formulaire à partir des 2 champs renseignés dans la structure "user" de notre contrôleur "Test".

Sauf qu'il manque quelque chose sur ce formulaire… Avant la fin de la balise de fermeture du formulaire (</form>), ajoutez le bouton de soumission des données :

<br />
<input type="submit" value="Envoyer" />

On va afficher le résultat dans une autre vue ("test/result_user.tpl") :

<h1>{{.username}}</h1>
<h2>{{.email}}</h2>

Ces variables mentionnées ci-dessus, ont besoin d'être définies dans le contrôleur. Ce sont les variables récupérées depuis notre formulaire. A la suite dans notre fonction "User", ajoutez la condition suivante :

    if this.Ctx.Input.Method() == "POST" {

        this.Data["username"] = this.Input().Get("username")
        this.Data["email"]    = this.Input().Get("email")

        this.TplNames = "test/result_user.tpl"
    }

Et là, vous vous dites que le formulaire à l'adresse http://localhost:8080/user… marche sauf que lors de l'envoi des données une erreur de type 404 apparait.

Allez dans votre fichier de routage et spécifiez que vous désirez à la fois du GET et du POST comme type de requêtes HTTP sur la page "/user". Remplacez donc :

beego.Router("/user", &controllers.TestController{}, "get:User")

Par :

beego.Router("/user", &controllers.TestController{}, "get,post:User")

Désormais, le formulaire peut envoyer des données via POST.

En ce qui concerne le parsage automatique du formulaire, rapide à déployer, hélas, ce dernier est assez limité car il ne propose pas d'inclure de label et il n'est pas possible d'ajouter un id ou une classe pour chaque champ d'un formulaire (input et textarea).

Upgrade du framework

Avant de terminer cet article, j'ai mis à jour Beego (de la version 1.4.1 vers 1.4.2) en tapant simplement la commande ci-dessous :
go get –u github.com/astaxie/beego

Conclusion

Beego est un framework Web qui permet de se mettre doucement au Golang, même si il est recommandé de connaitre les bases du langage au préalable. Conçu par des ingénieurs de chez Google, il fait beaucoup parler de lui en ce moment, principalement dans les benchmarks.

Sources