ORM dans Beego - utiliser Xorm pour faciliter les opérations de base de données

Beego est un framework Web open source en langage Go qui fournit de nombreux outils et bibliothèques pratiques pour accélérer le développement Web. Parmi eux, la bibliothèque ORM (Object Relational Mapping) est un composant très important, qui permet aux développeurs d'effectuer plus facilement des opérations sur les données. Dans Beego, Xorm est une bibliothèque d'opérations de base de données basée sur ORM, très simple et efficace à utiliser. Cet article explique comment utiliser Xorm pour faire fonctionner la base de données.

1. Introduction à Xorm

Xorm est une bibliothèque ORM basée sur le langage Go, similaire à Hibernate ou MyBatis de Java. Il prend en charge plusieurs bases de données relationnelles, notamment MySQL, PostgreSQL, SQLite, etc. Contrairement aux autres bibliothèques ORM du langage Go, Xorm utilise un mécanisme de réflexion pour cartographier la relation entre les objets et les tables, ce qui la rend plus flexible et plus pratique.

2. Installez Xorm

Avant d'utiliser Xorm, nous devons d'abord l'installer. Vous pouvez utiliser l'outil de ligne de commande de Go pour installer Xorm :

go get xorm.io/xorm

3. Configurer Xorm

Utiliser Xorm dans Beego est très simple Il vous suffit de spécifier le type de base de données, l'adresse de la base de données, le nom d'utilisateur et le mot de passe dans le fichier de configuration :

.

# 配置数据库类型
db_driver = mysql
# 配置数据库地址
db_address = root:password@/testdb?charset=utf8
# 配置数据库最大闲置连接数
db_max_idle_conn = 10
# 配置数据库最大连接数
db_max_open_conn = 100

4. Faire fonctionner la base de données

1. Définir la structure

La première étape pour utiliser Xorm pour faire fonctionner la base de données est de définir la structure dans la table de la base de données et d'utiliser des balises pour identifier la relation de mappage entre la structure et le table de base de données. Par exemple, nous avons une table de données nommée user avec la structure suivante : user的数据表，其结构如下：

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) NOT NULL,
  `email` varchar(255) NOT NULL,
  `age` int(11) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

那么我们定义的结构体将会是：

type User struct {
    Id    int    `xorm:"pk autoincr"`
    Name  string `xorm:"varchar(255) notnull"`
    Email string `xorm:"varchar(255) notnull"`
    Age   int    `xorm:"int(11) notnull"`
}

2. 创建引擎

在操作数据库之前，我们需要先创建一个Xorm引擎。引擎是Xorm与数据库之间的桥梁，我们使用它来进行各种数据库操作，例如插入、查询、更新和删除等。创建引擎的方式如下：

import (
    "xorm.io/xorm"
    "github.com/astaxie/beego"
)

var (
    engine *xorm.Engine
)

func init() {
    dbDriver := beego.AppConfig.String("db_driver")
    dbAddress := beego.AppConfig.String("db_address")
    engine, err = xorm.NewEngine(dbDriver, dbAddress)
    if err != nil {
        beego.Error(err)
    }

    // 配置连接池
    maxIdleConn := beego.AppConfig.DefaultInt("db_max_idle_conn", 10)
    maxOpenConn := beego.AppConfig.DefaultInt("db_max_open_conn", 100)
    engine.SetMaxIdleConns(maxIdleConn)
    engine.SetMaxOpenConns(maxOpenConn)
}

3. 插入数据

使用Xorm插入数据非常简单，只需创建一个结构体对象并赋值，然后使用engine.Insert()函数即可：

func insertUser(user *User) error {
    _, err := engine.Insert(user)
    if err != nil {
        beego.Error(err)
        return err
    }
    return nil
}

4. 查询数据

使用Xorm查询数据也很方便。可以使用engine.Where()和engine.And()等函数来指定查询条件，还可以使用engine.OrderBy()来指定排序方式。查询结果可以使用Find()、Get()和Iterate()等函数进行处理：

func getUserByName(name string) (*User, error) {
    user := &User{}
    _, err := engine.Where("name = ?", name).Get(user)
    if err != nil {
        beego.Error(err)
        return nil, err
    }
    return user, nil
}

func getAllUsers() ([]*User, error) {
    users := make([]*User, 0)
    err := engine.Find(&users)
    if err != nil {
        beego.Error(err)
        return nil, err
    }
    return users, nil
}

5. 更新数据

使用Xorm更新数据也很简单，只需创建一个结构体对象并赋值，然后使用engine.Id()和engine.Update()函数即可：

func updateUser(user *User) error {
    _, err := engine.Id(user.Id).Update(user)
    if err != nil {
        beego.Error(err)
        return err
    }
    return nil
}

6. 删除数据

使用Xorm删除数据同样很容易。可以使用engine.Id()和engine.Delete()

func deleteUser(id int) error {
    _, err := engine.Id(id).Delete(&User{})
    if err != nil {
        beego.Error(err)
        return err
    }
    return nil
}

Ensuite, la structure que nous définirons sera :

rrreee

Create engine
🎜Avant Pour exploiter la base de données, nous devons d'abord créer un moteur Xorm. Le moteur est le pont entre Xorm et la base de données. Nous l'utilisons pour effectuer diverses opérations sur la base de données, telles que les insertions, les requêtes, les mises à jour et les suppressions. La façon de créer un moteur est la suivante : 🎜rrreee
🎜Insérer des données🎜🎜🎜Insérer des données à l'aide de Xorm est très simple, il suffit de créer un objet de structure et d'attribuer une valeur, puis d'utiliser Fonction engine.Insert() : 🎜rrreee<ol start="4">🎜Interroger des données🎜🎜🎜Il est également très pratique d'utiliser Xorm pour interroger des données. Vous pouvez utiliser des fonctions telles que <code>engine.Where() et engine.And() pour spécifier les conditions de requête, et vous pouvez également utiliser engine.OrderBy() pour spécifier la méthode de tri. Les résultats de la requête peuvent être traités à l'aide de fonctions telles que <code>Find(), Get() et Iterate() : 🎜rrreee
🎜Mettre à jour les données🎜🎜🎜La mise à jour des données à l'aide de Xorm est également très simple. Créez simplement un objet de structure et attribuez une valeur, puis utilisez engine.Id() et engine.Update( ) code> fonction : 🎜rrreee
🎜Supprimer des données🎜🎜🎜La suppression de données à l'aide de Xorm est également simple. Vous pouvez utiliser les fonctions engine.Id() et engine.Delete() pour spécifier les données à supprimer : 🎜rrreee🎜 5. Résumé 🎜🎜Xorm est un très Bibliothèque ORM du langage Go pratique et facile à utiliser. Il utilise un mécanisme de réflexion pour cartographier la relation entre les objets et les tables de base de données, afin que les développeurs n'aient pas à écrire manuellement des instructions SQL, ce qui rend les opérations de base de données plus faciles et plus efficaces. Utiliser Xorm dans Beego est très simple. Configurez simplement les informations de la base de données et suivez le processus ci-dessus. 🎜

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!