CRUD avec Postgres et MongoDB ?

l'éditeur php Xigua vous apprendra comment utiliser Postgres et MongoDB pour effectuer des opérations CRUD dans cet article. Postgres est une base de données relationnelle, tandis que MongoDB est une base de données documentaire. Les opérations CRUD font référence au processus de création (Créer), de lecture (Lecture), de mise à jour (Mise à jour) et de suppression (Supprimer) de données. En combinant ces deux types de bases de données, vous pouvez choisir la base de données la plus adaptée aux opérations de données en fonction de différents besoins afin d'améliorer l'efficacité et la flexibilité. Explorons ensuite l'application de ces deux bases de données dans les opérations CRUD !

Contenu de la question

Je suis assez nouveau sur Go et les backends, et je participe au programme de stages Go. Nous avons construit un CRUD qui se connecte à une base de données psql et maintenant on me dit de me connecter à mongoDB, que nous utiliserons pour le développement et PSQL pour la production. Dois-je créer un nouveau gestionnaire pour mongo à partir de zéro ou puis-je utiliser le même gestionnaire et déterminer d'une manière ou d'une autre le type de base de données utilisée et utiliser la logique en conséquence ? Par exemple, j'ai un gestionnaire pour le point de terminaison d'enregistrement des utilisateurs :

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
}

J'ai construit les fonctions d'insertion, d'enregistrement et CheckIfEmailExists pour mongo :

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
}

Solution de contournement

Vous n'avez pas fourni de code sur la façon de créer UserService.

Idéalement, vous devriez avoir une interface qui ressemble à ceci :

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

Ensuite, le UserService doit être créé comme ceci :

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

Et vous aurez deux référentiels distincts, tous deux implémentant l'interface UserRepository - ce qui signifie qu'ils doivent avoir des méthodes avec le même nom et la même signature (paramètres, type de retour) que l'interface :

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
}

Vous pouvez transmettre n'importe lequel de ces éléments en fonction du cas d'utilisation, comme le (très mauvais) exemple ci-dessous :

main.go

…

var userService UserService

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!