golang简单实现socket tcp通信

先做一个服务器端,接受来自客户端的数据,由于没有什么gui来显示数据输出情况,就将从客户端传送的数据写入一个文件中.
先看一下socket tcp通信的流程

图片.png

服务器端和客户端socket创建套接字,返回套接字描述符,套接字描述符相当于套接字的ID,描述符对应着套接字信息.
服务器端通过bind()绑定端口,然后listen监听端口的动态.accept()接收来自客户端的连接,如果没有连接,就会一直阻塞.成功连接后就可以往连接中写入和读取数据.最后要关闭连接.
客户端connect()请求连接服务器,如果失败返回一个负数.如果成功,就可以向服务器发送和接收数据了.

我们再来看看golang的socket.
首先服务器端通过net.Listen()方法实现创建套接字,绑定端口和监听端口.
func Listen(net, laddr string) (Listener, error)
net为网络协议,常用的有tcp,tcp4,tcp6,udp,updp4,udp6,unix, laddr为绑定地址.返回的Listener实际上就是一个套接字描述符.

Accpet()方法接收来自客户端的连接,连接成功后就可以进行读取和接收数据
Accept() (Conn, error)

golang的socket是非阻塞式的,也就是说不管是accpet,还是读写都是非阻塞的.但是golang本身对socket做了一定的处理,让其看起来实行起来是阻塞的.
发现自己写的态垃圾啦,赶紧码完代码完事..........

/*
    服务器端程序
    接收客户端连接
    将客户端发送的数据写入记录文件中
    每个新连接都会创建新记录文件
*/

package main

import (
    "fmt"
    "os"
    "net"
    "log"
    "sync"
    "strconv"
    "io"
)

const (
    NETWORK string = "tcp"     //socket网络协议
    LADDR   string = ":8080"   //绑定的本机地址和端口
    LOGFILE string = "log.txt" //日子文件名
)

func main(){
    var mu sync.Mutex         //创建锁,主要是防止协程将连接的传输写入同一个文件中
    var  count int = 0        //创建文件时区分文件用的
    f,err := os.OpenFile(LOGFILE,os.O_RDWR | os.O_APPEND|os.O_CREATE,0666)      //打开文件日志,没有就创建
    if err != nil{
        fmt.Printf("打开日志文件失败!error:%s\n",err)
        os.Exit(1)
    }
    defer f.Close()
    logger := log.New(f,"",1)    //创建日志对象 
    listener,err := net.Listen(NETWORK,LADDR)   //创建socket,绑定绑定端口,实现监听
    if err != nil {
        logger.Printf("监听端口失败!error:%s",err)  //将错误写入日志文件中
        os.Exit(1)
    }
    defer listener.Close()    //延迟关闭socket
    for {
        conn,err := listener.Accept()   //创建连接

        if err != nil {
            logger.Printf("创建连接失败!error:err%s",err)
            os.Exit(1)
        }
        go connHandle(conn,logger,&count,mu)     //创建协程处理连接
    }

}

func connHandle(conn net.Conn,logger *log.Logger,countPtr *int,mu sync.Mutex){
    mu.Lock()
    defer mu.Unlock()          //实现协程并发安全,防止不同连接数据写入同一个记录文件中
    defer conn.Close()         //延迟关闭连接
    *countPtr++
    fileName := "记录"+strconv.Itoa(*countPtr)      
    f,err := os.OpenFile(fileName,os.O_RDWR | os.O_APPEND|os.O_CREATE,0666)    //创建并打开连接记录文件
    if err != nil{
        logger.Printf("打开记录文件失败!error:%s\n",err)
        return
    }
    defer f.Close()       //关闭文件
    Raddr := conn.RemoteAddr().String()       //客户端的IP和端口号
    f.WriteString("客户端:"+Raddr+"已连接")     
    var buf []byte = make([]byte,4096)
    for{
        n,err := conn.Read(buf)      //将客户端发送的数据写入buf中
        if err != nil {
            if err == io.EOF {
                f.WriteString("socket连接已关闭!\n")
                break
            }else {
                f.WriteString("写入数据失败!error:"+err.Error()+"\n")
                break
            }
        }
        f.WriteString(string(buf[:n])+"\n")  //将buf中的数据写入文件中
    }
}

客户端更是草草了事

/*
   客户端
   连接服务器
   简单的发送数据
*/


package main

import (
    "fmt"
    "os"
    "net"
    "time"
)


const(
    NETWORK = "tcp"
    RADDR = "127.0.0.1:8080"  //服务器地址
)

func main(){
    conn,err := net.DialTimeout(NETWORK,RADDR,5*time.Second)  //创建套接字,连接服务器,设置超时时间

    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    defer conn.Close()
    for i := 0; i< 100;i++{
        conn.Write([]byte("hello socket\n"))     //发送数据给服务器端
        time.Sleep(1*time.Second)
    }
}

建立socket连接后是可以双向通信的,不管是客户端还是服务器端都是可以读写的,我只写了单方向的.服务器写,客户端读其实也是一样的方式.
写这些主要是加强一下自己的学习记忆,并不适合作为学习参考.
写完睡觉,请原谅我水文章的行为.