Wie kann eine verschachtelte Entität nach dem Erstellen eines neuen Objekts zurückgegeben werden?

In PHP ist die Frage, wie verschachtelte Entitäten nach dem Erstellen eines neuen Objekts zurückgegeben werden, eine häufige Frage. Wenn wir ein neues Objekt in einer Klasse erstellen und es als Attribut einer anderen Entität verwenden müssen, müssen wir auf einige Techniken und Methoden achten. Zunächst können wir im Konstruktor der Klasse ein neues Objekt erstellen und es der Eigenschaft zuweisen. Anschließend können wir das Schlüsselwort $this verwenden, um auf das aktuelle Objekt zu verweisen und auf seine Eigenschaften zuzugreifen. Darüber hinaus können wir auch statische Methoden oder Factory-Muster verwenden, um neue Objekte zu erstellen und diese an den Aufrufer zurückzugeben. Unabhängig von der Methode liegt der Schlüssel zur Rückgabe verschachtelter Entitäten darin, die Beziehungen zwischen Objekten korrekt zu handhaben und sicherzustellen, dass sie interagieren und Daten korrekt zwischen Entitäten weitergeben. Mit diesen Methoden können wir problemlos verschachtelte Entitätsobjekte in PHP erstellen und zurückgeben.

Frageninhalt

Modell account 包含嵌套结构 - currency 和 user

Wenn ich eine neue Instanz von account in der Datenbank erstelle und sie dann in der Antwort zurückgebe, ist die verschachtelte Entität leer:

type account struct {
    basemodel
    name       string          `gorm:"size:64;not null" json:"name"`
    balance    decimal.decimal `gorm:"type:decimal(16, 2);default:0;not null;" json:"balance"`
    userid     int             `gorm:"not null" json:"-"`
    user       user            `gorm:"foreignkey:userid" json:"user"`
    currencyid int             `gorm:"not null" json:"-"`
    currency   currency        `gorm:"foreignkey:currencyid" json:"currency"`
}

type createaccountbody struct {
    name       string          `json:"name" binding:"required"`
    balance    decimal.decimal `json:"balance"`
    currencyid int             `json:"currency_id" binding:"required"`
}

func createaccount(ctx *gin.context) {
    body := createaccountbody{}

    if err := ctx.bind(&body); err != nil {
        log.println("error while binding body:", err)
        ctx.json(
            http.statusbadrequest,
            gin.h{"error": "wrong request parameters"},
        )
        return
    }

    account := account {
        name:       body.name,
        balance:    body.balance,
        currencyid: body.currencyid,
        userid:     1,
    }
    
    if result := db.db.create(&account); result.error != nil {
        log.println("unable to create an account:", result.error)
    }    

    ctx.json(http.statuscreated, gin.h{"data": account})
}

Um dieses Problem zu vermeiden, verwende ich eine separate Abfrage, um die Kontovariablen zu aktualisieren:

db.DB.Create(&account)
db.DB.Preload("User").Preload("Currency").Find(&account, account.ID)
ctx.JSON(http.StatusCreated, gin.H{"data": account})

Ist dies der effizienteste und korrekteste Weg, um die gewünschten Ergebnisse zu erzielen?

Lösung

Ich werde mit Ihnen teilen, wie ich normalerweise mit dieser Situation umgehe. Lassen Sie mich zunächst den Code teilen.

main.go Dateien

package main

import (
    "context"

    "gogindemo/handlers"

    "github.com/gin-gonic/gin"
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
)

var (
    db  *gorm.db
    ctx *gin.context
)

func init() {
    dsn := "host=localhost user=postgres password=postgres dbname=postgres port=5432 sslmode=disable"
    var err error
    db, err = gorm.open(postgres.open(dsn), &gorm.config{})
    if err != nil {
        panic(err)
    }

    db.automigrate(&handlers.currency{})
    db.automigrate(&handlers.user{})
    db.automigrate(&handlers.account{})
}

func adddb() gin.handlerfunc {
    return func(ctx *gin.context) {
        ctx.request = ctx.request.withcontext(context.withvalue(ctx.request.context(), "db", db))
        ctx.next()
    }
}

func main() {
    db.create(&handlers.user{id: 1, name: "john doe"})
    db.create(&handlers.user{id: 2, name: "mary hut"})
    db.create(&handlers.currency{id: 1, name: "eur"})
    db.create(&handlers.currency{id: 2, name: "usd"})

    r := gin.default()
    r.post("/account", adddb(), handlers.createaccount)

    r.run()
}

Hier habe ich gerade den Code zum Bootstrapping des Datenbankobjekts hinzugefügt und einige Dummy-Daten hinzugefügt.

handlers/handlers.go Dateien

package handlers

import (
    "net/http"

    "github.com/gin-gonic/gin"
    "github.com/shopspring/decimal"
    "gorm.io/gorm"
)

type User struct {
    Id   int
    Name string
}

type Currency struct {
    Id   int
    Name string
}

type Account struct {
    Id         int
    Name       string          `gorm:"size:64;not null" json:"name"`
    Balance    decimal.Decimal `gorm:"type:decimal(16, 2);default:0;not null;" json:"balance"`
    UserID     int             `gorm:"not null" json:"-"`
    User       User            `gorm:"foreignKey:UserID" json:"user"`
    CurrencyID int             `gorm:"not null" json:"-"`
    Currency   Currency        `gorm:"foreignKey:CurrencyID" json:"currency"`
}

type CreateAccountBody struct {
    Name       string          `json:"name" binding:"required"`
    Balance    decimal.Decimal `json:"balance"`
    CurrencyID int             `json:"currency_id" binding:"required"`
}

func CreateAccount(c *gin.Context) {
    db, ok := c.Request.Context().Value("DB").(*gorm.DB)
    if !ok {
        c.JSON(http.StatusInternalServerError, gin.H{"error": "internal server error"})
        return
    }
    var accountReq CreateAccountBody
    if err := c.BindJSON(&accountReq); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": "wrong request body payload"})
        return
    }

    // create Account & update the "account" variable
    account := Account{Name: accountReq.Name, Balance: accountReq.Balance, CurrencyID: accountReq.CurrencyID, UserID: 1}
    db.Create(&account).Preload("Currency").Preload("User").Find(&account, account.Id)

    c.IndentedJSON(http.StatusCreated, account)
}

In dieser Datei kommuniziere ich tatsächlich mit der Datenbank, indem ich es in context 中传递的 db tue. Nun zurück zu Ihrer Frage.
Wenn die Beziehung zwischen currency//account und user/currency//account 和 user/account 之间的关系是 1:1 类型，那么，您应该依赖 preload 子句。这将在单独的查询中加载相关实体，而不是将其添加到 inner join vom Typ 1:1 ist , dann sollten Sie sich auf die preload-Klausel verlassen. Dadurch werden die zugehörigen Entitäten in eine separate Abfrage geladen, anstatt sie der inner join-Klausel hinzuzufügen.

Bitte sagen Sie mir, ob dies Ihr Problem löst, vielen Dank!

Das obige ist der detaillierte Inhalt vonWie kann eine verschachtelte Entität nach dem Erstellen eines neuen Objekts zurückgegeben werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!