Golang Beego bauen

Golang ist eine beliebte Programmiersprache im Bereich der Webentwicklung. Es ist effizient, einfach und zuverlässig und eignet sich sehr gut für die Entwicklung von Webanwendungen mit hohen Anforderungen an Parallelität, Skalierbarkeit und Leistung. Beego ist ein sehr beliebtes MVC-Framework in Golang. Es ist einfach zu starten und bietet eine große Anzahl von Funktionen, die die Entwicklung von Webanwendungen einfacher und effizienter machen.

In diesem Artikel wird hauptsächlich die Verwendung des Golang- und Beego-Frameworks zum Erstellen einer Webanwendung vorgestellt.

1. Golang und Beego installieren

Bevor wir beginnen, müssen wir das Golang- und Beego-Framework installieren. Auf der offiziellen Website von Golang können Sie das Installationspaket von https://golang.org/ herunterladen und entsprechend Ihrem Betriebssystem installieren. Nach Abschluss der Installation müssen wir auch die Umgebungsvariable GOPATH konfigurieren.

In Windows-Systemen kann die Konfiguration von GOPATH durch die folgenden Schritte abgeschlossen werden:

• Erstellen Sie einen neuen Ordner, z. B. goproject, und verwenden Sie ihn als Stammverzeichnis von GOPATH.
• Fügen Sie %GOPATH% zum Pfad hinzu.

In Linux- und Mac-Systemen können Sie den folgenden Befehl zur Datei ~/.bash_profile hinzufügen:

export GOPATH=$HOME/goproject
export PATH=$PATH:$GOPATH/bin

Um Beego zu installieren, verwenden Sie den folgenden Befehl:

$ go get -u github.com/astaxie/beego
$ go get -u github.com/beego/bee

2. Erstellen Sie ein neues Beego-Projekt

Das Erstellen eines neuen Beego-Projekts ist sehr einfach , Sie müssen nur den folgenden Befehl ausführen:

$ bee new myproject

Dieser Befehl erstellt ein Beego-Projekt mit dem Namen „myproject“ und erstellt das entsprechende Verzeichnis unter dem src-Verzeichnis von GOPATH. Als nächstes müssen wir in das Verzeichnis wechseln und den folgenden Befehl ausführen, um die Anwendung zu starten:

$ cd myproject
$ bee run

Öffnen Sie dann die URL http://localhost:8080 im Browser und Sie können Beegos sehen Willkommensseite. Das bedeutet, dass wir erfolgreich eine neue Beego-Anwendung erstellt haben.

3. Controller und Ansichten schreiben

Jetzt können wir damit beginnen, unsere eigenen Controller und Ansichten zu schreiben. In Beego werden Controller zum Verarbeiten von Eingabeanforderungen und zum Generieren von Ausgabeantworten verwendet, und Ansichten werden zum Rendern von Ausgabeantworten verwendet.

Zuerst erstellen wir einen Controller mit dem Namen „mycontroller“ und fügen eine Methode mit dem Namen „index“ hinzu:

Paketcontroller

import (

"github.com/astaxie/beego"

)

type MyController struct {

beego.Controller

}

func (c *MyController ) Get() {

c.Data["Name"] = "Beego"
c.TplName = "index.html"

}

Dann erstellen wir eine Ansichtsdatei mit dem Namen „index.html“:

<title>Welcome to {{.Name}}!</title>

< ;/head>

<h1>Welcome to {{.Name}}!</h1>

Diese Ansichtsdatei verwendet Golangs Vorlagensprache zum Rendern der Ausgabeantwort und setzt den Wert der Variablen Name auf Beego. Jetzt können wir die Anwendung ausführen und die Seite im Browser anzeigen, um zu sehen, ob sie erfolgreich war. Wenn alles gut geht, sollten wir auf der Seite einen Text mit der Überschrift „Willkommen bei Beego!“ sehen können.

4. Mit Datenbank verbinden

Typischerweise müssen Webanwendungen auf eine Datenbank zugreifen, um Daten zu speichern oder Daten aus der Datenbank abzurufen. In Golang können wir viele verschiedene Datenbanktreiber verwenden, um eine Verbindung zu verschiedenen Datenbanktypen herzustellen. In diesem Artikel verwenden wir die MySQL-Datenbank als Beispiel.

