第十二课 go语言基础-反射和网络编程_go语言,网络传递结构体实例,反射-CSDN博客

本文链接：https://blog.csdn.net/aa18855953229/article/details/107133457

第十二课 go语言基础-反射和网络编程

tags:

golang
2019尚硅谷

categories:

反射
网络编程基础

文章目录

第十二课 go语言基础-反射和网络编程

第一节反射引出和定义

1.1 反射作用

反射最大价值在于重写我们的框架。
反射使用场景一：结构体序列化和反序列化中，Tags转换就用到了反射。
反射使用场景二：使用反射机制，编写函数的适配器,桥连接

1.2 反射的基本介绍

反射可以在运行时动态获取变量的各种信息，比如变量的类型(type)，类别(kind)。如果变量是基本数据类型类型和类别是一样的，如果是结构体可能不一样。
如果是结构体变量，还可以获取到结构体本身的信息(包括结构体的字段、方法)
通过反射，可以修改变量的值，可以调用关联的方法。
使用反射，需要import(“reflect”)
https://studygolang.com/pkgdoc

1.3 反射重要的函数和概念

reflect.TypeOf(变量名)，获取变量的类型，返回reflect.Type类型
reflect.ValueOf(变量名)，获取变量的值，返回reflect.Value类型reflect.value是一个结构体类型。[看文档] ,通过reflect.Value，可以获取到关于该变量的很多信息。
变量、interface{} 和reflect.Value 是可以相互转换的，这点在实际开发中，会经常使用到。

1.4 反射的快速入门

下面对(结构体类型、interface{}、 reflect.Value)进行反射的基本操作。

package main
import (
	"fmt"
	"reflect"
)

// 普通数据类型的反射
func reflectTest01(b interface{}){
	//通过反射获取的传入的变量的type(类型)、kind(类别)值
	//1.先获取到reflect.Type
	rTyp := reflect.TypeOf(b)
	fmt.Println("rType:", rTyp)
	//2.获取到reflect.Value
	rVal := reflect.ValueOf(b)
	fmt.Println("rVal:", rVal)
	// rVal直接输出虽然是100 但是实际上它的类型是reflect.Value类型 查看手册看函数
	fmt.Printf("rVal : %v, rVal Type : %T \n", rTyp, rTyp)
	n2 := 2 + rVal.Int()
	fmt.Println("n2:=", n2)
	// 3. 我们将rVal转为interface{}
	iV := rVal.Interface()
	// 将interface通过断言转成需要的类型
	num2 := iV.(int)
	fmt.Printf("num2:%v, num2的类型%T \n", num2, num2)
}

//对结构体的反射
func reflectTest02(b interface{}){
	//通过反射获取的传入的变量的type(类型)、kind(类别)值
	//1.先获取到reflect.Type
	rTyp := reflect.TypeOf(b)
	fmt.Println("rType:", rTyp)
	//2.获取到reflect.Value
	rVal := reflect.ValueOf(b)
	fmt.Println("rVal:", rVal)
	fmt.Printf("rVal : %v, rVal Type : %T \n", rTyp, rTyp)
	// 3. 我们将rVal转为interface{}
	iV := rVal.Interface()
	//将interface{} 通过断言转成需要的类型
	//这里，我们就简单使用了一带检测的类型断言.
	//fmt.Printf("iV:%v, iV的类型%T, iV Name的值%v \n", iV, iV, iV.Name)
	// 这里在运行时可以知道是Student类型 但是编译器并不知道它是哪个类型
	fmt.Printf("iV:%v, iV的类型%T \n", iV, iV)
	// 这里必须对它断言 获取它的值 
	// 这里可以使用swtich 的断言形式来做的更加的灵活
	stu, ok := iV.(Student)
	if ok {
		fmt.Printf("stu:%v, stu的类型%T, stu Name的值%v \n", stu, stu, stu.Name)
	}
}

type Student struct{
	Name string
	Age int
}

