go-net

2021-03-28

golang TCP/UDP连接


func UdpEcho() {
    upd, err := net.ResolveUDPAddr("udp4", ":1400")
    conn, err := net.ListenUDP("udp4", upd)
    if err != nil {
      fmt.Println(err)
      return
    }
    defer conn.Close()
    readBuf := make([]byte, 1024)
    for {
        time.Sleep(50 * time.Millisecond)
        n, remoteAddr, err := conn.ReadFromUDP(readBuf)
        if err != nil {
          fmt.Println(err)
          continue
        }
        fmt.Println("客户端 ip:", remoteAddr.IP, "端口:", remoteAddr.Port, "数据:", string(readBuf[:n]))
        peerConn, err := net.DialUDP("udp4", nil, remoteAddr)
        if err != nil {
            fmt.Println(err)
            continue
        }
        fmt.Println("发送响应....")
        peerConn.Write(writeBuf)
        peerConn.Close()
    }
}

func TCPEcho(){
    server, err := net.Listen("tcp", ":1402")
    if err != nil {
        fmt.Println(err)
        return
    }
    
    for true {
        select {
        case <- exit_ch:
            break
        default:
            conn, err := server.Accept()
            fmt.Println("客户端连接了")
            if err != nil {
                fmt.Println(err)
            }else{
                go func(conn){
                  // 处理请求数据和响应
                }{}
            }
        }
    }
}

Golang HttpRequest

使用golang构建Http请求

requestBody := fmt.Sprintf("{\"jsonrpc\":\"2.0\",\"method\":\"aria2.tellStatus\",\"id\":\"QXJpYU5nXzE2MTY4NTg0ODZfMC44NzA1NzgxMzY4ODM5NjUz\", \"params\":[\"%s\"]}",gid)
reader := bytes.NewReader([]byte(requestBody))
request,err := http.NewRequest("POST", rpc_url, reader)
if err != nil {
    fmt.Println(err)
    return nil, err
}
request.Header.Set("Content-Type", "application/json")
client := &http.Client{}
response, err := client.Do(request)

Https免认证证书

1
2
3

client := http.Client{Transport: &http.Transport{
    TLSClientConfig: &tls.Config{InsecureSkipVerify: true,}
}}

aira2c简单调用


var rpc_url = "http://localhost:6800/jsonrpc"

func AddNewDownloadTask(url string, dir string, filename string) (string, error) {
    requestBody := fmt.Sprintf("{\"jsonrpc\":\"2.0\",\"id\":\"QXJpYU5nXzE2MTY4NTc3MTZfMC4wNDc5NjM4NzcyODIzNTc2MjU=\",\"method\":\"aria2.addUri\",\"params\":[[\"%s\"],{\"dir\":\"%s\", \"out\":\"%s\",\"allow-overwrite\":\"true\"}]}",
        url, dir, filename)
    
    reader := bytes.NewReader([]byte(requestBody))
    request,err := http.NewRequest("POST", rpc_url, reader)
    if err != nil {
        fmt.Println(err)
        return "", err
    }
    request.Header.Set("Content-Type", "application/json")
    client := &http.Client{}
    response, err := client.Do(request)
    if err != nil {
        return "",err
    }
    defer response.Body.Close()
    resp, err := ioutil.ReadAll(response.Body)
    if err != nil {
        return "",err
    }
    res := struct {
        Id string `json:"id"`
        Result string `json:"result"`
    }{}
    err = json.Unmarshal(resp, &res)
    if err != nil {
        return "",err
    }
    return res.Result, nil
}

type GetGlobalStatResponseDAO struct {
    Id string `json:"id"`
    Jsonrpc string `json:"jsonrpc"`
    Result struct {
        DownloadSpeed string `json:"downloadSpeed"`
        NumActive string `json:"numActive"`
        NumStopped string `json:"numStopped"`
        NumStoppedTotal string `json:"numStoppedTotal"`
        NumWaiting string `json:"numWaiting"`
        UploadSpeed string `json:"uploadSpeed"`
    } `json:"result"`
}

func GetGlobalStat() (*GetGlobalStatResponseDAO, error){
    requestBody := "{\"jsonrpc\":\"2.0\",\"method\":\"aria2.getGlobalStat\",\"id\":\"QXJpYU5nXzE2MTY4NTg0ODZfMC44NzA1NzgxMzY4ODM5NjUz\"}"
    reader := bytes.NewReader([]byte(requestBody))
    request,err := http.NewRequest("POST", rpc_url, reader)
    if err != nil {
        fmt.Println(err)
        return nil, err
    }
    request.Header.Set("Content-Type", "application/json")
    client := &http.Client{}
    response, err := client.Do(request)
    if err != nil {
        return nil,err
    }
    defer response.Body.Close()
    resp, err := ioutil.ReadAll(response.Body)
    if err != nil {
        return nil,err
    }
    res := GetGlobalStatResponseDAO{}
    err = json.Unmarshal(resp, &res)
    if err != nil {
        return nil,err
    }
    return &res, nil
}

