golang怎么实现文件监控

本教程操作环境：windows10系统、GO 1.18版本、Dell G3电脑。

在golang中，可以利用fsnotify来实现文件监控。

golang 通过fsnotify监控文件，并通过文件变化重启程序。

go语言跨平台文件系统监控工具 — fsnotify

在 linux 内核中，Inotify 是一种用于通知用户空间程序文件系统变化的机制。它监控文件系统的变化，如文件新建、修改、删除等，并可以将相应的事件通知给应用程序。

Inotify 既可以监控文件，也可以监控目录。当监控目录时，它可以同时监控目录及目录中的各子目录及文件。Golang 的标准库 syscall 实现了该机制。

为了进一步扩展和抽象， github.com/fsnotify/fsnotify 包实现了一个基于 channel 的、跨平台的实时监听接口。

fsnotify工具的使用

一、下载我们需要的包

go get github.com/fsnotify/fsnotify

登录后复制

二、使用fsnotify监控文件

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

package main; import ( "github.com/fsnotify/fsnotify" "log" "fmt" ) func main() { //创建一个监控对象 watch, err := fsnotify.NewWatcher(); if err != nil { log.Fatal(err); } defer watch.Close(); //添加要监控的对象，文件或文件夹 err = watch.Add("./tmp"); if err != nil { log.Fatal(err); } //我们另启一个goroutine来处理监控对象的事件 go func() { for { select { case ev := <-watch.Events: { //判断事件发生的类型，如下5种 // Create 创建 // Write 写入 // Remove 删除 // Rename 重命名 // Chmod 修改权限 if ev.Op&fsnotify.Create == fsnotify.Create { log.Println("创建文件 : ", ev.Name); } if ev.Op&fsnotify.Write == fsnotify.Write { log.Println("写入文件 : ", ev.Name); } if ev.Op&fsnotify.Remove == fsnotify.Remove { log.Println("删除文件 : ", ev.Name); } if ev.Op&fsnotify.Rename == fsnotify.Rename { log.Println("重命名文件 : ", ev.Name); } if ev.Op&fsnotify.Chmod == fsnotify.Chmod { log.Println("修改权限 : ", ev.Name); } } case err := <-watch.Errors: { log.Println("error : ", err); return; } } } }(); //循环 select {}; }

测试结果如下：

我们在tmp目录下的操作都被捕捉到了，但是fsnotify有一个问题，它无法递归的帮我们捕捉子目录、孙子目录的操作事件，这需要我们自已来实现。

还有一个问题就是当们修改文件夹名称时，fsnotify中event.Name仍然是原来的文件名，这就需要我们在重命名事件中，先移除之前的监控，然后添加新的监控。

修改如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88

package main; import ( "github.com/fsnotify/fsnotify" "fmt" "path/filepath" "os" ) type Watch struct { watch *fsnotify.Watcher; } //监控目录 func (w *Watch) watchDir(dir string) { //通过Walk来遍历目录下的所有子目录 filepath.Walk(dir, func(path string, info os.FileInfo, err error) error { //这里判断是否为目录，只需监控目录即可 //目录下的文件也在监控范围内，不需要我们一个一个加 if info.IsDir() { path, err := filepath.Abs(path); if err != nil { return err; } err = w.watch.Add(path); if err != nil { return err; } fmt.Println("监控 : ", path); } return nil; }); go func() { for { select { case ev := <-w.watch.Events: { if ev.Op&fsnotify.Create == fsnotify.Create { fmt.Println("创建文件 : ", ev.Name); //这里获取新创建文件的信息，如果是目录，则加入监控中 fi, err := os.Stat(ev.Name); if err == nil && fi.IsDir() { w.watch.Add(ev.Name); fmt.Println("添加监控 : ", ev.Name); } } if ev.Op&fsnotify.Write == fsnotify.Write { fmt.Println("写入文件 : ", ev.Name); } if ev.Op&fsnotify.Remove == fsnotify.Remove { fmt.Println("删除文件 : ", ev.Name); //如果删除文件是目录，则移除监控 fi, err := os.Stat(ev.Name); if err == nil && fi.IsDir() { w.watch.Remove(ev.Name); fmt.Println("删除监控 : ", ev.Name); } } if ev.Op&fsnotify.Rename == fsnotify.Rename { fmt.Println("重命名文件 : ", ev.Name); //如果重命名文件是目录，则移除监控 //注意这里无法使用os.Stat来判断是否是目录了 //因为重命名后，go已经无法找到原文件来获取信息了 //所以这里就简单粗爆的直接remove好了 w.watch.Remove(ev.Name); } if ev.Op&fsnotify.Chmod == fsnotify.Chmod { fmt.Println("修改权限 : ", ev.Name); } } case err := <-w.watch.Errors: { fmt.Println("error : ", err); return; } } } }(); } func main() { watch, _ := fsnotify.NewWatcher() w := Watch{ watch: watch, } w.watchDir("./tmp"); select {}; }

测试结果如下：

经过上面的例子，我们通过fsnotify来写一个监控配置文件，如果配置文件有修改，就重新启动服务。

我们先写一个可以运行的exe程序，server.go代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58

package main; import ( "io/ioutil" "log" "encoding/json" "net" "fmt" "os" "os/signal" ) const ( confFilePath = "./conf/conf.json"; ) //我们这里只是演示，配置项只设置一个 type Conf struct { Port int `json:port`; } func main() { //读取文件内容 data, err := ioutil.ReadFile(confFilePath); if err != nil { log.Fatal(err); } var c Conf; //解析配置文件 err = json.Unmarshal(data, &c); if err != nil { log.Fatal(err); } //根据配置项来监听端口 lis, err := net.Listen("tcp", fmt.Sprintf(":%d", c.Port)); if err != nil { log.Fatal(err); } log.Println("server start"); go func() { ch := make(chan os.Signal); //获取程序退出信号 signal.Notify(ch, os.Interrupt, os.Kill); <-ch; log.Println("server exit"); os.Exit(1); }(); for { conn, err := lis.Accept(); if err != nil { continue; } go func(conn net.Conn) { defer conn.Close(); conn.Write([]byte("hello\n")); }(conn); } }

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

1	> go build server.go

监控文件fsnotify3.go代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111

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"); } 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 := <-watch.Events: { //我们只需关心文件的修改 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 := <-watch.Errors: { fmt.Println("error : ", err); return; } } } }(); //循环 select {}; }

我们运行fsnotify3.go文件来监控我们的配置文件

通过上面的图可以看到，当我们修改配置文件中的端口号时，会先kill掉进程，然后再启动一个进程。

推荐学习：Golang教程

以上就是golang怎么实现文件监控的详细内容，更多请关注Work网其它相关文章！