func main(){
	//请编写一个案例，
	//演示对(基本数据类型、interface{}、 reflect.Value)进行反射的基本操作
	//1.先定义一个int
	var num int
	num = 100
	reflectTest01(num)

	//2.定义一个Students的实例
	stu := Student{
		Name: "Tom",
		Age: 20,
	}
	reflectTest02(stu)
}

第二节反射细节和最佳实践

2.1 反射的注意事项和细节

reflect.Value.Kind，获取变量的类别，返回的是一个常量
Type和Kind的区别
- Type是类型，Kind是类别，Type 和Kind可能是相同的，也可能是不同的.
- 比如: var num int= 10 num 的Type是int,Kind也是int (基本数据类型)
- 比如: var stu Student stu 的Type是pkg1.Student , Kind是struct
通过反射可以在让变量在interface{}和Reflect.Value之间相互转换
使用反射的方式来获取变量的值(并返回对应的类型)，要求数据类型匹配，比如x是int,那么就应该使用reflect.Value(x).Int(), 而不能使用其它的，否则报panic
通过反射的来修改变量,注意当使用SetXxx方法来设置需要通过对应的指针类型来完成,这样才能改变传入的变量的值,同时需要使用到reflect.Value.Elem()方法

package main
import (
	"fmt"
	"reflect"
)

func testInt(b interface{}) { 
	val := reflect.ValueOf(b)
	fmt.Printf("val type=%T\n", val)
	// SetInt不能用于地址 所以需要用到Elem的函数 进行指向
	val.Elem().SetInt(110)
	fmt.Printf("val=%v\n", val)
}

func main(){
	var num int = 20
	testInt(&num)
	fmt.Println("num=", num)
	
	// 你可以这样理解rVal.Elem()
	// num := 9
	// ptr *int = &num
	// num2 := *ptr //类似rVal.Elem()
}

反射的练习题

package main
import (
	"fmt"
	"reflect"
)


func main(){
	var str string = "tom"
	fs := reflect.ValueOf(&str)
	// fs的值:tom, fs的类型:reflect.Value
	fmt.Printf("fs的值:%v, fs的类型:%T\n", str, fs)
	// 这里fs需要是string或者v.CanSet()返回假
	fs.Elem().SetString("jack")
	fmt.Printf("fs的值:%v, fs的类型:%T\n", str, fs)
}

2.2 反射的最佳实践

使用反射来遍历结构体的字段，调用结构体的方法，并获取结构体标签的值
使用反射的方式来获取结构体的tag标签,遍历字段的值，修改字段值，调用结构体方法
- val.Method(0).Call() 调用第一个方法
- 方法的排序默认是按照函数名的排序(ASCII码)
定义了两个函数testl 和test2，定义一个适配器函数用作统一处理接口
使用反射操作任意结构体类型
使用反射创建并操作结构体

package main
import (
	"fmt"
	"reflect"
)

//定义了一个Monster结构体
type Monster struct{
	Name string `json:"name"`
	Age int `json:"age"`
	Score float32 `json:"成绩"`
	Sex string
}

// 方法: 返回两数之和
func(s Monster) GetSum(n1, n2 int) int{
	return n1 + n2
}

// 方法: 接收四个值, 给S赋值
func(s Monster) Set(name string, age int, score float32, sex string){
	s.Name = name
	s.Age = age
	s.Score = score
	s.Sex = sex
}

//方法，显示s的值
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) //4
	//变量结构体的所有字段
	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")
		//如果该字段于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个方法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.8,
	} 
	//将Monster实例传递给TestStruct函数
	TestStruct(a)
}

第三节 tcp编程

3.1 网络编程基本介绍