type TellStatusDAO struct {
    Id string `json:"id"`
    Jsonrpc string `json:"jsonrpc"`
    Result struct {
        Status string `json:"status"`
    } `json:"result"`
}

func TellStatus(gid string) (*TellStatusDAO, error) {
    requestBody := fmt.Sprintf("{\"jsonrpc\":\"2.0\",\"method\":\"aria2.tellStatus\",\"id\":\"QXJpYU5nXzE2MTY4NTg0ODZfMC44NzA1NzgxMzY4ODM5NjUz\", \"params\":[\"%s\"]}",gid)
    reader := bytes.NewReader([]byte(requestBody))
    request,err := http.NewRequest("POST", rpc_url, reader)
    if err != nil {
        fmt.Println(err)
        return nil, err
    }
    request.Header.Set("Content-Type", "application/json")
    client := &http.Client{}
    response, err := client.Do(request)
    if err != nil {
        return nil,err
    }
    defer response.Body.Close()
    resp, err := ioutil.ReadAll(response.Body)
    if err != nil {
        return nil,err
    }
    res := TellStatusDAO{}
    err = json.Unmarshal(resp, &res)
    if err != nil {
        return nil,err
    }
    return &res, nil
}

go-MQTT客户端demo

package main

import (
    "fmt"
    mqtt "github.com/eclipse/paho.mqtt.golang"
    "log"
    "os"
    "time"
)

func sub(client mqtt.Client, topic string) {
    token := client.Subscribe(topic, 1, nil)
    token.Wait()
    log.Printf("Subscribed to topic %s", topic)
}
func public(client mqtt.Client, topic string) {
    for i := 0;i < 10;i ++ {
        payload := fmt.Sprintf("Paylod data[%d]", i)
        token := client.Publish(topic, 0, false, payload)
        token.Wait()
        time.Sleep(1 * time.Second)
    }
}

func main() {
    args := os.Args
    if len(args) < 4 {
        return
    }
    clienId := args[1]
    subTopic := args[2]
    pubTopic := args[3]

    var broker = "localhost"
    var port = 1883
    opts := mqtt.NewClientOptions()
    opts.AddBroker(fmt.Sprintf("tcp://%s:%d", broker, port))
    opts.SetClientID(clienId)
    opts.SetUsername("emqx")
    opts.SetPassword("public")
    opts.SetDefaultPublishHandler(func(client mqtt.Client, message mqtt.Message) {
        log.Printf("Recieve message : %s from topic: %s\n", message.Payload(), message.Topic())
    })
    opts.OnConnect = func(client mqtt.Client) {
        log.Println("Connected")
    }

    opts.OnConnectionLost = func(client mqtt.Client, err error) {
        log.Printf("Connect lost: %v", err)
    }

    client := mqtt.NewClient(opts)
    if token := client.Connect(); token.Wait() && token.Error() != nil {
        panic(token.Error())
    }
    log.Println("start???")
    sub(client, subTopic)
    public(client, pubTopic)

    client.Disconnect(250)
}

UDP使用不同端口进行收发

从某个端口接收数据并从该端口返回数据

var port = 1400
func UdpEcho() {
    addr := fmt.Sprintf(":%d", port)
    upd, err := net.ResolveUDPAddr("udp4", addr)
    conn, err := net.ListenUDP("udp4", upd)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()
    readBuf := make([]byte, 1024)
    writeBuf := []byte("HI,Client")
    log.Printf("server listen %d ", port)

    laddr := net.UDPAddr{}
    laddr.Port = 1402
    for {
        time.Sleep(50 * time.Millisecond)
        n, remoteAddr, err := conn.ReadFromUDP(readBuf)
        if err != nil {
            fmt.Println(err)
            continue
        }
        fmt.Println("客户端 ip:", remoteAddr.IP, "端口:", remoteAddr.Port, "数据:", string(readBuf[:n]))
        // peerConn, err := net.DialUDP("udp4", &laddr , remoteAddr)
        conn.WriteTo(writeBuf, remoteAddr)
        if err != nil {
            fmt.Println(err)
            continue
        }
        fmt.Println("发送响应....")
        //peerConn.Write(writeBuf)
        //peerConn.Close()
    }
}

func main() {
    UdpEcho()
}

如果使用peerConn可以使用某个端口返回响应

1	peerConn, err := net.DialUDP("udp4", &laddr , remoteAddr)

使用golang起一个HTTP服务

package main
import "net/http"

func main()  {
    http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
        writer.Write([]byte("HelloWorld"))
    })
    _ = http.ListenAndServe(":9090", nil)
}

使用gin框架起一个http服务

package main

import (
    "github.com/gin-gonic/gin"
)
func main() {
    e := gin.Default()

    e.GET("/", func(context *gin.Context) {
        context.Writer.Write([]byte("HelloWorld"))
    })
    e.Run(":8088")
}