TCP
TCP server
package main
import (
"fmt"
"net"
)
func main() {
// 一. 创建套接字socket
// 指定server端使用的通信协议, 并绑定ip 和 port
listener, err := net.Listen("tcp", "127.0.0.1:8384")
if err != nil{
fmt.Println("server start err :", err)
return
}
fmt.Println("server start success...")
// 二. 创建用于连接和通信的socket
// 调用 Accept 监听连接,此时会阻塞server端,直到有客户端发送连接, server端每收到一个连接,都会创建一个conn 套接字(socket)
conn, err:= listener.Accept() // 等待连接
if err != nil{
fmt.Println("server accept err :", err)
return
}
// 三. 向client收发数据
// 1.读取客户端发送的数据
// 创建用于保存收到的数据大小的切片
buf := make([]byte, 4096)
n, err := conn.Read(buf) // 返回的是所收到数据的字节数
if err != nil{
fmt.Println("server read err :", err)
return
}
// 处理收到的数据后,如打印
fmt.Println("server 收到数据:", string(buf[:n])) // 将收到的数据,按照收到的字节数从头切到 n,即:读多少打印多少
// 2.向client发送数据
_, err = conn.Write([]byte("Im ok!"))
if err != nil{
fmt.Println("server write err :", err)
return
}
// 四. 关闭socker , 包括监听socket 和 通信socket
defer listener.Close()
defer conn.Close()
}
TCP client
package main
import (
"fmt"
"net"
)
func main() {
// 一. 客户端创建用于通信的socket
// 指定通信协议,并指定server端 IP PORT
conn, err := net.Dial("tcp", "127.0.0.1:8384")
if err != nil{
fmt.Println("client start err :", err)
return
}
// 二. 收发server端数据
// 1.主动向server端发送数据
msg := "Are you ok?"
_, err = conn.Write([]byte(msg))
if err != nil{
fmt.Println("client write err :", err)
return
}
// 2.接收server端的数据
buf := make([]byte, 4096)
n, err := conn.Read(buf)
if err != nil{
fmt.Println("client read err :", err)
return
}
fmt.Println("client 收到数据:", string(buf[:n]))
// 三. 关闭socker
defer conn.Close()
}
并发版server
package main
import (
"fmt"
"net"
"strings"
)
func HandlerConnent(conn net.Conn) {
defer conn.Close() // 注意完成数据通信后关闭conn
// server可以做一些事情,如处理数据
addr := conn.RemoteAddr() // 获取client addr
fmt.Println(addr.Network()) // 获取socket协议 : tcp
fmt.Println(addr.String()) // 获取client IP PORT : 127.0.0.1:54331
// 三. 循环读取客户端发送的数据
// 创建用于保存收到的数据大小的切片
buf := make([]byte, 4096)
for{
n, err := conn.Read(buf) // 返回的是所收到数据的字节数
// server 与 client 之间的 Read, Write 类似channel的读写端,
// 当写端主动关闭后,读端可以继续读数据,但读到的是0, 所以可以通过是否为0来判断client是否关闭连接
if n == 0{
fmt.Println("client stop..., 断开连接")
return
}
if "exit\n" == string(buf[:n]) || "exit\r\n" == string(buf[:n]){
fmt.Println("client stop..., 断开连接")
return
}
if err != nil{
fmt.Println("server read err :", err) // 注意: 当客户端关闭后,n 等于 0 , err 等于 EOF
return
}
msg := string(buf[:n]) // 将收到的数据,按照收到的字节数从头切到 n,即:读多少打印多少
fmt.Println("server 收到数据:", msg)
// 将客户端发送的数据转大写并返回给client端
_, err = conn.Write([]byte(strings.ToUpper(msg)))
if err != nil{
fmt.Println("server write err :", err)
return
}
}
}
func main() {
// 一. 创建套接字socket
// 指定server端使用的通信协议, 并绑定ip 和 port
listener, err := net.Listen("tcp", "127.0.0.1:8384")
defer listener.Close()
if err != nil{
fmt.Println("server start err :", err)
return
}
fmt.Println("server start success...")
// 二. 创建用于连接通信的socket
// 调用 Accept 监听连接,此时会阻塞server端,直到有客户端发送连接,, server端每收到一个连接,都会创建一个conn
for { // 循环等待创建连接,实现可以接收多个client的连接功能
conn, err:= listener.Accept() // 阻塞等待连接
if err != nil{
fmt.Println("server accept err :", err)
return
}
// 并发创建用于完成server 与 client 数据通信的函数
go HandlerConnent(conn) // 将conn socket传入
}
}
并发版client
package main
import (
"fmt"
"net"
"os"
)
func main() {
// 一. 客户端创建用于通信的socket
// 指定通信协议,并指定server端 IP PORT
conn, err := net.Dial("tcp", "127.0.0.1:8384")
if err != nil{
fmt.Println("client start err :", err)
return
}
// 创建go程, 用来获取键盘输入
go func() {
str := make([]byte, 4096)
for{
n, err := os.Stdin.Read(str) // 获取键盘输入
if err != nil{
fmt.Println("client os.Stdin.Read err :", err)
continue
}
_, err = conn.Write(str[:n])
if err != nil{
fmt.Println("client write err :", err)
return
}
}
}()
// 打印server 返回的数据
buf := make([]byte, 4096)
for{
n, err := conn.Read(buf)
if err != nil{
fmt.Println("client read err :", n, err) // 当server断开与client的连接后 client read err : 0 EOF
return
}
fmt.Println("client 收到数据:", string(buf[:n]))
}
}
UDP
UCP server
package main
import (
"net"
"fmt"
"time"
)
func main() {
// 一. 组织一个udp地址结构,绑定IP PORT
serverAddr, err:= net.ResolveUDPAddr("udp","127.0.0.1:8001")
if err != nil{
fmt.Println("server band IP err :", err) // 当server断开与client的连接后 client read err : 0 EOF
return
}
// 二. 创建用于通信的socket 注意:UDP 只有一个套接字socket
udpConn, err := net.ListenUDP("udp", serverAddr)
if err != nil{
fmt.Println("server ListenUDP err :", err) // 当server断开与client的连接后 client read err : 0 EOF
return
}
fmt.Println("server start success...")
defer udpConn.Close()
// 三. 读取client发送的数据
buf := make([]byte, 4096)
n, clientAddr, err := udpConn.ReadFromUDP(buf) // n:读到的字节数 clientAddr:客户端地址 err:错误信息
if err != nil{
fmt.Println("server ReadFromUDP err :", err) // 当server断开与client的连接后 client read err : 0 EOF
return
}
// 四. 处理数据
fmt.Println(clientAddr)
fmt.Println(string(buf[:n]))
// 会写数据给client
nowTime := time.Now().String()
n, err = udpConn.WriteToUDP([]byte(nowTime),clientAddr)
if err != nil{
fmt.Println("server WriteToUDP err :", err)
return
}
}
并发版 server
package main
import (
"net"
"fmt"
"time"
)
func main() {
// 一. 组织一个udp地址结构,绑定IP PORT
serverAddr, err:= net.ResolveUDPAddr("udp","127.0.0.1:8001")
if err != nil{
fmt.Println("server band IP err :", err) // 当server断开与client的连接后 client read err : 0 EOF
return
}
// 二. 创建用于通信的socket
udpConn, err := net.ListenUDP("udp", serverAddr)
if err != nil{
fmt.Println("server ListenUDP err :", err) // 当server断开与client的连接后 client read err : 0 EOF
return
}
fmt.Println("server start success...")
defer udpConn.Close()
for{
// 三. 读取client发送的数据
buf := make([]byte, 4096)
n, clientAddr, err := udpConn.ReadFromUDP(buf) // n:读到的字节数 clientAddr:客户端地址 err:错误信息
if err != nil{
fmt.Println("server ReadFromUDP err :", err) // 当server断开与client的连接后 client read err : 0 EOF
return
}
// 四. 处理数据
fmt.Println(clientAddr)
fmt.Println(string(buf[:n]))
go func() {
// 回写数据交给go程,udp socket 将写好的数据发送给目标IP
nowTime := time.Now().String()
n, err = udpConn.WriteToUDP([]byte(nowTime),clientAddr)
if err != nil{
fmt.Println("server WriteToUDP err :", err)
return
}
}()
}
}
案例 TCP 聊天室
server
package main
import (
"encoding/json"
"fmt"
"net"
"strings"
"time"
)
// 创建用户结构体类型
type Client struct {
C chan string // 传输用户接收的msg信息
Name string
Addr string
}
func (c *Client)setName(name string) {
c.Name = name
}
// 创建用于存储用户的map
var onlineMap map[string]*Client
// 创建全局 channle 用来传递用户消息
var message = make(chan string)
func Manager() {
// 初始化全局map
onlineMap = make(map[string]*Client)
for{
// 监听全局channel是否有数据,有数据取出,无数据阻塞
msg := <- message
// 将数据发送个每个用户
for _,user := range onlineMap{
user.C <- msg
}
}
}
func WriteMsgToClient(cli *Client, conn net.Conn) {
for sendMsg := range cli.C{
_, err := conn.Write([]byte(sendMsg + "\n"))
if err != nil{
fmt.Println("conn.Write err", err)
}
}
}
func ReadMsgFromClient(cli *Client, conn net.Conn, quit ,hasActive chan <- int) {
buf := make([]byte, 4096)
flg: for{
n, err := conn.Read(buf)
if n == 0{
quit <- 1
return
}
if err != nil{
fmt.Println("conn.Read err", err)
continue flg
}
strList := strings.Split(string(buf[:n]), " ")
switch strList[0] {
case "exit":
quit <- 1
case "setName":
cli.setName(strList[1])
cli.C <- "setName success"
continue flg
case "getUsers":
//usersBuf := make([]byte, 4096)
userList := []string{}
for _,user := range onlineMap{
userList = append(userList, user.Name)
}
data, _ := json.Marshal(userList)
cli.C <- string(data)
}
hasActive <- 1
message <- cli.Name + ":" +string(buf[:n])
}
}
func HanderConnect(conn net.Conn) {
defer conn.Close()
// 获取client IP
addr:=conn.RemoteAddr().String()
// 创建用户
cli := Client{make(chan string),addr,addr}
// 将用户添加到全局map中
onlineMap[addr]=&cli
// 创建监听用户瑞出的channel
quit := make(chan int)
// 创建判断用户是否活跃的channel
hasActive := make(chan int)
// 创建给该用户传递消息的go程
go WriteMsgToClient(&cli, conn)
// 将用户上线信息写到message
message <- "["+ addr +"] "+ cli.Name +" login"
// 获取用户输入,将输入信息写入message送给所有人
go ReadMsgFromClient(&cli, conn, quit, hasActive)
for{
select {
case <- quit:
delete(onlineMap, cli.Addr)
fmt.Printf("%s 退出, 断开连接 \n", cli.Name)
return
case <- time.After(time.Second*5): // 定时器, select刷新一遍,定时器才会重新计时
delete(onlineMap, cli.Addr)
fmt.Printf("%s 超时退出 \n",cli.Name)
return
case <- hasActive: // 这个channel的作用是判断用户若活跃,则刷新select,使计时器重新计时
}
}
}
func main() {
// 创建socket
Listener , err := net.Listen("tcp", "127.0.0.1:8000")
if err != nil{
fmt.Println(" net.Listen err", err)
return
}
fmt.Println("server starting...")
// 创建管理者go程,用来管理 全局map和全局channel
go Manager()
// 循环监听连接
for{
conn,err := Listener.Accept()
if err != nil{
fmt.Println(" Listener.Accept err", err)
return
}
// 循环通信
go HanderConnect(conn)
}
}
Client
package main
import (
"fmt"
"net"
"os"
)
func main() {
// 一. 客户端创建用于通信的socket
// 指定通信协议,并指定server端 IP PORT
conn, err := net.Dial("tcp", "127.0.0.1:8000")
if err != nil{
fmt.Println("client start err :", err)
return
}
// 创建go程, 用来获取键盘输入
go func() {
str := make([]byte, 4096)
for{
n, err := os.Stdin.Read(str) // 获取键盘输入
if err != nil{
fmt.Println("client os.Stdin.Read err :", err)
continue
}
_, err = conn.Write(str[:n])
if err != nil{
fmt.Println("client write err :", err)
return
}
}
}()
// 打印server 返回的数据
buf := make([]byte, 4096)
for{
n, err := conn.Read(buf)
if err != nil{
fmt.Println("client read err :", n, err) // 当server断开与client的连接后 client read err : 0 EOF
return
}
fmt.Println(string(buf[:n]))
}
}