Go学习笔记5

十六、基于TCP协议的网络通信

创建客户端

【1】调用Dial函数：（net包下）

【2】代码：

1. package main
2. import(
3.         "fmt"
4.         "net" //所需的网络编程全部都在net包下
5. )
6. func main(){
7.         //打印：
8.         fmt.Println("客服端启动。。")
9.         //调用Dial函数：参数需要指定tcp协议，需要指定服务器端的IP+PORT
10.         conn,err := net.Dial("tcp","127.0.0.1:8888")
11.         if err != nil {//连接失败
12.                 fmt.Println("客户端连接失败：err:",err)
13.                 return
14.         }
15.         fmt.Println("连接成功，conn:",conn)
16. }

复制代码

创建服务端

【1】进行监听：（Listen函数在net包下）

【2】代码：

1. package main
2. import(
3.         "fmt"
4.         "net" //所需的网络编程全部都在net包下
5. )
6. func main(){
7.         //打印：
8.         fmt.Println("服务器端启动了。。")
9.         //进行监听：需要指定服务器端TCP协议，服务器端的IP+PORT
10.         listen,err := net.Listen("tcp","127.0.0.1:8888")
11.         if err != nil{//监听失败
12.                 fmt.Println("监听失败，err:",err)
13.                 return
14.         }
15.         //监听成功以后：
16.         //循环等待客户端的链接：
17.         for{
18.                 conn,err2 := listen.Accept()
19.                 if err2 != nil {//客户端的等待失败
20.                         fmt.Println("客户端的等待失败,err2:",err2)
21.                 }else{
22.                         //连接成功：
23.                         fmt.Printf("等待链接成功，con=%v ，接收到的客户端信息：%v \n",conn,conn.RemoteAddr().String())
24.                 }
25.         }
26. }

复制代码

运行时注意：需要先启动服务器端，然后启动客户端进行访问：

处理终端数据

【1】客户端发送数据：

1. package main
2. import(
3.         "fmt"
4.         "net" //所需的网络编程全部都在net包下
5.         "bufio"
6.         "os"
7. )
8. func main(){
9.         //打印：
10.         fmt.Println("客服端启动。。")
11.         //调用Dial函数：参数需要指定tcp协议，需要指定服务器端的IP+PORT
12.         conn,err := net.Dial("tcp","127.0.0.1:8888")
13.         if err != nil {//连接失败
14.                 fmt.Println("客户端连接失败：err:",err)
15.                 return
16.         }
17.         fmt.Println("连接成功，conn:",conn)
18.         //通过客户端发送单行数据，然后退出：
19.         reader := bufio.NewReader(os.Stdin)//os.Stdin代表终端标准输入
20.         //从终端读取一行用户输入的信息：
21.         str,err := reader.ReadString('\n')
22.         if err != nil {
23.                 fmt.Println("终端输入失败，err:",err)
24.         }
25.         //将str数据发送给服务器：
26.         n,err := conn.Write([]byte(str))
27.         if err != nil{
28.                 fmt.Println("连接失败，err:",err)
29.         }
30.         fmt.Printf("终端数据通过客户端发送成功，一共发送了%d字节的数据,并退出",n)
31. }

复制代码

【2】服务器端接收数据：