Zuerst müssen wir die MySQL-Datenbank installieren und konfigurieren. Nachdem die Installation abgeschlossen ist, müssen wir den folgenden Code zum Code hinzufügen, um eine Verbindung zur Datenbank herzustellen:

package main

import (

"github.com/astaxie/beego"
_ "github.com/go-sql-driver/mysql"

)

func init() {

// Set database information.
mysqluser := beego.AppConfig.String("mysqluser")
mysqlpass := beego.AppConfig.String("mysqlpass")
mysqlurls := beego.AppConfig.String("mysqlurls")
mysqlport := beego.AppConfig.String("mysqlport")
mysqldb := beego.AppConfig.String("mysqldb")

// Connect to MySQL database.
dsn := mysqluser + ":" + mysqlpass + "@tcp(" + mysqlurls + ":" + mysqlport + ")/" + mysqldb + "?charset=utf8"
orm.RegisterDataBase("default", "mysql", dsn)

}

Dieser Codeausschnitt stammt aus der Konfigurationsdatei von Beego. Rufen Sie die Konto- und Kennwortinformationen ab, die für die Verbindung mit MySQL erforderlich sind, und stellen Sie beim Start der Anwendung eine Verbindung zur MySQL-Datenbank her.

5. Modell erstellen

Jetzt haben wir erfolgreich eine Verbindung zur MySQL-Datenbank hergestellt. Als nächstes müssen wir das Datenmodell definieren, um Daten aus der Datenbank abzurufen und zu speichern. In Golang können wir ORM-Bibliotheken (Object-Relational Mapping) wie GORM oder XORM verwenden, um Datenbanken einfach zu verwalten.

In diesem Abschnitt verwenden wir die GORM-Bibliothek als Beispiel. Zuerst müssen wir die GORM-Bibliothek installieren:

$ go get -u github.com/jinzhu/gorm

Dann können wir wie folgt ein Modell mit dem Namen „mymodel“ im Projekt erstellen:

Paketmodelle

import (

"github.com/jinzhu/gorm"

)

type MyModel struct {

gorm.Model
Name string

}

Dann müssen wir die GORM-Datenbank in der Hauptfunktion initialisieren:

package main

import (

"github.com/astaxie/beego"
"github.com/astaxie/beego/orm"
_ "github.com/go-sql-driver/mysql"
"myproject/models"

)

func init() {

// Set database information.
mysqluser := beego.AppConfig.String("mysqluser")
mysqlpass := beego.AppConfig.String("mysqlpass")
mysqlurls := beego.AppConfig.String("mysqlurls")
mysqlport := beego.AppConfig.String("mysqlport")
mysqldb := beego.AppConfig.String("mysqldb")

// Connect to MySQL database.
dsn := mysqluser + ":" + mysqlpass + "@tcp(" + mysqlurls + ":" + mysqlport + ")/" + mysqldb + "?charset=utf8"
orm.RegisterDataBase("default", "mysql", dsn)

// Register ORM model.
orm.RegisterModel(new(models.MyModel))

}

Jetzt haben wir das Modell erfolgreich erstellt und eine Verbindung zur Datenbank hergestellt. Wir können den folgenden Code im Controller verwenden, um das Modell abzufragen:

Paketcontroller

import (

"github.com/astaxie/beego"
"myproject/models"

)

type MyController struct {

beego.Controller

}

func (c *MyController) Get() {

var mymodels []models.MyModel
orm.NewOrm().QueryTable("my_model").All(&mymodels)

c.Data["MyModels"] = mymodels
c.TplName = "index.html"

}

6. Zusammenfassung

In diesem Artikel haben wir vorgestellt, wie man Webanwendungen mit den Frameworks Golang und Beego erstellt. Wir haben gelernt, wie man Controller und Ansichten erstellt, eine Verbindung zu Datenbanken herstellt und Modelle erstellt. Obwohl es sich bei diesem Artikel nur um ein einfaches Beispiel handelt, kann er als Ausgangspunkt für den Einstieg in Golang und Beego dienen. Wenn Sie mehr über die Funktionen und die Verwendung von Golang und Beego erfahren möchten, schauen Sie sich bitte die offizielle Dokumentation und den Beispielcode an.

Das obige ist der detaillierte Inhalt vonGolang Beego bauen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!