Golang implémente la pagination

Avec le développement de la technologie Internet et la quantité croissante de données, les requêtes de pagination de données deviennent de plus en plus courantes. En Golang, la requête de pagination n'est pas trop gênante et l'efficacité de la pagination peut être améliorée grâce à certaines optimisations.

1. Pagination de base

En Golang, la méthode la plus basique de requête de pagination consiste à utiliser la clause limit dans l'instruction SQL. Par exemple :

SELECT * FROM table LIMIT offset, limit;

où offset représente le décalage et limit représente le nombre d'enregistrements renvoyés. Par exemple, si 10 éléments de données sont affichés sur chaque page, alors l'instruction SQL de la page 1 est :

SELECT * FROM table LIMIT 0, 10;

L'instruction SQL de la page 2 est :

SELECT * FROM table LIMIT 10, 10;

Cette méthode nécessite un calcul manuel du décalage et du nombre d'enregistrements pour chaque page, ce qui est plus fastidieux et sujet aux erreurs. Par conséquent, nous pouvons utiliser certaines bibliothèques pour simplifier la mise en œuvre des requêtes paginées.

2. Utilisez la bibliothèque gorm pour implémenter la pagination

gorm est une bibliothèque golang orm couramment utilisée, qui fournit une méthode de requête de pagination très pratique. Nous pouvons utiliser ses méthodes Limit et Offset intégrées pour implémenter des requêtes de pagination. Par exemple :

db.Limit(10).Offset(0).Find(&users)

Parmi elles, la méthode Limit représente le nombre d'enregistrements renvoyés, la méthode Offset représente le décalage et la méthode Find est utilisée pour exécuter la requête.

Ce qui suit est un exemple simple pour montrer comment utiliser la bibliothèque gorm pour implémenter des requêtes de pagination :

package main

import (
    "fmt"
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/mysql"
)

type User struct {
    Id   int
    Name string
    Age  int
}