1. package main
2. import(
3.         "fmt"
4.         "net" //所需的网络编程全部都在net包下
5. )
6. func process(conn net.Conn){
7.         //连接用完一定要关闭：
8.         defer conn.Close()
9.         for{
10.                 //创建一个切片，准备：将读取的数据放入切片：
11.                 buf := make([]byte,1024)
12.                 //从conn连接中读取数据：
13.                 n,err := conn.Read(buf)
14.                 if err != nil{
15.                         return
16.                 }
17.                 //将读取内容在服务器端输出：
18.                 fmt.Println(string(buf[0:n]))
19.         }
20. }
21. func main(){
22.         //打印：
23.         fmt.Println("服务器端启动了。。")
24.         //进行监听：需要指定服务器端TCP协议，服务器端的IP+PORT
25.         listen,err := net.Listen("tcp","127.0.0.1:8888")
26.         if err != nil{//监听失败
27.                 fmt.Println("监听失败，err:",err)
28.                 return
29.         }
30.         //监听成功以后：
31.         //循环等待客户端的链接：
32.         for{
33.                 conn,err2 := listen.Accept()
34.                 if err2 != nil {//客户端的等待失败
35.                         fmt.Println("客户端的等待失败,err2:",err2)
36.                 }else{
37.                         //连接成功：
38.                         fmt.Printf("等待链接成功，con=%v ，接收到的客户端信息：%v \n",conn,conn.RemoteAddr().String())
39.                 }
40.                 //准备一个协程，协程处理客户端服务请求：
41.                 go process(conn)//不同的客户端的请求，连接conn不一样的
42.         }
43. }

复制代码

【3】处理结果：

十七、反射

反射的引入

【1】反射可以做什么？

• 反射可以在运行时动态获取变量的各种信息，比如变量的类型，类别等信息
  
• 如果是结构体变量，还可以获取到结构体本身的信息(包括结构体的字段、方法)
  
• 通过反射，可以修改变量的值，可以调用关联的方法。
  
• 使用反射，需要import ("reflect")
  【2】反射相关的函数
  
• reflect.TypeOf(变量名)，获取变量的类型，返回reflect.Type类型
  
• reflect.ValueOf(变量名)，获取变量的值，返回reflect.Value类型(reflect.Value是一个结构体类型),通过reflect.Value，可以获取到关于该变量的很多信息。
  

基本数据类型的反射

【1】反射相关的函数

• reflect.TypeOf(变量名)，获取变量的类型，返回reflect.Type类型
  
• reflect.ValueOf(变量名)，获取变量的值，返回reflect.Value类型(reflect.Value是一个结构体类型),通过reflect.Value，可以获取到关于该变量的很多信息。
  【2】代码：
  

1. package main
2. import(
3.         "fmt"
4.         "reflect"
5. )
6. //利用一个函数，函数的参数定义为空接口：
7. func testReflect(i interface{}){//空接口没有任何方法,所以可以理解为所有类型都实现了空接口，也可以理解为我们可以把任何一个变量赋给空接口。
8.         //1.调用TypeOf函数，返回reflect.Type类型数据：
9.         reType := reflect.TypeOf(i)
10.         fmt.Println("reType:",reType)
11.         fmt.Printf("reType的具体类型是：%T",reType)
12.         //2.调用ValueOf函数，返回reflect.Value类型数据：
13.         reValue :=reflect.ValueOf(i)
14.         fmt.Println("reValue:",reValue)
15.         fmt.Printf("reValue的具体类型是：%T",reValue)
16.         //num1 := 100
17.         //如果真想获取reValue的数值，要调用Int()方法：返回v持有的有符号整数
18.         num2 := 80 + reValue.Int()
19.         fmt.Println(num2)
20.         //reValue转成空接口：
21.         i2 := reValue.Interface()
22.         //类型断言：
23.         n := i2.(int)
24.         n2 := n + 30
25.         fmt.Println(n2)
26. }
27. func main(){
28.         //对基本数据类型进行反射：
29.         //定义一个基本数据类型：
30.         var num int = 100
31.         testReflect(num)
32. }

复制代码

结构体类型的反射

【1】反射相关的函数

• reflect.TypeOf(变量名)，获取变量的类型，返回reflect.Type类型
  
• reflect.ValueOf(变量名)，获取变量的值，返回reflect.Value类型(reflect.Value是一个结构体类型),通过reflect.Value，可以获取到关于该变量的很多信息。
  【2】代码：
  

