GoWeb——Socket编程

最新推荐文章于 2025-06-24 09:00:06 发布
原创 最新推荐文章于 2025-06-24 09:00:06 发布 · 1.2k 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#网络 #tcp/ip #udp #go

1、Go语言中的Socket

在Go语言中进行网络编程，比传统的网络编程更加简洁。Go语言提供了net包来处理Socket。net包对Socket连接过程进行了抽象和封装，无论使用什么协议建立什么形式的连接，都只需要调用net.Dial()函数即可，从而大大简化了代码的编写量。

在服务器端和客户端的通信过程中，服务器端有两个Socket连接参与进来，但用于通信的只有conn结构体中的Socket连接。conn是由listener创建的用于Socket连接的结构体，隶属于服务器端。

服务器端通过net.Listen()方法建立连接并监听指定IP地址和端口号，等待客户端连接。客户端则通过net.Dial()函数连接指定的IP地址和端口号，建立连接后即可发送消息，如图所示。

在这里插入图片描述

2、客户端Dial()函数

2.1、Dial()函数的定义

在Go语言中，net包，的Dial()函数的定义如下：

func Dial(net,addr string)(Conn,error)

其中，net参数是网络协议的名字，addr参数是IP地址或域名，而端口号以“:”的形式跟随在P地址或域名的后面，端口号可选。如果连接成功，则返回连接对象，否则返回error。

2.2、Dial()函数的使用

2.2.1、 TCP连接

TCP连接直接通过net.Dial(“tcp”,“ip:port”)的形式调用：

conn,err := net.Dia1("tcp","192.168.0.1:8087")
2.2.2、UDP连接

UDP连接直接通过net.Dial(“udp”,“ip:port”)的形式调用：

conn,err := net.Dia1("udp","192.168.0.2:8088")
2.2.3、ICMP连接（使用协议名称)

ICMP连接（使用协议名称)通过net.Dial(“ip4:icmp”,“www.shirdon.com”)的形式调用：

conn,err := net.Dial("ip4:icmp","www.shirdon.com"
2.2.4、ICMP连接（使用协议编号)

ICMP连接（使用协议名称)的用法如下：

conn,err := net.Dia1("ip4:1","10.0.0.8")

目前，Dial()函数支持如下几种网络协议：TCP、TCP4(仅限IPv4)、TCP6(仅限IPv6)、UDP、UDP4(仅限IPv4)、UDP6(仅限IPv6)、IP、IP4(仅限IPv4)和IP6(仅限IPv6)。
在成功建立连接后，就可以进行数据的发送和接收。使用Write()方法发送数据，使用Read()方法接收数据。下面这个示例代码展示了使用Read()方法来接收数据。

import (
	"bytes"
	"fmt"
	"io"
	"net"
	"os"
)

func main() {
	conn, err := net.Dial("tcp", "127.0.0.1:8888")
	validateError(err)

	//调用由返回的连接对象提供的Write()方法发送请求
	_, err = conn.Write([]byte("hello world"))
	validateError(err)

	result, err := fullyRead(conn)
	validateError(err)

	fmt.Println(string(result))
	os.Exit(0)
}

// 如果连接出错，则打印错误消息并退出程序
func validateError(err error) {
	if err != nil {
		fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
		os.Exit(1)
	}
}

// 通过由连接对象提供的Read()方法读取所有响应数据
func fullyRead(conn net.Conn) ([]byte, error) {
	defer conn.Close()

	result := bytes.NewBuffer(nil)
	var buf [512]byte
	for {
		_, err := conn.Read(buf[0:])
		result.Write(buf[0:])
		if err != nil {
			if err == io.EOF {
				break
			}
			return nil, err
		}
	}
	return result.Bytes(), nil
}

3、客户端DialTCP()函数的使用

3.1、DialTCP()函数的定义

除Dial()函数外，还有一个名为DialTCP()的函数用来建立TCP连接。
DialTCP()函数和Dial()函数类似，该函数的定义如下：

func DialTCP(network string, laddr, raddr *TCPAddr)(*TCPConn, error)

其中，network参数可以是tcp、tcp4或tcp6;laddr为本地地址，通常为nil;raddr为目的地址，为TCPAddr类型的指针。该函数返回一个*TCPConn对象，可通过Read()和Write()方法传递数据。例如要访问网址127.0.0.1:8086，则使用方法见下方示例。

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

