Fiber和gin实战-《GO开发知识笔记》

admin
admin
admin
0
文章
0
评论
2025-11-04 01:30:43 编程 来源：ZONE.CI 全球网 0 阅读模式

    image.png

    1. package config
    3. import (
    4.     "context"
    5.     "fmt"
    6.     "github.com/aliyun/aliyun-oss-go-sdk/oss"
    7.     "github.com/go-redis/redis/v8" //"github.com/gomodule/redigo/redis"
    8.     _ "github.com/gofiber/fiber/v2"
    9.     "github.com/olivere/elastic/v7"
    10.     "github.com/programmerug/fibergorm/entities"
    11.     "go.mongodb.org/mongo-driver/mongo"
    12.     "go.mongodb.org/mongo-driver/mongo/options"
    13.     "gorm.io/driver/mysql"
    14.     "gorm.io/gorm"
    15.     _ "gorm.io/hints"
    16. )
    18. var DB *gorm.DB
    19. var ES *elastic.Client
    20. var esUrl = "http://192.168.5.88:9205"
    21. var RDB *redis.Client
    22. var MONGO *mongo.Client
    23. var OssCli *oss.Client
    25. func Connect() (err error) {
    26.     //初始化数据库连接
    27.     dns := "root:123456@(localhost:3306)/test?charset=utf8mb4&parseTime=True&loc=Local"
    28.     DB, err = gorm.Open(mysql.Open(dns), &gorm.Config{})
    29.     if err != nil {
    30.         fmt.Printf("连接mysql出错，错误信息：%v", err)
    31.     } else {
    32.         fmt.Println("成功连接mysql!")
    33.     }
    34.     return
    35. }
    37. func ConnectEs() (err error) {
    38.     //连接客户端
    39.     ES, err := elastic.NewClient(elastic.SetURL(esUrl), elastic.SetSniff(false))
    40.     if err != nil {
    41.         // Handle error
    42.         panic(err)
    43.     }
    44.     // 获取版本号的直接API
    45.     esVersion, err := ES.ElasticsearchVersion(esUrl)
    46.     if err != nil {
    47.         panic(err)
    48.         fmt.Printf("连接es出错，错误信息：%v", err)
    49.     } else {
    50.         fmt.Println("成功连接es!")
    51.         fmt.Printf("es的版本为%s\n", esVersion)
    52.     }
    53.     return
    54. }
    56. func ConnectRedis() (err error) {
    57.     //Background返回一个非空的Context。 它永远不会被取消，没有值，也没有期限。
    58.     //它通常在main函数，初始化和测试时使用，并用作传入请求的顶级上下文。
    59.     var ctx = context.Background()
    60.     RDB := redis.NewClient(&redis.Options{
    61.         Addr:     "192.168.5.86:8001",
    62.         Password: "12345678",
    63.         DB:       0,
    64.     })
    65.     _, err = RDB.Ping(ctx).Result()
    66.     if err != nil {
    67.         fmt.Printf("连接redis出错，错误信息：%v", err)
    68.     } else {
    69.         fmt.Println("成功连接redis!")
    70.     }
    71.     return
    72. }
    74. func ConnectMongoDB() (err error) {
    75.     // Set client options 建立mongodb连接
    76.     clientOptions := options.Client().ApplyURI("mongodb://127.0.0.1:27017/test")
    77.     // Connect to MongoDB
    78.     MONGO, err := mongo.Connect(context.TODO(), clientOptions)
    79.     if err != nil {
    80.         fmt.Printf("连接MongoDB出错，错误信息：%v", err)
    81.     }
    82.     err = MONGO.Ping(context.TODO(), nil)
    83.     if err != nil {
    84.         fmt.Printf("Ping MongoDB出错，错误信息：%v", err)
    85.     } else {
    86.         fmt.Println("成功连接MongoDB!")
    87.     }
    88.     return
    89. }
    91. //创建oss连接
    92. func ConnectOss() (err error) {
    93.     var ossConfig entities.OssCon
    94.     OssCli, err = oss.New(ossConfig.OssEndpoint, ossConfig.OssAccessKeyID, ossConfig.OssAccessKeySecret)
    95.     if err != nil {
    96.         panic(err)
    97.     }else {
    98.         fmt.Println("成功连接Oss!")
    99.     }
    100.     return
    101. }
    1. package entities
    3. import (
    4.     "fmt"
    5.     "log"
    6.     _ "time"
    7. )
    9. type Todo struct {
    10.     ID     int    `json:"id"`
    11.     Tiltle string `json:"title"`
    12.     Status bool   `json:"status"`
    13. }
    15. type Language struct {
    16.     Content string `json:"content"`
    17. }
    19. type OssCon struct {
    20.     OssBucket string `json:"oss_bucket"`
    21.     OssEndpoint string `json:"oss_endpoint"`
    22.     // oss访问key
    23.     OssAccessKeyID string `json:"oss_access_key_id"`
    24.     // oss访问key secret
    25.     OssAccessKeySecret string `json:"oss_access_key_secret"`
    26. }
    28. type Info struct {
    29.     Name  string
    30.     Price int `json:"price" from:"pri"`
    31. }
    33. type DBDrive struct {
    34.     Type   string
    35.     Mysql  Mysql
    36.     Badger Badger
    37. }
    39. type User struct {
    40.     Id       int `PK`
    41.     Username string
    42.     Pwd      string
    43. }
    45. type Mysql struct{}
    46. type Badger struct{}
    48. func (m Mysql) GetGlobalObj() {
    49.     fmt.Println("mysql func")
    50. }
    53. func (b Badger) GetGlobalObj() {
    54.     fmt.Println("badger func")
    55. }
    57. //xxl.Logger接口实现
    58. type Logger struct{}
    60. func (l *Logger) Info(format string, a ...interface{}) {
    61.     fmt.Println(fmt.Sprintf("自定义日志 - "+format, a...))
    62. }
    64. func (l *Logger) Error(format string, a ...interface{}) {
    65.     log.Println(fmt.Sprintf("自定义日志 - "+format, a...))
    66. }
    68. type Student struct {
    69.     Name string
    70.     Age  int
    71. }
    1. package handlers
    3. import (
    4.     "bufio"
    5.     "context"
    6.     "encoding/json"
    7.     "flag"
    8.     "fmt"
    9.     "github.com/aliyun/aliyun-oss-go-sdk/oss"
    10.     "github.com/apache/rocketmq-client-go/v2"
    11.     "github.com/apache/rocketmq-client-go/v2/consumer"
    12.     "github.com/apache/rocketmq-client-go/v2/primitive"
    13.     _ "github.com/apache/rocketmq-client-go/v2/primitive"
    14.     "github.com/apache/rocketmq-client-go/v2/producer"
    15.     _ "github.com/apache/rocketmq-client-go/v2/producer"
    16.     "github.com/blugelabs/bluge"
    17.     dlp "github.com/bytedance/godlp"
    18.     "github.com/fatih/set"
    19.     _ "github.com/go-redis/redis/v8"
    20.     "github.com/gofiber/fiber/v2"
    21.     "github.com/gofiber/fiber/v2/utils"
    22.     "github.com/google/go-querystring/query"
    23.     "github.com/kardianos/service"
    24.     _ "github.com/olivere/elastic/v7"
    25.     "github.com/pkg/errors"
    26.     "github.com/programmerug/fibergorm/config"
    27.     "github.com/programmerug/fibergorm/entities"
    28.     "github.com/xxl-job/xxl-job-executor-go"
    29.     "github.com/xxl-job/xxl-job-executor-go/example/task"
    30.     "go.mongodb.org/mongo-driver/bson"
    31.     "log"
    32.     "os"
    33.     "reflect"
    34.     "runtime"
    35.     "strconv"
    36.     "testing"
    37.     "time"
    38. )
    40. func GetDogs(c *fiber.Ctx) error {
    41.     var dogs []entities.Todo
    42.     config.DB.Find(&dogs)
    43.     return c.Status(200).JSON(dogs)
    44. }
    46. func GetDog(c *fiber.Ctx) error {
    47.     id := c.Params("id")
    48.     results := utils.ImmutableString(c.Params("id"))
    49.     log.Println("打印格式化参数:" + results)
    50.     //拷贝相关参数
    51.     // Make a copy
    52.     buffer := make([]byte, len(results))
    53.     copy(buffer, results)
    54.     resultCopy := string(buffer)
    55.     log.Println("打印拷贝参数:" + resultCopy)
    56.     var dog entities.Todo
    57.     result := config.DB.Find(&dog, id)
    58.     if result.RowsAffected == 0 {
    59.         return c.SendStatus(404)
    60.     }
    61.     return c.Status(200).JSON(&dog)
    62. }
    64. func Get(c *fiber.Ctx) error {
    65.     return c.Send([]byte("Hello, World!"))
    66. }
    68. func AddDog(c *fiber.Ctx) error {
    69.     dog := new(entities.Todo)
    70.     if err := c.BodyParser(dog); err != nil {
    71.         return c.Status(503).SendString(err.Error())
    72.     }
    73.     config.DB.Create(&dog)
    74.     return c.Status(201).JSON(dog)
    75. }
    77. func UpdateDog(c *fiber.Ctx) error {
    78.     dog := new(entities.Todo)
    79.     id := c.Params("id")
    80.     if err := c.BodyParser(dog); err != nil {
    81.         return c.Status(503).SendString(err.Error())
    82.     }
    83.     config.DB.Where("id = ?", id).Updates(&dog)
    84.     return c.Status(200).JSON(dog)
    85. }
    87. func RemoveDog(c *fiber.Ctx) error {
    88.     id := c.Params("id")
    89.     var dog entities.Todo
    90.     result := config.DB.Delete(&dog, id)
    91.     if result.RowsAffected == 0 {
    92.         return c.SendStatus(404)
    93.     }
    94.     return c.SendStatus(200)
    95. }
    97. func Create(c *fiber.Ctx) error {
    98.     e1 := entities.Language{Content: "golang"}
    99.     _, err := config.ES.Index().
    100.         Index("es").
    101.         Id("1").
    102.         BodyJson(e1).
    103.         Do(context.Background())
    104.     if err != nil {
    105.         panic(err)
    106.     }
    107.     return c.SendStatus(200)
    108. }
    110. func GetEs(c *fiber.Ctx) error {
    111.     query, err := config.ES.Get().Index("es").Id("1").Do(context.Background())
    112.     if err != nil {
    113.         panic(err)
    114.     }
    115.     var result entities.Language
    116.     if query.Found {
    117.         err := json.Unmarshal(query.Source, &result)
    118.         if err != nil {
    119.             fmt.Println(err)
    120.         }
    121.         fmt.Println(result.Content)
    122.     }
    123.     return c.Status(200).JSON(result)
    124. }
    126. func DeleteEs(c *fiber.Ctx) error {
    127.     //Background返回一个非空的Context。 它永远不会被取消，没有值，也没有期限。
    128.     //它通常在main函数，初始化和测试时使用，并用作传入请求的顶级上下文。
    129.     var ctx = context.Background()
    130.     response, err := config.ES.Delete().Index("es").Id("1").Do(ctx)
    131.     if err != nil {
    132.         panic(err)
    133.     }
    134.     //打印删除返回数据
    135.     fmt.Println(response)
    136.     return c.SendStatus(200)
    137. }
    139. func DeleteRedis(c *fiber.Ctx) error {
    140.     //Background返回一个非空的Context。 它永远不会被取消，没有值，也没有期限。
    141.     //它通常在main函数，初始化和测试时使用，并用作传入请求的顶级上下文。
    142.     var ctx = context.Background()
    143.     n, err := config.RDB.Del(ctx, "key1", "key2").Result()
    144.     if err != nil {
    145.         panic(err)
    146.     }
    147.     fmt.Printf("成功删除了 %v 个\n", n)
    148.     return c.SendStatus(200)
    149. }
    151. func GetRedis(c *fiber.Ctx) error {
    152.     //Background返回一个非空的Context。 它永远不会被取消，没有值，也没有期限。
    153.     //它通常在main函数，初始化和测试时使用，并用作传入请求的顶级上下文。
    154.     var ctx = context.Background()
    155.     vType, err := config.RDB.Type(ctx, "key").Result()
    156.     if err != nil {
    157.         panic(err)
    158.     }
    159.     return c.Status(200).JSON(vType)
    160. }
    162. func SetRedis(c *fiber.Ctx) error {
    163.     //Background返回一个非空的Context。 它永远不会被取消，没有值，也没有期限。
    164.     //它通常在main函数，初始化和测试时使用，并用作传入请求的顶级上下文。
    165.     var ctx = context.Background()
    166.     err := config.RDB.SetEX(ctx, "key", "value", time.Hour*2).Err()
    167.     if err != nil {
    168.         panic(err)
    169.     }
    170.     return c.SendStatus(200)
    171. }
    173. func GetMongoDB(c *fiber.Ctx) error {
    174.     // 2, 选择数据库ichunt  3, 选择表cron_log
    175.     connect := config.MONGO.Database("ichunt").Collection("cron_log")
    176.     var result struct {
    177.         Value float64
    178.     }
    179.     filter := bson.D{{"name", "pi"}}
    180.     err := connect.FindOne(context.TODO(), filter).Decode(result)
    181.     if err != nil {
    182.         log.Fatal(err)
    183.     }
    184.     fmt.Printf("Found a single document: %+v\n", result)
    185.     return c.Status(200).JSON(result)
    186. }
    189. func Consumer(c *fiber.Ctx) error {
    190.     // 设置推送消费者
    191.     pull, _ := rocketmq.NewPushConsumer(
    192.         //消费组
    193.         consumer.WithGroupName("testGroup"),
    194.         // namesrv地址
    195.         consumer.WithNameServer([]string{"127.0.0.1:9876"}),
    196.     )
    197.     // 必须先在 开始前
    198.     err := pull.Subscribe("Topic-test", consumer.MessageSelector{}, func(ctx context.Context, ext ...*primitive.MessageExt) (consumer.ConsumeResult, error) {
    199.         for i := range ext {
    200.             fmt.Printf("subscribe callback:%v \n", ext[i])
    201.         }
    202.         return consumer.ConsumeSuccess, nil
    203.     })
    204.     if err != nil {
    205.         fmt.Println(err.Error())
    206.     }
    207.     err = pull.Start()
    208.     if err != nil {
    209.         fmt.Println(err.Error())
    210.         os.Exit(-1)
    211.     }
    212.     time.Sleep(time.Hour)
    213.     err = pull.Shutdown()
    214.     if err != nil {
    215.         fmt.Printf("shutdown Consumer error:%s",err.Error())
    216.     }
    217.     return c.SendStatus(200)
    218. }
    221. func Producer(c *fiber.Ctx) error {
    222.     push, _ := rocketmq.NewProducer(
    223.         // 设置  nameSrvAddr
    224.         // nameSrvAddr 是 Topic 路由注册中心
    225.         producer.WithNameServer([]string{"127.0.0.1:9876"}),
    226.         // 指定发送失败时的重试时间
    227.         producer.WithRetry(2),
    228.         // 设置 Group
    229.         producer.WithGroupName("testGroup"),
    230.     )
    231.     // 开始连接
    232.     err := push.Start()
    233.     if err != nil {
    234.         fmt.Printf("start producer error: %s", err.Error())
    235.         os.Exit(1)
    236.     }
    237.     // 设置节点名称
    238.     topic := "Topic-test"
    239.     // 循坏发送信息 (同步发送)
    240.     for i := 0; i < 10; i++ {
    241.         msg := &primitive.Message{
    242.             Topic: topic,
    243.             Body:  []byte("Hello RocketMQ Go Client" + strconv.Itoa(i)),
    244.         }
    245.         // 发送信息
    246.         res, err := push.SendSync(context.Background(),msg)
    247.         if err != nil {
    248.             fmt.Printf("send message error:%s\n",err)
    249.         }else {
    250.             fmt.Printf("send message success: result=%s\n",res.String())
    251.         }
    252.     }
    253.     // 关闭生产者
    254.     err = push.Shutdown()
    255.     if err != nil {
    256.         fmt.Printf("shutdown producer error:%s",err.Error())
    257.     }
    258.     return c.SendStatus(200)
    259. }
    262. // Bucket: 获取bucket存储空间
    263. func Bucket() *oss.Bucket {
    264.     var ossConfig entities.OssCon
    265.     bucket, err := config.OssCli.Bucket(ossConfig.OssBucket)
    266.     if err != nil {
    267.         log.Println(err.Error())
    268.         return nil
    269.     }
    270.     return bucket
    271. }
    274. func Upload(c *fiber.Ctx) error{
    275.     filename := "hes.text"
    276.     ossPath := "oss/" + filename // oss不能以/开头
    277.     file, _ := os.Open(filename)
    278.     err := Bucket().PutObject(ossPath, file)
    279.     if err != nil {
    280.         fmt.Printf("上传oss失败: %+v\n", err.Error())
    281.         return c.SendStatus(503)
    282.     }
    283.     return c.SendStatus(200)
    284. }
    287. // 临时下载授权
    288. func DownUrl(c *fiber.Ctx) error{
    289.     filepath := "oss/hes.text"
    290.     url, err := Bucket().SignURL(filepath, oss.HTTPGet, 3600)
    291.     if err != nil {
    292.         fmt.Printf("下载oss失败: %+v\n", err.Error())
    293.         return c.SendStatus(503)
    294.     }
    295.     return c.Status(200).JSON(url)
    296. }
    299. //运行相关参数
    300. func GetTest(c *fiber.Ctx) error{
    301.     var name = flag.String("name", "everyon", "object")
    302.     names := "robot"
    303.     fmt.Printf("---:%s\n", names)
    304.     fmt.Printf("-----:%s\n", *name)
    305.     //var container = []string{"zero", "one", "two"}
    306.     container := map[int]string{0: "zero", 1: "one", 2: "two"}
    307.     fmt.Printf("The element is %q.\n", container[1])
    308.     block := "function"
    309.     {
    310.         block := "inner"
    311.         fmt.Printf("The block is %s.\n", block)
    312.     }
    313.     fmt.Printf("The block is %s.\n", block)
    314.     s1 := make([]int, 5)
    315.     fmt.Printf("The length of s1: %d\n", len(s1))
    316.     fmt.Printf("The capacity of s1: %d\n", cap(s1))
    317.     fmt.Printf("The value of s1: %d\n", s1)
    318.     s2 := make([]int, 5, 8)
    319.     fmt.Printf("The length of s2: %d\n", len(s2))
    320.     fmt.Printf("The capacity of s2: %d\n", cap(s2))
    321.     fmt.Printf("The value of s2: %d\n", s2)
    322.     return c.SendStatus(200)
    323. }
    326. func StaticHtml(c *fiber.Ctx) error {
    327.     if c.Path() == "/" || c.Path() == "" || c.Path() == "/index.html" {
    328.         ht := `<!DOCTYPE html>
    329.         <html lang="en">
    330.         <head>
    331.             <meta charset="UTF-8">
    332.             <meta name="viewport" content="width=device-width, initial-scale=1.0">
    333.             <meta http-equiv="X-UA-Compatible" content="ie=edge">
    334.             <title>go api doc</title>
    335.             <body>
    336.             <h3>hhh</h3>
    337.             <hr></hr>
    338.             <h1>卧槽 哈哈哈哈哈</h1>
    339.             </body>
    340.         </html>`
    341.         c.Response().Header.SetContentType("text/html; charset=utf-8") // 以HTML的方式解析显示
    342.         return c.Send([]byte(ht))
    343.     } else{
    344.         return c.Send([]byte("404"))
    345.     }
    346. }
    348. func SetHeader() map[string]string {
    349.     headers := make(map[string]string)
    350.     headers["X-Auth-AppId"] = "Auth.AppID"
    351.     headers["X-Auth-Token"] = "common.GlobalObjs.User.Token"
    352.     headers["X-Client-ID"] = "common.GlobalVar.ID"
    353.     return headers
    354. }
    357. //将对象解析成sql
    358. func reflectSql(data interface{}) (error, string) {
    359.     v := reflect.ValueOf(data)
    360.     t := reflect.TypeOf(data)
    361.     if t.Kind() != reflect.Struct {
    362.         return errors.New("unsupported argument type"), ""
    363.     }
    364.     sql := "insert into " + t.Name()
    365.     sqlEle := " ("
    366.     sqlValue := " values("
    367.     fieldNum := t.NumField()
    368.     for i := 0; i < fieldNum; i++ {
    369.         switch t.Field(i).Type.Kind() {
    370.         case reflect.Int:
    371.             if i == fieldNum-1 {
    372.                 sqlEle += t.Field(i).Name
    373.                 sqlValue += fmt.Sprintf("%d", v.Field(i).Int())
    374.             } else {
    375.                 sqlEle += t.Field(i).Name + ","
    376.                 sqlValue += fmt.Sprintf("%d,", v.Field(i).Int())
    377.             }
    378.         case reflect.String:
    379.             if i == fieldNum-1 {
    380.                 sqlEle += t.Field(i).Name
    381.                 sqlValue += v.Field(i).String()
    382.             } else {
    383.                 sqlEle += t.Field(i).Name + ","
    384.                 sqlValue += v.Field(i).String() + ","
    385.             }
    386.         }
    387.     }
    388.     sqlEle += ")"
    389.     sqlValue += ")"
    390.     sql += sqlEle + sqlValue
    391.     return nil, sql
    392. }
    395. func SaveSql(c *fiber.Ctx) error{
    396.     info := entities.Info{
    397.         Name:  "name1",
    398.         Price: 1,
    399.     }
    400.     err, sql := reflectSql(info)
    401.     fmt.Println(err, sql) // <nil> insert into Info (Name,Price) values(name1,1)
    402.     v, err := query.Values(info)   // 会自动a-z排序、转义
    403.     fmt.Println(v.Encode(), err) // age=2&comments=%E6%B5%8B%E8%AF%95&name=aq <nil>
    404.     section1 := []string{"33", "22", "11"}
    405.     section2 := []string{"33", "22","66"}
    406.     hh := DifferenceString(section1, section2)
    407.     fmt.Println(hh) // [11]
    408.     return c.SendStatus(200)
    409. }
    412. // DifferenceString 取字符串切片的差集 (section1存在，不存在section2)
    413. func DifferenceString(section1, section2 []string) (intersection []string) {
    414.     if len(section1) == 0 || len(section2) == 0 {
    415.         return section1
    416.     }
    417.     a := set.New(set.ThreadSafe)
    418.     b := set.New(set.ThreadSafe)
    419.     for _, v := range section1 {
    420.         a.Add(v)
    421.     }
    422.     for _, v := range section2 {
    423.         b.Add(v)
    424.     }
    425.     intersectionSet := set.Difference(a, b)
    426.     return set.StringSlice(intersectionSet)
    427. }
    429. // 取phone交集
    430. func intersectionPhone(section1, section2 []string) (intersection []string) {
    431.     if len(section1) == 0 || len(section2) == 0 {
    432.         return nil
    433.     }
    434.     a := set.New(set.ThreadSafe)
    435.     b := set.New(set.ThreadSafe)
    436.     for _, v := range section1 {
    437.         a.Add(v)
    438.     }
    439.     for _, v := range section2 {
    440.         b.Add(v)
    441.     }
    442.     intersectionSet := set.Intersection(a, b)
    443.     return set.StringSlice(intersectionSet)
    444. }
    446. //超时控制
    447. func Close() {
    448.     ch := make(chan struct{})
    449.     go func() {
    450.         // TODO s.Close()
    451.         time.Sleep(time.Second*2)
    452.         close(ch)
    453.     }()
    454.     select {
    455.     case <-ch:
    456.         fmt.Println("close ok")
    457.     case <-time.After(time.Second):
    458.         fmt.Println("close timeout")
    459.     }
    460. }
    463. //获取传入的时间所在月份的第一天，即某月第一天的0点。如传入time.Now(), 返回当前月份的第一天0点时间。
    464. func GetFirstDateOfMonth(d time.Time) time.Time {
    465.     d = d.AddDate(0, 0, -d.Day()+1)
    466.     return GetZeroTime(d)
    467. }
    469. //获取传入的时间所在月份的最后一天，即某月最后一天的23:59:59。如传入time.Now(), 返回当前月份的最后一天0点时间。
    470. func GetLastDateOfMonth(d time.Time) time.Time {
    471.     d = d.AddDate(0, 0, -d.Day()+1)
    472.     d = Get23Time(d)
    473.     return d.AddDate(0, 1, -1)
    474. }
    476. //获取某一天的0点时间
    477. func GetZeroTime(d time.Time) time.Time {
    478.     return time.Date(d.Year(), d.Month(), d.Day(), 0, 0, 0, 0, d.Location())
    479. }
    481. //获取某一天的0点时间
    482. func Get23Time(d time.Time) time.Time {
    483.     return time.Date(d.Year(), d.Month(), d.Day(), 23, 59, 59, 0, d.Location())
    484. }
    486. func Reflect() {
    487.     hh := entities.DBDrive{
    488.         Type: "Badger",
    489.     }
    490.     checkReflect(hh, hh.Type, "GetGlobalObj")
    491. }
    494. // inter一个嵌套结构体
    495. func checkReflect(inter interface{}, attributeName, method string) {
    496.     v := reflect.ValueOf(inter)
    497.     dbObj := v.FieldByName(attributeName) // 根据字段名获取属性 // 获得struct inter内嵌套的struct attributeName
    498.     m := dbObj.MethodByName(method)       // 获取 struct attributeName的method方法
    499.     m.Call([]reflect.Value{})             // 调用struct attributeName的method方法  m.Call([]reflect.Value{reflect.ValueOf("参数值")})
    500. }
    502. type Program struct{}
    504. func (p *Program) Start(s service.Service) error {
    505.     fmt.Println("server start")
    506.     go p.run()
    507.     return nil
    508. }
    510. func (p *Program) run() {
    511.     fmt.Println("开机自启动服务 - run")
    512. }
    514. func (p *Program) Stop(s service.Service) error {
    515.     fmt.Println("server stop")
    516.     return nil
    517. }
    519. func runTime()  {
    520.     NCPU := runtime.NumCPU()
    521.     runtime.GOMAXPROCS(NCPU)
    523.     serConfig := &service.Config{
    524.         Name:        "hhhh",
    525.         DisplayName: "test2",
    526.         Description: "test 开机自启动",
    527.     }
    529.     pro := &Program{}
    530.     s, err := service.New(pro, serConfig)
    531.     if err != nil {
    532.         fmt.Println(err, "service.New() err")
    533.     }
    535.     if len(os.Args) > 1 {
    536.         if os.Args[1] == "install" {
    537.             err = s.Install()
    538.             if err != nil {
    539.                 fmt.Println("install err", err)
    540.             } else {
    541.                 fmt.Println("install success")
    542.             }
    543.             return
    544.         }
    546.         if os.Args[1] == "remove" {
    547.             err = s.Uninstall()
    548.             if err != nil {
    549.                 fmt.Println("Uninstall err", err)
    550.             } else {
    551.                 fmt.Println("Uninstall success")
    552.             }
    553.             return
    554.         }
    555.     }
    557.     err = s.Run() // 运行服务
    558.     if err != nil {
    559.         fmt.Println("s.Run err", err)
    560.     }
    561. }
    563. //寻找最长不含有重复字符的子串
    564. func lengthOf(s string) int {
    565.     lastOccurred := make(map[rune]int)
    566.     start := 0
    567.     maxLength := 0
    568.     for i, ch := range []rune(s) {
    569.         if lastI, ok := lastOccurred[ch]; ok && lastI >= start {
    570.             start = lastI + 1
    571.         }
    572.         if i - start + 1 > maxLength {
    573.             maxLength = i - start + 1
    574.         }
    575.         lastOccurred[ch] = i
    576.     }
    577.     return maxLength
    578. }
    580. // GetWeekDay returns the week day name of a week day index.
    581. func GetWeekDay(index int) string {
    582.     if index < 0 || index > 6 {
    583.         return "Unknown"
    584.     }
    585.     weekDays := []string{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}
    586.     return weekDays[index]
    587. }
    590. // table-driven 单测法，就是将流程沉淀为一个可复用的模板、并交由机器自动生成；
    591. // 人类则只需要准备数据部分，将自己的多条不同的数据一行行填充到表里，交给流程模板
    592. // 去构造子测试用例、查表、跑数据、比对结果，写单测这事就大功告成了。
    594. func TestGetWeekDay(t *testing.T) {
    595.     // a subtest named "index=0"
    596.     t.Run("index=0", func(t *testing.T) {
    597.         index := 0
    598.         want := "Sunday"
    599.         if got := GetWeekDay(index); got != want {
    600.             t.Errorf("GetWeekDay() = %v, want %v", got, want)
    601.         }
    602.     })
    604.     // a subtest named "index=1"
    605.     t.Run("index=1", func(t *testing.T) {
    606.         index := 1
    607.         want := "Monday"
    608.         if got := GetWeekDay(index); got != want {
    609.             t.Errorf("GetWeekDay() = %v, want %v", got, want)
    610.         }
    611.     })
    612. }
    614. func TestGetWeekDay1(t *testing.T) {
    615.     type args struct {
    616.         index int
    617.     }
    618.     tests := []struct {
    619.         name string
    620.         args args
    621.         want string
    622.     }{
    623.         //todo： add test case
    625.     }
    626.     for _, tt := range tests {
    627.         t.Run(tt.name, func(t *testing.T) {
    628.             if got := GetWeekDay(tt.args.index); got != tt.want {
    629.                 t.Errorf("getweekday() = %v, want %v", got, tt.want)
    630.             }
    631.         })
    632.     }
    633. }
    636. // 创建索引
    637. func writeIndex(indexPath string) {
    638.     config := bluge.DefaultConfig(indexPath)
    639.     writer, err := bluge.OpenWriter(config)
    640.     if err != nil {
    641.         log.Fatalf("error opening writer: %v", err)
    642.     }
    643.     defer writer.Close()
    644.     // 新建文档
    645.     doc := bluge.NewDocument("example").
    646.         AddField(bluge.NewTextField("name", "bluge")).AddField(bluge.NewDateTimeField("created_at", time.Now()))
    647.     err = writer.Update(doc.ID(), doc)
    648.     if err != nil {
    649.         log.Fatalf("error updating document: %v", err)
    650.     }
    651. }
    653. // 批量创建
    654. func batch(indexPath string) {
    655.     writer, err := bluge.OpenWriter(bluge.DefaultConfig(indexPath))
    656.     batch := bluge.NewBatch()
    657.     for i := 0; i < 10; i++ {
    658.         doc := bluge.NewDocument(fmt.Sprintf("example_%d", i)).
    659.             AddField(bluge.NewTextField(fmt.Sprintf("field_%d", i), fmt.Sprintf("value_%d", i%2))).AddField(bluge.NewDateTimeField("created_at", time.Now()))
    660.         batch.Insert(doc)
    661.     }
    662.     err = writer.Batch(batch)
    663.     if err != nil {
    664.         log.Fatalf("error executing batch: %v", err)
    665.     }
    666.     batch.Reset()
    667. }
    669. // 查询
    670. func search(indexPath string) {
    671.     config := bluge.DefaultConfig(indexPath)
    672.     reader, err := bluge.OpenReader(config)
    674.     if err != nil {
    675.         log.Fatalf("error getting index reader: %v", err)
    676.     }
    677.     defer reader.Close()
    679.     query := bluge.NewMatchQuery("value_1").SetField("field_1")
    680.     request := bluge.NewTopNSearch(10, query).
    681.         WithStandardAggregations()
    682.     documentMatchIterator, err := reader.Search(context.Background(), request)
    683.     if err != nil {
    684.         log.Fatalf("error executing search: %v", err)
    685.     }
    686.     match, err := documentMatchIterator.Next()
    687.     for err == nil && match != nil {
    688.         err = match.VisitStoredFields(func(field string, value []byte) bool {
    689.             fmt.Printf("match: %s:%s\n", field, string(value))
    690.             return true
    691.         })
    692.         if err != nil {
    693.             log.Fatalf("error loading stored fields: %v", err)
    694.         }
    695.         fmt.Println(match)
    696.         match, err = documentMatchIterator.Next()
    697.     }
    698.     if err != nil {
    699.         log.Fatalf("error iterator document matches: %v", err)
    700.     }
    701. }
    703. func DlpDemoCtx(c *fiber.Ctx) error{
    704.     dlpDemo()
    705.     return c.SendStatus(200)
    706. }
    710. // 敏感信息参数过滤
    711. func dlpDemo() {
    712.     caller := "replace.your.caller"
    713.     if eng, err := dlp.NewEngine(caller); err == nil {
    714.         eng.ApplyConfigDefault()
    715.         fmt.Printf("DLP %s Demo:\n\n", eng.GetVersion())
    716.         inStr := `我的邮件是[email protected],
    717.                     18612341234是我的电话
    718.                     你家住在哪里啊? 我家住在北京市海淀区北三环西路43号,
    719.                     mac地址 06-06-06-aa-bb-cc
    720.                     收件人：张真人  手机号码：13900000000`
    721.         if outStr, _, err := eng.Deidentify(inStr); err == nil {
    722.             fmt.Printf("\t1. Deidentify( inStr: %s )\n", inStr)
    723.             fmt.Printf("\toutStr: %s\n", outStr)
    724.             //eng.ShowResults(results)
    725.             fmt.Println()
    726.         }
    727.         eng.Close()
    728.     } else {
    729.         fmt.Println("[dlp] NewEngine error: ", err.Error())
    730.     }
    731. }
    734. func Reader(c *fiber.Ctx) error {
    735.     reader := bufio.NewReader(os.Stdin)
    736.     fmt.Println("请输入你想要输入的内容，按回车结束")
    737.     fmt.Print("-> ")
    738.     text, err := reader.ReadString('\n')
    739.     if err != nil{
    740.         panic(fmt.Errorf("发生致命错误: %w \n", err))
    741.     }
    742.     fmt.Println("刚接收到的内容是：",text)
    743.     unix := time.Now().Unix();
    744.     fmt.Println("time:", unix)
    745.     return  c.Send([]byte(text))
    746. }
    748. func XXLJob(c *fiber.Ctx) error{
    749.     exec := xxl.NewExecutor(
    750.         xxl.ServerAddr("http://dev-a-b2b-xxl-job.vandream.com/xxl-job-admin"),
    751.         xxl.AccessToken(""),               //请求令牌(默认为空)
    752.         xxl.ExecutorIp(""),                //可自动获取
    753.         xxl.ExecutorPort("9156"),          //默认9999（非必填）
    754.         xxl.RegistryKey("obmp-apm"),       //执行器名称
    755.         xxl.SetLogger(&entities.Logger{}), //自定义日志
    756.     )
    757.     exec.Init()
    758.     //设置日志查看handler
    759.     exec.LogHandler(func(req *xxl.LogReq) *xxl.LogRes {
    760.         return &xxl.LogRes{Code: 200, Msg: "", Content: xxl.LogResContent{
    761.             FromLineNum: req.FromLineNum,
    762.             ToLineNum:   2,
    763.             LogContent:  "SettlementCheckHandler",
    764.             IsEnd:       true,
    765.         }}
    766.     })
    767.     //注册任务handler
    768.     exec.RegTask("Task_Test", task.Test)
    769.     defer exec.Run()
    770.     return c.Next()
    771. }
    773. // 注册
    774. func SaveUser(c *fiber.Ctx) error {
    775.     user := new(entities.User)
    776.     if err := c.BodyParser(user); err != nil {
    777.         return c.Status(503).SendString(err.Error())
    778.     }
    779.     config.DB.Create(&user)
    780.     return c.Status(201).JSON(user)
    781. }
    783. //登录
    784. func ValidateUser(c *fiber.Ctx) error {
    785.     username := c.Params("username")
    786.     pwd := c.Params("pwd")
    787.     var user entities.User
    788.     result := config.DB.Find(&user, username, pwd)
    789.     if result.RowsAffected == 0 {
    790.         return errors.New("用户名或密码错误！")
    791.     }
    792.     return c.Status(200).JSON(user)
    793. }
    1. package main
    3. import (
    4.     "encoding/json"
    5.     "fmt"
    6.     "github.com/gin-gonic/gin"
    7.     "github.com/gofiber/fiber/v2"
    8.     "github.com/gofiber/websocket/v2"
    9.     "github.com/programmerug/fibergorm/config"
    10.     _ "github.com/programmerug/fibergorm/config"
    11.     "github.com/programmerug/fibergorm/entities"
    12.     "github.com/programmerug/fibergorm/handlers"
    13.     "github.com/pyroscope-io/pyroscope/pkg/agent/profiler"
    14.     "io/ioutil"
    15.     "log"
    16.     "net/http"
    17.     "time"
    18. )
    20. func main() {
    21.     //fiberInit()
    22.     ginInit()
    23.     //监控 服务端： docker run -it -p 4040:4040 pyroscope/pyroscope:latest server
    24.     // go get -u github.com/pyroscope-io/pyroscope/pkg/agent/profiler
    25.     // Pyroscope 是一套开源的效能即时监控平台，简单的Server 及Agent 架构，让开发者可以轻松监控代码效能，不管你要找10 秒或几分钟内的效能数据，都可以快速的即时呈现，
    26.     //开发者也不用在意装了此监控会造成任何效能上的负担。
    27.     //Pyroscope 背后的储存采用 目前只有支援3 种语言(Python, Ruby 及Go) 未来会 假设您还没导入任何效能分析工具或平台，那Pyroscope 会是您最好的选择。
    28.     profiler.Start(profiler.Config{
    29.         ApplicationName: "simple.golang.app",
    30.         ServerAddress:   "http://localhost:4040",
    31.     })
    32. }
    34. /**
    35.  * fiber框架
    36.  */
    37. func fiberInit(){
    38.     app := fiber.New()
    40.     config.Connect()
    42.     app.Static("/", "/public")
    43.     // => http://localhost:3000/js/script.js
    44.     // => http://localhost:3000/css/style.css
    46.     app.Static("/prefix", "/public")
    47.     // => http://localhost:3000/prefix/js/script.js
    48.     // => http://localhost:3000/prefix/css/style.css
    50.     app.Static("*", "/public/index.html")
    51.     // => http://localhost:3000/any/path/shows/index/html
    53.     app.Get("/dogs", handlers.GetDogs)
    54.     app.Get("/list", handlers.Get)
    55.     app.Get("/dogs/:id", handlers.GetDog)
    56.     app.Post("/dogs", handlers.AddDog)
    57.     app.Put("/dogs/:id", handlers.UpdateDog)
    58.     app.Delete("/dogs/:id", handlers.RemoveDog)
    59.     app.Get("/test", handlers.GetTest)
    61.     config.ConnectEs()
    63.     //app.Get("/es", handlers.Create)
    64.     app.Get("/es", handlers.GetEs)
    65.     app.Delete("/deletes", handlers.DeleteEs)
    67.     config.ConnectRedis()
    69.     app.Put("/set", handlers.SetRedis)
    70.     app.Get("/get", handlers.GetRedis)
    71.     app.Delete("/deletes", handlers.DeleteRedis)
    73.     config.ConnectMongoDB()
    75.     app.Get("/mongodb", handlers.GetMongoDB)
    78.     //登录
    79.     // GET /flights/LAX-SFO
    80.     app.Get("/login/:username/:pwd", handlers.ValidateUser)
    82.     //注册
    83.     app.Get("/login/:username/:pwd", handlers.SaveUser)
    85.     // GET /api/register
    86.     app.Get("/api/*", func(c *fiber.Ctx) error {
    87.         msg := fmt.Sprintf("✋ %s", c.Params("*"))
    88.         return c.SendString(msg) // => ✋ register
    89.     })
    91.     // GET /flights/LAX-SFO
    92.     app.Get("/flights/:from-:to", func(c *fiber.Ctx) error {
    93.         msg := fmt.Sprintf("💸 From: %s, To: %s", c.Params("from"), c.Params("to"))
    94.         return c.SendString(msg) // => 💸 From: LAX, To: SFO
    95.     })
    97.     // GET /dictionary.txt
    98.     app.Get("/:file.:ext", func(c *fiber.Ctx) error {
    99.         msg := fmt.Sprintf("📃 %s.%s", c.Params("file"), c.Params("ext"))
    100.         return c.SendString(msg) // => 📃 dictionary.txt
    101.     })
    103.     // GET /john/75
    104.     app.Get("/:name/:age/:gender?", func(c *fiber.Ctx) error {
    105.         msg := fmt.Sprintf("👴 %s is %s years old", c.Params("name"), c.Params("age"))
    106.         return c.SendString(msg) // => 👴 john is 75 years old
    107.     })
    109.     // GET /john
    110.     app.Get("/:name", func(c *fiber.Ctx) error {
    111.         msg := fmt.Sprintf("Hello, %s 👋!", c.Params("name"))
    112.         return c.SendString(msg) // => Hello john 👋!
    113.     })
    115.     app.Post("/post", func(c *fiber.Ctx) error {
    116.         payload := struct {
    117.             Name  string `json:"name"`
    118.             Email string `json:"email"`
    119.         }{}
    120.         if err := c.BodyParser(&payload); err != nil {
    121.             return err
    122.         }
    123.         return c.JSON(payload)
    124.     })
    126.     app.Post("/post", func(c *fiber.Ctx) error {
    127.         user := new(entities.User)
    128.         if err := c.BodyParser(user); err != nil {
    129.             fmt.Println("error = ",err)
    130.             return c.SendStatus(200)
    131.         }
    132.         // getting user if no error
    133.         fmt.Println("user = ", user)
    134.         fmt.Println("user = ", user.Pwd)
    135.         fmt.Println("user = ", user.Username)
    136.         return c.SendString(user.Username)
    137.     })
    139.     // websocket 服务
    141.     app.Use("/ws", func(c *fiber.Ctx) error {
    142.         // IsWebSocketUpgrade returns true if the client
    143.         // requested upgrade to the WebSocket protocol.
    144.         if websocket.IsWebSocketUpgrade(c) {
    145.             c.Locals("allowed", true)
    146.             return c.Next()
    147.         }
    148.         return fiber.ErrUpgradeRequired
    149.     })
    151.     app.Get("/ws/:id", websocket.New(func(c *websocket.Conn) {
    152.         // c.Locals is added to the *websocket.Conn
    153.         log.Println(c.Locals("allowed"))  // true
    154.         log.Println(c.Params("id"))       // 123
    155.         log.Println(c.Query("v"))         // 1.0
    156.         log.Println(c.Cookies("session")) // ""
    157.         // websocket.Conn bindings https://pkg.go.dev/github.com/fasthttp/websocket?tab=doc#pkg-index
    158.         var (
    159.             mt  int
    160.             msg []byte
    161.             err error
    162.         )
    163.         for {
    164.             if mt, msg, err = c.ReadMessage(); err != nil {
    165.                 log.Println("read:", err)
    166.                 break
    167.             }
    168.             log.Printf("recv: %s", msg)
    169.             if err = c.WriteMessage(mt, msg); err != nil {
    170.                 log.Println("write:", err)
    171.                 break
    172.             }
    173.         }
    174.     }))
    176.     app.Get("/index.html", handlers.StaticHtml)
    178.     app.Post("/get", func(c *fiber.Ctx) error {
    179.         fmt.Println("c.get-appID", c.Get("X-Auth-AppId"), c.Get("X-Auth-Token"))
    180.         return c.SendString("Hello, World!")
    181.     })
    183.     app.Get("/index.html", handlers.DlpDemoCtx)
    184.     //打印屏幕输入数据
    185.     app.Put("/put", handlers.Reader)
    187.     data, _ := json.MarshalIndent(app.Stack(), "", "  ")
    188.     fmt.Println(string(data))
    190.     // //执行xxl-job服务
    191.     app.Use("/xxlJob", handlers.XXLJob)
    193.     //延迟执行
    194.     time.AfterFunc(time.Second * 5, Get)
    196.     //监听端口
    197.     log.Fatal(app.Listen(":3000"))
    198. }
    201. /**
    202.  * gin框架
    203.  */
    204. func ginInit(){
    205.     r := gin.Default()
    207.     // 匹配/users/xxx
    208.     r.GET("/users/:name", func(c *gin.Context) {
    209.         name := c.Param("name")
    210.         c.String(http.StatusOK, "Hello %s\n", name)
    211.     })
    212.     // 带query参数
    213.     r.GET("/books", func(c *gin.Context) {
    214.         name := c.Query("name")
    215.         c.String(http.StatusOK, "finding for book: %s\n", name)
    216.     })
    218.     // 表单数据
    219.     r.POST("/register", func(c *gin.Context) {
    220.         email := c.PostForm("email")
    221.         password := c.DefaultPostForm("password", "123456")
    222.         c.JSON(http.StatusOK, gin.H {
    223.             "email": email,
    224.             "password": password,
    225.         })
    226.     })
    228.     // 分组
    229.     defaultHandler := func(c *gin.Context) {
    230.         c.JSON(http.StatusOK, gin.H{
    231.             "path": c.FullPath(),
    232.         })
    233.     }
    234.     // group: v1
    235.     v1 := r.Group("/v1")
    236.     {
    237.         v1.GET("/posts", defaultHandler)
    238.         v1.GET("/series", defaultHandler)
    239.     }
    240.     // group: v2
    241.     v2 := r.Group("/v2")
    242.     {
    243.         v2.GET("/posts", defaultHandler)
    244.         v2.GET("/series", defaultHandler)
    245.     }
    248.     // 模板渲染
    249.     //r.LoadHTMLGlob("templates/*")
    251.     r.GET("/students", func(c *gin.Context) {
    252.         stus := []entities.Student{
    253.             { Name: "Jack", Age: 20 },
    254.             { Name: "David", Age: 18 },
    255.         }
    256.         c.HTML(http.StatusOK, "arr.tmpl", gin.H{
    257.             "title": "Gin",
    258.             "stuArr": stus,
    259.         })
    260.     })
    261.     // listen and serve on 0.0.0.0:8080
    262.     r.Run(":8080")
    263. }
    267. // 触发xxl-job服务方法
    268. func Get(){
    269.     fmt.Println("开启延时执行")
    270.     resp, err := http.Get("http://127.0.0.1:3000/xxlJob")
    271.     if err != nil {
    272.         fmt.Println(err)
    273.         return
    274.     }
    275.     defer resp.Body.Close()
    276.     body, err := ioutil.ReadAll(resp.Body)
    277.     fmt.Println(string(body))
    278.     fmt.Println(resp.StatusCode)
    279.     if resp.StatusCode == 200 {
    280.         fmt.Println("ok")
    281.     }
    282. }
    1. package testing
    4. import (
    5.     "fmt"
    6.     "strings"
    8.     "github.com/buckhx/gobert/tokenize"
    9.     "github.com/buckhx/gobert/tokenize/vocab"
    10.     tf "github.com/tensorflow/tensorflow/tensorflow/go"
    11.     "github.com/aclements/go-gg/generic/slice"
    12. )
    15. var corpus = `深度学习的基础是机器学习中的分散表示（distributed representation）。分散表示假定观测值是由不同因
    16. 子相互作用生成。在此基础上，深度学习进一步假定这一相互作用的过程可分为多个层次，代表对观测值的多层抽象。不同
    17. 的层数和层的规模可用于不同程度的抽象。深度学习运用了这分层次抽象的思想，更高层次的概念从低层次的概念学习得到。
    18. 这一分层结构常常使用贪心算法逐层构建而成，并从中选取有助于机器学习的更有效的特征。不少深度学习算法都以无监督
    19. 学习的形式出现，因而这些算法能被应用于其他算法无法企及的无标签数据，这一类数据比有标签数据更丰富，也更容易获
    20. 得。这一点也为深度学习赢得了重要的优势。`
    21. var question = "深度学习的基础是什么？"
    24. /* 判断是否是英文字符 */
    25. func isAlpha(c byte) bool {
    26.     return (c>=65 && c<=90) || (c>=97 && c<=122)
    27. }
    29. func main() {
    30.     modelPath := "../../../nlp/albert_QA/outputs/saved-model"
    31.     vocabPath := "../../../nlp/nlp_model/albert_zh_base/vocab_chinese.txt"
    32.     voc, err := vocab.FromFile(vocabPath)
    33.     if err != nil {
    34.         panic(err)
    35.     }
    36.     m, err := tf.LoadSavedModel(modelPath, []string{"train"}, nil)
    37.     if err != nil {
    38.         panic(err)
    39.     }
    41.     tkz := tokenize.NewTokenizer(voc)
    42.     ff := tokenize.FeatureFactory{Tokenizer: tkz, SeqLen: 512}
    43.     // 拼接输入
    44.     input_tokens := question + tokenize.SequenceSeparator + corpus
    45.     // 获取 token 向量
    46.     f := ff.Feature(input_tokens)
    48.     tids, err := tf.NewTensor([][]int32{f.TokenIDs})
    49.     if err != nil {
    50.         panic(err)
    51.     }
    52.     new_mask := make([]float32, len(f.Mask))
    53.     for i, v := range f.Mask {
    54.         new_mask[i] = float32(v)
    55.     }
    56.     mask, err := tf.NewTensor([][]float32{new_mask})
    57.     if err != nil {
    58.         panic(err)
    59.     }
    60.     sids, err := tf.NewTensor([][]int32{f.TypeIDs})
    61.     if err != nil {
    62.         panic(err)
    63.     }
    65.     fmt.Println(f.Tokens)
    66.     //fmt.Println(f.TokenIDs)
    67.     //fmt.Println(f.Mask)
    68.     //fmt.Println(f.TypeIDs)
    70.     res, err := m.Session.Run(
    71.         map[tf.Output]*tf.Tensor{
    72.             m.Graph.Operation("input_ids").Output(0):      tids,
    73.             m.Graph.Operation("input_mask").Output(0):     mask,
    74.             m.Graph.Operation("segment_ids").Output(0):    sids,
    75.         },
    76.         []tf.Output{
    77.             m.Graph.Operation("finetune_mrc/Squeeze").Output(0),
    78.             m.Graph.Operation("finetune_mrc/Squeeze_1").Output(0),
    79.         },
    80.         nil,
    81.     )
    82.     if err != nil {
    83.         panic(err)
    84.     }
    85.     //fmt.Println("DataType", res[0].DataType())
    86.     //fmt.Println("Shape", res[0].Shape())
    87.     //fmt.Println("Value", res[0].Value().([][]float32))
    89.     st := slice.ArgMax(res[0].Value().([][]float32)[0])
    90.     ed := slice.ArgMax(res[1].Value().([][]float32)[0])
    91.     fmt.Println(len(f.Tokens), st, ed)
    92.     if ed<st{ // ed 小于 st 说明未找到答案
    93.         st = 0
    94.         ed = 0
    95.     }
    96.     //ans := strings.Join(f.Tokens[st:ed+1], "")
    98.     // 处理token中的英文，例如： 'di', '##st', '##ri', '##bu', '##ted', 're', '##pr', '##ese', '##nt', '##ation',
    99.     ans := ""
    100.     for i:=st;i<ed+1;i++ {
    101.         if len(f.Tokens[i])>0 && isAlpha(f.Tokens[i][0]){ // 英文开头，加空格
    102.             ans += " "+f.Tokens[i]
    103.         } else if strings.HasPrefix(f.Tokens[i], "##"){ // ##开头，是英文中段，去掉##
    104.             ans += f.Tokens[i][2:]
    105.         } else {
    106.             ans += f.Tokens[i]
    107.         }
    108.     }
    110.     if strings.HasPrefix(ans, "[CLS]") || strings.HasPrefix(ans, "[SEP]") {
    111.         fmt.Println("未找到答案。")
    112.     } else {
    113.         fmt.Println("Question: ", question)
    114.         fmt.Println("Answer: ", ans)
    115.     }
    116. }
    1. package testing
    4. import (
    5.     "strings"
    7.     "github.com/buckhx/gobert/tokenize"
    8.     "github.com/buckhx/gobert/tokenize/vocab"
    9.     tf "github.com/tensorflow/tensorflow/tensorflow/go"
    10.     "github.com/aclements/go-gg/generic/slice"
    11. )
    13. const (
    14.     MaxSeqLength = 512
    15. )
    17. /* 训练好的模型权重 */
    18. var m *tf.SavedModel
    19. var voc vocab.Dict
    21. func InitModel(modelPath string, vocabPath string) {
    22.     var err error
    23.     voc, err = vocab.FromFile(vocabPath)
    24.     if err != nil {
    25.         panic(err)
    26.     }
    27.     m, err = tf.LoadSavedModel(modelPath, []string{"train"}, nil)
    28.     if err != nil {
    29.         panic(err)
    30.     }
    31. }
    33. /* 判断是否是英文字符 */
    34. func isAlphaQa(c byte) bool {
    35.     return (c>=65 && c<=90) || (c>=97 && c<=122)
    36. }
    39. func BertQA(corpus string, question string) (ans string, err error) {
    41.     tkz := tokenize.NewTokenizer(voc)
    42.     ff := tokenize.FeatureFactory{Tokenizer: tkz, SeqLen: MaxSeqLength}
    43.     // 拼接输入
    44.     input_tokens := question + tokenize.SequenceSeparator + corpus
    45.     // 获取 token 向量
    46.     f := ff.Feature(input_tokens)
    48.     tids, err := tf.NewTensor([][]int32{f.TokenIDs})
    49.     if err != nil {
    50.         return ans, err
    51.     }
    52.     new_mask := make([]float32, len(f.Mask))
    53.     for i, v := range f.Mask {
    54.         new_mask[i] = float32(v)
    55.     }
    56.     mask, err := tf.NewTensor([][]float32{new_mask})
    57.     if err != nil {
    58.         return ans, err
    59.     }
    60.     sids, err := tf.NewTensor([][]int32{f.TypeIDs})
    61.     if err != nil {
    62.         return ans, err
    63.     }
    65.     res, err := m.Session.Run(
    66.         map[tf.Output]*tf.Tensor{
    67.             m.Graph.Operation("input_ids").Output(0):      tids,
    68.             m.Graph.Operation("input_mask").Output(0):     mask,
    69.             m.Graph.Operation("segment_ids").Output(0):    sids,
    70.         },
    71.         []tf.Output{
    72.             m.Graph.Operation("finetune_mrc/Squeeze").Output(0),
    73.             m.Graph.Operation("finetune_mrc/Squeeze_1").Output(0),
    74.         },
    75.         nil,
    76.     )
    77.     if err != nil {
    78.         return ans, err
    79.     }
    81.     st := slice.ArgMax(res[0].Value().([][]float32)[0])
    82.     ed := slice.ArgMax(res[1].Value().([][]float32)[0])
    83.     if ed<st{ // ed 小于 st 说明未找到答案
    84.         st = ed
    85.     }
    86.     //ans = strings.Join(f.Tokens[st:ed+1], "")
    88.     // 处理token中的英文，例如： 'di', '##st', '##ri', '##bu', '##ted', 're', '##pr', '##ese', '##nt', '##ation',
    89.     ans = ""
    90.     for i:=st;i<ed+1;i++ {
    91.         if len(f.Tokens[i])>0 && isAlphaQa(f.Tokens[i][0]){ // 英文开头，加空格
    92.             ans += " "+f.Tokens[i]
    93.         } else if strings.HasPrefix(f.Tokens[i], "##"){ // ##开头，是英文中段，去掉##
    94.             ans += f.Tokens[i][2:]
    95.         } else {
    96.             ans += f.Tokens[i]
    97.         }
    98.     }
    100.     if strings.HasPrefix(ans, "[CLS]") || strings.HasPrefix(ans, "[SEP]") {
    101.         return "", nil
    102.     } else {
    103.         return ans, nil // 找到答案
    104.     }
    105. }
    1. package testing
    3. import (
    4.     "C"
    5.     "encoding/json"
    6.     "fmt"
    7.     "reflect"
    8.     "strings"
    9.     "sync"
    10.     "testing"
    11.     "unsafe"
    12. )
    14. type fakeService struct {
    16. }
    18. type Post struct {
    19.     Name string
    20.     Address string
    21. }
    23. type Service interface {
    24.     ListPosts() ([]*Post, error)
    25. }
    27. func ListPosts(svc Service) ([]*Post, error) { return svc.ListPosts()}
    29. func newFakeService() Service {
    30.     return &fakeService{}
    31. }
    33. func (s *fakeService) ListPosts() ([]*Post, error) {
    34.     posts := make([] *Post, 0)
    35.     posts = append(posts, &Post{
    36.         Name: "colin",
    37.         Address:"Shenzhen",
    38.     })
    39.     posts = append(posts, &Post{
    40.         Name:"alex",
    41.         Address:"beijing",
    42.     })
    43.     return posts, nil
    44. }
    47. func TestListPosts(t *testing.T){
    48.     fake := newFakeService()
    49.     if _, err := ListPosts(fake); err != nil {
    50.         t.Fatal("list posts failed")
    51.     }
    52. }
    57. type Bird interface {
    58.     Fly()
    59.     Type() string
    60. }
    62. type Canary struct {
    63.     Name string
    64. }
    66. func (c *Canary)Fly()  {
    67.     fmt.Printf("我是%s，用黄色的翅膀飞\n", c.Name)
    68. }
    70. func (c *Canary) Type() string {
    71.     return c.Name
    72. }
    75. type Crow struct {
    76.     Name string
    77. }
    79. func (c *Crow) Fly()  {
    80.     fmt.Printf("我是%s，我用黑色的翅膀飞\n", c.Name)
    81. }
    83. func (c *Crow) Type() string {
    84.     return c.Name
    85. }
    87. func LetFay(bird Bird)  {
    88.     fmt.Printf("Let %s \n", bird.Type())
    89.     bird.Fly()
    90. }
    92. func testFay(t *testing.T)  {
    93.     LetFay(&Canary{Name:"jj"})
    94.     LetFay(&Crow{Name:"gg"})
    95.     C.puts(C.CString("Hello, Cgo\n"))
    98.     cblob := C.blob{}                               // 在GO程序中创建的C对象，存储在Go的内存空间
    99.     cblob.repeat_time = 0
    101.     cblob.str = C.CString("Hello, World\n")         // C.CString 会在C的内存空间申请一个C语言字符串对象，再将Go字符串拷贝到C字符串
    103.     ret := C.SayHello(&cblob)                       // &cblob 取C语言对象cblob的地址
    105.     fmt.Println("ret", ret)
    106.     fmt.Println("repeat_time", cblob.repeat_time)
    108.     C.free(unsafe.Pointer(cblob.str))               // C.CString 申请的C空间内存不会自动释放，需要显示调用C中的free释放
    109. }
    111. //问题很简单，使⽤ channel 来控制打印的进度。使⽤两个 channel ，来分别控制数字和
    112. //字⺟的打印序列， 数字打印完成后通过 channel 通知字⺟打印, 字⺟打印完成后通知数
    113. //字打印，然后周⽽复始的⼯作。
    114. func testNumber(t *testing.T){
    115.     l,n:=make(chan bool), make(chan bool)
    116.     wait := sync.WaitGroup{}
    117.     go func() {
    118.         i:= 1
    119.         for  {
    120.             select {
    121.                 case <- n:
    122.                     fmt.Print(i)
    123.                     i++
    124.                     fmt.Print(i)
    125.                     i++
    126.                     l <- true
    127.                     break
    128.                 default:
    129.                     break
    130.             }
    131.         }
    132.     }()
    133.     wait.Add(1)
    134.     go func(wait *sync.WaitGroup) {
    135.         str := "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    136.         i:= 1
    137.         for  {
    138.             select {
    139.             case <- l:
    140.                 if i >= strings.Count(str, "")-1 {
    141.                     wait.Done()
    142.                     return
    143.                 }
    144.                 fmt.Print(str[i:i+1])
    145.                 i++
    146.                 if i >= strings.Count(str, "") {
    147.                     i = 0
    148.                 }
    149.                 fmt.Print(str[i:i+1])
    150.                 i++
    151.                 n <- true
    152.                 break
    153.             default:
    154.                 break
    155.             }
    156.         }
    158.     }(&wait)
    159.     n <- true
    160.     wait.Wait()
    161. }
    163. //第⼀个⽅法使⽤的是golang内置⽅法 strings.Count ,可以⽤来判断在⼀个字符串中包含
    164. //的另外⼀个字符串的数量。
    165. func isUniqueString(s string) bool {
    166.     if strings.Count(s, "") > 3000 {
    167.         return false
    168.     }
    169.     for _,v := range s{
    170.         if v > 127 {
    171.             return false
    172.         }
    173.         if strings.Count(s, string(v)) > 1 {
    174.             return false
    175.         }
    176.     }
    177.     return true
    178. }
    183. //第⼆个⽅法使⽤的是golang内置⽅法 strings.Index 和 strings.LastIndex ，⽤来判断指
    184. //定字符串在另外⼀个字符串的索引未知，分别是第⼀次发现位置和最后发现位置。
    185. func isUniqueString2(s string) bool {
    186.     if strings.Count(s, "") > 3000 {
    187.         return false
    188.     }
    189.     for k,v := range s{
    190.         if v > 127 {
    191.             return false
    192.         }
    193.         if strings.Index(s, string(v)) != k {
    194.             return false
    195.         }
    196.     }
    197.     return true
    198. }
    201. //func reverString2(s string) (string, bool) {
    202. //    str := [] rune(s)
    203. //    l := len(str)
    204. //    if len > 5000 {
    205. //        return s, false
    206. //    }
    207. //    for i := 0; i< len/2 ; i++  {
    208. //        str[i], str[l-1-i] = str[l-1-i], str[i]
    209. //    }
    210. //    return string(str), true
    211. //}
    213. //在json的规范中，对于数字类型是不区分整形和浮点型的。
    214. //上游将id改为string传给下游
    215. //下游使用json.number类型来避免对float64的使用
    216. func  dealStrTest(t *testing.T){
    217.     var request = `{"id":7044144249855934983,"name":"demo"}`
    219.     var test interface{} // 不指定反序列化的类型
    220.     err := json.Unmarshal([]byte(request), &test)
    221.     if err != nil {
    222.         fmt.Println("error:", err)
    223.     }
    225.     obj := test.(map[string]interface{})
    227.     dealStr, err := json.Marshal(test)
    228.     if err != nil {
    229.         fmt.Println("error:", err)
    230.     }
    232.     id := obj["id"]
    234.     // 反序列化之后重新序列化打印
    235.     fmt.Println(string(dealStr))
    236.     fmt.Printf("%+v\n", reflect.TypeOf(id).Name())
    237.     fmt.Printf("%+v\n", id.(float64))
    238. }
    241. //饿汉模式
    242. type singleton struct {}
    243. var ins *singleton = &singleton{}
    244. var mu sync.Mutex
    245. var once sync.Once
    247. func GetInsOr() *singleton {
    248.     if ins == nil {
    249.        mu.Lock()
    250.        if ins == nil {
    251.            ins = &singleton{}
    252.        }
    253.        mu.Unlock()
    254.     }
    255.     return ins
    256. }
    257. //推荐  使用once.Do可以确保 ins 实例全局只被创建一次，once.Do 函数还可以确保当同时有多个创建动作时，只有一个创建动作在被执行。
    258. func GetIns() *singleton {
    259.     once.Do(func() {
    260.         ins = &singleton{}
    261.     })
    262.     return ins
    263. }
    266. //工厂模式
    267. //type Person struct {
    268. //    Name string
    269. //    Age int
    270. //}
    271. //
    272. //func (p Person) Greet() {
    273. //    fmt.Printf("Hi! My name is %s", p.Name)
    274. //}
    275. //
    276. //func NewPerson(name string, age int) *Person {
    277. //    return &Person{
    278. //        Name: name,
    279. //        Age: age,
    280. //    }
    281. //}
    284. //抽象工厂模式
    285. //type Person interface {
    286. //    Greet()
    287. //}
    288. //
    289. //type person struct {
    290. //    name string
    291. //    age int
    292. //}
    293. //
    294. //func (p person) Greet() {
    295. //    fmt.Printf("Hi! My name is %s", p.name)
    296. //}
    297. //
    298. //// Here, NewPerson returns an interface, and not the person struct itself
    299. //func NewPerson(name string, age int) Person {
    300. //    return person{
    301. //        name: name,
    302. //        age: age,
    303. //    }
    304. //}
    308. type Person struct {
    309.     name string
    310.     age int
    311. }
    313. func NewPersonFactory(age int) func(name string) Person {
    314.     return func(name string) Person {
    315.         return Person{
    316.             name: name,
    317.             age: age,
    318.         }
    319.     }
    320. }
    322. func NewTest(){
    323.     newBaby := NewPersonFactory(1)
    324.     _ = newBaby("john")
    326.     newTeenager := NewPersonFactory(16)
    327.     _ = newTeenager("jill")
    328. }
    331. //type Doer struct {
    332. //    name string
    333. //}
    334. //
    335. //func QueryUser(doer Doer) error {
    336. //    req, err := http.NewRequest("Get", "http://iam.api.marmotedu.com:8080/v1/secrets", nil)
    337. //    if err != nil {
    338. //        return err
    339. //    }
    340. //    _, err := doer.Do(req)
    341. //    if err != nil {
    342. //        return err
    343. //    }
    344. //
    345. //    return nil
    346. //}
    347. //
    348. //
    349. //func TestQueryUser(t *testing.T) {
    350. //    doer := NewMockHTTPClient()
    351. //    if err := QueryUser(doer); err != nil {
    352. //        t.Errorf("QueryUser failed, err: %v", err)
    353. //    }
    354. //}
    357. // 策略模式
    359. // 定义一个策略类
    360. type IStrategy interface {
    361.     do(int, int) int
    362. }
    364. // 策略实现：加
    365. type add struct{}
    367. func (*add) do(a, b int) int {
    368.     return a + b
    369. }
    371. // 策略实现：减
    372. type reduce struct{}
    374. func (*reduce) do(a, b int) int {
    375.     return a - b
    376. }
    378. // 具体策略的执行者
    379. type Operator struct {
    380.     strategy IStrategy
    381. }
    383. // 设置策略
    384. func (operator *Operator) setStrategy(strategy IStrategy) {
    385.     operator.strategy = strategy
    386. }
    388. // 调用策略中的方法
    389. func (operator *Operator) calculate(a, b int) int {
    390.     return operator.strategy.do(a, b)
    391. }
    1. package testing
    4. import (
    5.     tf "github.com/tensorflow/tensorflow/tensorflow/go"
    6.     "github.com/tensorflow/tensorflow/tensorflow/go/op"
    7.     "fmt"
    8. )
    10. func testTf() {
    11.     // Construct a graph with an operation that produces a string constant.
    12.     s := op.NewScope()
    13.     c := op.Const(s, "Hello from TensorFlow version " + tf.Version())
    14.     graph, err := s.Finalize()
    15.     if err != nil {
    16.         panic(err)
    17.     }
    19.     // Execute the graph in a session.
    20.     sess, err := tf.NewSession(graph, nil)
    21.     if err != nil {
    22.         panic(err)
    23.     }
    24.     output, err := sess.Run(nil, []tf.Output{c}, nil)
    25.     if err != nil {
    26.         panic(err)
    27.     }
    28.     fmt.Println(output[0].Value())
    29. }
    31. //go 调用 tensorflow模型
    32. //参考 https://blog.csdn.net/cdj0311/article/details/81773849
    33. // 参考 https://github.com/jack139/gotf
    34. func  model()  {
    35.     // 句子最大长度
    36.     const MAXLEN int = 20
    37.     // 将文本转换为id序列，为了实验方便直接使用转换好的ID序列即可
    38.     input_data := [1][MAXLEN]float32{{0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 208.0, 659.0, 180.0, 408.0, 42.0, 547.0, 829.0, 285.0, 334.0, 42.0, 642.0, 81.0, 800.0}}
    39.     tensor, err := tf.NewTensor(input_data)
    40.     if err != nil {
    41.         fmt.Printf("Error NewTensor: err: %s", err.Error())
    42.         return
    43.     }
    44.     //读取模型
    45.     model, err := tf.LoadSavedModel("cnnModel", []string{"myTag"}, nil)
    46.     if err != nil {
    47.         fmt.Printf("Error loading Saved Model: %s\n", err.Error())
    48.         return
    49.     }
    50.     // 识别
    51.     result, err := model.Session.Run(
    52.         map[tf.Output]*tf.Tensor{
    53.             // python版tensorflow/keras中定义的输入层input_layer
    54.             model.Graph.Operation("input_layer").Output(0): tensor,
    55.         },
    56.         []tf.Output{
    57.             // python版tensorflow/keras中定义的输出层output_layer
    58.             model.Graph.Operation("output_layer/Softmax").Output(0),
    59.         },
    60.         nil,
    61.     )
    63.     if err != nil {
    64.         fmt.Printf("Error running the session with input, err: %s  ", err.Error())
    65.         return
    66.     }
    67.     // 输出结果，interface{}格式
    68.     fmt.Printf("Result value: %v", result[0].Value())
    69. }
    1. module github.com/programmerug/fibergorm
    3. go 1.16
    5. require (
    6.     github.com/aclements/go-gg v0.0.0-20170323211221-abd1f791f5ee
    7.     github.com/aliyun/aliyun-oss-go-sdk v2.2.0+incompatible
    8.     github.com/andybalholm/brotli v1.0.4 // indirect
    9.     github.com/apache/rocketmq-client-go/v2 v2.1.0
    10.     github.com/baiyubin/aliyun-sts-go-sdk v0.0.0-20180326062324-cfa1a18b161f // indirect
    11.     github.com/blugelabs/bluge v0.1.9
    12.     github.com/buckhx/gobert v0.0.0-20190731141805-265756fed232
    13.     github.com/bytedance/godlp v1.2.15
    14.     github.com/fasthttp/websocket v1.4.5 // indirect
    15.     github.com/fatih/set v0.2.1
    16.     github.com/fsnotify/fsnotify v1.5.1 // indirect
    17.     github.com/gin-gonic/gin v1.6.3
    18.     github.com/go-redis/redis/v8 v8.11.4
    19.     github.com/go-stack/stack v1.8.1 // indirect
    20.     github.com/gofiber/fiber/v2 v2.24.0
    21.     github.com/gofiber/websocket/v2 v2.0.15
    22.     github.com/google/go-querystring v1.1.0
    23.     github.com/kardianos/service v1.2.0
    24.     github.com/klauspost/compress v1.14.1 // indirect
    25.     github.com/olivere/elastic/v7 v7.0.31
    26.     github.com/pkg/errors v0.9.1
    27.     github.com/pyroscope-io/pyroscope v0.7.2
    28.     github.com/satori/go.uuid v1.2.0 // indirect
    29.     github.com/sirupsen/logrus v1.8.1 // indirect
    30.     github.com/tensorflow/tensorflow v1.15.4
    31.     github.com/tidwall/gjson v1.12.1 // indirect
    32.     github.com/xxl-job/xxl-job-executor-go v1.1.0
    33.     github.com/youmark/pkcs8 v0.0.0-20201027041543-1326539a0a0a // indirect
    34.     go.mongodb.org/mongo-driver v1.8.2
    35.     go.uber.org/atomic v1.9.0 // indirect
    36.     golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3 // indirect
    37.     golang.org/x/net v0.0.0-20220111093109-d55c255bac03 // indirect
    38.     golang.org/x/sys v0.0.0-20220111092808-5a964db01320 // indirect
    39.     golang.org/x/time v0.0.0-20211116232009-f0f3c7e86c11 // indirect
    40.     gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
    41.     gorm.io/driver/mysql v1.2.3
    42.     gorm.io/gorm v1.22.5
    43.     gorm.io/hints v1.1.0
    44. )

    版权声明

    本站仅做备份收录，仅供研究与教学参考之用。
    读者将信息用于其他用途的，全部法律及连带责任由读者自行承担，本站不承担任何责任。

    ZONE.CI 全球网 | 安全领域涉猎者-乌云独行地带
    ZONE.CI 全球网
    安全领域涉猎者-乌云独行地带
    以太坊cppgolang区别 编程

    以太坊cppgolang区别

    以太坊是一种去中心化的开源平台，它采用智能合约技术，旨在构建和运行不受干扰的分布式应用程序。作为目前最受欢迎的区块链平台之一，以太坊提供了多种编程语言的支持，其
    12-282 评论
    progolang 编程

    progolang

    Go语言（Golang）是由Google开发的一门静态类型编程语言。作为一名专业的Golang开发者，我深知这门语言的优势和特点。在本文中，我将介绍Golang
    12-281 评论
    golangn个发送者 编程

    golangn个发送者

    Golang是一种开源的编程语言，由Google团队开发，旨在提高程序的并发性和简化软件开发过程。在Go语言中，有时需要向多个接收者发送信息。本文将介绍如何在G
    12-280 评论
    golang技能图谱 编程

    golang技能图谱

    从互联网行业的快速发展到人工智能技术的日益成熟，各种编程语言也应运而生。而在这众多的编程语言中，Golang（即Go）作为一门强大且高效的开发语言备受关注。Go
    12-281 评论
    ZONE.CI 全球网 | 安全领域涉猎者-乌云独行地带
    安全领域涉猎者-乌云独行地带
    ZONE.CI 全球网
    评论：0   参与：  18