CRUD-Operationen mit Goravel (Laravel für GO)

Über Goravel

Goravel ist ein Webanwendungs-Framework mit vollständigen Funktionen und hervorragender Skalierbarkeit, das Gopher als Startgerüst dabei hilft, schnell eigene Anwendungen zu erstellen.

Goravel ist der perfekte Klon von Laravel für Go-Entwickler, was bedeutet, dass ein PHP-Entwickler wie ich sich leicht mit dem Framework identifizieren und mit wenig Lernaufwand mit dem Schreiben beginnen kann.

Beginnen wir mit der Installation. Sie können diesem Artikel zur Installation folgen oder die offizielle Dokumentationswebsite von Goravel besuchen.

// Download framework
git clone https://github.com/goravel/goravel.git && rm -rf goravel/.git*

// Install dependencies
cd goravel && go mod tidy

// Create .env environment configuration file
cp .env.example .env

// Generate application key
go run . artisan key:generate

//start the application
go run .

Wenn Sie den Code in Ihrem bevorzugten Texteditor öffnen, werden Sie feststellen, dass die Projektstruktur genau der von Laravel entspricht, sodass sich Laravel-Entwickler nicht so verloren fühlen werden.

Modell, Migration und Controller

Um ein Modell, eine Migration und einen Controller zu erstellen, können wir den Befehl artisan verwenden, genau wie wir es in Laravel tun.

// create model 
go run . artisan make:model Category

// create migration 
go run . artisan make:migration create_categories_table

// create controller 
go run . artisan make:controller --resource category_controller

Wenn wir nun den Datenbank-/Migrationsordner überprüfen, sehen wir, dass Dateien für uns erstellt wurden, die Up- und Down-Datei. Öffnen Sie die Up-Migrationsdatei und fügen Sie den folgenden Code ein:

