Lernen Sie Golang, indem Sie eine Fintech-Banking-App erstellen – Lektion 1: Starten Sie das Projekt

Blog

Dieser Beitrag wurde ursprünglich hier veröffentlicht: https://www.blog.duomly.com/golang-course-with-building-a-fintech-banking-app-lesson-1-start-the-project/


Einführung in den Golang-Kurs

Es ist die erste Lektion des Golang-Kurses.

Erinnern Sie sich an die letzte Episode, in der wir eine Banking-App mit einer SQL-Injection gehackt haben?

Hier ist die URL:

Tutorial für SQL-Injection-Angriffe für Anfänger

In dieser Folge habe ich Ihnen versprochen, Ihnen beizubringen, wie Sie eine Banking-App erstellen.

Wir brauchen ein Frontend, das wir in Angular 9 und Tailwind einbauen werden, dazu erfahrt ihr von meiner Freundin Anna.

Die URL der ersten Episode von Fintech-App bauen mit Angular 9-Kurs und Tailwind CSS finden Sie (hier).

Wenn Anna ihre Stunde natürlich beenden wird :)

Und der zweite Teil der Fintech-Banking-App ist das Backend, das wir in Golang codieren.

In dieser Episode erfahren Sie im ersten Teil, wie Sie eine Fintech-App in Golang erstellen.

Wir werden das Projekt gemeinsam aufsetzen, einige Datenbankmigrationen durchführen und die ersten Daten wie Benutzer und Bankkonten erstellen.

Übrigens, wenn Sie Video bevorzugen, hier ist die Youtube-Version des Golang-Kurses:

PostgreSQL DB installieren und starten

Der erste Schritt, den Sie beginnen sollten, ist die Einrichtung Ihrer PostgreSQL-Datenbank.

Sie können dies auf Ihrem lokalen Computer tun oder kostenpflichtige Dienste wie Amazon RDS oder von Digital Ocean verwaltete Datenbanken verwenden.

fxnetworks com Xbox One aktivieren

Wenn Sie über Datenbank- und Verbindungsanmeldeinformationen verfügen, können wir mit den nächsten Schritten fortfahren.

Datei main.go erstellen

Der nächste Schritt, den wir tun sollten, ist, einen Ordner mit dem Projekt zu erstellen und die erste Datei namens main.go zu erstellen.

Innerhalb von main.go sollten Sie das Paket als main benennen und die erste Funktion namens main ebenfalls hinzufügen.

Ihr Code sollte wie im folgenden Beispiel aussehen.

package main func main() { }

Init-Paket

Ok, jetzt können wir unsere Anwendung starten.

Ich habe meinen eigenen Namen für die App erstellt, aber wenn Sie möchten, können Sie sie benennen, wie Sie möchten.

Sie können zum Beispiel hinzufügen github.com in der URL.

So sind Ihre Module auch für andere Benutzer aus der Ferne zugänglich.

Öffnen Sie das Terminal im Projektordner und geben Sie Folgendes ein:

go init duomly.com/go-bank-backend

Das sollte für deine eine Datei go.mod erstellen

Helferdatei erstellen

Der nächste Schritt besteht darin, Helfer für unsere Anwendung zu erstellen.

Helpers.go ist die Datei, in der wir alle freigegebenen Helfer hinzufügen, die wir überall in unserer App verwenden können.

Im Verzeichnis des Projekts müssen Sie ein Verzeichnis namens helpers und eine Datei namens helpers.go innerhalb des erstellten Verzeichnisses erstellen.

Als nächstes sollten Sie in die Datei helpers.go gehen, das Paket namens helpers deklarieren und das bcrypt-Paket in die Importe importieren.

Der Code Ihres Helfers sollte wie im folgenden Beispiel aussehen.

package helpers import ( 'golang.org/x/crypto/bcrypt' )

Erstellen Sie einen Fehlerhandler

Jetzt sollten wir den Fehlerhandler erstellen, den wir in anderen Komponenten verwenden können.

Diese Funktion sollte überprüfen, ob wir einen Fehler haben, wenn ja, die Panik senden.

Benennen Sie Ihre Funktion HandleErr und übergeben Sie err mit Typfehler. Denken Sie daran, den Namen groß zu schreiben. Andernfalls wird die Funktion nicht exportiert.

func HandleErr(err error) { if err != nil { panic(err.Error()) } }

HashAndSalt erstellen

Die wichtigste Logik für unser Passwort besteht darin, es zu hashen und zu salzen.

Hash- und Salted-Passwörter verbessern die Sicherheit unserer Passwörter dramatisch.

Es bedeutet, dass es fast unmöglich ist, den Pass zu entschlüsseln, selbst wenn jemand die Daten unserer DB stiehlt.

Dazu müssen wir eine Funktion namens HashAndSalt erstellen, die einen Parameter vom Typ Byte erhält und einen String zurückgibt.

Innerhalb der Funktion werden wir den Pass mit bcrypt.GenerateFromPassword verschlüsseln.

Wir sollten diese Funktion zu helpers.go unterhalb von HandleErr hinzufügen.

func HashAndSalt(pass []byte) string { hashed, err := bcrypt.GenerateFromPassword(pass, bcrypt.MinCost) HandleErr(err) return string(hashed) }

Herzlichen Glückwunsch, Ihre Helfer für diese Lektion sind bereit!

Wir können mit den Migrationen vorankommen.

Migrationsdatei erstellen

Beginnen wir mit der Migration, indem wir ein Verzeichnis namens 'migrations' und eine Datei mit demselben Namen darin erstellen (denken Sie natürlich an die Erweiterung .go).

In der Datei migrations.go sollten wir das Paket deklarieren und es migrations nennen.

Als nächstes deklarieren wir einige Importe, wie Helfer aus unserer App, gorm lib und den Postgres-Dialekt für den gorm.

