精华内容
下载资源
问答
  • go网络编程

    2018-02-20 16:59:44
    go网络编程都是网络搜索到的资料.对于go开发者有点参考作用
  • GO网络编程

    2018-06-30 16:57:56
    golang网络编程,内容非常好,值得推荐,下载看看增加
  • Go网络编程Go网络编程
  • Go网络编程

    2020-07-19 16:13:38
    在计算机世界,两个或多个计算机之间的通信是基于OSI(Open System Interconnection)开放式系统互联协议进行网络通信。该通信协议分为7层,然而实际上在现实世界中OSI并没有大规模使用,现实世界常用的是tcp/ip协议,...
    一、概述

    在计算机世界,两个或多个计算机之间的通信是基于OSI(Open System Interconnection)开放式系统互联协议进行网络通信。该通信协议分为7层,然而实际上在现实世界中OSI并没有大规模使用,现实世界常用的是tcp/ip协议,而tcp/ip协议可划分为4或5层。

    • 应用层,表示层,会话层,传输层,网络层,数据链路层,物理层
    • 应用层,传输层,网络层,数据链路层,物理层
    • 应用层,传输层,网络层,网络接口层

    关系如图:
    在这里插入图片描述
    可以看出4层模型是由5层合并得到,5层模型是由7层归纳合并得到。
    在5层模型结构中:
    应用层(http,ftp协议,一些自定义协议:数据的加密,规定应用程序的数据格式)
    传输层(tcp,udp协议:建立port到port的通信协议)
    网络层(ip协议:包装本,目标网ip信息协议)
    数据链路层(Ethernet以太网协议:包装了本地MAC和目标MAC地址相关信息协议)
    物理层(将以上各层的数据打包层二进制发送给目标网络,目标网络反向逐层解析数据)

    二、Go中的网络编程

    在上述的模型中,在应用层和传输层中,基于传输层抽象了一些列接口而此接口即用于我们的实际开发中为socket(套接字)。
    socket也叫套接字, 是为了方便程序员进行网络开发而被设计出来的编程接口. socket在七层模型中是属于传输层(TCP,UDP协议)之上 的一个抽象接口.
    Go语言的标准库net包里对socket封装了一些列实现网络通信的api

    1、基于tcp

    tcp协议:两网络通信之前需要建立链接,其处于OSI 7层模型中的传输层。其建立端到端的通信协议,其链接和断开有3次握手和4次挥手的特点。
    相关api:

    server端:
      socket,_ := net.Listen("tcp","127.0.0.1:8080")
      socket.Accept()
      conn.Read([]byte) 
      conn.Write([]byte)
      defer -> socket.Close() conn.Close() 
    client端:
      conn,_ := net.Dial("tcp","127.0.0.1:8080")
      conn.Read([]byte) 
      conn.Write(data)
      defer -> conn.Close()
    

    server端通过net.Listen方法获取到socket对象,通过此socket的Accept()阻塞等待一个client端的一次链接。当链接建立成功后拿到conn通道对象,通过其Read(),Write()方法即可向该链接通道里读写数据,继而实现网络通信。在方法结束或对方结束通信后应该关闭socket和链接conn通道。
    client端通过net.Dai()方法建立一个通信链接conn,通过其Read(),Write()方法实现其个server之间的通信。
    注意当通道conn里没有数据时Read()方法为一阻塞状态,故可以通过for循环来实现不断的获取对方发送来的数据。

    server:

    package main
    
    import (
    	"fmt"
    	"io"
    	"net"
    	"strings"
    )
    /**
    结论:
    0.listener.Accept()在client未Dial请求链接前为阻塞
    1.无论server还是clien端只要conn.Close()关闭了,自己的conn.Read()方法就会在循环里不断调用,读取的字节大小n为0,err为EOF.故要做判断。
    2.conn.Read()方法在conn链接未关闭前,没接收到数据是阻塞的。
    3.conn.Write()方法向对方发送二进制流数据。
     */
    //服务端
    func main(){
    	socket,err := net.Listen("tcp","127.0.0.1:8080")
    	checkError(err)
    	defer socket.Close()
    	fmt.Println("socket server start ...")
    	
    	for{
    		conn,err := socket.Accept()//阻塞于此,等待client端的链接请求
    		go handlerConn(conn,err)//开启协程独立处理每条client的链接请求与响应
    	}
    }
    func checkError(err error){
    	if err!=nil {
    		panic(err)
    	}
    }
    func handlerConn(conn net.Conn,err error){
    	defer conn.Close()
    	checkError(err)
    	for{
    		//读取客户端发来的信息
    		receiveData := make([]byte,4)
    		n,resErr:=conn.Read(receiveData) //阻塞等待client端发送到conn链接通道数据。n为每次读取到的字节数,将每次读取的数据最大以len(receiveData)字节长度存储到切片中,若超过则再遍历一次进行读取后段数据
    		data := receiveData[0:n] //切片切取到实际数据量
    		if  strings.ToUpper(strings.TrimSpace(string(data))) == "EXIT" {
    			conn.Close()
    			fmt.Println("client结束了聊天!")
    			return
    		}
    		if n==0 && resErr == io.EOF {
    			conn.Close()
    			return
    		}
    		fmt.Printf("收到client信息:%d %v %s",n,resErr,string(receiveData))
    	}
    }
    

    client:

    package main
    
    import (
    	"bufio"
    	"fmt"
    	"net"
    	"os"
    	"strings"
    )
    
    //客户端
    func main(){
    	conn,err := net.Dial("tcp","127.0.0.1:8080")
    	checkError(err)
    	defer conn.Close()//关闭链接
    
    	for{
    		//监听输入,将输入发送给服务端
    		fmt.Println("input>>")
    		r := bufio.NewReader(os.Stdin)
    		data,_,_ := r.ReadLine()
    		conn.Write(data)
    		if strings.ToUpper(string(data)) == "EXIT" {
    			break //跳出循环,结束程序
    		}
    	}
    }
    func checkError(err error){
    	if err!=nil {
    		panic(err)
    	}
    }
    
    1. 1v1: 以上为server To Client端1v1的方式实现通信
    2. nvn: 可以想到server端在和多个client建立链接conn后我们可以对这些链接进行一些列的处理,将2. client之间发送来到信息进行指定链接通道的写入。从而实现多个client之间的通信。此时的server就相当于一个信息中转站的角色。
    2、基于udp

    udp协议:是一种不需要建立链接,故存在数据可能会丢失的情况,不可靠。但其速度快,UCP不维护连接状态,也不跟踪这些参数,开销小。空间和时间上都具有优势。UDP也常用于多媒体应用(如IP电话,实时视频会议,直播,流媒体等)数据的可靠传输对他们而言并不重要,TCP的拥塞控制会使他们有较大的延迟,也是不可容忍的。
    相关api:

    server:
    	udpAddr,err := net.ResolveUDPAddr("udp","127.0.0.1:8080") //创建server端地址结构
    	socket,err := net.ListenUDP("udp",udpAddr)  //创建socket
    	socket.ReadFromUDP(data) //读取client端数据
    	socket.WriteToUDP()  // 向client发送数据
    	defer -> socket.Close()
    client:
    	conn,_ := net.Dial("udp","127.0.0.1:8080")
    	conn.Read([]byte) 
    	conn.Write(data)
    	defer -> conn.Close()
    

    server:

    package main
    
    import (
    	"fmt"
    	"io"
    	"net"
    )
    
    func main(){
    	udpAddr,err := net.ResolveUDPAddr("udp","127.0.0.1:8080")
    	checkError(err)
    	socket,err := net.ListenUDP("udp",udpAddr)
    	checkError(err)
    	//读取client端信息
    	for{
    		data := make([]byte,1024)
    		n,_,err:=socket.ReadFromUDP(data)
    		if n == 0 && err == io.EOF {
    			break
    		}
    		fmt.Println("收到client端信息:",string(data[0:n]))
    	}
    	//向client写数据
    	//udpConn.WriteToUDP()
    	defer  socket.Close()
    }
    func checkError(err error){
    	if err!=nil {
    		panic(err)
    	}
    }
    

    client:

    package main
    
    import (
    	"bufio"
    	"fmt"
    	"net"
    	"os"
    	"strings"
    )
    
    //客户端
    func main(){
    	conn,err := net.Dial("udp","127.0.0.1:8080")
    	checkError(err)
    	defer conn.Close()//关闭链接
    
    	for{
    		//监听输入,将输入发送给服务端
    		fmt.Println("input>>")
    		r := bufio.NewReader(os.Stdin)
    		data,_,_ := r.ReadLine()
    		conn.Write(data)
    		if strings.ToUpper(string(data)) == "EXIT" {
    			break //跳出循环,结束程序
    		}
    	}
    }
    func checkError(err error){
    	if err!=nil {
    		panic(err)
    	}
    }
    
    展开全文
  • go 网络编程

    2014-12-31 14:25:44
    首先复习一下go的基本语法1:变量定义val 变量 变量类型 val v1 int val v2 string val v3 [10]int //定义一个int10的数组 val v4 map[string] string //定义一个字典 key为string value也为string val v5 ...

    首先复习一下go的基本语法
    1:变量定义
    val 变量 变量类型

    val v1 int 
    val v2 string
    val v3 [10]int  //定义一个int10的数组
    val v4 map[string] string //定义一个字典 key为string value也为string
    val v5 func(a int) int  //v5指向一个函数

     可以更简单一些,根据数据推断类型,如下:

    v6 := 90
    v7 := "hello china"

     匿名变量  _,_,name := GetName()
        如果调用一个方法返回多个变量,有些变量不使用,可以用——代替
    常量 const mark = 1<<3

     

     

    go server

    package main
    
    /*
    *go server
    *can be serve as chat,game,file trans server
    *also can be serve as proxy server
    *surpport protocal :http tcp udp ftp https sock5 and so on
    *
    *************************************************************************/
    
    import (
    	"fmt"
    	"io"
    	"log"
    )
    import "net"
    
    const addr = "127.0.0.1:1080"
    const bufferSize = 4096
    const maxConn = 1000
    
    type bundle struct {
    	clientNO int64                   //current client num
    	clients  map[string]serverClient //store client in the map,key:client name,value: serverClient
    }
    
    func (s bundle) init() {
    }
    
    func (s bundle) startNewClient(clientName string, client serverClient) {
    	s.clients[clientName] = client
    	s.clientNO++
    	client.startProcess()
    }
    
    type serverClient struct {
    	clientName string //client username
    	Conn       net.Conn
    	//send       chan []byte
    	//reply      io.Writer
    }
    
    //process client data
    func (client serverClient) startProcess() {
    	data := make([]byte, bufferSize)
    	n, _ := io.ReadFull(client.Conn, data)
    	if n > 0 {
    		fmt.Println(string(data[0:n]))
    	}
    	client.Conn.Write([]byte("hello "))
    }
    
    //start server,when accept ,let gorountine to process
    func startServer() {
    	b := new(bundle)
    	b.clients = make(map[string]serverClient)
    
    	a, err := net.ResolveTCPAddr("tcp", addr)
    	if err != nil {
    		log.Fatal(err)
    	}
    	l, err2 := net.ListenTCP("tcp", a)
    	if err2 != nil {
    		log.Fatal(err2)
    	}
    
    	for {
    		c, err3 := l.Accept()
    		if err3 != nil {
    			log.Fatal(err3)
    		}
    		fmt.Print("new client from :")
    		fmt.Println(c.RemoteAddr())
    
    		ch := serverClient{"1", c}
    		go b.startNewClient(c.RemoteAddr().String(), ch)
    	}
    
    }
    
    func main() {
    	fmt.Println("start server")
    	startServer()
    
    }
    

     go client

    package main
    
    import (
    	"fmt"
    	"io"
    	"log"
    )
    import "net"
    
    const svrAddr = "127.0.0.1:1080"
    const clientAddr = "127.0.0.1:2090"
    const bufferSize = 4096
    
    type clientBundle struct {
    	conn net.Conn
    }
    
    func startClient(ch chan int) {
    	conn, err := net.Dial("tcp", svrAddr)
    	if err != nil {
    		log.Fatal(err)
    	}
    	defer conn.Close()
    	b := clientBundle{conn}
    	//conn.Write([]byte("hello server"))
    	io.WriteString(conn, "sfsf")
    
    	//io.Writer.
    	b.processRead()
    
    }
    
    func (b clientBundle) processRead() {
    	//data := make([]byte, bufferSize)
    	//n, _ := io.ReadFull(b.conn, data)
    	//if n > 0 {
    	//	fmt.Println(data[:n])
    	//}
    
    }
    
    func main() {
    	fmt.Println("start client")
    	for {
    
    		conns := make(chan int)
    		startClient(conns)
    	}
    	//<-conns
    	fmt.Println("finish send")
    }
    

     

    展开全文
  • go网络编程学习资料,英文文档及中文翻译,Network Programming with Go
  • Go网络编程——http

    2021-01-11 09:39:00
    Go网络编程——http 一、Http概述 1.概念 2.HTTP请求方法 3.HTTPS通信原理 4.Https的作用 二、http客户端实现 1.客户端基本方法 三、http服务端实现 1.服务端代码实现 2.服务端获取客户端请求数据 .....

    Go网络编程——http

    一、Http概述

    1.概念

    在这里插入图片描述

    2.HTTP请求方法

    在这里插入图片描述

    3.HTTPS通信原理

    在这里插入图片描述
    在这里插入图片描述

    4.Https的作用

    在这里插入图片描述

    二、http客户端实现

    在这里插入图片描述

    1.客户端基本方法

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    三、http服务端实现

    1.服务端代码实现

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    2.服务端获取客户端请求数据

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 网络编程中cookie和session是必不可少的,今天就简单说一下go语言对session的实现。图片来源于网络cookie,简而言之就是在本地计算机保存一些用户操作的历史信息(当然包括登录信息),并在用户再次访问该站点时浏览器...

    网络编程中cookie和session是必不可少的,今天就简单说一下go语言对session的实现。

    d68cccdce154c485103c27be344254fb.gif

    图片来源于网络

    cookie,简而言之就是在本地计算机保存一些用户操作的历史信息(当然包括登录信息),并在用户再次访问该站点时浏览器通过HTTP协议将本地cookie内容发送给服务器,从而完成验证,或继续上一步操作。

    session在Web开发环境下,它的含义是指一类用来在客户端与服务器端之间保持状态的解决方案。有时候Session也用来指这种解决方案的存储结构。

    简而言之,cookie是本地的文件,存储一下和服务器相关的内容,session的服务端存储的数据,用来和cookie相互对应,简化用户登录等,因为http都是无状态的,在用户登录后,再访问其他页面时不应该再次登录,所以可以使用cookie和session来解决,我们不可能每一次访问界面都要将用户的账号密码等信息都发送一次,这样不仅是做无用功,而且也很危险。

    下面是我用go语言实现的一个简单的session:

    package mainimport ( "crypto/rand" "encoding/base64" "errors" "io" "net/http" "net/url" "strconv" "sync" "time")// SessionMgr session managertype SessionMgr struct { cookieName string mLock sync.RWMutex maxLifeTime int64 sessions map[string]*Session}// Sessiontype Session struct { sessionID string lastTime time.Time values map[interface{}]interface{}}// NewSessionMgr create session managerfunc NewSessionMgr(cookieName string, maxLifeTime int64) *SessionMgr { mgr := &SessionMgr{cookieName: cookieName, maxLifeTime: maxLifeTime, sessions: make(map[string]*Session)} go mgr.SessionGC() return mgr}// NewSession create sessionfunc (mgr *SessionMgr) NewSession(w http.ResponseWriter, r *http.Request) string { mgr.mLock.Lock() defer mgr.mLock.Unlock() newSessionID := url.QueryEscape(mgr.NewSessionID()) session := &Session{sessionID: newSessionID, lastTime: time.Now(), values: make(map[interface{}]interface{})} mgr.sessions[newSessionID] = session cookie := http.Cookie{Name: mgr.cookieName, Value: newSessionID, Path: "/
    展开全文
  • [GO语言基础] GO网络编程、实现TCP/IP模型(十)
  • 《TCP IP网络编程》链接:https://pan.baidu.com/s/1gLs6inqEG7v3T0mcKT6iSg提取码:SK01《MFC网络编程》链接:https://pan.baidu.com/s/1VLLl7exgYzvhU-vL1Jnraw提取码:SK02《openssl-编程入门(含完整示例)》链接...
  • 传统编程语言的Socket设计流程: 1.创建socket:socekt(); 2.绑定socekt:bind(); 3.监听:listen(); 4.连接:connect(); 5.接受:accept(); 6.接受:receive(); 7.发送:send(); 但Go语言标准对...
  • go web programming,2016 by Manning Publications 清晰,无水印
  • 由客户端解释HTML文档,在客户端屏幕上渲染图形效果 二、HTTP协议 超文本传输协议(HTTP)是互联网上应用最为广泛的一种网络协议,它详细规定了浏览器和万维网服务器之间互相通信的规则,通过因特网传送万维网文档的...
  • 6 go 网络编程

    2020-04-12 22:20:18
    1网络分层 1网络分层:每一层利用下一层提供的服务来为上一层提供服务,本层服务的实现对上层屏蔽。 2tcp/ip分层:应用层、传输层、网络层、链路层。 3以太网规定,连入网络的所有设备,都必须具有”王康...
  • Go语言中编写网络程序时,我们将看不到传统的编码形式。以前我们使用Socket编程时,会按照如下步骤展开:  (1)建立Socket:使用socket()函数。  (2)绑定Socket:使用bind()函数。  (3)监听:使用listen()函数...
  • 04 GO 网络编程

    2018-06-26 18:07:53
    Socket 编程建立socket:socket()绑定socket:bind()监听:listen()或者 connect()接受连接: accept()接收: receive() send()Dial函数func Dial(net, addr string) (conn, error)net 可选参数tcp udp ...
  • Go网络编程之HTTP编程

    千次阅读 2017-12-06 09:23:37
    HTTP(HyperText Transfer Protocol,超文本传输协议)是互联网上应用最为广泛的一种网络协议,定义了客户端和服务端之间请求和响应的传输标准。  Go语言标准库内建提供了net/http包,涵盖了HTTP客户端和服务端的具体...
  • Go 网络编程示例

    2019-05-13 10:56:54
    示例:并发时钟服务器 ...网络服务 net/http 包是在 net 包的基础上构建的。 时钟服务器 这个示例是一个时钟服务器,它以每秒一次的频率向客户端发送当前时间: package main import ( "io" "log" "net" ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,450
精华内容 580
关键字:

go网络编程