func main() {
	service := "127.0.0.1:8888"
	tcpAddr, err := net.ResolveTCPAddr("tcp", service)
	checkError(err)
	fmt.Println("tcpAddr:")
	typeof(tcpAddr)

	myConn, err1 := net.DialTCP("tcp", nil, tcpAddr)
	checkError(err1)
	fmt.Println("myConn:")
	typeof(myConn)

	_, err = myConn.Write([]byte("hello world!"))
	checkError(err)

	result, err := io.ReadAll(myConn)
	checkError(err)
	fmt.Println(string(result))
	os.Exit(0)
}

tcpAddr:
type is:*net.TCPAddr
myConn:
type is:*net.TCPConn

3.2、DialTCP()函数的使用

3.2.1、TCP服务器端代码

编写一个TCP服务器端程序，在8088端口监听；可以和多个客户端建立连接；连接成功后，客户端可以发送数据，服务器端接收数据，并显示在命令行终端。先使用telnet来测试，然后编写客户端程序来测试。该程序的服务器端和客户端的示意图如图所示。
在这里插入图片描述

import (
	"fmt"
	"log"
	"net"
)

func main() {
	Server()
}

func Server() {
	//用Listen()函数创建的服务器端
	//tcp: 网络协议
	//本机的IP地址和端口号：127.0.0.1:8088
	l, err := net.Listen("tcp", "127.0.0.1:8088")
	if err != nil {
		log.Fatalln(err)
	}
	defer l.Close()
	//循环等待客户端范文
	for {
		conn, err := l.Accept()
		if err != nil {
			log.Fatalln(err)
		}
		fmt.Printf("范文客户端信息：con=%v客户端 ip=%v\n", conn, conn.RemoteAddr().String())
		go handleConnection(conn)
	}
}

//服务端处理从客户端接收的数据
func handleConnection(c net.Conn) {
	defer c.Close()

	for {
		//1. 等待客户端捅咕oconn对象发送信息
		//2. 如果客户端没有发送数据，则goroutine就阻塞在这里
		fmt.Printf("服务器在等待客户端%s发送信息\n", c.RemoteAddr().String())
		buf := make([]byte, 1024)
		n, err := c.Read(buf)
		if err != nil {
			log.Fatalln(err)
			break
		}
		//3. 显示客户端发送到服务器端的内容
		fmt.Println(string(buf[:n]))
	}
}
3.2.2、TCP客户端代码

编写一个TCP客户端程序，该客户端有如下的功能：

  • 能连接到服务器端的8088端口；
  • 客户端可以发送单行数据，然后退出；
  • 能通过客户端命令行终端输入数据（输入一行就发送一行），并发送给服务器端；
  • 在客户端命令行终端输入exit,表示退出程序。
import (
	"bufio"
	"fmt"
	"log"
	"net"
	"os"
	"strings"
)

func main() {
	Client()
}

func Client() {
	conn, err := net.Dial("tcp", "127.0.0.1:8088")
	if err != nil {
		log.Fatalln(err)
	}
	//客户端可以发送单行数据，然后退出
	reader := bufio.NewReader(os.Stdin)
	for {
		//从客户端读取一行用户输入，并准备发送给服务器端
		line, err := reader.ReadString('\n')
		if err != nil {
			log.Fatalln(err)
		}
		line = strings.Trim(line, "\r\n")
		if line == "exit" {
			fmt.Println("用户退出客户端")
			break
		}
		//将line发送给服务器端
		conent, err := conn.Write([]byte(line + "\n"))
		if err != nil {
			log.Fatalln(err)
		}
		fmt.Printf("客户端发送了%d字节的数据到服务器端\n", conent)
	}
}

4、UDP Socket的使用

4.1、UDP Socket的定义

由于UDP是“无连接”的，所以服务器端只需要指定P地址和端口号，然后监听该地址，等待客户端与之建立连接，两端即可通信。

下面在Go语言中创建UDP Socket,用函数或者方法来实现。

4.1.1、创建监听地址

创建监听地址使用ResolveUDPAddr()函数，其定义如下：

func ResolveUDPAddr(network,address string)(*UDPAddr,error)
4.1.2、创建监听连接

