8 channel、反射、网络编程【Go语言教程】

╰半橙微兮° 2024-03-22 15:44 168阅读 0赞

## 8 channel、反射、网络编程【Go语言教程】 ##

### 1 channel ###

> errChan := make(chan err) 不指定管道长度则表明创建了一个无缓冲通道
> 
>  *  对于无缓冲通道，发送和接收操作是同步的。发送操作会等待接收方准备好接收值，而接收操作会等待发送方准备好发送值。因此，无缓冲通道的发送和接收操作必须在不同的协程中进行，以避免死锁。

在 Go 中，通道（channel）的长度是固定的，一旦创建就无法更改。当我们使用 make 函数创建通道时，可以选择指定通道的容量（长度）。

如果我们不指定通道的容量，则默认为无缓冲通道（unbuffered channel），也就是长度为 0 的通道。无缓冲通道在发送操作时会阻塞，直到有协程准备好接收该值；在接收操作时也会阻塞，直到有协程准备好发送值。

对于无缓冲通道，发送和接收操作是同步的。发送操作会等待接收方准备好接收值，而接收操作会等待发送方准备好发送值。因此，无缓冲通道的发送和接收操作必须在不同的协程中进行，以避免死锁。

对于带有缓冲的通道（buffered channel），我们可以在创建通道时指定通道的容量。带有缓冲的通道允许在发送操作时不立即阻塞，只有当通道的缓冲区满时才会阻塞。类似地，在接收操作时，只有当通道的缓冲区为空时才会阻塞。

需要注意的是，通道的容量只影响通道的缓冲区大小，而不是通道可以存放的值的数量。无论通道的容量是多少，我们都可以向通道发送任意数量的值，只要接收方及时接收这些值。

综上所述，通道的容量是指通道的缓冲区大小，而不是通道可以存放的值的数量。无缓冲通道的容量为 0，而带有缓冲的通道可以指定任意大于 0 的容量。

#### 1.1 概念及快速入门 ####

`channel:管道，主要用于不同goroutine之间的通讯`

> 需求：现在要计算 1-200 的各个数的阶乘，并且把各个数的阶乘放入到 map 中。最后显示出来。要求使用 goroutine 完成

> 分析思路：

1.  使用 goroutine 来完成，效率高，但是会出现并发/并行安全问题.
2.  这里就提出了不同 goroutine 如何通信的问题

![在这里插入图片描述][e4d3181ad8844a4fa5e601ecfc308b4e.png]

package main
    import(
    	"fmt"
    	"time"
    )
    
    var (
    	myMap = make(map[int]int, 10)
    )
    
    //计算n！，将计算结果放入myMap
    func test(n int){
        
    	res := 1
    	for i := 1; i <= n; i++ {
        
    		res *= i
    	}
    	myMap[n] = res //concurrent map writes?
    }
    
    func main(){
        
    	//开启200个协程
    	for i := 1; i <= 200; i++ {
        
    		go test(i)
    	}
    	//休眠10s[防止主线程直接跑完，而协程中的任务未完成]
    	time.Sleep(time.Second * 10)
    	for i, v := range myMap {
        
    		fmt.Printf("map[%d]=%d\n", i, v)
    	}
    }

运行代码会出现并发问题：  
![在这里插入图片描述][ee4c44a3f8db41ed97187d48c432fcb4.png]

不同goroutine之间如何通讯：

1.  全局变量的互斥锁
2.  使用管道channel来解决

> 计算 1-200 的各个数的阶乘，并且把各个数的阶乘放入到 map 中。最后显示出来。用下面方法改进：

##### ①使用全局变量的互斥锁\[并发、并行问题\] #####

>  *  没有对全局变量m加索，会出现资源争夺问题，提示：concurrent map writes
>  *  加入互斥锁
>  *  我们的数的阶乘很大，结果会越界,可以将求阶乘改成 sum += i

