GO语言的进阶之路-网络编程之socket

　　　　　　　　　　　　　　　　　　　　　　　　　　GO语言的进阶之路-网络编程之socket

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

 

一.什么是socket;

　　在说socket之前，我们要对两个概念要有所了解，就是IP和端口。

1.什么是IP；

　　IP地址是我们进行TCP/IP通讯的基础，每个链接到网络的计算机都必须有一个IP地址。在这里我不打算给大家说IPV4和IPV6，也不打算说主机位和网络位。

　　我们可以简单的理解，在局域网中，IP就是用来标识主机的。（大家不要钻牛角尖说NAT这种情况，我们在这里是忽略的。）

 

2.什么是端口；

　　如果说IP是用来标识主机的，那么端口就是用来标识这台主机的所有服务。

　　这样我们就方便理解了，端口是用来标识服务的，只要主机的服务启动，然后我们访问主机的对应端口就能被提供服务。欢聚话说，局域网中如果别人知道你IP和端口，就能访问到的你的服务了（前提下是别人的主机和你的主机是要互通的。）

 

3.什么是socket;

　　网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。

　　建立网络通信连接至少要一对端口号(socket)。socket本质是编程接口(API)，对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口；HTTP是轿车，提供了封装或者显示数据的具体形式；Socket是发动机，提供了网络通信的能力。

　　Socket的英文原义是“孔”或“插座”。作为BSD UNIX的进程通信机制，取后一种意思。通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。每种服务都打开一个Socket，并绑定到一个端口上，不同的端口对应于不同的服务。Socket正如其英文原意那样，像一个多孔插座。插座是用来给插头提供一个接口让其通电的，此时我们就可以将插座当做一个服务端,不同的插头当做客户端。

 
二.客户端Socket；

1.串行指定读取客户端返回内容大小；(这种方法我不推荐使用！我推荐使用的是后三种方式读取。请看下面的备注。)

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

import (
    "net"
    "log"
    "fmt"
    "reflect"
    "io"
)

func main() {
    addr := "wwww.baidu.com:80" //定义主机名
    conn,err := net.Dial("tcp",addr) //拨号操作，需要指定协议。
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("访问公网IP地址是：",conn.RemoteAddr().String()) /*获取“conn”中的公网地址。注意：最好是加上后面的String方法，因为他们的那些是不一样的哟·当然你打印的时候
    可以不加输出结果是一样的，但是你的内心是不一样的哟！*/
    fmt.Printf("客户端链接的地址及端口是：%v\n",conn.LocalAddr()) //获取到本地的访问地址和端口。
    fmt.Println("“conn.LocalAddr()”所对应的数据类型是：",reflect.TypeOf(conn.LocalAddr()))
    fmt.Println("“conn.RemoteAddr().String()”所对应的数据类型是：",reflect.TypeOf(conn.RemoteAddr().String()))
    n,err := conn.Write([]byte("GET / HTTP/1.1\r\n\r\n")) //向服务端发送数据。用n接受返回的数据大小，用err接受错误信息。
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("向服务端发送的数据大小是:",n)

    buf := make([]byte,1024) //定义一个切片的长度是1024。

    n,err = conn.Read(buf) //接收到的内容大小。

    if err != nil && err != io.EOF {  //io.EOF在网络编程中表示对端把链接关闭了。
        log.Fatal(err)
    }
    fmt.Println(string(buf[:n])) //将接受的内容都读取出来。
    conn.Close()  //断开TCP链接。
}



#以上代码输出结果如下：
访问公网IP地址是： 111.13.101.208:80
客户端链接的地址及端口是：172.16.3.210:49568
“conn.LocalAddr()”所对应的数据类型是： *net.TCPAddr
“conn.RemoteAddr().String()”所对应的数据类型是： string
向服务端发送的数据大小是: 18
HTTP/1.1 400 Bad Request
Date: Mon, 31 Jul 2017 06:22:41 GMT
Server: Apache
Content-Length: 226
Connection: Keep-Alive
Content-Type: text/html; charset=iso-8859-1

 　　备注：io.Copy不会主动调用close，io.Copy结束的条件是reader得到EOF。感兴趣的可以看下源码。

func copyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
      // If the reader has a WriteTo method, use it to do the copy.
      // Avoids an allocation and a copy.
      if wt, ok := src.(WriterTo); ok {
          return wt.WriteTo(dst)
      }
      // Similarly, if the writer has a ReadFrom method, use it to do the copy.
      if rt, ok := dst.(ReaderFrom); ok {
          return rt.ReadFrom(src)
      }
      if buf == nil {
          buf = make([]byte, 32*1024)
      }
      for {
          nr, er := src.Read(buf)
          if nr > 0 {
              nw, ew := dst.Write(buf[0:nr])
              if nw > 0 {
                  written += int64(nw)
              }
              if ew != nil {
                  err = ew
                  break
              }
              if nr != nw {
                  err = ErrShortWrite
                  break
              }
          }
          if er != nil {
              if er != EOF {
                  err = er
              }
              break
          }
      }
      return written, err
  }

 

2.按照指定大小循环读取;

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

import (
    "net"
    "log"
    "fmt"
    "reflect"
    "io"
)

func main() {
    addr := "wwww.baidu.com:80" //定义主机名
    conn,err := net.Dial("tcp",addr) //拨号操作，需要指定协议。
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(conn.RemoteAddr().String()) //最好是加上后面的String方法，因为他们的那些是不一样的哟·当然你打印的时候可以不加。
    fmt.Println(conn.LocalAddr())
    fmt.Println(reflect.TypeOf(conn.LocalAddr()))
    fmt.Println(reflect.TypeOf(conn.RemoteAddr().String()))
    n,err := conn.Write([]byte("GET / HTTP/1.1\r\n\r\n")) //向服务端发送数据。用n接受返回的数据大小，用err接受错误信息。
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("写入的大小是:",n)

    buf := make([]byte,10) //定义一个切片的长度是1024。

    for  {
        n,err = conn.Read(buf) //接收到的内容大小。
        if err == io.EOF {
            conn.Close()
        }
        fmt.Print(string(buf[:n]))
    }

    fmt.Println(string(buf[:n])) //将接受的内容都读取出来。

}




#以上代码输出结果如下：
111.13.101.208:80
172.16.3.210:63838
*net.TCPAddr
string
写入的大小是: 18
HTTP/1.1 400 Bad Request
Date: Mon, 31 Jul 2017 10:38:42 GMT
Server: Apache
Content-Length: 226
Connection: Keep-Alive
Content-Type: text/html; charset=iso-8859-1

<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>400 Bad Request</title>
</head><body>
<h1>Bad Request</h1>
<p>Your browser sent a request that this server could not understand.<br />
</p>
</body></html>

 

3.按行读取；

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

import (
    "net"
    "log"
    "fmt"
    "reflect"
    "io"
    "bufio"
)

func main() {
    addr := "wwww.baidu.com:80" //定义主机名
    conn,err := net.Dial("tcp",addr) //拨号操作，需要指定协议。
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(conn.RemoteAddr().String()) //最好是加上后面的String方法，因为他们的那些是不一样的哟·当然你打印的时候可以不加。
    fmt.Println(conn.LocalAddr())
    fmt.Println(reflect.TypeOf(conn.LocalAddr()))
    fmt.Println(reflect.TypeOf(conn.RemoteAddr().String()))
    n,err := conn.Write([]byte("GET / HTTP/1.1\r\n\r\n")) //向服务端发送数据。用n接受返回的数据大小，用err接受错误信息。
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("写入的大小是:",n)

    r := bufio.NewReader(conn) //将这个链接（connection）包装以下。将conn的内容都放入r中，但是没有进行读取，让步我们一会对其进行操作。
    for  {
        line,err := r.ReadString('\n') //将r的内容也就是conn的数据按照换行符进行读取。
        if err == io.EOF {
            conn.Close()
        }
        fmt.Print(line)
    }


}