创建监听连接使用ListenUDP()函数，其定义如下：

func ListenUDP(network string,laddr UDPAddr)
(UDPConn,error)
4.1.3、接收UDP数据

接收UDP数据使用ReadFromUDP()方法，其定义如下：

func (c *UDPConn)ReadFromUDP(b []byte)(int, *UDPAddr,error)
4.1.4、写出数据到UDP

写出数据到UDP使用WriteToUDP()方法，其定义如下：

func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (int, error)

4.2、UDP Socket的使用

4.2.1、UDP服务器端代码
import (
	"fmt"
	"net"
)

func main() {
	//创建监听的地址，并且指定为UDP协议
	udpAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:8012")
	if err != nil {
		fmt.Println("ResolveUDPAddr err:", err)
		return
	}
	conn, err := net.ListenUDP("udp", udpAddr)
	if err != nil {
		fmt.Println("ListenUDP err", udpAddr)
		return
	}
	defer conn.Close()

	buf := make([]byte, 1024)
	//接收客户端发送过来的数据，并填充到切片buf中
	n, raddr, err := conn.ReadFromUDP(buf)
	if err != nil {
		return
	}
	fmt.Println("客户端发送：", string(buf[:n]))
	_, err = conn.WriteToUDP([]byte("您好，客户端，我是服务器端"), raddr) //想客户端发送数据
	if err != nil {
		fmt.Println("WriteToUDP err:", err)
		return
	}
}
4.2.2、UDP客户端代码
import (
	"fmt"
	"net"
)

func main() {
	conn, err := net.Dial("udp", "127.0.0.1:8012")
	if err != nil {
		fmt.Println("net.Dial err:", err)
		return
	}
	defer conn.Close()

	conn.Write([]byte("你好，我是用UDP的客户端"))
	buf := make([]byte, 1024)
	n, err1 := conn.Read(buf)
	if err1 != nil {
		return
	}
	fmt.Println("服务器发来：", string(buf[:n]))
}
4.2.3、UDP并发编程

要实现UDP并发编程，需要在UDP客户端通过go关键字启动goroutine来处理请求。同时在服务器端需要通过for语句循环处理客户端数据。

1. 并发版UDP服务器端：

import (
	"fmt"
	"net"
)

func main() {
	//创建服务器端UDP地址结构：指定IP地址和端口号
	laddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:8023")
	if err != nil {
		fmt.Println("ResolveUDPAddr err:", err)
		return
	}
	//监听客户端连接
	conn, err := net.ListenUDP("udp", laddr)
	if err != nil {
		fmt.Println("net.ListenUDP err:", err)
		return
	}
	defer conn.Close()
	for {
		buf := make([]byte, 1024)
		n, raddr, err := conn.ReadFromUDP(buf)
		if err != nil {
			fmt.Println("conn.ReadFromUDP err:", err)
			return
		}
		fmt.Printf("接收到客户端[%s]:%s", raddr, string(buf[:n]))
		conn.WriteToUDP([]byte("i am server"), raddr)
	}
}

2. 并发版UDP客户端：

import (
	"fmt"
	"net"
)

func main() {
	conn, err := net.Dial("udp", "127.0.0.1:8023")
	if err != nil {
		fmt.Println("net.Dial err:", err)
		return
	}
	defer conn.Close()
	//通过go关键字启动goroutine，从而支持并发
	go func() {
		var str string
		for {
			_, err := fmt.Scanln(&str)
			if err != nil {
				fmt.Println("os.Stdin.err = ", err)
				return
			}
			conn.Write([]byte(str))
		}
	}()
	buf := make([]byte, 1024)
	for {
		n, err := conn.Read(buf)
		if err != nil {
			fmt.Println("conn.Read err:", err)
			return
		}
		fmt.Println("服务器发送来：", string(buf[:n]))
	}
}

5、简单的聊天程序

5.1、服务器端代码编写

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

var ConnSlice map[net.Conn]*Heartbeat

// 心跳结构体
type Heartbeat struct {
	endTime int64 //过期时间
}

