So implementieren Sie die Dateiüberwachung in Golang

In Golang können Sie fsnotify verwenden, um die Dateiüberwachung zu implementieren. fsnotify ist ein plattformübergreifendes Dateisystemüberwachungstool in der Go-Sprache, das eine kanalbasierte, plattformübergreifende Echtzeitüberwachungsschnittstelle implementiert. Golang kann Dateien über fsnotify überwachen und das Programm durch Dateiänderungen neu starten.

Die Betriebsumgebung dieses Tutorials: Windows 10-System, GO Version 1.18, Dell G3-Computer.

In Golang können Sie fsnotify verwenden, um die Dateiüberwachung zu implementieren.

golang überwacht Dateien über fsnotify und startet das Programm bei Dateiänderungen neu.

Plattformübergreifendes Dateisystem-Überwachungstool der Go-Sprache – fsnotify

Im Linux-Kernel ist Inotify ein Mechanismus, der verwendet wird, um User-Space-Programme über Dateisystemänderungen zu benachrichtigen. Es überwacht Dateisystemänderungen wie das Erstellen, Ändern, Löschen usw. von Dateien und kann Anwendungen über entsprechende Ereignisse benachrichtigen.

Inotify kann sowohl Dateien als auch Verzeichnisse überwachen. Bei der Überwachung eines Verzeichnisses können das Verzeichnis und jedes Unterverzeichnis und jede Datei im Verzeichnis gleichzeitig überwacht werden. Der Standardbibliotheks-Systemaufruf von Golang implementiert diesen Mechanismus.

Zur weiteren Erweiterung und Abstraktion implementiert das Paket github.com/fsnotify/fsnotify eine kanalbasierte, plattformübergreifende Echtzeit-Überwachungsschnittstelle.

Verwendung des fsnotify-Tools

1. Laden Sie die benötigten Pakete herunter

go get github.com/fsnotify/fsnotify

2. Verwenden Sie fsnotify, um Dateien zu überwachen

Die Testergebnisse lauten wie folgt:

Alle unsere Vorgänge im tmp-Verzeichnis wurden erfasst, aber es gibt ein Problem mit fsnotify. Es kann uns nicht dabei helfen, die Vorgangsereignisse von Unterverzeichnissen und Enkelverzeichnissen rekursiv zu erfassen von uns selbst umgesetzt.

Ein weiteres Problem besteht darin, dass, wenn wir den Ordnernamen ändern, der event.Name in fsnotify immer noch der ursprüngliche Dateiname ist, was erfordert, dass wir zuerst die vorherige Überwachung entfernen und dann eine neue Überwachung im Umbenennungsereignis hinzufügen.

Geändert wie folgt:

Die Testergebnisse lauten wie folgt:

Nach dem obigen Beispiel verwenden wir fsnotify, um eine Überwachungskonfigurationsdatei zu schreiben. Wenn die Konfigurationsdatei geändert wird, wird der Dienst neu gestartet.

Wir schreiben zunächst ein exe-Programm, das ausgeführt werden kann. Der server.go-Code lautet wie folgt:

使用如下命令，编译成exe文件

> go build server.go

Der Code der Überwachungsdatei fsnotify3.go lautet wie folgt:

package main;package main;

import (
    "github.com/fsnotify/fsnotify"
    "log"
    "fmt"
    "os/exec"
    "regexp"
    "strconv"
    "bytes"
    "errors"
    "os"
    "path/filepath"
)

const (
    confFilePath = "./conf";
)

//获取进程ID
func getPid(processName string) (int, error) {
    //通过wmic process get name,processid | findstr server.exe获取进程ID
    buf := bytes.Buffer{};
    cmd := exec.Command("wmic", "process", "get", "name,processid");
    cmd.Stdout = &buf;
    cmd.Run();
    cmd2 := exec.Command("findstr", processName);
    cmd2.Stdin = &buf;
    data, _ := cmd2.CombinedOutput();
    if len(data) == 0 {
        return -1, errors.New("not find");
    }

import (🎜
    "github.com/fsnotify/fsnotify"🎜
    "log"🎜
    "fmt"🎜
    "os/exec" 🎜
    "regexp"🎜
    "strconv"🎜
    "bytes"🎜
    "errors"🎜
    "os "🎜
    "path/filepath"🎜)🎜
  🎜
const (🎜
    confFilePath = ./conf";🎜)🎜
  🎜
//获取进程ID🎜
func getPid(processName string) (int, error) {🎜
    //通过wmic-Prozess get name,processid | findstr server.exe获取进程ID🎜
    buf := Bytes. Buffer{};🎜
    cmd := exec.Command("wmic", "process", "get", "name,processid");🎜
    cmd.Stdout = &buf;🎜
    cmd.Run();🎜
    cmd2 : = exec.Command("findstr", processName);🎜
    cmd2.Stdin = &buf;🎜
    data, _ := cmd2.CombinedOutput();🎜
    if len(data) == 0 {🎜
        return -1,errors.New( "not find");🎜
    }🎜
    info := string(data);
    //这里通过正则把进程id提取出来
    reg := regexp.MustCompile(`[0-9]+`);
    pid := reg.FindString(info);
    return strconv.Atoi(pid);
}

//启动进程
func startProcess(exePath string, args []string) error {
    attr := &os.ProcAttr{
        //files指定新进程继承的活动文件对象
        //前三个分别为，标准输入、标准输出、标准错误输出
        Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},
        //新进程的环境变量
        Env: os.Environ(),
    }

    p, err := os.StartProcess(exePath, args, attr);
    if err != nil {
        return err;
    }
    fmt.Println(exePath, "进程启动");
    p.Wait();
    return nil;
}

func main() {
    //创建一个监控对象
    watch, err := fsnotify.NewWatcher();
    if err != nil {
        log.Fatal(err);
    }
    defer watch.Close();
    //添加要监控的文件
    err = watch.Add(confFilePath);
    if err != nil {
        log.Fatal(err);
    }
    //我们另启一个goroutine来处理监控对象的事件
    go func() {
        for {
            select {
            case ev :=
                {
                    //我们只需关心文件的修改
                    if ev.Op&fsnotify.Write == fsnotify.Write {
                        fmt.Println(ev.Name, "文件写入");
                        //查找进程
                        pid, err := getPid("server.exe");
                        //获取运行文件的绝对路径
                        exePath, _ := filepath.Abs("./server.exe")
                        if err != nil {
                            //启动进程
                            go startProcess(exePath, []string{});
                        } else {
                            //找到进程，并退出
                            process, err := os.FindProcess(pid);
                            if err == nil {
                                //让进程退出
                                process.Kill();
                                fmt.Println(exePath, "进程退出");
                            }
                            //启动进程
                            go startProcess(exePath, []string{});
                        }
                    }
                }
            case err :=
                {
                    fmt.Println("error : ", err);
                    return;
                }
            }
        }
    }();

    //循环
    select {};
}

Wir führen die Datei fsnotify3.go aus, um unsere Konfigurationsdatei zu überwachen

Wie Sie auf dem Bild oben sehen können, wird der Vorgang ausgeführt, wenn wir die Portnummer in der Konfigurationsdatei ändern Zuerst getötet und dann einen anderen Prozess gestartet.

Empfohlenes Lernen: Golang-Tutorial

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die Dateiüberwachung in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!