func main() {
    db, _ := gorm.Open("mysql", "root:123456@/test?charset=utf8mb4&parseTime=True&loc=Local")

    defer db.Close()

    // 创建表
    db.AutoMigrate(&User{})

    // 添加测试数据
    for i := 0; i < 100; i++ {
        user := User{Id: i + 1, Name: fmt.Sprintf("user%d", i+1), Age: i%20 + 10}
        db.Create(&user)
    }

    // 分页查询
    page := 5       // 第5页
    pageSize := 10   // 每页10条记录
    offset := (page - 1) * pageSize // 计算偏移量
    var users []User

    // 查询第5页的记录
    db.Limit(pageSize).Offset(offset).Find(&users)

    // 输出结果
    for _, user := range users {
        fmt.Printf("ID: %d, Name: %s, Age: %d
", user.Id, user.Name, user.Age)
    }
}

Exécutez le code ci-dessus, le résultat de sortie est :

ID: 41, Name: user41, Age: 10
ID: 42, Name: user42, Age: 11
ID: 43, Name: user43, Age: 12
ID: 44, Name: user44, Age: 13
ID: 45, Name: user45, Age: 14
ID: 46, Name: user46, Age: 15
ID: 47, Name: user47, Age: 16
ID: 48, Name: user48, Age: 17
ID: 49, Name: user49, Age: 18
ID: 50, Name: user50, Age: 19

3 Utilisez la bibliothèque de pagination pour implémenter la pagination

De plus. à l'utilisation de la méthode de pagination intégrée de gorm. De plus, nous pouvons également utiliser certaines bibliothèques de pagination tierces pour implémenter la pagination. Par exemple :

1. paginator

paginator est une bibliothèque de pagination Golang légère qui prend en charge MySQL, Postgres, SQLite3 et d'autres bases de données. C'est très simple à utiliser, il suffit de spécifier le numéro de la page actuelle, le nombre d'enregistrements par page et le nombre total d'enregistrements. Voici un exemple :

package main

import (
    "fmt"
    "github.com/biezhi/gorm-paginator/pagination"
    _ "github.com/jinzhu/gorm/dialects/mysql"
    "github.com/jinzhu/gorm"
)

type User struct {
    Id   uint `gorm:"primary_key"`
    Name string
    Age  uint
}

func main() {
    db,_ := gorm.Open("mysql", "root:123456@/test?charset=utf8mb4&parseTime=True&loc=Local")

    var users []User
    pagination.Paging(&pagination.Param{
        DB:      db,
        Page:    5,
        Limit:   10,
        OrderBy: []string{"id desc"},
        ShowSQL: true,
    }, &users)

    for _, user := range users {
        fmt.Printf("ID: %d, Name: %s, Age: %d
", user.Id, user.Name, user.Age)
    }
}

2. go-paginator

go-paginator est une autre bibliothèque de pagination Golang légère qui ne repose sur aucune base de données et est très pratique à utiliser. Voici un exemple :

package main

import (
    "fmt"
    "github.com/liyuliang/go-paginator"
)

type User struct {
    Id   uint
    Name string
    Age  uint
}

func main() {
    var users []User
    pageSize := 10                                    // 每页记录数
    page, _ := paginator.New(paginator.Config{        // 初始化分页器
        CurrentPage: 5,                               // 当前页码
        PageSize:    pageSize,                         // 每页记录数
        Total:       100,                              // 总记录数
    })

    records := make([]interface{}, 100)                // 模拟100条记录
    for i := 0; i < 100; i++ {
        user := User{Id: uint(i + 1), Name: fmt.Sprintf("user%d", i+1), Age: uint(i%20 + 10)}
        records[i] = user
    }

    pageData := page.Data(records)                     // 获取分页数据
    offset := (page.CurrentPage - 1) * pageSize         // 计算偏移量
    users = pageData[offset : offset+pageSize].([]User) // 获取当前页的记录

    for _, user := range users {
        fmt.Printf("ID: %d, Name: %s, Age: %d
", user.Id, user.Name, user.Age)
    }
}

Cependant, il convient de noter que les bibliothèques de pagination nous obligent généralement à calculer manuellement le nombre total d'enregistrements, ce qui peut affecter l'efficacité des requêtes. Par conséquent, si le nombre total d'enregistrements n'est pas très grand, nous ne pouvons pas utiliser la bibliothèque de pagination, mais utiliser la méthode de pagination intégrée de gorm.

4. Optimisation de la pagination

Dans les applications réelles, les requêtes de pagination peuvent rencontrer des problèmes de performances, en particulier lorsque la quantité de données est importante. Afin d'améliorer l'efficacité des requêtes, certaines des méthodes d'optimisation suivantes peuvent être adoptées :

1. Utiliser le cache

Si les données n'ont pas besoin d'être mises à jour en temps réel, les résultats de la requête peuvent être mis en cache dans la mémoire, et le les données peuvent être obtenues directement à partir du cache lors de la prochaine visite pour éviter un accès fréquent à la base de données.

2. Réduisez le nombre de champs renvoyés

Si l'enregistrement interrogé contient un grand nombre de champs, vous ne pouvez renvoyer que certains champs pour éviter d'interroger une grande quantité de données inutiles.

3. Utilisez des index

Ajoutez des index aux champs fréquemment interrogés, ce qui peut considérablement améliorer l'efficacité des requêtes.

4. Requête par lots

Lorsque la quantité de données est importante, vous pouvez utiliser une requête par lots pour interroger un lot de données à la fois afin d'éviter l'inefficacité causée par l'interrogation de trop de données à la fois.

En général, il est très simple d'implémenter une requête de pagination dans Golang. Grâce à la bibliothèque gorm intégrée et à la bibliothèque de pagination tierce, nous pouvons facilement implémenter la fonction de pagination et améliorer l'efficacité des requêtes grâce à certaines optimisations.

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!