package main
    import(
    	"fmt"
    	"time"
    	"sync"
    )
    
    var (
    	myMap = make(map[int]int, 10)
    	//声明一个全局的互斥锁
    	//lock 是一个全局的互斥锁
    	//sync 是包， synchronized 同步
    	//Mutex：是互斥
    	lock sync.Mutex
    )
    
    //计算n！，将计算结果放入myMap
    func test(n int){
        
    	res := 1
    	for i := 1; i <= n; i++ {
        
    		res += int(i)
    	}
    	//加锁
    	lock.Lock()
    	myMap[n] = res //concurrent map writes?
    	//解锁
    	lock.Unlock()
    }
    
    func main(){
        
    	//开启200个协程
    	for i := 1; i <= 200; i++ {
        
    		go test(i)
    	}
    	//休眠10s[防止主线程直接跑完，而协程中的任务未完成]
    	time.Sleep(time.Second * 10)
    	for i, v := range myMap {
        
    		fmt.Printf("map[%d]=%d\n", i, v)
    	}
    }

![在这里插入图片描述][4891da4397944131987991d028954237.png]

##### ②使用channel #####

###### 1. 为什么需要channel ######

*  为什么需要channel？

> 1.  前面使用全局变量加锁同步来解决 goroutine 的通讯，但不完美
> 2.  主线程在等待所有 goroutine 全部完成的时间很难确定，我们这里设置 10 秒，仅仅是估算。
> 3.  如果主线程休眠时间长了，会加长等待时间，如果等待时间短了，可能还有 goroutine 处于工作状态，这时也会随主线程的退出而销毁
> 4.  通过全局变量加锁同步来实现通讯，也并不利用多个协程对全局变量的读写操作。
> 5.  上面种种分析都在呼唤一个新的通讯机制-channel

###### 2. 基本介绍 ######

1.  channle 本质就是一个数据结构-队列【示意图】
2.  数据是先进先出【FIFO : first in first out】
3.  线程安全，多 goroutine 访问时，不需要加锁，就是说 channel 本身就是线程安全的
4.  channel 有类型的，一个 string 的 channel 只能存放 string 类型数据。  
    ![在这里插入图片描述][b49e393968e84512843a470a7207f88e.png]

###### 3. 声明、定义channel ######

>  *  var 变量名 chan 数据类型  
>     举例：  
>     var intChan chan int (intChan 用于存放 int 数据)  
>     var mapChan chan map\[int\]string (mapChan 用于存放 map\[int\]string 类型) var perChan chan Person  
>     var perChan2 chan \*Person  
>     …
>  *  说明:  
>     channel 是引用类型  
>     channel 必须初始化才能写入数据, 即 make 后才能使用管道是有类型的，intChan 只能写入 整数 int

###### 4. 快速入门及注意事项 ######

（1）快速入门：

> 管道的初始化，写入数据到管道，从管道读取数据及基本的注意事项

package main
    import (
    	"fmt"
    )
    
    func main(){
        
    	//1. 创建一个可以存放3个int类型的管道
    	var intChan chan int
    	intChan = make(chan int, 3)
    	//2. 看看intChan是什么
    	fmt.Printf("intChan的值=%v intChan本身地址=%p\n", intChan, &intChan)
    	//3. 向管道写入数据
    	intChan <- 10
    	num := 211
    	intChan <- num
    	intChan <- -50
    	//intChan <- 100 //注意：我们在给管道写入数据时，不能超过其容量
    	//4. 看看管道的长度和cap（容量）
    	fmt.Printf("channel len=%v cap=%v\n", len(intChan), cap(intChan))
    	//5. 从管道中读取数据
    	var num2 int
    	num2 = <- intChan
    	fmt.Println("num2=", num2)
    	fmt.Printf("channel len=%v cap=%v\n", len(intChan), cap(intChan))
    
    	//6. 在没有使用协程的情况下，如果管道中的数据已经全部取出，再取就会报告deadlock
    	num3 := <- intChan
    	num4 := <- intChan
    	fmt.Printf("num3=%v, num4=%v", num3, num4)
    	// num5 := <- intChan
    	// fmt.Println("num5=", num5) //fatal error: all goroutines are asleep - deadlock!   
    }

![在这里插入图片描述][8f85a12bb5c746e3a2c66dd152b0e5af.png]  
（2）注意事项：

> 1.  channel 中只能存放指定的数据类型
> 2.  channle 的数据放满后，就不能再放入了
> 3.  如果从 channel 取出数据后，可以继续放入
> 4.  在没有使用协程的情况下，如果 channel 数据取完了，再取，就会报 dead lock