Golang的主要设计目标之一-就是面向大规模后端服务程序,网络通信这块是服务端程序必不可少
也是至关重要的一部分。
网络编程有两种:
- TCP socket编程，是网络编程的主流。之所以叫Tcp socket编程，是因为底层是基于Tcp/ip协议的.比如: QQ聊天
- b/s 结构的http 编程，我们使用浏览器去访问服务器时，使用的就是http 协议，而http 底层依旧是用tcp socket实现的。比如:京东商城[这属于go web开发范畴]
TCP/IP (Transmission Control Protocol/Internet Protocol)的简写，中文译名为传输控制协议/因特网互联协议，又叫网络通讯协议，这个协议是Intermet最基本的协议、Internet国际互联网络的基础，简单地说，就是由网络层的IP协议和传输层的TCP协议组成的。
OSI与Tcp/ip参考模型(推荐tcp/ip协议3卷)
通过命令：tracert www.baidu.com 可以追踪路由经过的ip

3.2 IP地址和端口

概述:每个internet.上的主机和路由器都有一个ip地址,它包括网络号和主机号,ip地址有ipv4(32位)或者ipv6(128位). 可以通过ipconfig 来查看
我们这里所指的端口不是指物理意义上的端口，而是特指TCP/IP协议中的端口，是逻辑意义上的端口。如果把IP地址比作一间房子，端口就是出入这间房子的门。真正的房子只有几个门，但是一个IP地址的端口可以有65536 (即: 256X256) 个。端口是通过端口号来标记的，端口号只有整数，范围是从0到65535 (256X 256-1)
端口分类
- 0号是保留端口.
- 1-1024是固定端口(程序员不要使用) 又叫有名端口，即被某些程序固定使用,一般程序员不使用.
  - 22: SSH远程登录协议
  - 23: telnet使用
  - 21: ftp使用
  - 25: smtp服务使用
  - 80:iis使用
  - 7:echo服务
- 1025-65535是动态端口这些端口，程序员可以使用
端口(port)-使用注意
- 在计算机(尤其是做服务器)要尽可能的少开端口
- 一个端口只能被一个程序监听
- 如果使用netsta t-an可以查看本机有哪些端口在监听可以使用
- netstat -anb来查看监听端口的pid,在结合任务管理器关闭不安全的端口

3.3 tcp socket编程的快速入门

服务端的处理流程
- 监听端口8888
- 接收客户端的tcp链接，建立客户端和服务器端的链接.
- 创建goroutine,处理该链接的请求(通常客户端会通过链接发送请求包)
客户端的处理流程
- 建立与服务端的链接
- 发送请求数据[终端]，接收服务器端返回的结果数据
- 关闭链接
服务器端代码实现。

package main
import (
	"fmt"
	"net" //做网络socket开发时, net包含了我们所需的所有的方法和函数 
)

func process(conn net.Conn) {
	//这里我们循环的接收客户端发送的数据
	defer conn.Close() //关闭conn
	for {
		//创建一个新的切片
		buf := make([]byte, 1024)
		//conn.Read(buf)
		//1.等待客户端通过conn发送信息
		//2.如果客户端没有wrtie[发送]，那么协程就阻塞在这里
		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("服务器开始监听...")
	//net.Listen("tcp", "0.0.0.0:888")
	//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() suc con=%v客户端ip=%v\n", conn, conn.RemoteAddr().String())
		}	
		//这里准备一个协程，为客户端服务
		go process(conn)
	}
	//fmt.Printf("listen suc=%v\n", listen)
}

客户端可以发送单行数据，然后就退出。能通过终端输入数据(输入一行发送一行),并发送给服务器端。在终端输入exit,表示退出程序。

package main
import (
	"fmt"
	"net"
	"bufio"
	"os"
	"strings"
)

func main(){
	conn, err := net.Dial("tcp", "127.0.0.1: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
		}

		//再将line发送给服务器
		_, err = conn.Write([]byte(line + "\n"))
		if err != nil {
			fmt.Println("conn. Write err=", err)
		}
		//fmt.Printf("客户端发送了%d字节的数据，并退出", n)
	}
	
}