The gudp module provides a very simple and easy-to-use gudp.Conn link operation object.

Usage:

  1. import "github.com/gogf/gf/v2/net/gudp"

API Documentation: https://pkg.go.dev/github.com/gogf/gf/v2/net/gudp

Introduction

Most of the operations of gudp.Conn are similar to the operation mode of gtcp (most of the method names are the same), but since UDP is a connectionless protocol, gudp.Conn (underlying communication port) can only complete up to one data write and read at a time. The client will need to create a new Conn object for communication the next time it communicates with the target server.

Usage Example

  1. package main
  3. import (
  4.     "context"
  5.     "fmt"
  6.     "time"
  8.     "github.com/gogf/gf/v2/frame/g"
  9.     "github.com/gogf/gf/v2/net/gudp"
  10.     "github.com/gogf/gf/v2/os/gtime"
  11. )
  13. func main() {
  14.     var (
  15.         ctx    = context.Background()
  16.         logger = g.Log()
  17.     )
  18.     // Server
  19.     go gudp.NewServer("127.0.0.1:8999", func(conn *gudp.ServerConn) {
  20.         defer conn.Close()
  21.         for {
  22.             data, addr, err := conn.Recv(-1)
  23.             if len(data) > 0 {
  24.                 if err = conn.Send(append([]byte("> "), data...), addr); err != nil {
  25.                     logger.Error(ctx, err)
  26.                 }
  27.             }
  28.             if err != nil {
  29.                 logger.Error(ctx, err)
  30.             }
  31.         }
  32.     }).Run()
  34.     time.Sleep(time.Second)
  36.     // Client
  37.     for {
  38.         if conn, err := gudp.NewClientConn("127.0.0.1:8999"); err == nil {
  39.             if b, err := conn.SendRecv([]byte(gtime.Datetime()), -1); err == nil {
  40.                 fmt.Println(string(b), conn.LocalAddr(), conn.RemoteAddr())
  41.             } else {
  42.                 logger.Error(ctx, err)
  43.             }
  44.             conn.Close()
  45.         } else {
  46.             logger.Error(ctx, err)
  47.         }
  48.         time.Sleep(time.Second)
  49.     }
  50. }

This example is similar to the communication example in gtcp.Conn, with the difference that the client and server cannot maintain a connection, requiring a new connection object for each communication.

After execution, the output is as follows:

  1. > 2018-07-21 23:13:31 127.0.0.1:33271 127.0.0.1:8999
  2. > 2018-07-21 23:13:32 127.0.0.1:45826 127.0.0.1:8999
  3. > 2018-07-21 23:13:33 127.0.0.1:58027 127.0.0.1:8999
  4. > 2018-07-21 23:13:34 127.0.0.1:33056 127.0.0.1:8999
  5. > 2018-07-21 23:13:35 127.0.0.1:39260 127.0.0.1:8999
  6. > 2018-07-21 23:13:36 127.0.0.1:33967 127.0.0.1:8999
  7. > 2018-07-21 23:13:37 127.0.0.1:52359 127.0.0.1:8999
  8. ...