GO Dialer用法及代码示例

GO语言"net"包中"Dialer"类型的用法及代码示例。

拨号器包含连接到地址的选项。

每个字段的零值相当于没有该选项的拨号。因此，使用 Dialer 的零值拨号等同于调用 Dial 函数。

同时调用 Dialer 的方法是安全的。

用法:

type Dialer struct {
    // Timeout is the maximum amount of time a dial will wait for
    // a connect to complete.If Deadline is also set, it may fail
    // earlier.
    //
    // The default is no timeout.
    //
    // When using TCP and dialing a host name with multiple IP
    // addresses, the timeout may be divided between them.
    //
    // With or without a timeout, the operating system may impose
    // its own earlier timeout.For instance, TCP timeouts are
    // often around 3 minutes.
    Timeout time.Duration

    // Deadline is the absolute point in time after which dials
    // will fail.If Timeout is set, it may fail earlier.
    // Zero means no deadline, or dependent on the operating system
    // as with the Timeout option.
    Deadline time.Time

    // LocalAddr is the local address to use when dialing an
    // address.The address must be of a compatible type for the
    // network being dialed.
    // If nil, a local address is automatically chosen.
    LocalAddr Addr

    // DualStack previously enabled RFC 6555 Fast Fallback
    // support, also known as "Happy Eyeballs", in which IPv4 is
    // tried soon if IPv6 appears to be misconfigured and
    // hanging.
    //
    // Deprecated: Fast Fallback is enabled by default.To
    // disable, set FallbackDelay to a negative value.
    DualStack bool // Go 1.2

    // FallbackDelay specifies the length of time to wait before
    // spawning a RFC 6555 Fast Fallback connection.That is, this
    // is the amount of time to wait for IPv6 to succeed before
    // assuming that IPv6 is misconfigured and falling back to
    // IPv4.
    //
    // If zero, a default delay of 300ms is used.
    // A negative value disables Fast Fallback support.
    FallbackDelay time.Duration // Go 1.5

    // KeepAlive specifies the interval between keep-alive
    // probes for an active network connection.
    // If zero, keep-alive probes are sent with a default value
    //(currently 15 seconds), if supported by the protocol and operating
    // system.Network protocols or operating systems that do
    // not support keep-alives ignore this field.
    // If negative, keep-alive probes are disabled.
    KeepAlive time.Duration // Go 1.3

    // Resolver optionally specifies an alternate resolver to use.
    Resolver *Resolver // Go 1.8

    // Cancel is an optional channel whose closure indicates that
    // the dial should be canceled.Not all types of dials support
    // cancellation.
    //
    // Deprecated: Use DialContext instead.
    Cancel <-chan struct{} // Go 1.6

    // If Control is not nil, it is called after creating the network
    // connection but before actually dialing.
    //
    // Network and address parameters passed to Control method are not
    // necessarily the ones passed to Dial.For example, passing "tcp" to Dial
    // will cause the Control function to be called with "tcp4" or "tcp6".
    Control func(network, address string, c syscall.RawConn) error // Go 1.11
}

package main

import (
    "context"
    "log"
    "net"
    "time"
)

func main() {
    var d net.Dialer
    ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
    defer cancel()

    conn, err := d.DialContext(ctx, "tcp", "localhost:12345")
    if err != nil {
        log.Fatalf("Failed to dial: %v", err)
    }
    defer conn.Close()

    if _, err := conn.Write([]byte("Hello, World!")); err != nil {
        log.Fatal(err)
    }
}

package main

import (
    "context"
    "log"
    "net"
    "time"
)

func main() {
    // DialUnix does not take a context.Context parameter. This example shows
    // how to dial a Unix socket with a Context. Note that the Context only
    // applies to the dial operation; it does not apply to the connection once
    // it has been established.
    var d net.Dialer
    ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
    defer cancel()

    d.LocalAddr = nil // if you have a local addr, add it here
    raddr := net.UnixAddr{Name: "/path/to/unix.sock", Net: "unix"}
    conn, err := d.DialContext(ctx, "unix", raddr.String())
    if err != nil {
        log.Fatalf("Failed to dial: %v", err)
    }
    defer conn.Close()
    if _, err := conn.Write([]byte("Hello, socket!")); err != nil {
        log.Fatal(err)
    }
}