net.Dial与net.Listen

## net.Dial
### 作用
net.Dial能够使用特定协议建立连接，如果成功建立，则返回一个Conn接口
### 源码
```go
func Dial(network, address string) (Conn, error) {
    var d Dialer
    return d.Dial(network, address)
}
```

### 使用方法
建立TCP连接
```go
conn, err := net.Dial("tcp", "ip:port")
```

建立UDP连接
```go
conn, err := net.Dial("udp", "ip:port")
```

建立其它连接
```go
conn, err := net.Dial(network, "0.0.0.0:9999")
```

其中network可以是以下协议

- "tcp"
 - "tcp4" (IPv4-only)
 - "tcp6" (IPv6-only)
 - "udp"
 - "udp4" (IPv4-only)
 - "udp6" (IPv6-only)
 - "ip"
 - "ip4"(IPv4-only)
 - "ip6" (IPv6-only)
 - "unix"
 - "unixgram"
 - "unixpacket"

## net.Listen
### 作用
net.Listen能够监听本地端口，接收特定协议建立的连接，如果成功接收，则返回一个Listener接口
### 源码
```go
func Listen(network, address string) (Listener, error) {
    var lc ListenConfig
    return lc.Listen(context.Background(), network, address)
}
```

### 使用方法
监听TCP连接
```go
listen, err := net.Listen("tcp", "127.0.0.1:port")
```

监听UDP连接
```go
listen, err := net.Listen("udp", "127.0.0.1:port")
```

监听其它连接
```go
listen, err := net.Listen(network, "127.0.0.1:port")
```

其中network可以是以下协议

- "tcp"
 - "tcp4"
 - "tcp6"
 - "unix"
 - "unixpacket"

## Listener接口
### 作用
Listener是一个网络监听接口，不同的协程可以调用同一个Listener上的方法
### 源码
```go
type Listener interface {
    Accept() (Conn, error)
    Close() error
    Addr() Addr
}
```

### 接口方法

- Accept()：返回一个Conn接口建立连接
 - Close()：关闭监听，任何阻塞的Accept操作将被解除阻塞并返回错误，即关闭所有已经建立的连接
 - Addr()：返回监听的网络地址

## Conn接口
### 作用
Conn是一个网络连接接口，不同的协程可以调用同一个Conn上的方法
### 源码
```go
type Conn interface {
    Read(b []byte) (n int, err error)
    Write(b []byte) (n int, err error)
    Close() error
    LocalAddr() Addr
    RemoteAddr() Addr
    SetDeadline(t time.Time) error
    SetReadDeadline(t time.Time) error
    SetWriteDeadline(t time.Time) error
}
```

### 接口方法

- Read(b []byte)：将接收到的数据读取到b中，返回数据长度和错误信息
 - Write(b []byte)：将b中的数据发送出去，返回数据长度和错误信息
 - Close()：关闭连接
 - LocalAddr()：返回本地网络地址
 - RemoteAddr()：返回远程连接地址
 - SetDeadline(t time.Time)：设置超时时间，如果某段时间未进行读写操作，则返回错误信息，设置位0永不超时
 - SetReadDeadline(t time.Time)：单独设置读操作的超时时间
 - SetWriteDeadline(t time.Time)：单独设置写操作的超时时间

## 简易TCP服务
### 客户端
```go
package main

import (
    "bufio"
    "fmt"
    "net"
    "os"
    "strings"
)

func main() {
    //  建立conn连接
    conn, err := net.Dial("tcp", "127.0.0.1:8888")
    //  错误处理
    if err != nil {
        fmt.Println(err)
        return
    }
    //  程序执行完后关闭连接
    defer conn.Close()
    //  能够从键盘获取输入的接口
    inputReader := bufio.NewReader(os.Stdin)
    //  循环监听conn
    for {
        //  读取键盘输入
        readString, _ := inputReader.ReadString('\n')
        //  去除读取到的换行
        trim := strings.Trim(readString, "\r\n")
        //  发送信息
        _, err := conn.Write([]byte(trim))
        //  错误处理
        if err != nil {
            fmt.Println(err)
            return
        }
        //  读取返回信息
        buf := [512]byte{}
        n, err := conn.Read(buf[:])
        //  错误处理
        if err != nil {
            fmt.Println(err)
            return
        }
        //  输出返回信息
        fmt.Println(string(buf[:n]))
    }

}
```

### 服务端
```go
package main

import (
    "bufio"
    "fmt"
    "net"
)

func main() {
    //  监听端口
    listen, err := net.Listen("tcp", "127.0.0.1:8888")
    //  错误处理
    if err != nil {
        fmt.Println(err)
        return
    }
    //  循环监听listen
    for {
        //  建立conn连接
        conn, err := listen.Accept()
        //  错误处理
        if err != nil {
            fmt.Println(err)
            return
        }
        //  程序执行完后关闭连接
        defer conn.Close()
        //  循环监听conn
        for {
            //  能够从conn获取输入的接口
            reader := bufio.NewReader(conn)
            //  从conn中读取输入
            var buf [1024]byte
            read, err := reader.Read(buf[:])
            //  错误处理
            if err != nil {
                fmt.Println(err)
                return
            }
            //  保存从conn中读取的信息
            recv := string(buf[:read])
            //  输出recv
            fmt.Println("GET MESSAGE: ", recv)
            //  向客户端返回信息
            conn.Write([]byte(recv))
        }
    }
}
```

net.Dial与net.Listen

酷酷番茄