网络编程有两种：
1）TCP socket编程，是网络编程的主流。之所以叫tcp socket编程，是因为底层是基于tcp/ip协议的，比如QQ聊天。
2）b/s结构的http编程，我们使用浏览器去访问服务器时，使用的就是http协议，而http底层依旧是tcp socket实现的。

tcp编程

服务端的处理流程
1）监听端口
2）接收客户端的tcp链接，建立客户端和服务器端的链接
3）创建goroutine，处理该链接的请求（通常客户端会通过链接发送请求包）

客户端的处理流程
1）建立与服务端的链接
2）发送请求数据，接收服务器端返回的结果数据
3）关闭链接

server.go

  1. package main
  3. import (
  4.     "fmt"
  5.     "net"
  6. )
  8. func process(conn net.Conn) {
  10.     //这里我们循环的接收客户端发送的数据
  11.     defer conn.Close()
  12.     for true {
  13.         //创建一个新的切片
  14.         buf := make([]byte, 1024)
  15.         //1.等待客户端通过conn发送信息
  16.         //2.如果客户端没有write[发送]，那么协程就阻塞在这里
  17.         fmt.Println("服务器在等待客户端发送信息", conn.RemoteAddr())
  18.         n, err := conn.Read(buf) //从conn读取
  19.         if err != nil {
  20.             fmt.Println("客户端退出")
  21.             return
  22.         }
  23.         //3.显示客户端发送的内容到服务器的终端
  24.         fmt.Print(string(buf[:n]))
  26.     }
  27. }
  29. func main() {
  31.     fmt.Println("服务器开始监听。。。")
  32.     //1.tcp表示使用网络协议是tcp
  33.     //2. 0.0.0.0:8888表示在本地监听端口8888
  34.     listen, err := net.Listen("tcp", "0.0.0.0:9999")
  35.     if err != nil {
  36.         fmt.Println("listen err=", err)
  37.         return
  38.     }
  39.     defer listen.Close() //延时关闭listen
  41.     //循环等待客户端来连接我
  42.     for true {
  43.         //等待客户端连接
  44.         fmt.Println("等待客户端连接")
  45.         conn, err := listen.Accept()
  46.         if err != nil {
  47.             fmt.Println("accept() err=", err)
  48.         } else {
  49.             fmt.Printf("accept() suc con=%v 客户端ip=%v\n", conn, conn.RemoteAddr())
  50.         }
  51.         //这里准备起一个协程，为客户端服务
  52.         go process(conn)
  53.     }
  55.     fmt.Printf("listen suc=%v\n", listen)
  57. }

client.go

  1. package main
  3. import (
  4.     "bufio"
  5.     "fmt"
  6.     "net"
  7.     "os"
  8.     "strings"
  9. )
  11. func main() {
  12.     conn, err := net.Dial("tcp", "127.0.0.1:9999")
  13.     if err != nil {
  14.         fmt.Println("client dail err=", err)
  15.         return
  16.     } else {
  17.         fmt.Println("conn 成功=", conn)
  18.     }
  19.     for true {
  20.         //功能一：客户端可以发送单行数据，然后就退出
  21.         reader := bufio.NewReader(os.Stdin) //os.stdin 代表标准输入【终端】
  23.         //从终端读取一行用户输入，并准备发送给服务器
  24.         line, err := reader.ReadString('\n')
  25.         if err != nil {
  26.             fmt.Println("readstring err=", err)
  27.         }
  28.         line = strings.Trim(line, "\r\n")
  29.         //fmt.Println(line[:len(line)-2])
  30.         if line == "exit" {
  31.             fmt.Println("退出")
  32.             return
  33.         }
  35.         //再将line发送给服务器
  36.         n, err := conn.Write([]byte(line))
  37.         if err != nil {
  38.             fmt.Println("conn.Write err=", err)
  39.         }
  40.         fmt.Printf("客户端发送了%d字节的数据\n", n)
  41.     }
  43. }