#以上代码输出结果如下：
111.13.101.208:80
172.16.3.210:64613
*net.TCPAddr
string
写入的大小是: 18
HTTP/1.1 400 Bad Request
Date: Mon, 31 Jul 2017 10:41:48 GMT
Server: Apache
Content-Length: 226
Connection: Keep-Alive
Content-Type: text/html; charset=iso-8859-1

<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>400 Bad Request</title>
</head><body>
<h1>Bad Request</h1>
<p>Your browser sent a request that this server could not understand.<br />
</p>
</body></html>

 

4.io读取http请求

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/


package main

import (
    "net"
    "log"
    "fmt"
    "reflect"
    "io"
    "os"
)

func main() {
    addr := "wwww.baidu.com:80" //定义主机名
    conn,err := net.Dial("tcp",addr) //拨号操作，需要指定协议。
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("访问公网IP地址以及端口是：",conn.RemoteAddr().String()) /*获取“conn”中的公网地址。注意：最好是加上后面的String方法，因为他们的那些是不一样的哟·当然你打印的时候
    可以不加输出结果是一样的，但是你的内心是不一样的哟！*/
    fmt.Printf("客户端链接的地址及端口是：%v\n",conn.LocalAddr()) //获取到本地的访问地址和端口。
    fmt.Println("“conn.LocalAddr()”所对应的数据类型是：",reflect.TypeOf(conn.LocalAddr()))
    fmt.Println("“conn.RemoteAddr().String()”所对应的数据类型是：",reflect.TypeOf(conn.RemoteAddr().String()))
    n,err := conn.Write([]byte("GET / HTTP/1.1\r\n\r\n")) //向服务端发送数据。用n接受返回的数据大小，用err接受错误信息。
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("写入的大小是:",n)
    io.Copy(os.Stdout,conn)
    conn.Close()
}




#以上代码输出结果如下：
访问公网IP地址以及端口是： 111.13.101.208:80
客户端链接的地址及端口是：172.16.3.210:52409
“conn.LocalAddr()”所对应的数据类型是： *net.TCPAddr
“conn.RemoteAddr().String()”所对应的数据类型是： string
写入的大小是: 18
HTTP/1.1 400 Bad Request
Date: Tue, 01 Aug 2017 02:35:11 GMT
Server: Apache
Content-Length: 226
Connection: Keep-Alive
Content-Type: text/html; charset=iso-8859-1

<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html><head>
<title>400 Bad Request</title>
</head><body>
<h1>Bad Request</h1>
<p>Your browser sent a request that this server could not understand.<br />
</p>
</body></html>

 

三.服务端Socket；

1.串行服务端；

　　当客户端链接过来的时候，我们服务端可以给客户端回复特定的字符串等等。我们就以下面这段代码为例子：

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

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

func main() {
    addr := "0.0.0.0:8080" //表示监听本地所有ip的8080端口，也可以这样写：addr := ":8080"
    listener,err := net.Listen("tcp",addr) //使用协议是tcp，监听的地址是addr
    if err != nil {
        log.Fatal(err)
    }
    defer listener.Close() //关闭监听的端口
    for  {
        conn,err := listener.Accept() //用conn接收链接
        if err != nil {
            log.Fatal(err)
        }
        conn.Write([]byte("Yinzhengjie\n"))  //通过conn的wirte方法将这些数据返回给客户端。
        conn.Write([]byte("hello Golang\n"))
        time.Sleep(time.Minute) //在结束这个链接之前需要睡一分钟在结束当前循环。
        conn.Close() //与客户端断开连接。
    }
}

　　注意，我们需要在服务端运行代码，然后在客户端进行telnet连接，如果操作的呢？很简单，我用了2台网络设备做测试：

路由器连接：

　　　　　　　　　　 　　　　  

防火墙连接：

　　　　　　　　　　　　　　　　　　　　

 

　　我用两个网络设备在1分钟内同时连接服务器，发现先连接的路由器收到了回复，然后就一直在sleep，没有下文了，这个时候防火墙也在连接，但是一直是在连接状态，也未出现断开的情况，等过了一分钟之后，分别出现了以下现象：

