CRUD mit Postgres und MongoDB?

php-Editor Xigua zeigt Ihnen in diesem Artikel, wie Sie Postgres und MongoDB verwenden, um CRUD-Operationen durchzuführen. Postgres ist eine relationale Datenbank, während MongoDB eine Dokumentendatenbank ist. CRUD-Operationen beziehen sich auf den Prozess des Erstellens (Create), Lesens (Read), Aktualisierens (Update) und Löschens (Delete) von Daten. Durch die Kombination dieser beiden unterschiedlichen Datenbanktypen können Sie basierend auf unterschiedlichen Anforderungen die am besten geeignete Datenbank für Datenoperationen auswählen, um die Effizienz und Flexibilität zu verbessern. Lassen Sie uns als Nächstes die Anwendung dieser beiden Datenbanken in CRUD-Operationen untersuchen!

Frageninhalt

Ich bin ziemlich neu in Go und Backends und nehme am Go-Praktikumsprogramm teil. Wir haben ein CRUD erstellt, das eine Verbindung zu einer psql-Datenbank herstellt, und jetzt wird mir gesagt, ich solle eine Verbindung zu mongoDB herstellen, das wir für die Entwicklung und PSQL für die Produktion verwenden werden. Muss ich einen neuen Handler für Mongo von Grund auf erstellen oder kann ich denselben Handler verwenden und irgendwie den Typ der verwendeten Datenbank bestimmen und die Logik entsprechend verwenden? Ich habe zum Beispiel einen Handler für den Benutzerregistrierungsendpunkt:

func (ctrl *UserController) Register(c *gin.Context) {
    var user models.User
    if err := c.BindJSON(&user); err != nil {
        c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
            "error":   true,
            "message": err.Error(),
        })
        return
    }
    err := ctrl.userService.Register(&user)
    if err != nil {
        c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
            "error":   true,
            "message": err.Error(),
        })
        return
    }

    c.JSON(http.StatusCreated, gin.H{
        "message": "successfully created an user",
    })
}

func (svc *UserService) Register(user *models.User) error {
    if svc.userRepo.CheckIfEmailExists(user.Email) {
        return errors.New("user already registered")
    }
    hash, err := svc.generatePasswordHash(user.Password)
    if err != nil {
        return errors.New("err can't register user")
    }

    user.Password = hash

    return svc.userRepo.Insert(user)
}

func (repo *UserRepository) CheckIfEmailExists(mail string) bool {
    var user models.User
    err := repo.dbClient.Debug().Model(models.User{}).Where("email = ?", mail).Find(&user).Error
    return errors.Is(err, gorm.ErrRecordNotFound)
}

func (repo *UserRepository) Insert(user *models.User) error {
    err := repo.dbClient.Debug().Model(models.User{}).Create(user).Error
    if err != nil {
        log.Printf("failed to insert user: %v\n", err)
        return err
    }
    return nil
}

Ich habe die Funktionen insert, register und CheckIfEmailExists für Mongo erstellt:

func (repo *UserRepository) InsertInMongo(user *models.UserB) error {
    coll := repo.mongoClient.DB.Collection("users")
    _, err := coll.InsertOne(context.TODO(), user)
    if err != nil {
        log.Printf("failed to insert user: %v\n", err)
        return err
    }
    return nil
}

func (svc *UserService) RegisterToMongo(user *models.UserB) error {
    check := svc.userRepo.CheckIfEmailExistsInMongo(user.Email)
    if check {
        return errors.New("user already registered")
    }
    hash, err := svc.generatePasswordHash(user.Password)
    if err != nil {
        return errors.New("err can't register user")
    }
    user.Password = hash
    return svc.userRepo.InsertInMongo(user)
}

func (repo *UserRepository) CheckIfEmailExistsInMongo(email string) bool {
    coll := repo.mongoClient.Collection
    filter := bson.D{{Key: "email", Value: email}}

    count, err := coll.CountDocuments(context.TODO(), filter)
    if err != nil {
        panic(err)
    }
    if count != 0 {
        return true
    }
    return false
}

Workaround

Sie haben keinen Code zum Erstellen eines UserService bereitgestellt.

Idealerweise sollten Sie eine Schnittstelle haben, die so aussieht:

type UserRepository interface {
    CheckIfEmailExists(mail string) bool
    Insert(user *models.User) error
    …
}

Dann sollte der UserService wie folgt erstellt werden:

// We use the interface as param
func NewUserService(userRepo UserRepository) UserService {
    return UserService{
        UserRepo: userRepo
    }
}

Und Sie haben zwei separate Repositorys, die beide die UserRepository-Schnittstelle implementieren – das heißt, sie sollten Methoden mit demselben Namen und derselben Signatur (Parameter, Rückgabetyp) wie die Schnittstelle haben:

mongo_user_repository.go

Type MongoUserRepo struct {
    …
}

func (repo MongoUserRepo) CheckIfEmailExists(mail string) bool {
  … some mongo logic here
}

func (repo MongoUserRepo) Insert(user *models.User) error {
  … some mongo logic here
}

postgres_user_repository.go

type PostgresUserRepo struct {
    …
}

func (repo PostgresUserRepo) CheckIfEmailExists(mail string) bool {
  … some postgres logic here
}

func (repo PostgresUserRepo) Insert(user *models.User) error {
  … some postgres logic here
}

Sie können je nach Anwendungsfall jedes davon weitergeben, wie das (sehr schlechte) Beispiel unten:

main.go

…

var userService UserService

if os.Getenv(“environment”) == “prod” {
    userService = NewUserService(postgreUserRepo)
} else if os.Getenv(“environment”) == “dev” {
    userService = NewUserService(mongoUserRepo)
}

Das obige ist der detaillierte Inhalt vonCRUD mit Postgres und MongoDB?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!