###### 5. channel的使用 ######

![在这里插入图片描述][0fb579ca5d6f48c9b179d7b9dc4d03f9.png]  
![在这里插入图片描述][f75887713b9e4cdbbbf6956558629f2f.png]  
![在这里插入图片描述][0c5a2aede43f40a5b3c214865137d17d.png]  
![在这里插入图片描述][46d846fb6b2f441f960dbb0ae197d52d.png]  
![在这里插入图片描述][ba861cc967154ef3ab78f05f8b043691.png]  
![在这里插入图片描述][c3a289db5732424c8fd311ad284ce358.png]

![在这里插入图片描述][fdb375f04ece4bc09bac2515000a5d50.png]  
练习题：

> ![在这里插入图片描述][d8279f9457bb4fd8b13b509a21b4266c.png]

package main
    import (
    	"fmt"
    	"math/rand"
    	"time"
    	"strconv"
    )
    
    type Person struct {
        
    	Name string
    	Age int
    	Address string
    }
    
    func main(){
        
    	var personChan chan Person
    	//make给chan开辟空间
    	personChan = make(chan Person, 10)
    	//取纳秒时间戳作为种子，保证每次的随机种子都不同
    	//给rand种种子
    	rand.Seed(time.Now().UnixNano())
    	for i := 1; i <= 10; i++ {
        
    		index := rand.Int()
    		fmt.Println("index===", index)
    		person := Person{
        
    			Name: "zhangsan" + strconv.Itoa(index),
    			Age: i,
    			Address: "beijing" + strconv.Itoa(index),
    		}
    		personChan <- person
    	}
    	len := len(personChan)
    	for i := 0; i < len; i++ {
        
    		p := <- personChan
    		fmt.Println(p)
    	}
    }

###### 6. channel的关闭和遍历 ######

（1）channel的关闭

> 使用内置函数close 可以关闭 channel, 当 channel 关闭后，就不能再向 channel 写数据了，但是仍然可以从该 channel 读取数据

package main
    import (
    	"fmt"
    )
    
    func main(){
        
    	intChan := make(chan int, 5)
    	intChan <- 10
    	intChan <- 20
    	close(intChan) //close
    	//关闭之后不能再向chan写入数据，但是可以读取
    	// intChan <- 30 //panic: send on closed channel
    	n1 := <- intChan
    	fmt.Println("n1=", n1) //n1= 10
    }

（2）channel的遍历

> channel 支持 for–range 的方式进行遍历，请注意两个细节
> 
> 1.  在遍历时，如果 channel 没有关闭，则回出现 deadlock 的错误
> 2.  在遍历时，如果 channel 已经关闭，则会正常遍历数据，遍历完后，就会退出遍历。

package main
    import (
    	"fmt"
    )
    
    func main(){
        
    	intChan := make(chan int, 5)
    	intChan <- 10
    	intChan <- 20
    	intChan <- 50
    	close(intChan) //close
    	//关闭之后不能再向chan写入数据，但是可以读取
    	// intChan <- 30 //panic: send on closed channel
    	n1 := <- intChan
    	fmt.Println("n1=", n1) //n1= 10
    	for v := range intChan {
        
    		fmt.Printf("value=%v\n", v)
    	}
    }

###### 7. 综合实例 ######

>  *  需求：  
>     要求统计 1-8000的数字中，哪些是素数？使用 goroutine  
>     和 channel 的知识完成
>  *  分析思路：  
>     传统的方法，就是使用一个循环，循环的判断各个数是不是素数【ok】。  
>     使用并发/并行的方式，将统计素数的任务分配给多个(4 个)goroutine 去完成，完成任务时间短。  
>     ![在这里插入图片描述][a3a3ab1e2d04464a8dc4f2f8280a546f.png]