路由器连接：

　　　　　　　　　　　　　　　

防火墙连接：

 　　　　　　　　　　　　　　　　　　　　  

　　小伙伴们或许发现了规律，当路由器断开连接的时候，防火墙开始受到数据了，然后在过一分钟后防火墙也断开连接了。因为我的代码中在执行写的是睡眠一分钟后就断开连接。

一分钟后防火墙连接：

　　　　　　　　　　　　　　　　

 

2.并发服务端；

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

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

func Handle_conn(conn net.Conn) { //这个是在处理客户端会阻塞的代码。
    conn.Write([]byte("Yinzhengjie\n"))  //通过conn的wirte方法将这些数据返回给客户端。
    conn.Write([]byte("尹正杰是一个好男孩！\n"))
    time.Sleep(time.Minute)
    conn.Close() //与客户端断开连接。
}

func main() {
    addr := "0.0.0.0:8080" //表示监听本地所有ip的8080端口，也可以这样写：addr := ":8080"
    listener,err := net.Listen("tcp",addr)
    if err != nil {
        log.Fatal(err)
    }
    defer listener.Close()

    for  {
        conn,err := listener.Accept() //用conn接收链接
        if err != nil {
            log.Fatal(err)
        }
        go Handle_conn(conn)  //开启多个协程。
    }
}

 

　　同意，我还是用路由器和防火墙做测试，发现这次效果迥然不同。

路由器连接效果：

　　　　　　　　　　　　　　　　

防火墙连接效果：

　　　　　　　　　　　　　　　　　　　　　  

　　我们很明显发现，当两个网络设备同事去连接服务器的时候，此次的输出结果是不一致的，2个客户端同事获得了回应，这就是服务器的并发效果，可以在同一时间处理多个链接。等待一分钟后，两个客户端都会自动断开了链接。

路由器一分钟后状态：

　　　　　　　　　　　　　　　　  

防火墙一分钟后状态：

 　　　　　　　　　　　　　　　　　　　　　　

 3.web并发服务器；

　　其实我们写的代码也可以让访问对象是浏览器，这个时候我们返回其特定的html标签标签即可，代码如下：

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

import (
    "net"
    "log"
)


var content = `HTTP/1.1 200 OK
Date: Sat, 29 Jul 2017 06:18:23 GMT
Content-Type: text/html
Connection: Keep-Alive
Server: BWS/1.1
X-UA-Compatible: IE=Edge,chrome=1
BDPAGETYPE: 3
Set-Cookie: BDSVRTM=0; path=/

<html>
<head  name="尹正杰" age="25">  <!--标签的开头,其和面跟的内容（name="尹正杰"）是标签的属性,其属性可以定义多个。-->
    <meta charset="UTF-8"/>     <!--指定页面编码，-->
    <meta http-equiv="refresh" content="30; Url=http://www.cnblogs.com/yinzhengjie/"> <!--这是做了一个界面的跳转，表示30s不运行的话就跳转到指定的URL-->
    <title>尹正杰的个人主页</title> <!--定义头部的标题-->
</head> <!--标签的结尾-->

<body>
<h1 style="color:red">尹正杰</h1>
<h1 style="color:green">hello golang</h1>

</body>
</html>
`

func Handle_conn(conn net.Conn) { //这个是在处理客户端会阻塞。
    conn.Write([]byte(content)) //将html的代码返回给客户端，这样客户端在web上访问就可以拿到指定字符。
    conn.Close()
}


func main() {
    addr := "0.0.0.0:8080" //表示监听本地所有ip的8080端口，也可以这样写：addr := ":8080"
    listener,err := net.Listen("tcp",addr)
    if err != nil {
        log.Fatal(err)
    }
    defer listener.Close()

    for  {
        conn,err := listener.Accept() //用conn接收链接
        if err != nil {
            log.Fatal(err)
        }
        go Handle_conn(conn) //将接受来的链接交给该函数去处理。
    }
}

　　客户端访问效果如下：

　　　　　　　　

　　我们发现30s过后后页面发生了变化如下：

　　　　　　　　　　　　

