Go语言精修（尚硅谷笔记）第十七和十八章
十七、反射
17.1 基本介绍
1 ) 反射可以在运行时动态获取变量的各种信息, 比如变量的类型(type)，类别(kind)
2 ) 如果是结构体变量，还可以获取到结构体本身的信息(包括结构体的字段、方法)
3 ) 通过反射，可以修改变量的值，可以调用关联的方法。
4 ) 使用反射，需要 import(“ reflect ”)
5 ) 示意图
17.2 反射应用场景
- 不知道接口调用哪个函数，根据传入参数在运行时确定调用的具体接口，这种需要对函数或方法反射。例如以下这种桥接模式。
func bridge（funcPtr interface{}，args ...interface{})
第一个参数funcPtr以接口的形式传入函数指针，函数参数args以可变参数的形式传入，bridge函数中可以用反射来动态执行funcPtr函数
- 对结构体序列化时，如果结构体有指定Tag，也会使用到反射生成对应的字符串。
17.3 反射重要的函数和概念
- reflect.TypeOf(变量名)，获取变量的类型，返回reflext.Type类型
2）reflect.ValueOf(变量名)，获取变量的值，返回reflect.Value类型reflect.Value是一个结构体类型。通过reflect.Value，可以获取到该变量的很多信息。
3 ) 变量、interface{} 和 reflect.Value是可以相互转换的，这点在实际开发中，会经常使用到。画 出示意图
案例
package main
import (
"reflect"
"fmt"
)
//专门演示反射
func reflectTest01(b interface{}) {
//通过反射获取的传入的变量的 type , kind, 值
//1. 先获取到 reflect.Type
rTyp := reflect.TypeOf(b)
fmt.Println("rType=", rTyp)
//2. 获取到 reflect.Value
rVal := reflect.ValueOf(b)
n2 := 2 + rVal.Int()
//n3 := rVal.Float()
fmt.Println("n2=", n2)
//fmt.Println("n3=", n3)
fmt.Printf("rVal=%v rVal type=%T\n", rVal, rVal)
//下面我们将 rVal 转成 interface{}
iV := rVal.Interface()
//将 interface{} 通过断言转成需要的类型
num2 := iV.(int)
fmt.Println("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)
//3. 获取 变量对应的Kind
//(1) rVal.Kind() ==>
kind1 := rVal.Kind()
//(2) rTyp.Kind() ==>
kind2 := rTyp.Kind()
fmt.Printf("kind =%v kind=%v\n", kind1, kind2)
//下面我们将 rVal 转成 interface{}
iV := rVal.Interface()
fmt.Printf("iv=%v iv type=%T \n", iV, iV)
//将 interface{} 通过断言转成需要的类型
//这里，我们就简单使用了一带检测的类型断言.
//同学们可以使用 swtich 的断言形式来做的更加的灵活
stu, ok := iV.(Student)
if ok {
fmt.Printf("stu.Name=%v\n", stu.Name)
}
}
type Student struct {
Name string
Age int
}
type Monster struct {
Name string
Age int
}
func main() {
//请编写一个案例，
//演示对(基本数据类型、interface{}、reflect.Value)进行反射的基本操作
//1. 先定义一个int
var num int = 100
reflectTest01(num)
//2. 定义一个Student的实例
stu := Student{
Name : "tom",
Age : 20,
}
reflectTest02(stu)
}
17.4 反射注意事项
1 ) reflect.Value.Kind，获取变量的类别，返回的是一个常量
2 ) Type 和 Kind 的区别
-
Type是类型,Kind是类别，Type 和 Kind 可能是相同的，也可能是不同的
比如: varnumint= 10 num的Type是int,Kind也是int
比如: varstuStudent stu的Type是 pkg 1 .Student,Kind是struct
3）通过反射可以在让变量在interface{}和Reflect.Value之间相互转换，这点在前面画过示意图并在快速入门案例中讲解过，这里我们看下是如何在代码中体现的。
5 ) 通过反射的来修改变量, 注意当使用SetXxx方法来设置需要通过对应的指针类型来完成, 这样才能改变传入的变量的值, 同时需要使用到reflect.Value.Elem()方法
package main
import (
"reflect"
"fmt"
)
//通过反射，修改,
// num int 的值
// 修改 student的值
func reflect01(b interface{}) {
//2. 获取到 reflect.Value
rVal := reflect.ValueOf(b)
// 看看 rVal的Kind是
fmt.Printf("rVal kind=%v\n", rVal.Kind())
//3. rVal
//Elem返回v持有的接口保管的值的Value封装，或者v持有的指针指向的值的Value封装
rVal.Elem().SetInt(20)
}
func main() {
var num int = 10
reflect01(&num)
fmt.Println("num=", num) // 20
//你可以这样理解rVal.Elem()
// num := 9
// ptr *int = &num
// num2 := *ptr //=== 类似 rVal.Elem()
}
6 ) reflect.Value.Elem() 应该如何理解？
17.4 反射实践
1 ) 使用反射来遍历结构体的字段，调用结构体的方法，并获取结构体标签的值
package main
import (
"fmt"
"reflect"
)
//定义了一个Monster结构体
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
}
//方法， 接收四个值，给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() {
//创建了一个Monster实例
var a Monster = Monster{
Name: "黄鼠狼精",
Age: 400,
Score: 30.8,
}
//将Monster实例传递给TestStruct函数
TestStruct(a)
}
) 使用反射的方式来获取结构体的tag标签, 遍历字段的值，修改字段值，调用结构体方法(要求： 通过传递地址的方式完成, 在前面案例上修改即可)
3 ) 定义了两个函数test 1 和test 2 ，定义一个适配器函数用作统一处理接口【了解】
4 ) 使用反射操作任意结构体类型：【了解】
5 ) 使用反射创建并操作结构体
十八、TCP编程
Golang的主要设计目标之一就是面向大规模后端服务程序，网络通信这块是服务端 程序必不可少 也是至关重要的一部分。
网络编程有两种:
1 ) TCPsocket编程，是网络编程的主流。之所以叫Tcpsocket编程，是因为底层是基于Tcp/ip协 议的. 比如:QQ聊天 [示意图]
2 ) b/s结构的http编程，我们使用浏览器去访问服务器时，使用的就是http协议，而http底层依 旧是用tcpsocket实现的。[示意图] 比如: 京东商城 【这属于goweb 开发范畴 】
18.1 TCP/IP协议
TCP/IP（TransmissionControlProtocol/InternetProtocol)的简写,中文译名为传输控制协议/因特网互联协议，又叫网络通讯协议，这个协议是Internet最基本的协议、Internet国际互联网络的基础，简单地说，就是由网络层的IP协议和传输层的TCP协议组成的。
18.2 端口
这里所指的端口不是指物理意义上的端口，而是特指TCP/IP协议中的端口，是逻辑意义上的端口。
如果把IP地址比作一间房子，端口就是出入这间房子的门。真正的房子只有几个门，但是一个IP地址的端口 可以有 65536 （即： 256 × 256 ）个之多！端口是通过端口号来标记的，端口号只有整数，范围是从 0 到 65535 （ 256 × 256 - 1 ）
端口分类
-
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,在结合任务管理器关闭不安全的端口
18.3 socket编程
18.3.1 服务端的处理流程
1 ) 监听端口 8888
2 ) 接收客户端的tcp链接，建立客户端和服务器端的链接
3 ) 创建 goroutine ，处理该链接的请求(通常客户端会通过链接发送请求包)
18.3.2 客户端的处理流程
1 ) 建立与服务端的链接
2 ) 发送请求数据[终端]，接收服务器端返回的结果数据
3 ) 关闭链接
18.3.3 代码实现
- 程序框架图示意图
服务器端功能:
- 编写一个服务器端程序，在 8888 端口监听
- 可以和多个客户端创建链接
- 链接成功后，客户端可以发送数据，服务器端接受数据，并显示在终端上
- 先使用telnet 来测试，然后编写客户端程序来测试
- 服务端的代码:
package main
import (
"fmt"
"net" //做网络socket开发时,net包含有我们需要所有的方法和函数
_"io"
)
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:8888")
//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)
}
客户端功能:
- 编写一个客户端端程序，能链接到 服务器端的 8888 端口
- 客户端可以发送单行数据，然后就退出
- 能通过终端输入数据(输入一行发送一行), 并发送给服务器端 []
- 在终端输入exit,表示退出程序.
package main
import (
"fmt"
"net"
"bufio"
"os"
"strings"
)
func main() {
conn, err := net.Dial("tcp", "192.168.20.253: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)
}
}
}