package main
    import (
    	"fmt"
    	"time"
    )
    
    //向intChan放入1-8000个数
    func putNum(intChan chan int){
        
    	for i := 1; i <= 8000; i++ {
        
    		intChan <- i
    	}
    	//关闭chan
    	close(intChan)
    }
    
    //从intChan取出数据，并判断是否是素数，如果是，就放入到primeChan
    func primeNum(intChan chan int, primeChan chan int, exitChan chan bool){
        
    	var flag bool
    	for {
        
    		time.Sleep(time.Millisecond * 10)
    		num, ok := <- intChan
    		if !ok {
         //取不到数据了，就退出
    			break
    		}
    		flag = true //假设是素数
    		for i := 2; i < num; i++ {
        
    			if num % i == 0 {
        
    				flag = false
    				break
    			}
    		}
    		if flag {
        
    			primeChan <- num
    		}
    	}
    	fmt.Println("有一个primeNum协程因为取不到数据，退出")
    	//这里我们还不能关闭primeChan
    	//向exitChan写入true
    	exitChan <- true
    }
    
    func main(){
        
    	intChan := make(chan int, 1000)
    	primeChan := make(chan int, 2000)
    	//标识退出的管道
    	exitChan := make(chan bool, 4)
    	//开启一个协程，向intChan放入1-8000个数
    	go putNum(intChan)
    	//开启4个协程，从intChan取出数据，并判断是否是素数
    	for i := 0; i < 4; i++ {
        
    		go primeNum(intChan, primeChan, exitChan)
    	}
    	//主线程进行处理
    	go func(){
        
    		for i:= 0; i < 4; i++{
        
    			<-exitChan
    		}
    		//当我们从exitChan取出了4个结果，就可以放心的关闭primeChan
    		close(primeChan)
    	}()
    
    	//遍历primeChan，把结果取出
    	for {
        
    		res, ok := <- primeChan
    		if !ok {
        
    			break
    		}
    		//将结果取出
    		fmt.Printf("素数=%d\n", res)
    	}
    }

结果：  
![在这里插入图片描述][f5fe8ef38c99446b9f93991da64ad377.png]

###### 8. 只读、只写管道及注意事项 ######

*  只读、只写管道：  
    ![在这里插入图片描述][64aabf48890744f3943738fd2636d09e.png]  
    ![在这里插入图片描述][2efca0a94e924266981255143b6caca2.png]
 *  注意事项

> 1.  channel 可以声明为只读，或者只写性质
> 2.  只读只写案例  
>     ![在这里插入图片描述][90ff40ab9916488db11c2c2096270c91.png]  
>     3）使用 select 可以解决从管道取数据的阻塞问题

select用法：

package main
    import (
    	"fmt"
    	"time"
    )
    
    func main(){
        
    	//使用select可以解决管道取数据的阻塞问题
    	//1. 定义一个管道 10 int
    	intChan := make(chan int, 10)
    	for i := 0; i < 10; i++ {
        
    		intChan <- i
    	}
    	//2. 定义一个管道 5 string
    	stringChan := make(chan string, 5)
    	for i := 0; i < 5; i++ {
        
    		stringChan <- "hello" + fmt.Sprintf("%d", i)
    	}
    	//传统的方法在遍历管道时，如果不关闭，则会因阻塞导致deadlock
    	//可是我们在实际开发中，我们可能不好确定什么时候关闭管道
    	//办法：我们可以使用select方式解决
    	//label:
    	for {
        
    		select {
        
    			//注意：这里，如果intChan一直没有关闭，不会一直阻塞而deadlock，会自动到下一个case匹配
    			case v := <- intChan:
    				fmt.Printf("从intChan读取的数据=%d\n", v)
    				time.Sleep(time.Second)
    			case v := <- stringChan:
    				fmt.Printf("从stringChan读取的数据=%s\n", v)
    				time.Sleep(time.Second)
    			default:
    				fmt.Printf("不玩了，都取不到了【程序员可以在这里加入自己的逻辑】\n")
    				time.Sleep(time.Second)
    				return
    				//break label
    		}
    	}
    }

![在这里插入图片描述][eb76b21c9aec459b866c5fec4c373a3a.png]

### 2 反射 ###

#### 2.1 概念 ####

> 1.  反射可以在运行时动态获取变量的各种信息, 比如变量的类型(type)，类别(kind)
> 2.  如果是结构体变量，还可以获取到结构体本身的信息(包括结构体的字段、方法)
> 3.  通过反射，可以修改变量的值，可以调用关联的方法。
> 4.  使用反射，需要 import (“reflect”)  
>     ![在这里插入图片描述][a6728f37cf704966b8df176fb9b4b45a.png]  
>     5）反射常见的应用场景  
>     ![在这里插入图片描述][6c5e2b99acc14f9ca3023b6f25e6706c.png]

