读文件
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)
}
}