![\"\"](\"https:\/\/media.jfrog.com\/wp-content\/uploads\/2020\/09\/16180948\/Gorm-863x300-1.png\")
<\/p>\n<\/p>\n
UPDATE:<\/strong> Am 1. Mai 2021 wird das zentrale Repository von GoCenter einschlie\u00dflich aller Funktionen eingestellt. Weitere Informationen zur Einstellung der Center finden Sie im Blog-Beitrag zur Einstellung<\/a><\/span><\/p>\n <\/p>\n Jeden Monat verleiht GoCenter den leistungsst\u00e4rksten Modulen ein <\/b>Gopher Badge<\/b><\/a> als Auszeichnung f\u00fcr ihre Leistung. Wir schreiben \u00fcber einige dieser <\/b>Top-Module<\/b><\/a> und wie sie in Go verwendet werden.<\/b><\/span><\/p>\n Robert Greiseimer hat Go als die Sprache des Cloud Computing bezeichnet. Es ist zwar kein Geheimnis, dass Go \u00fcber starke Funktionen verf\u00fcgt, die die Anforderungen von Microservice-Architekturen, verteilten Systemen und gro\u00df angelegten Unternehmensanwendungen unterst\u00fctzen, aber was weniger bekannt ist, ist, dass Go von Anfang an auch mit Blick auf die Webentwicklung erstellt wurde. In der Tat verwenden viele Entwickler in der Community Go f\u00fcr die Full-Stack-Entwicklung und bef\u00fcrworten neue Module und Frameworks ein, die Go zu einer starken Sprache f\u00fcr das Web machen. <\/span><\/p>\n Werfen wir einen Blick auf einige der M\u00f6glichkeiten, wie Golang und die wachsende Welt der von der Community betriebenen Go-Module<\/a> den Datenaustausch in Web-Apps unterst\u00fctzen. Ich zeige auch, wie man mit GoCenter, dem kostenlosen Go-Modul-Proxy f\u00fcr die Entwicklergemeinde, einige wertvolle Module identifizieren kann, und werfe einen detaillierten Blick auf eines meiner Favoriten.<\/span><\/p>\n Go verf\u00fcgt \u00fcber ausgefeilte Web-Pakete, die Teil seiner Kernbibliothek sind. Mit dem j\u00fcngsten Golang 1.15-Release <\/span>wurde diese Kernbibliothek<\/span><\/a> durch Verbesserungen an <\/span>database\/sql<\/span><\/a>, <\/span>database\/sql\/driver<\/span><\/a>, <\/span>net\/http<\/span><\/a> und <\/span>encoding\/json<\/span><\/a> aktualisiert, sodass Go jetzt noch besser mit Web-Daten arbeiten kann. Diese \u00c4nderungen f\u00fcgen Begrenzungen hinzu, die das Risiko einer \u00dcberbeanspruchung des Stapelspeichers durch gro\u00dfe Mengen von Datendiensten verringern. Au\u00dferdem wurde eine Leerlaufzeit f\u00fcr Datenbankverbindungen festgelegt.<\/span><\/p>\n Go's Zum Starten des Webdienstes m\u00fcssen das net\/http-Paket importiert und zwei Funktionen geschrieben werden.<\/span><\/p>\n <\/p>\n Mit dieser sehr einfachen Datei haben Sie einen funktionierenden Webserver eingerichtet. Dieser Server sendet, speichert und ruft nat\u00fcrlich nicht tats\u00e4chlich Informationen aus dem Web an eine Datenbank ab. Um diese Funktionalit\u00e4t einzubauen, w\u00fcrden wir eine grundlegende CRUD-Anwendung erstellen, die Informationen in Ihrer API <\/span>ERSTELLEN<\/span>, <\/span>LESEN<\/span>, <\/span>AKTUALISIEREN<\/span> und <\/span>L\u00d6SCHEN <\/span>kann.<\/span><\/p>\n Weitere Details zur Verwendung dieses Pakets f\u00fcr die Erstellung von RESTful-APIs erfahren Sie in einem <\/span>ausgezeichneten Tutorial von Elliot Forbes<\/span><\/a>.<\/span><\/p>\n Eine M\u00f6glichkeit, Informationen zu senden und zu empfangen, ist die Verwendung der Kernbibliothek von Go <\/span> Zum Gl\u00fcck hat die Go-Gemeinschaft eine Reihe von Object Relational Mapping-Bibliotheken (ORMs) entwickelt, die es Go-Entwicklern erm\u00f6glichen, JSON-key:value-Paarsyntax und-Kodierung zu verwenden, um direkt auf eine SQL-Datenbank wie PostgreSQL zu mappen. ORMs erm\u00f6glichen es Entwicklern, ihr natives Programmierparadigma zu verwenden, um Daten auf SQL zu mappen. <\/span><\/p>\n Ein ORM verwandelt Ihre Datenbankinformationen in Golang-Objekte und umgekehrt. Bei der Arbeit mit einem ORM k\u00f6nnen Sie, anstatt SQL-Abfragen direkt in Ihre Anwendung zu schreiben, Ihre Daten viel besser mit Golang struct wie in diesem Beispiel abbilden:<\/span><\/p>\n <\/p>\n Nicht jeder ist ein Fan der Verwendung von ORMs, weil sie eine Abstraktionsebene von den eigentlichen Daten in der Datenbank schaffen. Je nachdem, welche Bibliothek Sie verwenden, ist ein weiterer Nachteil, dass, w\u00e4hrend SQL langfristig bleibt, ORM-Frameworks \u00fcber Nacht erscheinen und verschwinden k\u00f6nnen. Aber insgesamt habe ich festgestellt, dass ORMs es viel einfacher machen, die Daten einer Webanwendung in Go im Auge zu behalten und die Menge an langwieriger Codierung zu reduzieren, indem ich einen Haufen SQL-Befehle innerhalb meiner Anwendung gegen etwas austausche, das einfacher zu handhaben ist. <\/span><\/p>\n Es gibt eine Reihe von Go-ORMs, die in der Community unterst\u00fctzt und gef\u00f6rdert werden und alle im GoCenter verf\u00fcgbar sind:<\/span><\/p>\n GORM<\/b> ist ein entwicklerfreundlicher ORM, der von <\/span>Jinzhu Zhang<\/span><\/a> entwickelt wurde, mehr als 19.000 Sterne auf GitHub hat, ausgezeichneten Support von der Community erh\u00e4lt und f\u00fcr den es eine <\/span>leicht verst\u00e4ndliche Dokumentation gibt<\/span><\/a>. GORM erm\u00f6glicht CRUD-Operationen und kann auch f\u00fcr die anf\u00e4ngliche Migration und Erstellung des Datenbankschemas verwendet werden. Zu den weiteren Vorz\u00fcgen von GORM geh\u00f6ren die Erweiterbarkeit mit nativer Plugin-Unterst\u00fctzung, der Einsatz von Tests sowie 1:1- bzw. 1:n-Gruppen von Assoziationen Gorm unterst\u00fctzt au\u00dferdem <\/span>sqlite<\/span>, <\/span>mysql<\/span>, <\/span>postgres<\/span>, <\/span>and mssql.<\/span><\/p>\n <\/p>\n Nehmen wir an, Sie wollten eine API (oder sp\u00e4ter eine Webanwendung) erstellen, die Benutzer auffordert, Ihnen ihren Namen, ihre E-Mail-Adresse und eine kurze Nachricht mitzuteilen. Mit GORM w\u00e4re es eine ziemlich einfache Reihe von Schritten, um dies in einer Datenbank abzubilden. Die Schritte:<\/span><\/p>\n Nehmen wir an, dass meine Teilzeit-Immobilienmaklerin (oder vielleicht meine Schwester) eine Webanwendung ben\u00f6tigt, die Anfragen zu Immobilien, die sie in unserer Heimatstadt verwaltet, sammeln und speichern kann. Das erste, was ich tun m\u00fcsste, ist eine Datenbank zu entwickeln, die Benutzerinformationen speichern kann, sowie eine Web-API, die diese Informationen \u00fcber ein Kontaktformular sammelt und sp\u00e4ter auf diese Benutzerinformationen zugreifen kann, damit sie in einem Browser gelesen werden k\u00f6nnen. Wir werden einige der wichtigsten Schritte durchgehen, die ich unternommen habe, um diese Art von Anwendung zu entwickeln.<\/span><\/p>\n Zuerst k\u00f6nnen wir in unserer <\/span>main.go<\/b>-Datei unsere Module mit den folgenden Befehlen importieren:<\/span><\/p>\n <\/p>\n Erstellen Sie eine einfache Variable f\u00fcr die GORM-Datenbank:<\/span><\/p>\n <\/p>\n Wir werden unsere Modelldefinition mit einer Golang struct erstellen, die den Namen des Benutzers, seine E-Mail und die Nachricht abbildet. <\/span><\/p>\n <\/p>\n Ich habe meine sqlite-Datenbank <\/span>projekt.db <\/b>genannt und kann die AutoMigrate-Funktion von GORM mit einer Funktion verwenden, die wie folgt aussieht:<\/span><\/p>\n <\/p>\n Dadurch k\u00f6nnen wir die API-Daten im Browser sehen:<\/span><\/p>\n <\/p>\n Die API verwendet vier Hauptfunktionen, die es uns erm\u00f6glichen, Benutzer zu finden\/zu bekommen, neue Benutzer hinzuzuf\u00fcgen, Benutzer zu l\u00f6schen und Benutzerinformationen in der Datenbank zu aktualisieren. Diese k\u00f6nnen wie folgt umrissen werden:<\/span><\/p>\n Diese Funktion stellt z. B. eine Verbindung zur Datenbank her und zeigt alle Eintr\u00e4ge f\u00fcr Benutzer an:<\/span><\/p>\n <\/p>\n Nachdem jede der obigen Funktionen erstellt wurde, w\u00fcrde die Funktion f\u00fcr das Routing wie folgt aussehen:<\/span><\/p>\n <\/p>\n Zuletzt k\u00f6nnen Sie die Anwendung ausf\u00fchren, indem Sie Folgendes in Ihrer Hauptfunktion platzieren:<\/span><\/p>\n <\/p>\n Dann werden wir unter Verwendung von Und wenn ich ein paar Anfragen an meine API POSTE, kann ich diese Anfrage BEKOMMEN und die Daten im Browser sehen:<\/span><\/p>\n Als Go-Entwickler, der GORM zum ersten Mal verwendet, war die Migration und das Mapping von Daten in eine Sqlite-Datenbank sehr einfach. Der obige Code ist nur eine Momentaufnahme, um Ihnen den Einstieg zu erleichtern.<\/span><\/p>\n Weitere Informationen zur <\/span>Verwendung von GORM zur Erstellung von APIs <\/span>finden Sie indiesem ausgezeichneten und umfassenden Tutorial mit Video von Elliot Forbes<\/span><\/a>. <\/span>\u00a0Vergessen Sie nicht, sich bei <\/span>Elliot auf Twitter<\/span><\/a> f\u00fcr sein wunderbares Tutorial zu bedanken, das jeden Aspekt der Golang-APIs beleuchtet.\u00a0<\/span><\/p>\n GORM v2 ist nun ebenfalls ver\u00f6ffentlicht und wird f\u00fcr \u00f6ffentliche Tests verwendet. <\/span><\/p>\n Zu den St\u00e4rken von Go in der Web-API-Entwicklung geh\u00f6ren seine Geschwindigkeit und Skalierbarkeit, was im Zeitalter des Machine Learning ziemlich wichtig ist. Go wurde in der \u00c4ra der Mehrkernprozessoren entwickelt und verwendet <\/span>Goroutinen<\/span><\/i>, um Aufgaben gleichzeitig durch mehrere Kan\u00e4le auf mehreren CPUs zu f\u00fchren. Das bedeutet, dass es die Skalierung und Infrastruktur bew\u00e4ltigen kann, die f\u00fcr gro\u00dfe Datenanwendungen erforderlich ist, und Millionen von HTTP-Anfragen gleichzeitig verarbeiten kann. Au\u00dferdem ist es statisch typisiert und seine strenge Syntax macht es viel einfacher, Fehler zu debuggen und zu verhindern, die weniger strenge Sprachen mit riesigen Bibliotheken wie Javascript einf\u00fchren k\u00f6nnten. Aus diesem Grund haben sich Unternehmen von Uber bis DropBox als Sprache der Wahl f\u00fcr APIs und zur Skalierung ihrer webf\u00e4higen Anwendungen f\u00fcr Go entschieden. <\/span><\/p>\n Sollten Sie die API-F\u00e4higkeiten von Go ausprobieren wollen, ist die Erstellung einer eigenen Web-API mit ORMs wie GORM ein guter Anfang.<\/span><\/p>\n<\/div>\n","protected":false},"excerpt":{"rendered":" UPDATE: Am 1. Mai 2021 wird das zentrale Repository von GoCenter einschlie\u00dflich aller Funktionen eingestellt. Weitere Informationen zur Einstellung der Center finden Sie im Blog-Beitrag zur Einstellung Jeden Monat verleiht GoCenter den leistungsst\u00e4rksten Modulen ein Gopher Badge als Auszeichnung f\u00fcr ihre Leistung. Wir schreiben \u00fcber einige dieser Top-Module und wie sie in Go verwendet …<\/p>\n","protected":false},"author":140,"featured_media":64362,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"inline_featured_image":false,"footnotes":""},"categories":[9969],"tags":[9437,9438],"class_list":["post-80769","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-artefakt-management","tag-go-module","tag-gocenter-de"],"yoast_head":"\nGolang liebt Daten im Web<\/span><\/h2>\n
Web-Server-Erstellung<\/span><\/h3>\n
net\/http<\/code> -Paket von Go ist Teil der Standardbibliothek und dient dem Transport von HTML vom Server zum Client. Dies geschieht mit Hilfe einer http.Handler<\/code> -Schnittstelle, die ihren eigenen Webserver bildet. Diese Bibliothek macht die RESTful-API-Entwicklung sehr einfach, und mit Go structs k\u00f6nnen Big-Data-Anwendungen auf eine Reihe von verschiedenen Datenbanken und Datentypen abgebildet werden.<\/span><\/p>\n\npackage main\r\n \r\nimport (\r\n "fmt"\r\n "log"\r\n "net\/http"\r\n)\r\n \r\nfunc homePage(w http.ResponseWriter, r *http.Request){\r\n fmt.Fprintf(w, "Willkommen auf der HomePage!")\r\n fmt.Println("Endpunkt-Hit: homePage")\r\n}\r\n \r\nfunc handleRequests() {\r\n http.HandleFunc("\/", homePage)\r\n log.Fatal(http.ListenAndServe(":10000", nil))\r\n}\r\n \r\nfunc main() {\r\n handleRequests()\r\n}<\/span><\/pre>\n<\/div>\nJSON<\/span><\/h3>\n
encoding\/json<\/code><\/a>. Diese Bibliothek macht es einfach, Daten aus JSON in Ihre Go-Anwendungen zu lesen\/schreiben. JSON oder Javascript Object Notation wurde entwickelt, um Daten im Web zu kodieren bzw. zu dekodieren und ist viel besser f\u00fcr das Web geeignet als reines XML. Durch die Verwendung von key:value-Paaren liest sich JSON eher wie Klartext und sein lesbares Datenformat kann beim Aufbau Ihrer Full-Stack-Anwendungen auf eine Weise genutzt werden, die langwieriges SQL vermeidet. W\u00e4hrend JSON das Senden von Daten einfach macht, wird weiterhin eine M\u00f6glichkeit ben\u00f6tigt, um mit einer Datenbank wie PostgreSQL zu sprechen. <\/span><\/p>\nGolang ORMs<\/span><\/h3>\n
\n\/\/ User struct f\u00fcr meine Datenbank\r\ntype User struct {\r\n gorm.Model\r\n firstName string\r\n lastName string\r\n email string\r\n message string\r\n profession string\r\n age int\r\n zipCode int\r\n}<\/span><\/pre>\n<\/div>\n\n
GORM: Ein Top-Gopher<\/h2>\n
\n\nDiese Funktionen haben einen gro\u00dfen Anteil daran, dass das GORM-Modul als "Top-Gopher" in GoCenter ausgezeichnet wurde. Wenn Sie die reichhaltigen Metadaten von GoCenter \u00fcber das GORM-Modul betrachten, k\u00f6nnen Sie sehen, warum:<\/div>\n![\"\"](\"https:\/\/media.jfrog.com\/wp-content\/uploads\/2020\/09\/03205610\/Go-Badge.png\"){kind=icon}
<\/div>\n<\/div>\n\n
\n![\"\"](\"https:\/\/media.jfrog.com\/wp-content\/uploads\/2020\/09\/03205654\/GORM-Metrics-1024x396.png\")
<\/li>\n
\n![\"\"](\"https:\/\/media.jfrog.com\/wp-content\/uploads\/2020\/09\/03205723\/GORM-Security-1024x205.png\")
<\/span><\/li>\n<\/ul>\nGORM verwenden<\/span><\/h2>\n
\n
GORM Schritt f\u00fcr Schritt<\/span><\/h3>\n
Meine Module importieren<\/h4>\n
\n$ export GOPROXY=https:\/\/gocenter.io\r\n$ go get github.com\/jinzhu\/gorm\r\n$ go get github.com\/mattn\/go-sqlite3<\/span><\/pre>\n<\/div>\nDB-Verbindungsvariable<\/h4>\n
\nvar db *gorm.DB<\/span><\/pre>\n<\/div>\nUser Struct<\/h4>\n
\n\/\/ User struct for my db\r\ntype User struct {\r\n gorm.Model\r\n name string\r\n email string\r\n message string\r\n}<\/span><\/pre>\n<\/div>\nAnf\u00e4ngliche Migration f\u00fcr DB<\/h4>\n
\n\/\/ InitialMigration for project with db.AutoMigrate\r\nfunc InitialMigration() {\r\n db, err = gorm.Open("sqlite3", "project.db")\r\n if err != nil {\r\n fmt.Println(err.Error())\r\n panic("Verbindung zur Datenbank fehlgeschlagen")\r\n }\r\n defer db.Close()\r\n \r\n db.AutoMigrate(&User{})\r\n}<\/span><\/pre>\n<\/div>\nHandler-Funktion anzeigen<\/h4>\n
\nfunc viewHandler(writer http.ResponseWriter, request *http.Request) {\r\n placeholder := []byte("Erfolgreich mit der Datenbank verbunden...")\r\n _, err := writer.Write(placeholder)\r\n check(err)\r\n}<\/span><\/pre>\n<\/div>\nAPI-Funktion<\/h4>\n
\n
\nfunc allUsers(w http.ResponseWriter, r *http.Request) {\r\n db, err := gorm.Open("sqlite3", "projekt.db")\r\n if err != nil {\r\n panic("Verbindung zur Datenbank fehlgeschlagen")\r\n }\r\n defer db.Close()\r\n \r\n var users []Benutzer\r\n db.Find(&users)\r\n fmt.Println("{}", users)\r\n \r\n json.NewEncoder(w).Encode(users)\r\n}<\/span><\/pre>\n<\/div>\nRouter<\/h4>\n
\nfunc handleRequests() {\r\n myRouter := mux.NewRouter().StrictSlash(true)\r\n myRouter.HandleFunc("\/users", allUsers).Methods("GET")\r\n myRouter.HandleFunc("\/user\/{name}", deleteUser).Methods("DELETE")\r\n myRouter.HandleFunc("\/user\/{name}\/{email}", updateUser).Methods("PUT")\r\n myRouter.HandleFunc("\/user\/{name}\/{email}", newUser).Methods("POST")\r\n myRouter.HandleFunc("\/user\/{name}\/{email}\/{message}", updateUser).Methods("PUT")\r\n myRouter.HandleFunc("\/user\/{name}\/{email}\/{message}", newUser).Methods("POST")\r\n log.Fatal(http.ListenAndServe(":8081", myRouter))\r\n}<\/span><\/pre>\n<\/div>\nHauptfunktion<\/h4>\n
\nfunc main() {\r\n fmt.Println("GORM API-Projekt gestartet")\r\n initialMigration()\r\n handleRequests()\r\n}<\/span><\/pre>\n<\/div>\nAnwendung ausf\u00fchren<\/h4>\n
go run main.go<\/code>, die Reaktion sehen:<\/span><\/span><\/p>\n\nGORM-API-Projekt gestartet<\/span><\/pre>\n<\/div>\n![\"\"](\"https:\/\/media.jfrog.com\/wp-content\/uploads\/2020\/09\/03211425\/GORM-Run-1024x238.png\")
<\/p>\nTiefer in das Thema eintauchen<\/span><\/h3>\n
Fazit<\/h2>\n