#### 2.2 反射中重要的函数 ####

![在这里插入图片描述][4e1dc3618cfe4405ab1fd3036a69fa15.png]

> 1.  变量、interface\{\} 和 reflect.Value 是可以相互转换的，这点在实际开发中，会经常使用到。  
>     ![在这里插入图片描述][aed57672c80b48d0b08f4ec1c162db48.png]

#### 2.3 快速入门 ####

> 请编写一个案例，演示对(结构体类型、interface\{\}、reflect.Value)进行反射的基本操作

package main
    import (
    	"reflect"
    	"fmt"
    )
    
    type Student struct {
        
    	Name string
    	Age int
    }
    
    func reflectTest01(b interface{
        }){
        
    	//通过反射获取到传入变量的type、kind值
    	//1. 先获取到reflect.Type
    	rType := reflect.TypeOf(b)
    	fmt.Println("rType=", rType)
    	//2. 获取到reflect.Value
    	rVal := reflect.ValueOf(b)
    	n2 := 2 + rVal.Int()
    	fmt.Println("n2=", n2)
    	fmt.Printf("rVal=%v rType=%T\n", rVal, rType)
    	//下面我们将rVal转成interface{}
    	iV := rVal.Interface()
    	//将interface{}通过断言转成需要的类型
    	num2 := iV.(int)
    	fmt.Println("num2=", num2)
    }
    
    //对结构体的反射
    func reflectTest02(b interface{
        }){
        
    	//通过反射获取到传入的变量的type、kind，值
    	//1. 先获取到reflect.Type
    	rType := reflect.TypeOf(b)
    	fmt.Println("rType=", rType)
    	//2. 获取到reflect.Value
    	rVal := reflect.ValueOf(b)
    	//下面我们将rVal转成interface{}
    	iV := rVal.Interface()
    	fmt.Printf("iv=%v iv type=%T\b", iV, iV)
    	//将interface{}通过断言转成需要的类型
    	//这里，我们使用类型断言【同学们可以使用switch的断言形式来更加灵活的判断】
    	stu, ok := iV.(Student)
    	if ok {
        
    		fmt.Printf("stu.Name=%v\n", stu.Name)
    	}
    
    }
    
    func main(){
        
    	//1. 基本数据类型 反射
    	var num int = 100
    	reflectTest01(num)
    	//2. 定义一个Student实例
    	stu := Student{
        
    		Name: "tom",
    		Age: 20,
    	}
    	reflectTest02(stu)
    }

![在这里插入图片描述][d0e214110f2c4b06a036027828706036.png]

#### 2.4 反射的细节和注意事项 ####

> 1.  reflect.Value.Kind，获取变量的类别，返回的是一个常量  
>     ![在这里插入图片描述][900a7ffb5ed04367b75428585598eaad.png]
> 2.  Type 和 Kind 的区别【type更加具体】  
>     Type 是类型, Kind 是类别， Type 和 Kind 可能是相同的，也可能是不同的. 比如: var num int = 10 num 的 Type 是 int , Kind 也是 int  
>     比如: var stu Student stu 的 Type 是 pkg1.Student , Kind 是 struct  
>     ![在这里插入图片描述][d2d6c29ea20246f0b4b070698a1c8082.png]
> 
> 1.  通过反射的来修改变量, 注意当使用 SetXxx 方法来设置需要通过对应的指针类型来完成, 这样才能改变传入的变量的值, 同时需要使用到reflect.Value.Elem()方法  
>     ![在这里插入图片描述][2640e49951874140ac1739e9b626bc91.png]
> 
> 1.  reflect.Value.Elem() 应该如何理解？  
>     ![在这里插入图片描述][a71c52c342c6434d8794b59c8525a4ed.png]

#### 2.5 综合案例 ####

> 使用反射来遍历结构体的字段，调用结构体的方法，并获取结构体标签的值

