一、下载我们需要的包
> go get github.com/fsnotify/fsnotify
二、使用fsnotify监控文件
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仍然是原来的文件名，这就需要我们在重命名事件中，先移除之前的监控，然后添加新的监控。
修改如下：
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代码如下：
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文件
> go build server.go
监控文件fsnotify3.go代码如下：
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掉进程，然后再启动一个进程。