扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > GO >golang如何实现文件监控
  • 650

0
分享到

golang如何实现文件监控

2023-07-05 03:07:11 650人浏览 泡泡鱼
摘要

本篇内容介绍了“golang如何实现文件监控”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！在Golang中，可以利用fsnotify来实现文

本篇内容介绍了“golang如何实现文件监控”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

在Golang中，可以利用fsnotify来实现文件监控。fsnotify是go语言跨平台文件系统监控工具，实现了一个基于channel的、跨平台的实时监听接口；golang通过fsnotify可监控文件，并通过文件变化重启程序。

在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 {};

}

测试结果如下：

golang如何实现文件监控

我们在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 {};

}

测试结果如下：

golang如何实现文件监控

经过上面的例子，我们通过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文件来监控我们的配置文件

golang如何实现文件监控

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

golang如何实现文件监控

“golang如何实现文件监控”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注编程网网站，小编将为大家输出更多高质量的实用文章！

您可能感兴趣的文档:

--结束END--

本文标题: golang如何实现文件监控

本文链接: https://lsjlt.com/news/349343.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • golang如何实现文件监控
    本篇内容介绍了“golang如何实现文件监控”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！在golang中，可以利用fsnotify来实现文...
    99+
    2023-07-05
  • golang怎么实现文件监控
    在golang中，可以利用fsnotify来实现文件监控。fsnotify是go语言跨平台文件系统监控工具，实现了一个基于channel的、跨平台的实时监听接口；golang通过fsnotify可监控文件，并通过文件变化重启程序。本教程操作...
    99+
    2023-05-14
    go语言 Golang
  • 深入探究：Golang如何实现文件监控功能
    Golang作为一种高效、简洁的编程语言，在文件处理方面有着出色的表现。其中，文件监控是一个非常常见且有用的功能，可以帮助我们实时监测文件系统中的变化，从而及时做出相应的处理。本文将深...
    99+
    2024-02-23
    golang 实现 文件监控 日志监控
  • golang进程监控如何实现
    在Golang中，可以使用一些库来实现进程监控，如Prometheus和Gin等。下面是一个使用Gin和Prometheus库实现进...
    99+
    2023-10-26
    golang
  • 详细介绍如何在Golang中实现文件监控功能
    使用Golang实现文件监控功能的方法详解 随着软件开发的日益普及，文件监控功能在很多应用中变得越来越重要。无论是监视配置文件的更改、日志文件的更新，还是监控文件夹中新文件的添加，都是...
    99+
    2024-02-23
    监控文件变化 golang实现 文件监听
  • Java实现文件监控器FileMonitor
    　　应用场景：　　代码可以实现文件变化后的监听，如文件变化，自动重新加载文件内容，实现配置文件的热部署。　　代码：　　package com.yx.demo.filemonitor;　　import java.io.File;　　impor...
    99+
    2023-06-02
  • Linux中如何实时监控日志文件
    这期内容当中小编将会给大家带来有关Linux中如何实时监控日志文件，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。1. tail Command &ndash; Monitor Logs in Re...
    99+
    2023-06-16
  • Linux下如何实时监控日志文件
    这篇文章给大家分享的是有关Linux下如何实时监控日志文件的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。如何在Linux中实时查看日志文件的内容有很多实用工具可以帮助用户在文件修改或不断更新时跟踪或监控文件发生的...
    99+
    2023-06-27
  • 如何监控Linux文件变化
    这篇文章主要介绍了如何监控Linux文件变化，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。概述在*nix体系一切皆文件，系统文件的变化往往反应着系统的变化，比如系统应用的更新...
    99+
    2023-06-16
  • 如何使用Python实现实时监控数组文件变化？
    在日常的编程工作中，我们经常需要监控某些文件的变化，并且在文件发生变化时能够及时作出相应的处理。在本文中，我们将介绍如何使用Python实现实时监控数组文件变化，并且通过演示代码来帮助您更好地理解。 使用Python的watchdog模...
    99+
    2023-07-05
    实时 数组 文件
  • golang如何实现文件锁
    本篇内容主要讲解“golang如何实现文件锁”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“golang如何实现文件锁”吧!在golang中，可以利用sync包的api来实现文件锁。文件锁（flo...
    99+
    2023-07-04
  • python实现实时监控文件的方法
    在业务稳定性要求比较高的情况下，运维为能及时发现问题，有时需要对应用程序的日志进行实时分析，当符合某个条件时就立刻报警，而不是被动等待出问题后去解决，比如要监控nginx的$request_time和$up...
    99+
    2022-06-04
    实时监控 文件 方法
  • GoLang日志监控系统实现
    目录日志监控系统项目简答介绍系统架构读取模块具体实现日志解析模块日志监控系统 Nginx（日志文件） -> log_process (实时读取解析写入) -> influ...
    99+
    2022-12-15
    GoLang日志监控 GoLang日志
  • Golang哈希算法实现配置文件的监控功能详解
    目录Golang hash256实现包使用sha256.New()使用sha256.Sum256()函数监控配置文件变化获取配置hash值总结SHA(secure hashing a...
    99+
    2023-03-08
    Go哈希算法监控配置文件 Go哈希算法
  • 创建有效的文件监控系统：使用Golang实现指南
    构建高效的文件监控系统：Golang实现指南 随着信息技术的不断发展，文件管理和数据监控成为了现代软件开发中一个不可或缺的环节。在众多的编程语言中，Golang以其高效、并发性强、易于...
    99+
    2024-02-24
    golang 文件监控 高效
  • 如何用Shell监控文件变化
    这篇文章主要讲解了“如何用Shell监控文件变化”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“如何用Shell监控文件变化”吧！文件监控可以配合rsync实现文件自动同步，例如监听某个目录，...
    99+
    2023-06-15
  • 分享Golang文件监控的实践经验和技巧
    Golang文件监控实践与技巧分享 在日常的开发工作中，文件监控是一项极其重要的任务，它可以帮助我们实时监控文件的变化并做出相应的处理。Golang作为一门强大的编程语言，在文件监控领...
    99+
    2024-02-26
    golang 文件监控 技巧分享
  • Redis如何实现性能监控
    小编给大家分享一下Redis如何实现性能监控，希望大家阅读完这篇文章之后都有所收获，下面让我们一起去探讨吧！redis_exporter + prometheus +grafana监控Redis服务指标1....
    99+
    2024-04-02
  • Linux如何实现性能监控
    小编给大家分享一下Linux如何实现性能监控，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！ TOP命令显示的是一些Oracle session占用CPU...
    99+
    2023-06-13
  • golang如何实现大文件传输
    在 Golang 中，可以使用 io 和 os 包来实现大文件的传输。以下是一种可能的实现方式： 首先，需要创建一个服务器端和一个客...
    99+
    2023-10-21
    golang
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作