读文件

ReadFile直接读取

package main

import (
    "fmt"
    "io/ioutil"
    "strings"
)

// 使用ReadFile直接读取
// 读取文件内容，并返回[]byte数据和错误信息。err == nil时，读取成功
func main() {
    file := "/usr/local/nginx/logs/access.log"
    if contents, err := ioutil.ReadFile(file); err == nil {
        //[]byte类型，转换成string类型后会多一行空格,使用strings.Replace替换换行符
        result := strings.Replace(string(contents), "\n", "", 1)
        fmt.Println(result)
    }
}

ReadAll 读取文件

package main

import (
    "fmt"
    "io/ioutil"
    "os"
    "strings"
)

// ioutil.ReadAll()读取文件示例
// ReadAll从源中读取数据直到EOF
func main() {
    file := "/usr/local/nginx/logs/access.log"
    if fileObj,err := os.Open(file);err == nil {
        //if fileObj,err := os.OpenFile(name,os.O_RDONLY,0644); err == nil {
        defer fileObj.Close()
        if contents,err := ioutil.ReadAll(fileObj); err == nil {
            result := strings.Replace(string(contents),"\n","",1)
            fmt.Println("Use os.Open family functions and ioutil.ReadAll to read a file contents:",result)
        }

    }
}

Read方法读取

package main

import (
    "fmt"
    "os"
    "strconv"
    "strings"
)

// 使用文件对象的Read方法读取
// Read方法从文件中读取最多len(b)字节数据并写入
func main() {
    file := "/usr/local/nginx/logs/access.log"
    if fileObj,err := os.Open(file);err == nil {
        defer fileObj.Close()
        //在定义空的byte列表时尽量大一些，否则这种方式读取内容可能造成文件读取不完整
        buf := make([]byte, 1024)
        if n,err := fileObj.Read(buf);err == nil {
            fmt.Println("字节数:"+strconv.Itoa(n))
            result := strings.Replace(string(buf),"\n","",1)
            fmt.Println(result)
        }
    }
}

使用os.Open和bufio.Reader读取文件内容

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
)

// 使用os.Open和bufio.Reader读取文件内容
func main() {

    file := "/usr/local/nginx/logs/access.log"
    if fileObj, err := os.Open(file); err == nil {
        defer fileObj.Close()

        // 一个文件对象本身是实现了io.Reader的
        // 使用bufio.NewReader去初始化一个Reader对象，存在buffer中的，读取一次就会被清空
        reader := bufio.NewReader(fileObj)

        // 使用ReadString(delim byte)来读取delim以及之前的数据并返回相关的字符串.
        if result, err := reader.ReadString(byte('\n')); err == nil {
            fmt.Println("使用ReadSlince相关方法读取内容:", result)
        }

        // 注意:上述ReadString已经将buffer中的数据读取出来了，下面将不会输出内容
        // 需要注意的是，因为是将文件内容读取到[]byte中，因此需要对大小进行一定的把控
        buf := make([]byte, 1024)

        // 读取Reader对象中的内容到[]byte类型的buf中
        if n, err := reader.Read(buf); err == nil {
            fmt.Println(strconv.Itoa(n))
            fmt.Println(string(buf))
        }

    }
}

写文件

使用 WriteFile方式写入文件

package main

import (
    "fmt"
    "io/ioutil"
)

// 使用ioutil.WriteFile方式写入文件
// 将[]byte内容写入文件,如果content字符串中没有换行符的话，默认就不会有换行符
func main() {
    name := "./test.txt"
    content := "Hello, World!"
    data :=  []byte(content)
    if ioutil.WriteFile(name,data,0644) == nil {
        fmt.Println("写入文件成功:",content)
    }
}

使用WriteString 方式写入文件

package main

import (
    "fmt"
    "io"
    "os"
)