package main
    import (
    	"reflect"
    	"fmt"
    )
    
    type Monster struct {
        
    	Name string `json:"name"`
    	Age	int `json:"monster_age"` 
    	Score float32 `json:"成绩"`
    	Sex	string
    }
    //方法，返回两数的和
    func (s Monster) GetSum(n1, n2 int) int {
        
    	return n1 + n2
    }
    
    //方法，接收四个值，给结构体赋值
    func (s Monster) Set(name string, age int, score float32, sex string){
        
    	s.Name = name
    	s.Age = age
    	s.Score = score
    	s.Sex = sex
    }
    
    //方法，显示结构体的值
    func (s Monster) Print(){
        
    	fmt.Println("----start----")
    	fmt.Println(s)
    	fmt.Println("----end----")
    }
    
    func TestStruct(a interface{
        }){
        
    	//获取reflect.Type类型
    	typ := reflect.TypeOf(a)
    	//获取reflect.Value类型
    	val := reflect.ValueOf(a)
    	//获取到a对应的类别
    	kd := val.Kind()
    	//如果传入的不是struct，就退出
    	if kd != reflect.Struct {
        
    		fmt.Println("expect struct")
    		return 
    	}
    	//是结构体，获取该结构体有几个字段
    	num := val.NumField()
    	fmt.Printf("struct has %d fields\n", num)
    	for i := 0; i < num; i++ {
        
    		fmt.Printf("Field %d值为=%v\n", i, val.Field(i))
    		//获取到struct标签，注意需要通过reflect.Type来获取tag标签的值
    		tagVal := typ.Field(i).Tag.Get("json") //因为前面定义结构体用到了'json标签'
    		//如果该字段有tag标签就显示，否则就不显示
    		if tagVal != "" {
        
    			fmt.Printf("Field %d tag 为=%v\n", i, tagVal)
    		}
    	}
    
    	//获取到该结构体有多少个方法
    	numOfMethod := val.NumMethod()
    	fmt.Printf("struct has %d methods\n", numOfMethod)
    	//var params []reflect.Value
    	//方法的排序默认是按照函数名的排序（ASCII码）
    	val.Method(1).Call(nil) //获取到第二个【下标为1】方法，调用它 【传参为空】
    
    	//调用结构体的第1个方法 Method（0）
    	var params []reflect.Value //声明了 []reflect.Value()
    	params = append(params, reflect.ValueOf(10))
    	params = append(params, reflect.ValueOf(40))
    	res := val.Method(0).Call(params) //传入的参数是[]reflect.Value，返回[]reflect.Value
    	fmt.Println("res=", res[0].Int()) //返回结果，返回的结果是[]reflect.Value
    }
    
    func main(){
        
    	var a Monster = Monster{
        
    		Name: "黄鼠狼精",
    		Age: 400,
    		Score: 30.9,
    	}
    	TestStruct(a)
    }

![在这里插入图片描述][3a73216e8c2c46fbb0366a3b01cd8971.png]

### 3 网络编程 ###

#### 3.1 概念及前置知识 ####

1.  TCP socket 编程，是网络编程的主流。之所以叫 Tcp socket 编程，是因为底层是基于 Tcp/ip 协议的. 比如: QQ 聊天
2.  b/s 结构的 http 编程，我们使用浏览器去访问服务器时，使用的就是 http 协议，而 http 底层依旧是用 tcp socket 实现的。 比如: 京东商城 【这属于 go web 开发范畴 】
3.  计算机间要相互通讯,必须要求网线,网卡,或者是无线网卡.

![在这里插入图片描述][a9983eb8100c46f8a99a4a0b5074f93d.png]  
4. 协议  
![在这里插入图片描述][e1c9857b421d4f5f974aab3b940a2a4d.png]

![在这里插入图片描述][4ab82ebf820a4c659a714c94ff298e1b.png]  
5. 端口

>  *  0 号是保留端口.
>  *  1-1024 是固定端口(程序员不要使用),又叫有名端口,即被某些程序固定使用,一般程序员不使用.
>  *  常见端口：22: SSH 远程登录协议 23: telnet 使用 21: ftp 使用  
>     25: smtp 服务使用 80: iis 使用 7: echo 服务
>  *  1025-65535 是动态端口  
>     这些端口，程序员可以使用.

`注意：`