1. package main
2. import(
3.         "fmt"
4.         "reflect"
5. )
6. //利用一个函数，函数的参数定义为空接口：
7. func testReflect(i interface{}){//空接口没有任何方法,所以可以理解为所有类型都实现了空接口，也可以理解为我们可以把任何一个变量赋给空接口。
8.         //1.调用TypeOf函数，返回reflect.Type类型数据：
9.         reType := reflect.TypeOf(i)
10.         fmt.Println("reType:",reType)
11.         fmt.Printf("reType的具体类型是：%T",reType)
12.         //2.调用ValueOf函数，返回reflect.Value类型数据：
13.         reValue :=reflect.ValueOf(i)
14.         fmt.Println("reValue:",reValue)
15.         fmt.Printf("reValue的具体类型是：%T",reValue)
16.         //reValue转成空接口：
17.         i2 := reValue.Interface()
18.         //类型断言：
19.         n,flag := i2.(Student)
20.         if flag == true {//断言成功
21.                 fmt.Printf("学生的名字是：%v,学生的年龄是：%v",n.Name,n.Age)
22.         }
23.         
24. }
25. //定义学生结构体：
26. type Student struct{
27.         Name string
28.         Age int
29. }
30. func main(){
31.         //对结构体类型进行反射：
32.         //定义结构体具体的实例：
33.         stu := Student{
34.                 Name : "丽丽",
35.                 Age : 18,       
36.         }
37.         testReflect(stu)
38. }

复制代码

获取变量的类别

【1】获取变量的类别：两种方式：
（1）reflect.Type.Kind()
（2）reflect.Value.Kind()
【2】Kind的值是常量值：
【3】代码：

1. package main
2. import(
3.         "fmt"
4.         "reflect"
5. )
6. //利用一个函数，函数的参数定义为空接口：
7. func testReflect(i interface{}){//空接口没有任何方法,所以可以理解为所有类型都实现了空接口，也可以理解为我们可以把任何一个变量赋给空接口。
8.         //1.调用TypeOf函数，返回reflect.Type类型数据：
9.         reType := reflect.TypeOf(i)
10.         //2.调用ValueOf函数，返回reflect.Value类型数据：
11.         reValue :=reflect.ValueOf(i)
12.         //获取变量的类别：
13.         //（1）reType.Kind()
14.         k1 := reType.Kind()
15.         fmt.Println(k1)
16.         //（2）reValue.Kind()
17.         k2 := reValue.Kind()
18.         fmt.Println(k2)
19.         //获取变量的类型：
20.         //reValue转成空接口：
21.         i2 := reValue.Interface()
22.         //类型断言：
23.         n,flag := i2.(Student)
24.         if flag == true {//断言成功
25.                 fmt.Printf("结构体的类型是：%T",n)
26.         }
27. }
28. //定义学生结构体：
29. type Student struct{
30.         Name string
31.         Age int
32. }
33. func main(){
34.         //对结构体类型进行反射：
35.         //定义结构体具体的实例：
36.         stu := Student{
37.                 Name : "丽丽",
38.                 Age : 18,       
39.         }
40.         testReflect(stu)
41. }

复制代码

【4】Type和 Kind 的区别
Type是类型, Kind是类别,Type和Kind 可能是相同的，也可能是不同的.
比如:var num int = 10 num的Type是int , Kind也是int
比如:var stu Studentstu的 Type是 pkg1.Student , Kind是struct
通过反射修改变量

【1】修改基本数据类型的值：

1. package main
2. import(
3.         "fmt"
4.         "reflect"
5. )
6. //利用一个函数，函数的参数定义为空接口：
7. func testReflect(i interface{}){//空接口没有任何方法,所以可以理解为所有类型都实现了空接口，也可以理解为我们可以把任何一个变量赋给空接口。
8.         reValue :=reflect.ValueOf(i)
9.         //通过SetInt()来改变值：
10.         reValue.Elem().SetInt(40)
11.         
12. }
13. func main(){
14.         //对基本数据类型进行反射：
15.         //定义一个基本数据类型：
16.         var num int = 100
17.         testReflect(&num) //传入指针地址
18.         fmt.Println(num)
19. }