func main() {
	ConnSlice = map[net.Conn]*Heartbeat{}
	l, err := net.Listen("tcp", "127.0.0.1:8086")
	if err != nil {
		fmt.Println("服务器启动失败")
	}
	defer l.Close()
	for {
		conn, err := l.Accept()
		if err != nil {
			fmt.Println("Error accepting: ", err)
		}
		fmt.Printf("Received message %s -> %s \n", conn.RemoteAddr(), conn.LocalAddr())
		ConnSlice[conn] = &Heartbeat{
			endTime: time.Now().Add(time.Second * 5).Unix(), //初始化过期时间
		}
		go handelConn(conn)
	}
}

func handelConn(c net.Conn) {
	buffer := make([]byte, 1024)
	for {
		n, err := c.Read(buffer)
		if ConnSlice[c].endTime > time.Now().Unix() {
			ConnSlice[c].endTime = time.Now().Add(time.Second * 5).Unix() //更新心跳时间
		} else {
			fmt.Println("长时间未发消息断开连接")
			return
		}
		if err != nil {
			return
		}
		//如果是心跳检测，那就不要执行剩下的代码
		if string(buffer[0:n]) == "1" {
			c.Write([]byte("1"))
			continue
		}
		for conn, heart := range ConnSlice {
			if conn == c {
				continue
			}
			//心跳检测 使用懒惰更新,需要发送数据的时候才检查规定时间内有没有数据到达
			if heart.endTime < time.Now().Unix() {
				delete(ConnSlice, conn) //从房间列表中删除连接，并且关闭
				conn.Close()
				fmt.Println("删除连接", conn.RemoteAddr())
				fmt.Println("现在存有链接", ConnSlice)
				continue
			}
			conn.Write(buffer[0:n])
		}
	}
}

5.2、客户端代码编写


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

func main() {
	server := "127.0.0.1:8086"
	tcpAddr, err := net.ResolveTCPAddr("tcp4", server)
	if err != nil {
		Log(os.Stderr, "Fatal error:", err.Error())
		os.Exit(1)
	}
	conn, err := net.DialTCP("tcp", nil, tcpAddr)
	if err != nil {
		Log("Fatal error:", err.Error())
		os.Exit(1)
	}
	Log(conn.RemoteAddr().String(), "connect success!")
	Sender(conn)
	Log("end")
}

func Sender(conn *net.TCPConn) {
	defer conn.Close()
	sc := bufio.NewReader(os.Stdin)
	go func() {
		t := time.NewTicker(time.Second) //创建定时器,用来实现定期发送心跳包给服务端
		defer t.Stop()
		for {
			<-t.C
			_, err := conn.Write([]byte("1"))
			if err != nil {
				fmt.Println(err.Error())
				return
			}
		}
	}()
	name := ""
	fmt.Println("请输入聊天昵称") //用户聊天的昵称
	fmt.Fscan(sc, &name)
	msg := ""
	buffer := make([]byte, 1024)
	_t := time.NewTimer(time.Second * 5) //创建定时器,每次服务端发送消息就刷新时间
	defer _t.Stop()

	go func() {
		<-_t.C
		fmt.Println("服务器出现故障，断开链接")
		return
	}()
	for {
		go func() {
			for {
				n, err := conn.Read(buffer)
				if err != nil {
					return
				}
				_t.Reset(time.Second * 5)       //收到消息就刷新_t定时器，如果time.Second*5时间到了，那么就会<-_t.C就不会阻塞，代码会往下走，return结束
				if string(buffer[0:1]) != "1" { //心跳包消息定义为字符串"1",不需要打印出来
					fmt.Println(string(buffer[0:n]))
				}
			}
		}()
		fmt.Fscan(sc, &msg)
		i := time.Now().Format("2006-01-02 15:04:05")
		conn.Write([]byte(fmt.Sprintf("%s\n\t%s: %s", i, name, msg))) //发送消息
	}
}