1.  在计算机(尤其是做服务器)要尽可能的少开端口
2.  一个端口只能被一个程序监听
3.  如果使用 netstat –an 可以查看本机有哪些端口在监听
4.  可以使用 netstat –anb 来查看监听端口的 pid,在结合任务管理器关闭不安全的端口

#### 3.2 快速入门 ####

*  服务端的处理流程

> 1.  监听端口 8888
> 2.  接收客户端的 tcp 链接，建立客户端和服务器端的链接.
> 3.  创建 goroutine，处理该链接的请求(通常客户端会通过链接发送请求包)

*  客户端的处理流程

> 1.  建立与服务端的链接
> 2.  发送请求数据\[终端\]，接收服务器端返回的结果数据
> 3.  关闭链接

##### ①服务端功能及代码 #####

功能：

*  编写一个服务器端程序，在 8888 端口监听可以和多个客户端创建链接  
    链接成功后，客户端可以发送数据，服务器端接受数据，并显示在终端上. 先使用 telnet 来测试，然后编写客户端程序来测试

代码：

package main
    
    import (
    	"fmt"
    	"net"
    )
    
    func process(conn net.Conn) {
        
    	//循环接收客户端发送的数据
    	defer conn.Close()
    	for {
        
    		//创建一个新的切片
    		buf := make([]byte, 1024)
    		//1. 等待客户端通过conn发送消息
    		//2. 如果客户端没有write（发送消息），那么协程就阻塞在这里
    		fmt.Printf("服务器在等待客户端%s 发送信息\n", conn.RemoteAddr().String())
    		n, err := conn.Read(buf) //从conn中读取
    		if err != nil {
        
    			fmt.Printf("客户端退出 err=%v", err)
    			return
    		}
    		//3. 显示客户端给服务端发送的数据（打印在控制台上）
    		fmt.Print(string(buf[:n]))
    	}
    }
    func main() {
        
    	fmt.Println("服务器开始监听...")
    	//1. tcp表示使用的网络协议是tcp
    	//2. 0.0.0.0:8888表示在本地监听8888端口
    	listen, err := net.Listen("tcp", "0.0.0.0:8888")
    	if err != nil {
        
    		fmt.Println("listen err=", err)
    		return
    	}
    	defer listen.Close() //延时关闭listen
    	//循环等待客户端来连接服务端
    	for {
        
    		//等待客户端连接
    		fmt.Println("等待客户端来连接...")
    		conn, err := listen.Accept()
    		if err != nil {
        
    			fmt.Println("Accept() err=", err)
    		} else {
        
    			fmt.Printf("Accept() success con=%v 客户端ip=%v\n", conn, conn.RemoteAddr().String())
    		}
    		//这里准备起一个协程，为客户端服务
    		go process(conn)
    	}
    }

运行之后效果：

服务器开始监听...
    等待客户端来连接...

##### ②客户端功能及代码 #####

> 1.  编写一个客户端端程序，能链接到 服务器端的 8888 端口
> 2.  客户端可以发送单行数据，然后就退出
> 3.  能通过终端输入数据(输入一行发送一行), 并发送给服务器端
> 4.  在终端输入 exit,表示退出程序.

package main
    
    import (
    	"bufio"
    	"fmt"
    	"net"
    	"os"
    	"strings"
    )
    
    func main() {
        
    	conn, err := net.Dial("tcp", "192.168.1.100:8888")
    	if err != nil {
        
    		fmt.Println("client dial err=", err)
    		return
    	}
    	//功能一：客户端可以发送单行数据，然后就退出
    	reader := bufio.NewReader(os.Stdin) //os.Stdin 表示标准输入：【终端】
    	for {
        
    		//从终端读取一行用户输入，并发送给服务端
    		line, err := reader.ReadString('\n')
    		if err != nil {
        
    			fmt.Println("readString err=", err)
    		}
    		//功能二：当用户输入exit就退出
    		line = strings.Trim(line, "\r\n")
    		if line == "exit" {
        
    			fmt.Println("客户端退出...")
    			break
    		}
    		n, err := conn.Write([]byte(line))
    		if err != nil {
        
    			fmt.Println("conn Write err=", err)
    		}
    		fmt.Printf("客户端发送了 %d字节的数据\n", n)
    	}
    }