　　通过这个案例，可能大家会想我能不能把文件的内容传给客户端呢？当然是可以的啦~写法也很简单，就直接把读内容转换成“[]byte”类型然后返回给客户端即可，在这里我就不多废话了。

 

四.socket链接的应用；

1.写个FTP服务器初级版本；

服务端：

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

import (
    "net"
    "log"
    "io"
    "fmt"
    "bufio"
    "strings"
    "os"
    "path/filepath"
    "io/ioutil"
)

var  (
    cmd  string
    file_name string
)

func main() {
    addr := "0.0.0.0:8080" //表示监听本地所有ip的8080端口，也可以这样写：addr := ":8080"
    listener,err := net.Listen("tcp",addr)
    if err != nil {
        log.Fatal(err)
    }
    defer listener.Close()
    conn,err := listener.Accept() //用conn接收链接
    if err != nil {
        log.Fatal(err)
    }
    conn.Write([]byte("欢迎来到尹正杰迷你FTP服务器！"))
    r := bufio.NewReader(conn) //将这个链接（connection）包装以下。将conn的内容都放入r中，但是没有进行读取，让步我们一会对其进行操作。
    for  {
        line,err := r.ReadString('\n') //将r的内容也就是conn的数据按照换行符进行读取。
        if err == io.EOF {
            conn.Close()
        }
        fmt.Print(line)
        line = strings.TrimSpace(line)  //去掉换行符。
        fmt.Println(len(strings.Fields(line)))
        if len(line) == 0 {  //为了让客户端长时间和服务器通话。
            continue
        }
        cmd = strings.Fields(line)[0]
        if len(strings.Fields(line)) > 1 {
            file_name = strings.Fields(line)[1]  //需要获取服务器的文件
        }
        pwd,err := os.Getwd()
        if err != nil {
            panic("获取路径出错了！")
        }
        file_name = filepath.Join(pwd,file_name)
        fmt.Println(file_name)
        switch  cmd{
        case  "GET","get":
            f,err := os.Open(file_name) //打开文件的内容。
            if err != nil {
                fmt.Println(err)
            }
            defer f.Close()
            buf,err := ioutil.ReadAll(f)
            if err != nil {
                log.Print(err)
                return
            }
            conn.Write(buf)
        case "PUSH","push":
            fmt.Println("上传文件的语句")
            conn.Write([]byte("上传文件的命令\n"))

        case "EXIT","exit":
            //conn.Close()
            return
        default:
            fmt.Println("您输入的命令无效！")
            conn.Write([]byte("您输入的指令有问题!\n"))
        }
    }
}

客户端：

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

import (
    "net"
    "log"
    "fmt"
    "bufio"
    "os"
    "io"
)

var   (
    cmd string
    line string
)

func main() {
    addr := "172.16.3.210:8080" //定义主机名
    conn,err := net.Dial("tcp",addr) //拨号操作，用于连接服务端，需要指定协议。
    if err != nil {
        log.Fatal(err)
    }

    buf := make([]byte,10240) //定义一个切片的长度是10240。
    n,err := conn.Read(buf) //接收到的内容大小为我们提前定义好的大小。
    if err != nil && err != io.EOF {  //io.EOF在网络编程中表示对端把链接关闭了。
        log.Fatal(err)
    }
    fmt.Println(string(buf[:n])) //将接受的内容都读取出来。



    f := bufio.NewReader(os.Stdin)
    for  {
        //fmt.Print("请输入>>>:")
        line,err = f.ReadString('\n') //定义一行的内容，结束标识符是换行符“\n”
        fmt.Sscan(line,&cmd)
        if len(line) == 1 {
            continue
        }
        //fmt.Print(line)
        go sender(conn,line)
    }
    conn.Close()  //断开TCP链接。
}

func sender(conn net.Conn ,line string)  {
    n,err := conn.Write([]byte(line)) //向服务端发送数据。用n接受返回的数据大小，用err接受错误信息。
    if err != nil {
        log.Fatal(err)
    }

    buf := make([]byte,10) //定义一个切片的长度是1024。

    for  {
        n,err = conn.Read(buf) //接收到的内容大小。
        if err == io.EOF {
            conn.Close()
        }
        fmt.Print(string(buf[:n]))
    }
    return
}