Gorm ist eine Bibliothek, die unsere DB verwaltet.

Es erleichtert SQL-Aufrufe und verbessert die Sicherheit erheblich.

Ihr erster Code in migrations.go sollte wie im folgenden Beispiel aussehen.

package migrations import ( 'duomly.com/go-bank-backend/helpers' 'github.com/jinzhu/gorm' _ 'github.com/jinzhu/gorm/dialects/postgres' )

Schnittstellen erstellen

Im nächsten Schritt werden Schnittstellen für Benutzer und Konto definiert.

Dazu müssen wir eine Struktur namens User mit Requisiten wie gorm.Model, Benutzername als String, Email als String und auch ein Passwort als String erstellen.

Die nächste struct-Schnittstelle ist das Konto mit den Requisiten wie gorm.Model, Type als String, Name als String, Balance als uint und die UserID als uint.

Fügen Sie die Schnittstellen unterhalb der Importe in der Datei migrations.go hinzu.

type User struct { gorm.Model Username string Email string Password string } type Account struct { gorm.Model Type string Name string Balance uint UserID uint }

Erstellen Sie eine DB-Verbindung

Jetzt sollten wir eine Funktion namens 'connectDB' erstellen, die eine Gorm-DB-Verbindung zurückgibt.

Mit dieser Funktion können wir uns mit DB verbinden und als nächstes innerhalb der Datenbank aufrufen.

material-ui tabs reagieren router

Erstellen Sie diese Funktion unterhalb der Schnittstellen in derselben migrations.go-Datei.

func connectDB() *gorm.DB { db, err := gorm.Open('postgres', 'host=127.0.0.1 port=5432 user=user dbname=dbname password=password sslmode=disable') helpers.HandleErr(err) return db }

Fake-Accounts erstellen

Es ist Zeit für ein paar Daten!

Wir brauchen Benutzer, und Benutzer brauchen Bankkonten, auf die wir etwas Geld einzahlen.

Das createAccounts ist die größte Funktion in Lektion Nummer 1.

Zuerst müssen wir eine Funktion namens createAccounts erstellen.

Innerhalb der Funktion müssen wir eine Variable namens db erstellen, der wir die connectDB-Funktion zuweisen sollten.

Der nächste Schritt besteht darin, ein Slice mit zwei Benutzern zu erstellen (ich habe einige Dummy-Daten hinzugefügt, Sie können weitere hinzufügen oder dies ändern, wenn Sie möchten).

Wenn wir Code für die Benutzer geschrieben haben, sollten wir eine for-Schleife starten, die unser Dataset durchläuft.

Innerhalb der for-Schleife müssen wir die Variable createdPassword erstellen, in der wir ein Passwort für den x-Benutzer übergeben sollen, aber denken Sie daran, den String in das Byte umzuwandeln.

Als nächstes sollten wir eine Datenstruktur für den Benutzer erstellen und diese Daten an die Funktion db.Create übergeben.

Für den erstellten Benutzer sollten wir eine Kontostruktur entwickeln, die wir ebenfalls an db.Create übergeben.

Der letzte Schritt dieser Funktion ist ein Schließen der DB-Verbindung durch Hinzufügen von db.Close.

func createAccounts() { db := connectDB() users := [2]User{ {Username: 'Martin', Email: 'martin@martin.com'}, {Username: 'Michael', Email: 'michael@michael.com'}, } for i := 0; i 

Migrationsfunktion erstellen

Wir sind fast fertig!

Einer der letzten Schritte und die letzte Funktion heißt Migrate.

Innerhalb der Funktion müssen wir db erneut verbinden, die Methode db.Automigrate verwenden und unsere beiden Strukturen übergeben.

Als nächstes sollten wir die DB-Verbindung schließen und die Funktion createAccounts auslösen.

wie man Bluestacks entfernt

Wir sollten diesen Code in dieselbe migrations.go-Datei unter der Funktion createAccounts schreiben.

func Migrate() { db := connectDB() db.AutoMigrate(&User{}, &Account{}) defer db.Close() createAccounts() }

Migrationslogik in main.go hinzufügen

Die letzte Codierung, die wir in dieser Lektion vornehmen müssen, ist eine sehr einfache Änderung in der Datei main.go.

Sie sollten das Migrationspaket importieren und die Funktion Migrieren in der Hauptfunktion aufrufen.

Ihre main.go-Datei sollte wie im folgenden Beispiel aussehen.

package main import 'duomly.com/go-bank-backend/migrations' func main() { migrations.Migrate() }

Migration ausführen

Jetzt können wir die Migration ausführen und unseren Code testen.

Gehen wir im Terminal in das Verzeichnis des Projekts und geben Sie Folgendes ein:

go run main.go

Abschluss des Golang-Kurses Lektion 1

Herzlichen Glückwunsch, Ihr Fintech-Banking-Projekt ist bereit für die Entwicklung der nächsten Module!

Wenn Sie den Code mit dem vergleichen möchten, was ich hier gemacht habe, ist die URL:

https://github.com/Duomly/go-bank-backend

Der Zweig für diese Lektion heißt Golang-Kurs-Lektion-1.

Wir sehen uns in der nächsten Lektion, wenn wir die Login-Funktion und die Rest-API erstellen.

Danke fürs Lesen,

Radek aus Duomly

#web-entwicklung #api #datenbank #sql #postgresql

www.blog.duomly.com

Lernen Sie Golang, indem Sie eine Fintech-Banking-App erstellen – Lektion 1: Starten Sie das Projekt

Einführung in den Golang-Kurs

Es ist die erste Lektion des Golang-Kurses.Erinnern Sie sich an die letzte Episode, in der wir eine Banking-App gehackt haben, indem wir...