##### ③运行效果 #####

![在这里插入图片描述][63738c01876d459a8e87eb72c6a7be66.png]

[e4d3181ad8844a4fa5e601ecfc308b4e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/189be52c6dca4a77bcaf5a9ce072cea9.png
[ee4c44a3f8db41ed97187d48c432fcb4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/58165cbcc2b347dc9c5d08b9acd1749e.png
[4891da4397944131987991d028954237.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/5c0c2137ba0c49c2ae6d089ba65870c2.png
[b49e393968e84512843a470a7207f88e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/cc48984975b34e60acaa7dbec5afd8b3.png
[8f85a12bb5c746e3a2c66dd152b0e5af.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/968e378ac30a49248a6fb0790e603488.png
[0fb579ca5d6f48c9b179d7b9dc4d03f9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/ff5bd6bad8764e5ba089d0892b1ca4ca.png
[f75887713b9e4cdbbbf6956558629f2f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/17788fb0f96d4a6189545cb08380c807.png
[0c5a2aede43f40a5b3c214865137d17d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/b873be73242446df9c6e6f1b1931bc6b.png
[46d846fb6b2f441f960dbb0ae197d52d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/c5e2664c11be4cd891025328b565d25b.png
[ba861cc967154ef3ab78f05f8b043691.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/ccfb5b9bdcfd49edb20c9b81baec4374.png
[c3a289db5732424c8fd311ad284ce358.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/0b6ff3ac8a194312ac07c81ebfe079b1.png
[fdb375f04ece4bc09bac2515000a5d50.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/4d2e45118a6c4716b771248f3263ccf7.png
[d8279f9457bb4fd8b13b509a21b4266c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/170efc1d9dc54d50acfc3086dba0e5df.png
[a3a3ab1e2d04464a8dc4f2f8280a546f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/107f4d40167c4db0b673c621801927d4.png
[f5fe8ef38c99446b9f93991da64ad377.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/71e3a2729bd24b7382e757e8dda45414.png
[64aabf48890744f3943738fd2636d09e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/47d8098132b741ec94f77c5bd91001c4.png
[2efca0a94e924266981255143b6caca2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/7ddca34e0b564c16b69dc3170524842a.png
[90ff40ab9916488db11c2c2096270c91.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/bbe10bae241b4e91a508c8dcca46a3ec.png
[eb76b21c9aec459b866c5fec4c373a3a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/3c44843542fa4a34bb494a8e0be1a8ee.png
[a6728f37cf704966b8df176fb9b4b45a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/8bcc9f6418154655b71f0bbd27b6961f.png
[6c5e2b99acc14f9ca3023b6f25e6706c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/a80d765f0111427fa6112487b4959961.png
[4e1dc3618cfe4405ab1fd3036a69fa15.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/38fac1e330084230a9a1706db3a21e5b.png
[aed57672c80b48d0b08f4ec1c162db48.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/6807f6901a3446618328d8fb50261565.png
[d0e214110f2c4b06a036027828706036.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/988c5fbc1ab74ab690b6fd7f3c1a2237.png
[900a7ffb5ed04367b75428585598eaad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/60e4dc1ec6ee4ce5aae9f0a6d4b63933.png
[d2d6c29ea20246f0b4b070698a1c8082.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/a8270932940d4e98a2a2aa3307aab490.png
[2640e49951874140ac1739e9b626bc91.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/10372bb206e44b7fa19e3a791fa4e614.png
[a71c52c342c6434d8794b59c8525a4ed.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/ca0a3ccf256e4d329ed7d30c59cb4fdc.png
[3a73216e8c2c46fbb0366a3b01cd8971.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/65d44155a1b44dd89004ef75a59c6d47.png
[a9983eb8100c46f8a99a4a0b5074f93d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/54c4da7b71d74a28b974180a9bf27a99.png
[e1c9857b421d4f5f974aab3b940a2a4d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/4402776f2afd4900aa76470c43edc0c7.png
[4ab82ebf820a4c659a714c94ff298e1b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/580986d53a604a4781d6d3e3c9458e39.png
[63738c01876d459a8e87eb72c6a7be66.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/7a0a15ccbc7d4a32b2309d39a7f0c6be.png