测试结果：

欢迎来到尹正杰迷你FTP服务器！
get a.txt
11111
22222
33333

get \Day9\yinzhengjie.html
<!DOCTYPE html>       <!--Doctype告诉浏览器使用什么样的html或xhtml规范来解析html文档。html这种模式兼容浏览器是最好的-->
<html lang="en">
<head  name="尹正杰" age="25">  <!--标签的开头,其和面跟的内容（name="尹正杰"）是标签的属性,其属性可以定义多个。-->
    <meta charset="UTF-8"/>     <!--指定页面编码，-->
    <meta http-equiv="refresh" content="30; Url=http://www.cnblogs.com/yinzhengjie/"> <!--这是做了一个界面的跳转，表示3s不运行的话就跳转到指定的URL-->
    <title>尹正杰的个人主页</title> <!--定义头部的标题-->
    <meta name="keywords" content="开发者,博客园,开发者,程序猿,程序媛,极客,编程,代码,开源,IT网站,Developer,Programmer,Coder,Geek,技术社区" /> <!--“content”定义关键字，其作用就是让浏览器通过搜索关键字时，会匹配该网站，这就是说如果你没有单独给百度钱的话，这些关键字就尤为重要啦！-->
    <meta name="description" content="博客园是一个面向开发者的知识分享社区。自创建以来，博客园一直致力并专注于为开发者打造一个纯净的技术交流社区，推动并帮助开发者通过互联网分享知识，从而让更多开发者从中受益。博客园的使命是帮助开发者用代码改变世界。" />  <!--定义描述字符,其作用就告诉客户你的这个网站是干嘛使用的。-->
    <link rel="shortcut icon" href="https://baike.baidu.com/pic/%E9%82%93%E7%B4%AB%E6%A3%8B/6798196/0/d1a20cf431adcbef011db9bba6af2edda3cc9f66?fr=lemma&ct=single#aid=0&pic=d1a20cf431adcbef011db9bba6af2edda3cc9f66" type="image/x-icon" /> <!--定义头部图标-->
    <meta http-equiv="x-ua-compatible" content="IE=Edge"> <!--这个是IE的浏览器生效的规则，如果你用的是谷歌，360等浏览器的话，这行规则不生效，如果你用的是IE浏览器的话，表示用IE最新的引擎去渲染HTML-->
</head> <!--标签的结尾-->
<body>
<h1>尹正杰</h1><!--定义文件的内容，其中“h1”标签中-->
<h2>尹正杰</h2>
<h3>尹正杰</h3>
<h4>尹正杰</h4>
<h5>尹正杰</h5>
<h6>尹正杰</h6>
<h1>You are a good boy!</h1>
<div style="width: 4000px">  <!--是其缩进代码的腹肌标签，给其定义宽度属性是200像素大小-->
    <h1>尹正杰</h1><!--块级标签：也叫父�即自己单独占了一行空�标签，��说是占它父级标签的100%。作�间，或蔨：定义文件的内容-->
    <h1>You are a good boy!</h1>
</div>  <!--div的标签的结尾-->
<p>素胚勾勒出青花笔锋浓转淡<br/>瓶身描绘的牡丹一如你初妆<br/>冉冉檀香��事我�透过窗宣纸上赆然<br/>�笔至此搁一半<渲染仕�br/>釉色�被私藏<br/>而佥�图韵呠嫣然的一笑如含苞待放</p> <!--其中<br/>表示换行符的意思，<p></p>表示一个段落的意思。-->
<a>yinzhengjie</a> <!--内联标签，以a开头的标签都是内联标签，�的内容�些标签��连接在一起的a>2017</a>。:-->
<"http://ww
<a href=w.cnblogs.com/yinzhengjie/" target="_blank">尹正杰博客</a>  <!--a标签特有的性能，重定向，通过href属性定义需要跳转的网站，通过target="_blank"表示新打开一个标签页并打开新的URL地址-->

