完善glog示例程序文件

g/container/gvar/gvar.go

@@ -4,7 +4,7 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://gitee.com/johng/gf.
 
-// 通用动态变量(支持并发安全).
+// 通用动态变量.
 package gvar
 
 import (

g/database/gdb/gdb_base.go

@@ -75,7 +75,7 @@ func (db *Db) printSql(v *Sql) {
     )
     if v.Error != nil {
         s += "\nError: " + v.Error.Error()
-        glog.Backtrace(true, 1).Error(s)
+        glog.Backtrace(true).Error(s)
     } else {
         glog.Debug(s)
     }

g/os/gfile/gfile.go

@@ -339,20 +339,18 @@ func doScanDir(path string, pattern string, recursive ... bool) ([]string, error
         return nil, err
     }
     // 是否递归遍历
-    if len(recursive) > 0 && recursive[0] && len(names) > 0 {
-        for _, name := range names {
-            path := fmt.Sprintf("%s%s%s", path, Separator, name)
-            if IsDir(path) {
-                array, _ := doScanDir(path, pattern, true)
-                if len(array) > 0 {
-                    list = append(list, array...)
-                }
-            }
-            // 满足pattern才加入结果列表
-            if match, err := filepath.Match(pattern, name); err == nil && match {
-                list = append(list, path)
+    for _, name := range names {
+        path := fmt.Sprintf("%s%s%s", path, Separator, name)
+        if IsDir(path) && len(recursive) > 0 && recursive[0] {
+            array, _ := doScanDir(path, pattern, true)
+            if len(array) > 0 {
+                list = append(list, array...)
             }
         }
+        // 满足pattern才加入结果列表
+        if match, err := filepath.Match(pattern, name); err == nil && match {
+            list = append(list, path)
+        }
     }
     return list, nil
 }

g/os/glog/glog.go

@@ -68,21 +68,13 @@ func GetPath() string {
 }
 
 // 打印文件调用回溯信息
-func PrintBacktrace(skip...int) {
-    customSkip := 1
-    if len(skip) > 0 {
-        customSkip += skip[0]
-    }
-    logger.PrintBacktrace(customSkip)
+func PrintBacktrace() {
+    logger.PrintBacktrace()
 }
 
 // 获取文件调用回溯信息
-func GetBacktrace(skip...int) string {
-    customSkip := 1
-    if len(skip) > 0 {
-        customSkip += skip[0]
-    }
-    return logger.GetBacktrace(customSkip)
+func GetBacktrace() string {
+    return logger.GetBacktrace()
 }
 
 // 设置下一次输出的分类，支持多级分类设置
@@ -101,8 +93,8 @@ func Level(level int) *Logger {
 }
 
 // 设置文件调用回溯信息
-func Backtrace(enabled bool, skip...int) *Logger {
-    return logger.Backtrace(enabled, skip...)
+func Backtrace(enabled bool) *Logger {
+    return logger.Backtrace(enabled)
 }
 
 // 是否允许在设置输出文件时同时也输出到终端

g/os/glog/glog_logger.go

@@ -30,7 +30,6 @@ type Logger struct {
     path         *gtype.String       // 日志写入的目录路径
     file         *gtype.String       // 日志文件名称格式
     level        *gtype.Int          // 日志输出等级
-    btSkip       *gtype.Int          // 错误产生时的backtrace回调信息skip条数
     btEnabled    *gtype.Bool         // 是否当打印错误时同时开启backtrace打印
     alsoStdPrint *gtype.Bool         // 控制台打印开关，当输出到文件/自定义输出时也同时打印到终端
 }
@@ -57,7 +56,6 @@ func New() *Logger {
         path         : gtype.NewString(),
         file         : gtype.NewString(gDEFAULT_FILE_FORMAT),
         level        : gtype.NewInt(defaultLevel.Val()),
-        btSkip       : gtype.NewInt(),
         btEnabled    : gtype.NewBool(true),
         alsoStdPrint : gtype.NewBool(true),
     }
@@ -69,9 +67,8 @@ func (l *Logger) Clone() *Logger {
         pr           : l,
         io           : l.GetIO(),
         path         : l.path.Clone(),
-        file         : l.path.Clone(),
+        file         : l.file.Clone(),
         level        : l.level.Clone(),
-        btSkip       : l.btSkip.Clone(),
         btEnabled    : l.btEnabled.Clone(),
         alsoStdPrint : l.alsoStdPrint.Clone(),
     }
@@ -100,11 +97,6 @@ func (l *Logger) SetBacktrace(enabled bool) {
     l.btEnabled.Set(enabled)
 }
 
-// 设置BacktraceSkip
-func (l *Logger) SetBacktraceSkip(skip int) {
-    l.btSkip.Set(skip)
-}
-
 // 可自定义IO接口，IO可以是文件输出、标准输出、网络输出
 func (l *Logger) SetIO(w io.Writer) {
     l.mu.Lock()
@@ -199,35 +191,30 @@ func (l *Logger) stdPrint(s string) {
 func (l *Logger) errPrint(s string) {
     // 记录调用回溯信息
     if l.btEnabled.Val() {
-        backtrace := "Backtrace:" + ln + l.GetBacktrace()
-        if s[len(s) - 1] == byte('\n') {
-            s = s + backtrace + ln
-        } else {
-            s = s + ln + backtrace + ln
+        tracestr := l.GetBacktrace()
+        if tracestr != "" {
+            backtrace := "Backtrace:" + ln + tracestr
+            if s[len(s) - 1] == byte('\n') {
+                s = s + backtrace + ln
+            } else {
+                s = s + ln + backtrace + ln
+            }
         }
     }
     l.print(os.Stderr, s)
 }
 
-// 直接打印回溯信息，参数skip表示调用端往上多少级开始回溯
-func (l *Logger) PrintBacktrace(skip...int) {
-    customSkip := 1
-    if len(skip) > 0 {
-        customSkip += skip[0]
-    }
-    l.Println(l.GetBacktrace(customSkip))
+// 直接打印回溯信息
+func (l *Logger) PrintBacktrace() {
+    l.Println(l.GetBacktrace())
 }
 
-// 获取文件调用回溯字符串，参数skip表示调用端往上多少级开始回溯
-func (l *Logger) GetBacktrace(skip...int) string {
-    customSkip := 0
-    if len(skip) > 0 {
-        customSkip += skip[0]
-    }
+// 获取文件调用回溯字符串
+func (l *Logger) GetBacktrace() string {
     backtrace := ""
     index     := 1
     for i := 1; i < 10000; i++ {
-        if _, cfile, cline, ok := runtime.Caller(customSkip + i + l.btSkip.Val()); ok {
+        if _, cfile, cline, ok := runtime.Caller(i); ok {
             // 不打印出go源码路径及glog包文件路径
             if !gregex.IsMatchString("/g/os/glog/glog.+$", cfile) &&
                !gregex.IsMatchString("^" + gfile.GoRootOfBuild(), cfile) &&

g/os/glog/glog_logger_linkop.go

@@ -54,7 +54,7 @@ func (l *Logger) Level(level int) *Logger {
 }
 
 // 设置文件调用回溯信息
-func (l *Logger) Backtrace(enabled bool, skip...int) *Logger {
+func (l *Logger) Backtrace(enabled bool) *Logger {
     logger := (*Logger)(nil)
     if l.pr == nil {
         logger = l.Clone()
@@ -62,9 +62,6 @@ func (l *Logger) Backtrace(enabled bool, skip...int) *Logger {
         logger = l
     }
     logger.SetBacktrace(enabled)
-    if len(skip) > 0 {
-        logger.SetBacktraceSkip(skip[0])
-    }
     return logger
 }
 

geg/container/gvar/g.var.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+    "gitee.com/johng/gf/g"
+    "fmt"
+)
+
+func main() {
+    var v g.Var
+
+    v.Set("123")
+
+    fmt.Println(v.Val())
+
+    // 基本类型转换
+    fmt.Println(v.Int())
+    fmt.Println(v.Uint())
+    fmt.Println(v.Float64())
+
+    // slice转换
+    fmt.Println(v.Ints())
+    fmt.Println(v.Floats())
+    fmt.Println(v.Strings())
+
+    // struct转换
+    type Score struct {
+        Value int
+    }
+    s := new(Score)
+    v.Struct(s)
+    fmt.Println(s)
+}

geg/database/kafka/gkafka_consumer.go

@@ -3,7 +3,6 @@ package main
 import (
     "fmt"
     "gitee.com/johng/gf/g/database/gkafka"
-    "time"
 )
 
 // 创建kafka消费客户端
@@ -17,23 +16,20 @@ func newKafkaClientConsumer(topic, group string) *gkafka.Client {
 }
 
 func main () {
-    group  := "test-group-206"
+    group  := "test-group"
     topic  := "test"
     client := newKafkaClientConsumer(topic, group)
     defer client.Close()
 
+    // 标记开始读取的offset位置
     client.MarkOffset(topic, 0, 6)
     for {
-        fmt.Println(group + " reading...")
-        for {
-            if msg, err := client.Receive(); err != nil {
-                fmt.Println(err)
-            } else {
-                fmt.Println(msg.Partition, msg.Offset, string(msg.Value))
-                msg.MarkOffset()
-            }
+        if msg, err := client.Receive(); err != nil {
+            fmt.Println(err)
+            break
+        } else {
+            fmt.Println(msg.Partition, msg.Offset, string(msg.Value))
+            msg.MarkOffset()
         }
-        time.Sleep(3*time.Second)
     }
-
 }

geg/database/kafka/gkafka_producer.go

@@ -4,7 +4,7 @@ import (
     "gitee.com/johng/gf/g/database/gkafka"
     "fmt"
     "gitee.com/johng/gf/g/os/gtime"
-    "gitee.com/johng/gf/g/util/gconv"
+    "time"
 )
 
 // 创建kafka生产客户端
@@ -19,17 +19,10 @@ func newKafkaClientProducer(topic string) *gkafka.Client {
 func main () {
     client := newKafkaClientProducer("test")
     defer client.Close()
-
-    for i := 1; i < 10; i++ {
-        if err := client.SyncSend(&gkafka.Message{Value: []byte(gconv.String(i))}); err != nil {
+    for {
+        if err := client.SyncSend(&gkafka.Message{Value: []byte(gtime.Now().String())}); err != nil {
             fmt.Println(err)
         }
+        time.Sleep(time.Second)
     }
-
-    if err := client.SyncSend(&gkafka.Message{Value: []byte(gtime.Now().String())}); err != nil {
-        fmt.Println(err)
-    }
-
-
-    fmt.Println("done")
 }

geg/database/kafka/kafka.go

@@ -1,124 +0,0 @@
-package main
-
-import (
-    "fmt"
-    "math/rand"
-    "os"
-    "strconv"
-    "strings"
-    "time"
-    "github.com/Shopify/sarama"
-    "github.com/bsm/sarama-cluster"
-)
-
-var (
-    topics = "abc"
-)
-
-func main() {
-    for {
-        fmt.Println("time to check")
-        syncProducer()
-        consumer()
-        time.Sleep(time.Second)
-    }
-}
-
-
-// consumer 消费者
-func consumer() {
-    groupID := "group-12345"
-    config  := cluster.NewConfig()
-    config.Group.Return.Notifications      = true
-    config.Consumer.Return.Errors          = true
-    config.Consumer.Offsets.CommitInterval = 1 * time.Second
-    config.Consumer.Offsets.Initial        = sarama.OffsetOldest
-
-    c, err := cluster.NewConsumer(strings.Split("localhost:9092", ","), groupID, strings.Split(topics, ","), config)
-    if err != nil {
-        fmt.Errorf("Failed open consumer: %v", err)
-        return
-    }
-    defer c.Close()
-
-    go func(c *cluster.Consumer) {
-        errors := c.Errors()
-        notify := c.Notifications()
-        for {
-            select {
-            case err := <-errors:
-                fmt.Println(err)
-            case <-notify:
-            }
-        }
-    }(c)
-
-    for msg := range c.Messages() {
-        fmt.Fprintf(os.Stdout, "%s/%d/%d\t%s\n", msg.Topic, msg.Partition, msg.Offset, msg.Value)
-        c.MarkOffset(msg, "")
-    }
-}
-
-// syncProducer 同步生产者
-// 并发量小时，可以用这种方式
-func syncProducer() {
-    config := sarama.NewConfig()
-    //  config.Producer.RequiredAcks = sarama.WaitForAll
-    //  config.Producer.Partitioner = sarama.NewRandomPartitioner
-    config.Producer.Return.Successes = true
-    config.Producer.Timeout          = 5 * time.Second
-    p, err := sarama.NewSyncProducer(strings.Split("localhost:9092", ","), config)
-    defer p.Close()
-    if err != nil {
-        fmt.Println(err)
-        return
-    }
-
-    v := "sync: " + strconv.Itoa(rand.New(rand.NewSource(time.Now().UnixNano())).Intn(10000))
-    fmt.Fprintln(os.Stdout, v)
-
-    msg := &sarama.ProducerMessage{
-        Topic: topics,
-        Value: sarama.ByteEncoder(v),
-    }
-    if _, _, err := p.SendMessage(msg); err != nil {
-        fmt.Println(err)
-        return
-    }
-}
-
-// asyncProducer 异步生产者
-// 并发量大时，必须采用这种方式
-func asyncProducer() {
-    config := sarama.NewConfig()
-    config.Producer.Return.Successes = true
-    config.Producer.Timeout          = 5 * time.Second
-    p, err := sarama.NewAsyncProducer(strings.Split("localhost:9092", ","), config)
-    defer p.Close()
-    if err != nil {
-        return
-    }
-
-    //必须有这个匿名函数内容
-    go func(p sarama.AsyncProducer) {
-        errors := p.Errors()
-        success := p.Successes()
-        for {
-            select {
-            case err := <-errors:
-                if err != nil {
-                    fmt.Println(err)
-                }
-            case <-success:
-            }
-        }
-    }(p)
-
-    v := "async: " + strconv.Itoa(rand.New(rand.NewSource(time.Now().UnixNano())).Intn(10000))
-    fmt.Fprintln(os.Stdout, v)
-    msg := &sarama.ProducerMessage{
-        Topic: topics,
-        Value: sarama.ByteEncoder(v),
-    }
-    p.Input() <- msg
-}

geg/os/glog/glog_category.go

@@ -2,12 +2,17 @@ package main
 
 import (
     "gitee.com/johng/gf/g/os/glog"
+    "gitee.com/johng/gf/g/os/gfile"
+    "gitee.com/johng/gf/g"
 )
 
 func main() {
-    glog.SetPath("/tmp/")
-    glog.Cat("test1").Cat("test2").Println("test")
-    glog.Println("test")
+    path := "/tmp/glog-cat"
+    glog.SetPath(path)
+    glog.StdPrint(false).Cat("cat1").Cat("cat2").Println("test")
+    list, err := gfile.ScanDir(path, "*", true)
+    g.Dump(err)
+    g.Dump(list)
 }
 
 

geg/os/glog/glog_file.go

@@ -2,21 +2,29 @@ package main
 
 import (
     "gitee.com/johng/gf/g/os/glog"
+    "gitee.com/johng/gf/g/os/gfile"
+    "gitee.com/johng/gf/g"
 )
 
 // 设置日志等级
 func main() {
-    l := glog.New()
-    l.SetPath("/tmp/glog")
+    l    := glog.New()
+    path := "/tmp/glog"
+    l.SetPath(path)
+    l.SetStdPrint(false)
+    // 使用默认文件名称格式
     l.Println("标准文件名称格式，使用当前时间时期")
-
+    // 通过SetFile设置文件名称格式
     l.SetFile("stdout.log")
     l.Println("设置日志输出文件名称格式为同一个文件")
-
+    // 链式操作设置文件名称格式
     l.File("stderr.log").Println("支持链式操作")
-
     l.File("error-{Ymd}.log").Println("文件名称支持带gtime日期格式")
     l.File("access-{Ymd}.log").Println("文件名称支持带gtime日期格式")
+
+    list, err := gfile.ScanDir(path, "*")
+    g.Dump(err)
+    g.Dump(list)
 }
 
 

geg/os/glog/glog_level.go

@@ -4,7 +4,7 @@ import (
     "gitee.com/johng/gf/g/os/glog"
 )
 
-// 设置日志等级
+// 设置日志等级，过滤掉Info日志信息
 func main() {
     l := glog.New()
     l.Info("info1")

geg/os/glog/glog_path.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+    "gitee.com/johng/gf/g/os/glog"
+    "gitee.com/johng/gf/g/os/gfile"
+    "gitee.com/johng/gf/g"
+)
+
+// 设置日志输出路径
+func main() {
+    path := "/tmp/glog"
+    glog.SetPath(path)
+    glog.Println("日志内容")
+    list, err := gfile.ScanDir(path, "*")
+    g.Dump(err)
+    g.Dump(list)
+}
+
+

geg/util/gconv/gconv.go

@@ -7,20 +7,24 @@ import (
 
 func main() {
     i := 123
-    fmt.Printf("%10s %v\n", "Int:",     gconv.Int(i))
-    fmt.Printf("%10s %v\n", "Int8:",    gconv.Int8(i))
-    fmt.Printf("%10s %v\n", "Int16:",   gconv.Int16(i))
-    fmt.Printf("%10s %v\n", "Int32:",   gconv.Int32(i))
-    fmt.Printf("%10s %v\n", "Int64:",   gconv.Int64(i))
-    fmt.Printf("%10s %v\n", "Uint:",    gconv.Uint(i))
-    fmt.Printf("%10s %v\n", "Uint8:",   gconv.Uint8(i))
-    fmt.Printf("%10s %v\n", "Uint16:",  gconv.Uint16(i))
-    fmt.Printf("%10s %v\n", "Uint32:",  gconv.Uint32(i))
-    fmt.Printf("%10s %v\n", "Uint64:",  gconv.Uint64(i))
-    fmt.Printf("%10s %v\n", "Float32:", gconv.Float32(i))
-    fmt.Printf("%10s %v\n", "Float64:", gconv.Float64(i))
-    fmt.Printf("%10s %v\n", "Bool:",    gconv.Bool(i))
-    fmt.Printf("%10s %v\n", "Bytes:",   gconv.Bytes(i))
-    fmt.Printf("%10s %v\n", "String:",  gconv.String(i))
-    fmt.Printf("%10s %v\n", "Strings:", gconv.Strings(i))
+    fmt.Printf("%10s %v\n", "Int:",        gconv.Int(i))
+    fmt.Printf("%10s %v\n", "Int8:",       gconv.Int8(i))
+    fmt.Printf("%10s %v\n", "Int16:",      gconv.Int16(i))
+    fmt.Printf("%10s %v\n", "Int32:",      gconv.Int32(i))
+    fmt.Printf("%10s %v\n", "Int64:",      gconv.Int64(i))
+    fmt.Printf("%10s %v\n", "Uint:",       gconv.Uint(i))
+    fmt.Printf("%10s %v\n", "Uint8:",      gconv.Uint8(i))
+    fmt.Printf("%10s %v\n", "Uint16:",     gconv.Uint16(i))
+    fmt.Printf("%10s %v\n", "Uint32:",     gconv.Uint32(i))
+    fmt.Printf("%10s %v\n", "Uint64:",     gconv.Uint64(i))
+    fmt.Printf("%10s %v\n", "Float32:",    gconv.Float32(i))
+    fmt.Printf("%10s %v\n", "Float64:",    gconv.Float64(i))
+    fmt.Printf("%10s %v\n", "Bool:",       gconv.Bool(i))
+    fmt.Printf("%10s %v\n", "String:",     gconv.String(i))
+
+    fmt.Printf("%10s %v\n", "Bytes:",      gconv.Bytes(i))
+    fmt.Printf("%10s %v\n", "Strings:",    gconv.Strings(i))
+    fmt.Printf("%10s %v\n", "Ints:",       gconv.Ints(i))
+    fmt.Printf("%10s %v\n", "Floats:",     gconv.Floats(i))
+    fmt.Printf("%10s %v\n", "Interfaces:", gconv.Interfaces(i))
 }