Golang implémente la surveillance des fichiers

À mesure que les systèmes logiciels deviennent de plus en plus complexes, les opérations sur les fichiers deviennent de plus en plus importantes dans les systèmes logiciels. La surveillance des opérations sur les fichiers est l’une des clés pour garantir la stabilité du système. Cet article explique comment utiliser le langage Go pour implémenter la surveillance des fichiers.

Le langage Go est un langage de programmation open source, simultané et typé statiquement. En raison de ses excellentes performances de concurrence, le langage Go devient de plus en plus populaire dans le domaine de la programmation côté serveur. Dans le même temps, le langage Go fournit également une puissante bibliothèque standard, comprenant les opérations sur les fichiers, les opérations réseau, etc. Dans le scénario de surveillance de fichiers, l'interface d'exploitation de fichiers dans le package os fourni par la bibliothèque standard du langage Go est très pratique.

En langage Go, vous pouvez ouvrir, fermer, lire, écrire, renommer, supprimer des fichiers, etc. via l'interface fournie par le package os. Voici quelques fonctions d'opération de fichier couramment utilisées :

1. Ouvrir un fichier

Vous devez d'abord utiliser la fonction os.Open pour ouvrir un fichier :

func Open(name string) (*File, error)

Le nom du paramètre est le nom du fichier à ouvrir, et la valeur de retour est un pointeur vers le type de fichier et un objet d'erreur.

2. Fermez le fichier

Une fois l'opération sur le fichier terminée, vous devez fermer le fichier et libérer les ressources associées. Utilisez la méthode Close du type os.File pour fermer le fichier.

func (f *File) Close() error

3. Lire le fichier

Utilisez la méthode Read du type os.File pour lire le contenu du fichier :

func (f *File) Read(b []byte) (n int, err error)

Le paramètre b est une tranche de type octet du contenu reçu, et la valeur de retour est le nombre de octets lus et un objet d'erreur.

4. Écrire dans un fichier

Utilisez la méthode Write du type os.File pour écrire du contenu dans le fichier :

func (f *File) Write(b []byte) (n int, err error)

Le paramètre b est le contenu à écrire, et la valeur de retour est le nombre d'octets écrits et un objet d'erreur.

5. Supprimer des fichiers

Utilisez la fonction os.Remove pour supprimer des fichiers :

func Remove(name string) error

Le nom du paramètre est le nom du fichier à supprimer et la valeur de retour est un objet d'erreur.

Ces fonctions ci-dessus sont couramment utilisées dans les opérations sur les fichiers. Ensuite, nous utiliserons ces fonctions pour implémenter la surveillance des fichiers.

La mise en place du suivi des dossiers nécessite la mise en place de deux fonctions. La première consiste à surveiller les modifications apportées aux fichiers et la seconde à répondre aux modifications.

1. Surveiller les modifications des fichiers

Utilisez la méthode Stat de la classe File du package os pour obtenir des informations sur le fichier (telles que la taille, l'heure de modification, etc.) et obtenez à nouveau les mêmes informations sur le fichier après un certain temps. Si les informations sont différentes, cela signifie que le fichier a changé. L'implémentation spécifique est la suivante :

package main

import (
    "fmt"
    "os"
    "time"
)

func main() {
    file := "./example.txt"

    fileInfo, _ := os.Stat(file)

    fileCreateTime := fileInfo.ModTime()

    for {
        time.Sleep(1 * time.Second)
        fileInfo, err := os.Stat(file)
        if err != nil {
            fmt.Println(err)
            continue
        }

        if fileInfo.ModTime() != fileCreateTime {
            fmt.Println("file changed: ", file)
            break
        }
    }
}

Dans le code ci-dessus, l'objet FileInfo du fichier à surveiller est d'abord obtenu. Ensuite, utilisez la méthode ModTime de l'objet pour obtenir l'heure de modification du fichier. Ensuite, exécutez une boucle toutes les 1 seconde pour obtenir le nouvel objet FileInfo du fichier et comparez si les valeurs ModTime des deux objets FileInfo sont les mêmes. S'il est différent, le fichier a changé.

2. Réponse aux modifications de fichier

Lorsque le fichier change, vous devez répondre aux modifications du fichier. En fonctionnement réel, il faut généralement relire le contenu du fichier et effectuer les opérations commerciales correspondantes. Voici un exemple simple :

package main

import (
    "fmt"
    "os"
    "time"
)

func main() {
    file := "./example.txt"
    fileList := []string{file}
    readFile(fileList)

    for {
        before := getFileModTime(fileList)

        time.Sleep(1 * time.Second)
        after := getFileModTime(fileList)

        for k, v := range before {
            if v != after[k] {
                fmt.Printf("file changed: %v
", k)
                readFile(fileList)
            }
        }
    }
}

func getFileModTime(fileList []string) map[string]time.Time {
    ret := map[string]time.Time{}
    for _, v := range fileList {
        fileInfo, _ := os.Stat(v)
        modTime := fileInfo.ModTime()
        ret[v] = modTime
    }
    return ret
}

func readFile(fileList []string) {
    for _, v := range fileList {
        f, err := os.Open(v)
        if err != nil {
            fmt.Println("read file failed: ", err)
            continue
        }
        defer f.Close()

        b := make([]byte, 1024)
        n, err := f.Read(b)
        if err != nil {
            fmt.Println("read file failed: ", err)
            continue
        }

        fmt.Printf("file content of %s: %s
", v, string(b[:n]))
    }
}

Dans le code ci-dessus, nous enregistrons les fichiers qui doivent être surveillés dans une liste de fichiers de tranches de chaîne et lisons le fichier une fois au démarrage. La partie surveillance est similaire à celle ci-dessus, sauf qu'après avoir comparé les informations statistiques des deux fichiers, elle répond aux fichiers modifiés. La partie réponse utilise une fonction readFile, qui ouvre le fichier, utilise la méthode Read du type os.File pour lire le contenu du fichier et effectue un traitement métier sur le contenu lu.

À ce stade, une simple mise en œuvre de la surveillance des fichiers est terminée. Les lecteurs peuvent mettre en œuvre les fonctions de surveillance et de réponse plus en détail en fonction des besoins réels.

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!