<a href="#Y1">Golang第一!--a标签特有的�章</a>  <�锚，找��能，�ID为"Y1"的标签--="#Y2">Gol>
<a href��</a>  <!ang第二�"Y2"的标--找ID为签-->
<a href="#Y3�三章</a">Golang�>  <!--找ID为"Y3"的标签-->



<div id="Y1" style="height:700px;background-color:antiquewhite">  <!--用id来定义标签为"Y1",用style来定义高度为700像素，颜色用background-color来定义-->
    Golang进阶之路Day1<br/>
    Go语言官方自称,之所以开发Go 语言,是因为“近10年来开发程序之难让我们有点沮丧”。 这一定位暗示了Go语言希望取代C和Java的地位,成为最流行的通用开发语言。博客地址：http://www.cnblogs.com/yinzhengjie/p/6482675.html
</div>

<div id="Y2" style="height:700px;background-color:rebeccapurple;">
    <br/>Golang进阶之路Day2<br/>
    前者大家应该都很熟悉，因为我在上一篇（http://www.cnblogs.com/yinzhengjie/p/6482675.html）关于GO的博客中用"go build"命令编译不同的版本，但是在这里我们还是要演示一下go build的花式用法。博客地址：http://www.cnblogs.com/yinzhengjie/p/7000272.html
</div>

<div id="Y3" style="height:700px;background-color:brown;">
    Golang进阶之路Day3<br/>
    当然我这里只是介绍��冰山�了Golang�角，对Golang感兴趣的小伙伴，可以看一下Golang官网的文档说明。毕竟官方才是最权�出国内地址：https://golang.org/pkg/!博客威的，�tp://www.c��址：htnblogs.com/yinzhengjie/p/7043430.html
</div>

<!--功能最少的标签，最纯洁的易于加工的标签-->
<div>我是块标签</div>
<span>我是内联标签</span>

<!--列表-->
<ul>    <!--打印字符穿前面带个小黑点-->
    一</li>
    <li>菜单二</li>
    <li>菜单三</li>
</ul>

<ol>  <!--打印字符串前面有数字标识-->
    <li>第�<li>菜单
    <li>第二章</li>
    <li>第三��章</li>章</li>
ol>
    <</ol>

<dd>北京<自带缩进，可以用于写新闻的�/dd>  <!--��题-->
    <dt>朝阳区</dt>亦庄�t>
    <d区</dt>
�济开发    <dt>�t>
    <dt>海淀区</dt>
    <dd>河�台区</d��</dd>
 家庄</dt>
    <dt>保定</d   <dt>石d>陕西</dd>
    <dt>西安</dt>
    <dt>安康t>
    <dl>


<!--表格-->
<table border="1">   <!--�</dt>
</o表格，�义一个�border="1��属性�"，表示加边框�-->
    <thead>    <!--定义表头信息-->
    <tr>   <��意思�!--'tr'表示定义一行的�面的内容由子栰据，里�签<th></th>实现-  <th>姓名</th>    <!--'th'�->
      ��义同一行的内是说只�容,也就��带有这个标签的且在其父标签"tr"标签中就是写的同�。-->
 ��行内�>年龄</t       <th  <td>性�h>
      ��</td>
    </tr>
    </thead>
    <tbody> <!--��的内容-->
    <tr>  <!--'tr'表示定义表暄数据�每一行�其定义的是行的操作。-->
        <td>尹正杰</tthead中的'th'用�d> <!--与�相同。只不过'th’有�！-->
        <td>�粗效果       <td25</td>
 
  <!--'tr'表示每�
    <tr>��行的数据-->
        <td>尹正杰</td> <!--‘<td></t�定义的d>’标�是列的操作-->
        <td colspan="2">26</td>     <!--表示这䭾占两券�'td'标�的空间-->
    </tr>
    'tr'表示<tr>  <!--每一行的数据-->
        <td>yinzhengjie</td> <!--‘<td></td>’标签定��的操�义的是�-->