func Log(v ...interface{}) {
	fmt.Println(v)
	return
}
GO：Socket编程
unravel_tom的博客
07-19 1381
在学习 Socket之前，我们需要了解、什么是TCP/IP以及如何使用TCP/IP中的Socket 连接实现网络通信。Socket是我们在使用Go语言的过程中会使用到的最底层的网络协议，大部分的网络通信协议都是基于TCP/IP的Socket协议
2025——》Socket编程
weixin_68013600的博客
06-11 786
Socket 编程是构建网络应用的基石，其核心在于根据业务需求选择合适的协议（TCP/UDP）、编程语言（Python/Java/Rust）和框架（Netty/smart-socket）。开发者需掌握连接管理、并发处理、安全加密等核心技术，并关注边缘计算、5G、量子安全等前沿趋势。通过结合官方文档、开源项目和实际案例，可逐步提升 Socket 编程能力，构建高效、可靠的分布式系统。
Go语言 Socket编程
谢谢你们的关注
07-22 2734
Go语言 Socket编程
go-socket.io：实时应用框架的Golang实现
最新发布
gitblog_00529的博客
06-24 281
go-socket.io：实时应用框架的Golang实现 项目核心功能/场景 go-socket.io 是 Socket.IO 的 Golang 实现，支持实时应用开发。 项目介绍 在实时通信和实时数据传输日益重要的今天，选择一个性能卓越、功能完善的库至关重要。go-socket.io 作为 Socket.IO 在 Golang 中的实现，为开发者提供了一个强大的实时应用框架。该框架支持房间(ro...
go语言socket编程
liu289747235的专栏
01-29 2018
包头部分的长度是固定的，并且它存储了包体的长度，根据包头长度固定以及包头中含有包体长度的变量就能正确的拆分出一个完整的数据包。将上面的代码编译成client或client.exe可执行文件，先启动server端再启动client端，在client端输入任意内容回车之后就能够在server端看到client端发送的数据，从而实现TCP通信。我们可以自己定义一个协议，比如数据包的前4个字节为包头，里面存储的是发送的数据的长度。主要原因就是tcp数据传递模式是流模式，在保持长连接的时候可以进行多次的收和发。
Go语言之Socket网络编程
程序彤的博客
06-07 310
Go网络编程 server.go package main import ( "fmt" "net" ) func main() { fmt.Println("服务器开始监听") listen,err:=net.Listen("tcp","127.0.0.1:8888") if err!=nil{ fmt.Printf("listen err=",err) return } defer listen.Close() // 延时关闭listen for { fmt.Print
go语言---socket网络编程
ixuery的博客
04-11 230
go语言—socket网络编程 (适合有基础计算机网络知识的) 服务端总体思路: 创建服务器地址; 创建监听器; 通过监听器监听客户端传递过来的数据;(这一步会阻塞) 转换数据; 关闭连接; // 这里是服务端代码 package main import ( "fmt" "net" ) func main() { // 1. 创建服务器地址;(暂不处理错误信息) addr, _ :...
Go语言从入门到精通八——socket和http编程
Dev-L的博客
03-03 772
golang中的socket编程 关于socket的基础知识，这里就不介绍了，可以参考python socket编程。 golang创建socket很简单，服务端处理流程通常为： 监听端口 接受客户端的连接请求 创建goroutine，处理该请求 示例代码如下： package main import ( &quot;fmt&quot; &quot;net&quot; ) func main() { //...
Go Web编程指南：从入门到实战
进入更高级的主题，书籍介绍了GoWeb编程的深入实践，如使用ORM（对象关系映射）库beedb进行开发，NOSQL数据库的操作，以及会话管理和数据存储，包括session、cookie的使用以及安全性措施如防止session劫持。...
关于socket编程的基础（基于go、python编码）
wd345901051的博客
05-29 299
本文章对于网络编程socker做了简答介绍，基于go&python编程，对socket进行了代码讲解，对socket的基本流程进行了简单说，希望通过学习，对套接字编程有一个深的理解
嵌入式学习——网络编程（TCP）——day31
qq_47798402的博客
06-03 1304
成功返回与发送端建立的新文件描述符（通信套接字）addrlen:想要接收地址大小变量空间首地址。addr:存放链接对方地址信息空间首地址。将本地字节序（小端）转换为网络字节序（大端）将网络字节序（大端）转换为本地字节序（小端）addrlen:接收方地址的大小。addr:接收方地址空间首地址。flags:属性 默认为0。buf:存放数据空间首地址。flags:属性 默认为0。buf:存放数据空间首地址。sockfd:文件描述符。sockfd:文件描述符。sockfd:文件描述符。sockfd:文件描述符。
Go-socket.io在golang中的一个实现一个实时应用程序框架
08-13
go-socket.io是socket.io在golang中的一个实现，一个实时应用程序框架
Go语言Socket
书香水墨
07-11 1868
一.Socket简介 在标准库的net包中可供了可移植的网络I/O接口,其中就包含了Socket Socket在TCP/IP网络分层中并不存在,是对TCP或UDP封装 如果非要给Socket一个解释 实现网络上双向通讯连接的一套API 常称Socket为"套接字" Socket分类: 按照连接时间 短连接 长连接(HTTP 1.1开始也支持长连接,Socket替换方案) 按照客户端和服务器端数量 点对点 点对多 多对多 网络通信内容都是包含客户端和服务端,服务端运行在服务器中,而客
Go语言TCP Socket编程
shenlanzifa的专栏
12-29 3006
Golang的主要 设计目标之一就是面向大规模后端服务程序，网络通信这块是服务端 程序必不可少也是至关重要的一部分。在日常应用中，我们也可以看到Go中的net以及其subdirectories下的包均是“高频+刚需”，而TCP socket则是网络编程的主流，即便您没有直接使用到net中有关TCP Socket方面的接口，但net/http总是用到了吧，http底层依旧是用tcp socket
Go_socket编程
fight fight fight,never ever ever give up
08-30 323
套接字级编程 Agenda 网络编程的基础方法，将涉及到主机和服务寻址，也会考虑到TCP和UDP 如何使用GO的TCP和UDP相关的API来构建服务器和客户端。 介绍了原生套接字来实现自己的协议 TCP/IP协议栈 TCP是一个面向连接的协议，UDP（User Datagram Protocol，用户数据报协议）是一种无连接的协议。 --｜应用层｜ 应用层 OSI 5-7 ^ ^ | | TCP
Go语言Web服务--Socket编程
一只IT小小鸟
07-22 2305
Web服务 Web服务可以让你在HTTP协议的基础上通过XML或者JSON来交换信息。如果你想知道上海的天气预报、中国石油的股价或者淘宝商家的一个商品信息，你可以编写一段简短的代码，通过抓取这些信息然后通过标准的接口开放出来，就如同你调用一个本地函数并返回一个值。 Web服务背后的关键在于平台的无关性，你可以运行你的服务在Linux系统，可以与其他Window的asp.net程序交互，同样的，...
网络编程(tcp,udp,http)
qq_36867807的博客
03-23 263
1.Go语言实现TCP通信 一个TCP服务端可以同时连接很多个客户端，例如世界各地的用户使用自己电脑上的浏览器访问淘宝网。因为Go语言中创建多个goroutine实现并发非常方便和高效，所以我们可以每建立一次链接就创建一个goroutine去处理。 TCP服务端程序的处理流程： 监听端口 接收客户端请求建立链接 创建goroutine处理链接。 我们使用Go语言的net包实现的TCP服务端代码如下： func process (coon net.Conn){ for { //3.与客
Go中的Socket编程
02-09 1035
在很多底层网络应用开发者的眼里一切编程都是Socket，话虽然有点夸张，但却也几乎如此了，现在的网络编程几乎都是用Socket来编程。你想过这些情景么？我们每天打开浏览器浏览网页时，浏览器进程怎么和Web服务器进行通信的呢？当你用QQ聊天时，QQ进程怎么和服务器或者是你的好友所在的QQ进程进行通信的呢？当你打开PPstream观看视频时，PPstream进程如何与视频服务器进行通信的呢？ 如此种种，都是靠Socket来进行通信的，以一斑窥全豹，可见Socket编程在现代编程中占据了多么重要的地位，这一节我们
go web socket
harryhare的专栏
06-10 341
有两个可用库，下面是两个简单的例子 web socket 似乎只是相当于在普通的http 协议中加入了一个升级协议的部分， gorilla/websocket 中显式的体现了这一步 x/net/websocket 中则把这一步封装成 websocket.Handler(handler) github.com/gorilla/websocket package main import ( "...
Go Web实战派编程源码深度解析
#### Go Web 编程实战派源码 - Go资源 **Go 语言基础** Go语言，又称Golang，是一种静态类型、编译型语言，由Google开发。它具有垃圾回收，同时支持并行运算，易于编写的特性，使得它成为现代编程语言中备受瞩目的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值