// WriteString()函数，用来将字符串写入一个Writer对象中
func main() {

    name := "./test.txt"
    content := "Hello, World!"

    /*
        O_RDONLY int = syscall.O_RDONLY // 只读打开文件和os.Open()同义
        O_WRONLY int = syscall.O_WRONLY // 只写打开文件
        O_RDWR   int = syscall.O_RDWR   // 读写方式打开文件
        O_APPEND int = syscall.O_APPEND // 当写的时候使用追加模式到文件末尾
        O_CREATE int = syscall.O_CREAT  // 如果文件不存在，此案创建
        O_EXCL   int = syscall.O_EXCL   // 和O_CREATE一起使用, 只有当文件不存在时才创建
        O_SYNC   int = syscall.O_SYNC   // 以同步I/O方式打开文件，直接写入硬盘.
        O_TRUNC  int = syscall.O_TRUNC  // 如果可以的话，当打开文件时先清空文件
    */
    fileObj,err := os.OpenFile(name,os.O_RDWR|os.O_CREATE|os.O_APPEND,0644)
    if err != nil {
        fmt.Println(err.Error())
        os.Exit(2)
    }
    if  _,err := io.WriteString(fileObj,content);err == nil {
        fmt.Println("写入文件成功:",content)
    }
}

使用bufio包中Writer对象的写入文件

package main

import (
    "bufio"
    "fmt"
    "os"
)

// 使用bufio包中Writer对象的相关方法进行数据的写入
func main() {

    name := "./test.txt"
    content := "Hello, World!\n"

    if fileObj,err := os.OpenFile(name,os.O_RDWR|os.O_CREATE|os.O_APPEND,0644);err == nil {
        defer fileObj.Close()

        // 使用WriteString方法,写入字符串并返回写入字节数和错误信息
        writeObj := bufio.NewWriterSize(fileObj,4096)
        if _,err := writeObj.WriteString(content);err == nil {
            fmt.Println(content)
        }

        // 使用Write方法,需要使用Writer对象的Flush方法将buffer中的数据刷到磁盘
        buf := []byte(content)
        if _,err := writeObj.Write(buf);err == nil {
            if  err := writeObj.Flush(); err != nil {panic(err)}
            fmt.Println(content)
        }
    }
}

文件实时读取

package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
    "strings"
    "time"
)

// 文件监控
type DocMonitoring struct {
    LogPath   string      // 日志文件路径
    ReadChan  chan string // 读取chan
    WriteChan chan string // 写入chan
}

// 文件读取逻辑
func (dm *DocMonitoring) Read() {
    fmt.Println("Read start-up success")

    fileObj, err := os.Open(dm.LogPath);
    if err != nil {
        fmt.Println(err)
        os.Exit(2)
    }

    defer fileObj.Close()

    buf := bufio.NewReader(fileObj)
    // 定位到末尾
    fileObj.Seek(0, 2)
    for {
        if result, err := buf.ReadString('\n'); err == nil {
            if err == io.EOF {
                time.Sleep(100 * time.Millisecond)
                continue;
            } else {
                dm.ReadChan <- result
            }
        }
    }

}

// 内容处理逻辑
func (dm *DocMonitoring) Handle() {
    fmt.Println("Handle start-up success")
    for   {
        content := <-dm.ReadChan
        // 内容处理逻辑
        dm.WriteChan <- strings.ToLower(content)
    }
}

// 文件存储逻辑 (文件/db/nosql)
func (dm *DocMonitoring) Write() {

    fmt.Println("Write start-up success")

    // 将处理后的结果写入文件
    name := "./Write.txt"
    fileObj,err := os.OpenFile(name,os.O_RDWR|os.O_CREATE|os.O_APPEND,0644)
    if err != nil {
        fmt.Println(err.Error())
        os.Exit(2)
    }

    for   {
        content := <-dm.WriteChan
        if  _,err := io.WriteString(fileObj,content);err == nil {
            fmt.Println("写入成功:",content)
        }
    }
}

// 文件实时监控
// go run readlog.go /usr/local/nginx/logs/access.log
func main() {

    args:=os.Args

    //file := "/usr/local/nginx/logs/access.log"
    file := args[1]

    dm := &DocMonitoring{
        LogPath:  file,
        ReadChan: make(chan string, 1024),
        WriteChan: make(chan string, 1024),
    }
    go dm.Read()
    go dm.Handle()
    go dm.Write()
    for {
        time.Sleep(time.Second)
    }

}