d'标签�
    </tr>
    <tr>  <!--'tr'表示每�据-->
        <td��行的�>yinzhengjie</td> <!--‘<td><签定义的是列�/td>’标�操作-->
        <td >26</t-表示这个'td'标签占两列的空�d>     <!-�-->
    </tr>
    </tbody>
</table>
</body>
</html>

　　该脚本并没有完成完整的FTP，只是写了一个引子，放在这里，如果以后我有兴趣了，可能会把它优化一下，我把这段代码贴在这里就是为了提供一个网络socket的传输案例，方便我以后查看，哈哈~

 

2.后台聊天程序；

　　该程序主要实现了，不同用户登录服务器可以输入相同的密码，然后大家可以互相通信的小程序。具体代码和注释如下：

/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/

package main

import (
    "bufio"
    "fmt"
    "log"
    "net"
    "strings"
    "time"
)

var globalRoom *Room = NewRoom()

type Room struct {
    users map[string]net.Conn
}

func NewRoom() *Room {
    return &Room{
        users: make(map[string]net.Conn),
    }
}

func (r *Room) Join(user string, conn net.Conn) {
    _, ok := r.users[user]
    if ok {
        r.Leave(user) //如果存在用户user就提出之前的链接，调用Leave方法实现。
    }
    r.users[user] = conn
    fmt.Printf("%s 登录成功。\n", user)
    conn.Write([]byte(user + ":加入聊天室!\n"))
}

func (r *Room) Leave(user string) {
    conn, ok := r.users[user]
    if !ok {
        fmt.Printf("%v用户不存在！", user)
    }
    conn.Close() //如果存在用户就断开链接。
    delete(r.users, user) //将用户从字典中删除。
    fmt.Printf("%s 离开", user)
}

func (r *Room) Broadcast(who string, msg string) {
    time_info := time.Now().Format("2006年01月02日 15:04:05") //这个是对日期定义一个格式化输出。告诉你一个记住它的方法：2006-01-02 15:04:05对应着2006 1(01) 2(02) 3(15) 4(04) 5(05) 哈哈
    tosend := fmt.Sprintf("%v %s:%s\n", time_info,who, msg)
    for user, conn := range r.users { //遍历所有用户，
        if user == who {
            continue //当发现用户是自己就不发送数据。即跳过循环。
        }
        conn.Write([]byte(tosend)) //将数据发送给登陆的用户。
    }
}

func Handle_Conn(conn net.Conn) {
    defer conn.Close()
    r := bufio.NewReader(conn) //将用户的输入存入“r”中，方便一会我们按块读取。
    line, err := r.ReadString('\n')
    if err != nil {
        fmt.Println(err)
        return
    }
    line = strings.TrimSpace(line)
    fields := strings.Fields(line)
    if len(fields) != 2 {
        conn.Write([]byte("您输入的字符串用户名活密码无效，程序强制退出！\n"))
        return
    }
    user := fields[0]
    password := fields[1]
    if password != "123" {
        return
    }
    globalRoom.Join(user, conn)
    globalRoom.Broadcast("System", fmt.Sprintf("%s join room", user))
    for { //获取用户的输入。
        conn.Write([]byte("按回车键发送消息：>>>"))//这里是给客户端增加一个提示符
        line, err := r.ReadString('\n') //循环读取用户输入的内容。换行符为“\n”
        if err != nil {                 //当用户主动关闭连接是，会出现报错就直接直接终止循环。
            break
        }
        line = strings.TrimSpace(line)   //去掉换行符
        fmt.Println(user,line)
        globalRoom.Broadcast(user, line) // 将用户输入的消息进行广播。
    }
    globalRoom.Broadcast("System", fmt.Sprintf("%s Leave room", user))
    globalRoom.Leave(user) //踢掉用户。
}

func main() {
    addr := "0.0.0.0:8888"
    listener, err := net.Listen("tcp", addr)
    if err != nil {
        log.Fatal(err)
    }
    defer listener.Close()
    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Fatal(err)
        }
        go Handle_Conn(conn)
    }
}