CREATE TABLE categories (
  id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  name varchar(255) NOT NULL,
  created_at datetime(3) NOT NULL,
  updated_at datetime(3) NOT NULL,
  PRIMARY KEY (id),
  KEY idx_categories_created_at (created_at),
  KEY idx_categories_updated_at (updated_at)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;NGINE = InnoDB DEFAULT CHARSET = utf8mb4;

Wenn wir im Ordner app/http/controllers nachsehen, haben wir eine Datei „category_controller.go“ und der darin enthaltene Inhalt sollte wie folgt aussehen:

package controllers

import (
 "github.com/goravel/framework/contracts/http"
)

type CategoryController struct {
 //Dependent services
}

func NewCategoryController() *CategoryController {
 return &CategoryController{
  //Inject services
 }
}

func (r *CategoryController) Index(ctx http.Context) http.Response {
 return nil
} 

func (r *CategoryController) Show(ctx http.Context) http.Response {
 return nil
}

func (r *CategoryController) Store(ctx http.Context) http.Response {
 return nil
}

func (r *CategoryController) Update(ctx http.Context) http.Response {
 return nil
}

func (r *CategoryController) Destroy(ctx http.Context) http.Response {
 return nil
}

Dann suchen wir die Kategoriemodelldatei in app/http/model und fügen dann den folgenden Code ein:

package models

import (
 "github.com/goravel/framework/database/orm"
)

type Category struct {
 orm.Model
 Name string
}

Hier ist nicht viel los, wir deklarieren nur unsere ausfüllbaren Dateien mit ihrem Datentyp.

Suchen wir unsere api.php-Datei im Routenordner und aktualisieren Sie den Code so, dass er wie folgt aussieht:

package routes

import (
 "github.com/goravel/framework/facades"

 "goravel/app/http/controllers"
)

func Api() {
 userController := controllers.NewUserController()
 facades.Route().Get("/users/{id}", userController.Show)

 //Resource route
 categoryController := controllers.NewCategoryController()
 facades.Route().Resource("/category", categoryController)
}

Jetzt aktualisieren wir unsere Importe in der Datei „category_controller.go“ und aktualisieren sie wie folgt:

import (
 "goravel/app/models"
 "github.com/goravel/framework/contracts/http"
  "github.com/goravel/framework/facades"
)

Wir haben gerade unsere Modelle und Fassaden importiert. Fassaden ermöglichen uns den Zugriff auf viele coole nützliche Dinge wie Validierung, Orm usw. Orm ist das ORM für GO.

Zeit, etwas Code zu schreiben!

Aktualisieren wir unsere Methoden in unserem Controller auf den folgenden Code:

Indexmethode

// this is just to pull all categories in our database
func (r *CategoryController) Index(ctx http.Context) http.Response {
 var categories []models.Category

 if err := facades.Orm().Query().Find(&categories); err != nil {
  return ctx.Response().Json(http.StatusInternalServerError, http.Json{
   "error": err.Error(),
  })
 }

 return ctx.Response().Success().Json(http.Json{
  "success": true,
  "message": "Data fetch successfully",
  "data":    categories,
 })
} 

Speichermethode

func (r *CategoryController) Store(ctx http.Context) http.Response {

// validate the input name that the user is passing
 validation, err := facades.Validation().Make(ctx.Request().All(), map[string]string{
        "name": "required|string",
    })

// check if an error occured, might not be validation error
    if err != nil {
        return ctx.Response().Json(http.StatusInternalServerError, http.Json{
            "success": false,
            "message": "Validation setup failed",
            "error":   err.Error(),
        })
    }

// check for validation errors
    if validation.Fails() {
        return ctx.Response().Json(http.StatusBadRequest, http.Json{
            "success": false,
            "message": "Validation failed",
            "errors":  validation.Errors().All(),
        })
    }

// Create the category
 category := &models.Category{
  Name: ctx.Request().Input("name"),
 }

// save the category and return error if there is any
 if err := facades.Orm().Query().Create(category); err != nil {
  return ctx.Response().Json(http.StatusInternalServerError, http.Json{
   "success": false,
   "errors": err.Error(),
  })
 }

// upon successfull creation return success response with the newly created category
 return ctx.Response().Success().Json(http.Json{
  "success": true,
  "message": "Category created successfully",
  "data":    category,
 })
}

Aktualisierungsmethode

func (r *CategoryController) Update(ctx http.Context) http.Response {

    validation, err := facades.Validation().Make(ctx.Request().All(), map[string]string{
        "id":   "required",
        "name": "required|string",
    })

    if err != nil {
        return ctx.Response().Json(http.StatusInternalServerError, http.Json{
            "success": false,
            "message": "Validation setup failed",
            "error":   err.Error(),
        })
    }

    if validation.Fails() {
        return ctx.Response().Json(http.StatusBadRequest, http.Json{
            "success": false,
            "message": "Validation failed",
            "errors":  validation.Errors().All(),
        })
    }

// find the category using the id
    var category models.Category
    if err := facades.Orm().Query().Where("id", ctx.Request().Input("id")).First(&category); err != nil {
        return ctx.Response().Json(http.StatusNotFound, http.Json{
            "success": false,
            "message": "Category not found",
        })
    }

// update or return error if there is any
    category.Name = ctx.Request().Input("name")
    if err := facades.Orm().Query().Save(&category); err != nil {
        return ctx.Response().Json(http.StatusInternalServerError, http.Json{
            "success": false,
            "message": "Failed to update category",
            "error":   err.Error(),
        })
    }

// return success if successfull
    return ctx.Response().Success().Json(http.Json{
        "success": true,
        "message": "Category updated successfully",
        "data":    category,
    })
}

Zerstörungsmethode

func (r *CategoryController) Destroy(ctx http.Context) http.Response {

// find the category by id
 var category models.Category
 facades.Orm().Query().Find(&category, ctx.Request().Input("id"))
 res, err := facades.Orm().Query().Delete(&category)

// return error if there is any
 if err != nil {
  return ctx.Response().Json(http.StatusInternalServerError, http.Json{
  "error": err.Error(),
  })
 }

// return success if successfull
 return ctx.Response().Success().Json(http.Json{
  "success": true,
  "message": "Category deleted successfully",
  "data":    res,
 })
}

Jetzt müssen wir die Datenbank einrichten. Ich werde MySQL verwenden. Es ist wichtig zu beachten, dass der Gravel mit mehreren Datenbanktreibern geliefert wird. Suchen Sie Ihre .env-Datei und bearbeiten Sie die folgende Zeile:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=DATABASE_NAME
DB_USERNAME=DATABASE_USERNAME
DB_PASSWORD=DATABASE_PASSWORD

Dann geben Sie in Ihrem Terminal Folgendes ein:

go run . artisan migrate

Dadurch wird unsere Kategorientabelle automatisch in unsere Datenbank migriert.

Jetzt müssen wir unseren Server stoppen, falls Sie ihn zuvor ausgeführt haben, und ihn neu starten.

Sie können jetzt Ihre Endpunkte von Postman aus testen. Beachten Sie bitte, dass Sie durch das Hinzufügen der Ressource zum Kategorieendpunkt jetzt Zugriff auf die Methoden GET, POST, PUT oder DELETE für Ihre Kategorieendpunkte haben. Sie können auf diese Weise auf Ihre Endpunkte zugreifen:

// GET category
http://localhost:3000/category

//POST catgory - with payload
http://localhost:3000/category
{
    "name": "goravel"
}

// PUT category - with payload
http://localhost:3000/category/{id}
{
    "id": 1,
    "name": "laravel"
}

//DELETE category
http://localhost:3000/category/{id}

So führen Sie mit Goravel einfache CRUD-Operationen durch.

Das obige ist der detaillierte Inhalt vonCRUD-Operationen mit Goravel (Laravel für GO). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!