复制代码

操作结构体的属性和方法

【1】代码：（熟知API）

1. package main
2. import(
3.         "fmt"
4.         "reflect"
5. )
6. //定义一个结构体：
7. type Student struct{
8.         Name string
9.         Age int
10. }
11. //给结构体绑定方法：
12. func (s Student) CPrint(){
13.         fmt.Println("调用了Print()方法")
14.         fmt.Println("学生的名字是：",s.Name)
15. }
16. func (s Student) AGetSum(n1,n2 int) int{
17.         fmt.Println("调用了AGetSum方法")
18.         return n1 + n2
19. }
20. func (s Student) BSet(name string,age int){
21.         s.Name = name
22.         s.Age = age
23. }
24. //定义函数操作结构体进行反射操作：
25. func TestStudentStruct(a interface{}){
26.         //a转成reflect.Value类型：
27.         val := reflect.ValueOf(a)
28.         fmt.Println(val)
29.         //通过reflect.Value类型操作结构体内部的字段：
30.         n1 := val.NumField()
31.         fmt.Println(n1)
32.         //遍历-获取具体的字段：
33.         for i := 0; i < n1;i++{
34.                 fmt.Printf("第%d个字段的值是：%v",i,val.Field(i))
35.         }
36.         fmt.Println()
37.         //通过reflect.Value类型操作结构体内部的方法：
38.         n2 := val.NumMethod()
39.         fmt.Println(n2)
40.         //调用CPrint()方法：
41.         //调用方法，方法的首字母必须大写才能有对应的反射的访问权限
42.         //方法的顺序按照ASCII的顺序排列的，a,b,c,,,,,,索引：0,1,2，，，，，
43.         val.Method(2).Call(nil)
44.         //调用AGetSum方法：
45.         //定义Value的切片：
46.         var params []reflect.Value
47.         params = append(params,reflect.ValueOf(10))
48.         params = append(params,reflect.ValueOf(20))
49.         result := val.Method(0).Call(params)
50.         fmt.Println("AGetSum方法的返回值为：",result[0].Int())
51. }
52. func main(){
53.         //定义结构体具体的实例：
54.         s := Student{
55.                 Name : "丽丽",
56.                 Age : 18,
57.         }
58.         //调用TestStudentStruct：
59.         TestStudentStruct(s)
60. }

复制代码

修改结构的变量

【1】代码：

1. package main
2. import(
3.         "fmt"
4.         "reflect"
5. )
6. //定义一个结构体：
7. type Student struct{
8.         Name string
9.         Age int
10. }
11. //给结构体绑定方法：
12. func (s Student) CPrint(){
13.         fmt.Println("调用了Print()方法")
14.         fmt.Println("学生的名字是：",s.Name)
15. }
16. func (s Student) AGetSum(n1,n2 int) int{
17.         fmt.Println("调用了AGetSum方法")
18.         return n1 + n2
19. }
20. func (s Student) BSet(name string,age int){
21.         s.Name = name
22.         s.Age = age
23. }
24. //定义函数操作结构体进行反射操作：
25. func TestStudentStruct(a interface{}){
26.         //a转成reflect.Value类型：
27.         val := reflect.ValueOf(a)
28.         fmt.Println(val)
29.         n := val.Elem().NumField()
30.         fmt.Println(n)
31.         //修改字段的值：
32.         val.Elem().Field(0).SetString("张三")
33. }
34. func main(){
35.         //定义结构体具体的实例：
36.         s := Student{
37.                 Name : "丽丽",
38.                 Age : 18,
39.         }
40.         //调用TestStudentStruct：
41.         TestStudentStruct(&s)
42.         fmt.Println(s)
43. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！