首页 > 其他分享 >Go学习笔记5

Go学习笔记5

时间：2023-09-12 22:56:47浏览次数：39  
标签：reflect reValue err fmt 笔记 学习 Println func Go

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

创建客户端

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

image-20230911152838914

【2】代码：

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

创建服务端

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

image-20230911152923493

【2】代码：

package main
import(
        "fmt"
        "net" //所需的网络编程全部都在net包下
)
func main(){
        //打印：
        fmt.Println("服务器端启动了。。")
        //进行监听：需要指定服务器端TCP协议，服务器端的IP+PORT
        listen,err := net.Listen("tcp","127.0.0.1:8888")
        if err != nil{//监听失败
                fmt.Println("监听失败，err:",err)
                return
        }
        //监听成功以后：
        //循环等待客户端的链接：
        for{
                conn,err2 := listen.Accept()
                if err2 != nil {//客户端的等待失败
                        fmt.Println("客户端的等待失败,err2:",err2)
                }else{
                        //连接成功：
                        fmt.Printf("等待链接成功，con=%v ，接收到的客户端信息：%v \n",conn,conn.RemoteAddr().String())
                }
        }
}

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

image-20230911152941882

处理终端数据

【1】客户端发送数据：

package main
import(
        "fmt"
        "net" //所需的网络编程全部都在net包下
        "bufio"
        "os"
)
func main(){
        //打印：
        fmt.Println("客服端启动。。")
        //调用Dial函数：参数需要指定tcp协议，需要指定服务器端的IP+PORT
        conn,err := net.Dial("tcp","127.0.0.1:8888")
        if err != nil {//连接失败
                fmt.Println("客户端连接失败：err:",err)
                return
        }
        fmt.Println("连接成功，conn:",conn)
        //通过客户端发送单行数据，然后退出：
        reader := bufio.NewReader(os.Stdin)//os.Stdin代表终端标准输入
        //从终端读取一行用户输入的信息：
        str,err := reader.ReadString('\n')
        if err != nil {
                fmt.Println("终端输入失败，err:",err)
        }
        //将str数据发送给服务器：
        n,err := conn.Write([]byte(str))
        if err != nil{
                fmt.Println("连接失败，err:",err)
        }
        fmt.Printf("终端数据通过客户端发送成功，一共发送了%d字节的数据,并退出",n)
}

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

package main
import(
        "fmt"
        "net" //所需的网络编程全部都在net包下
)
func process(conn net.Conn){
        //连接用完一定要关闭：
        defer conn.Close()
        for{
                //创建一个切片，准备：将读取的数据放入切片：
                buf := make([]byte,1024)
                //从conn连接中读取数据：
                n,err := conn.Read(buf)
                if err != nil{
                        return
                }
                //将读取内容在服务器端输出：
                fmt.Println(string(buf[0:n]))
        }
}
func main(){
        //打印：
        fmt.Println("服务器端启动了。。")
        //进行监听：需要指定服务器端TCP协议，服务器端的IP+PORT
        listen,err := net.Listen("tcp","127.0.0.1:8888")
        if err != nil{//监听失败
                fmt.Println("监听失败，err:",err)
                return
        }
        //监听成功以后：
        //循环等待客户端的链接：
        for{
                conn,err2 := listen.Accept()
                if err2 != nil {//客户端的等待失败
                        fmt.Println("客户端的等待失败,err2:",err2)
                }else{
                        //连接成功：
                        fmt.Printf("等待链接成功，con=%v ，接收到的客户端信息：%v \n",conn,conn.RemoteAddr().String())
                }
                //准备一个协程，协程处理客户端服务请求：
                go process(conn)//不同的客户端的请求，连接conn不一样的
        }
}

【3】处理结果：

image-20230911153049172

十七、反射

反射的引入

【1】反射可以做什么？

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

image-20230912223247803

基本数据类型的反射

【1】反射相关的函数

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

image-20230912223316684

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

结构体类型的反射

【1】反射相关的函数

  1. reflect.TypeOf(变量名)，获取变量的类型，返回reflect.Type类型
  2. reflect.ValueOf(变量名)，获取变量的值，返回reflect.Value类型(reflect.Value是一个结构体类型),通过reflect.Value，可以获取到关于该变量的很多信息。
    【2】代码：
package main
import(
        "fmt"
        "reflect"
)
//利用一个函数，函数的参数定义为空接口：
func testReflect(i interface{}){//空接口没有任何方法,所以可以理解为所有类型都实现了空接口，也可以理解为我们可以把任何一个变量赋给空接口。
        //1.调用TypeOf函数，返回reflect.Type类型数据：
        reType := reflect.TypeOf(i)
        fmt.Println("reType:",reType)
        fmt.Printf("reType的具体类型是：%T",reType)
        //2.调用ValueOf函数，返回reflect.Value类型数据：
        reValue :=reflect.ValueOf(i)
        fmt.Println("reValue:",reValue)
        fmt.Printf("reValue的具体类型是：%T",reValue)
        //reValue转成空接口：
        i2 := reValue.Interface()
        //类型断言：
        n,flag := i2.(Student)
        if flag == true {//断言成功
                fmt.Printf("学生的名字是：%v,学生的年龄是：%v",n.Name,n.Age)
        }
        
}
//定义学生结构体：
type Student struct{
        Name string
        Age int
}
func main(){
        //对结构体类型进行反射：
        //定义结构体具体的实例：
        stu := Student{
                Name : "丽丽",
                Age : 18,	
        }
        testReflect(stu)
}

获取变量的类别

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

image-20230912223535251

【3】代码：

package main
import(
        "fmt"
        "reflect"
)
//利用一个函数，函数的参数定义为空接口：
func testReflect(i interface{}){//空接口没有任何方法,所以可以理解为所有类型都实现了空接口，也可以理解为我们可以把任何一个变量赋给空接口。
        //1.调用TypeOf函数，返回reflect.Type类型数据：
        reType := reflect.TypeOf(i)
        //2.调用ValueOf函数，返回reflect.Value类型数据：
        reValue :=reflect.ValueOf(i)
        //获取变量的类别：
        //（1）reType.Kind()
        k1 := reType.Kind()
        fmt.Println(k1)
        //（2）reValue.Kind()
        k2 := reValue.Kind()
        fmt.Println(k2)
        //获取变量的类型：
        //reValue转成空接口：
        i2 := reValue.Interface()
        //类型断言：
        n,flag := i2.(Student)
        if flag == true {//断言成功
                fmt.Printf("结构体的类型是：%T",n)
        }
}
//定义学生结构体：
type Student struct{
        Name string
        Age int
}
func main(){
        //对结构体类型进行反射：
        //定义结构体具体的实例：
        stu := Student{
                Name : "丽丽",
                Age : 18,	
        }
        testReflect(stu)
}

【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】修改基本数据类型的值：

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

image-20230912223655856

操作结构体的属性和方法

【1】代码：（熟知API）

package main
import(
        "fmt"
        "reflect"
)
//定义一个结构体：
type Student struct{
        Name string
        Age int
}
//给结构体绑定方法：
func (s Student) CPrint(){
        fmt.Println("调用了Print()方法")
        fmt.Println("学生的名字是：",s.Name)
}
func (s Student) AGetSum(n1,n2 int) int{
        fmt.Println("调用了AGetSum方法")
        return n1 + n2
}
func (s Student) BSet(name string,age int){
        s.Name = name
        s.Age = age
}
//定义函数操作结构体进行反射操作：
func TestStudentStruct(a interface{}){
        //a转成reflect.Value类型：
        val := reflect.ValueOf(a)
        fmt.Println(val)
        //通过reflect.Value类型操作结构体内部的字段：
        n1 := val.NumField()
        fmt.Println(n1)
        //遍历-获取具体的字段：
        for i := 0; i < n1;i++{
                fmt.Printf("第%d个字段的值是：%v",i,val.Field(i))
        }
        fmt.Println()
        //通过reflect.Value类型操作结构体内部的方法：
        n2 := val.NumMethod()
        fmt.Println(n2)
        //调用CPrint()方法：
        //调用方法，方法的首字母必须大写才能有对应的反射的访问权限
        //方法的顺序按照ASCII的顺序排列的，a,b,c,,,,,,索引：0,1,2，，，，，
        val.Method(2).Call(nil)
        //调用AGetSum方法：
        //定义Value的切片：
        var params []reflect.Value
        params = append(params,reflect.ValueOf(10))
        params = append(params,reflect.ValueOf(20))
        result := val.Method(0).Call(params)
        fmt.Println("AGetSum方法的返回值为：",result[0].Int())
}
func main(){
        //定义结构体具体的实例：
        s := Student{
                Name : "丽丽",
                Age : 18,
        }
        //调用TestStudentStruct：
        TestStudentStruct(s)
}

修改结构的变量

【1】代码：

package main
import(
        "fmt"
        "reflect"
)
//定义一个结构体：
type Student struct{
        Name string
        Age int
}
//给结构体绑定方法：
func (s Student) CPrint(){
        fmt.Println("调用了Print()方法")
        fmt.Println("学生的名字是：",s.Name)
}
func (s Student) AGetSum(n1,n2 int) int{
        fmt.Println("调用了AGetSum方法")
        return n1 + n2
}
func (s Student) BSet(name string,age int){
        s.Name = name
        s.Age = age
}
//定义函数操作结构体进行反射操作：
func TestStudentStruct(a interface{}){
        //a转成reflect.Value类型：
        val := reflect.ValueOf(a)
        fmt.Println(val)
        n := val.Elem().NumField()
        fmt.Println(n)
        //修改字段的值：
        val.Elem().Field(0).SetString("张三")
}
func main(){
        //定义结构体具体的实例：
        s := Student{
                Name : "丽丽",
                Age : 18,
        }
        //调用TestStudentStruct：
        TestStudentStruct(&s)
        fmt.Println(s)
}

标签：reflect,reValue,err,fmt,笔记,学习,Println,func,Go
From： https://www.cnblogs.com/Gao-yubo/p/17698071.html

相关文章

  • ClickHouse使用之五 ——clickhouse-go内存泄露解决
    这个代码运行2亿条记录，发现内存使用一直增加，内存满了以后，直接被killed func(p*ClickHouseClient)CountAllTxTypees(startIdint,endIdint,SpaceStoreSpaceInterface)(web3datas[]Web3Data){ sql:=fmt.Sprintf(` SELECTgame_name,Address, CASEtx_type ......
  • 信息系统项目管理师教程（第四版） 第一章 信息化发展 学习笔记1-20230911
    第一章《信息化发展》 学习要点：1、信息的基本概念、信息的7个质量属性。2、信息系统的概念、特点或用途、抽象模型、信息系统生命周期。3、信息化、信息化系统。4、工业互联网（四大层级）、车联网（体系框架、链接方式、应用场景）。5、农业农村现代化、乡村振兴战略、两化融合与......
  • Java学习_005 if语句：奇偶数的判定
    需求：任意给出一个整数，使用程序判定该整数是奇数还是偶数，并在控制台输出。1importjava.util.Scanner;23publicclassMain{4publicstaticvoidmain(String[]args){5Scannersc=newScanner(System.in);6System.out.println("please......
  • 记录一次部署Hugo主题lotusdocs到Github Pages实践
    引言随着开源项目的越来越复杂，项目文档的重要性日渐突出。一个好的项目要有一个清晰明了的文档来帮助大家使用。最近一直有在找寻一个简洁明了的文档主题来放置项目的各种相关文档。最终找到这次的主角：LotusDocs基于Hugo的主题。LotusDocs的样子，可以移步这里查看。下面着重......
  • Vue学习三：生命周期和工程化开发
    一、Vue生命周期Vue生命周期就是一个Vue实例从创建到销毁的过程生命周期四个阶段：1、创建2、挂载3、更新4、销毁Vue生命周期函数（钩子函数）Vue生命周期过程中，会自动运行一些函数,被称为[生命周期钩子]→让开发者可以在[特定阶段]运行自己的代码。创建阶段其实就是开辟存放数......
  • 基于自定义表编写认证类、django-jwt源码分析、权限介绍、simpleui的使用
    基于自定义表编写认证类补充：翻译函数只要做了国际化，就会显示当前国家的语言fromdjango.utils.translationimportgettext_lazyas_msg=_('Signaturehasexpired.')#_是个函数的别名，这个函数是翻译函数，只要做了国际化，它就是中文认证类fromrest_framework_jwt......
  • kubernetes权威指南读书笔记-Serivce的ClusterIP地址
    EndPoint：由POD的IP加上容器的端口构造；它表示POD里的一个服务进程对外的通信地址；一个POD也存在多个ENDPOINT的情况。KuernetesService的一个功能就是实现负载均衡。它是这样来实现的，kubernetes内部在每个Node上都运行了一套全局的虚拟负载均衡器，自动注入并自动实时更新集群中所有......
  • springcloud日常学习
    一、 Feign客户端接口调用1. 分析与介绍   之前的消费者调用服务提供者是通过RestTemplate + Ribbon组合实现负载均衡进行调用   如果在消费者客户端能够通过面向接口编程的思想去实现对服务提供者进行调用，就更加接近软件工程的开发思想，Feign就可以实现。微服务之间的调......
  • 《Python数据分析基础教程：NumPy学习指南.第2版》高清高质量PDF电子书+源码
    罕见的NumPy中文入门教程，Python数据分析首选从最基础的知识讲起，手把手带你进入大数据挖掘领域囊括大量具有启发性与实用价值的实战案例下载：https://pan.quark.cn/s/730b594117c0......
  • Go每日一库之6：viper
    简介上一篇文章介绍cobra的时候提到了viper，今天我们就来介绍一下这个库。viper是一个配置解决方案，拥有丰富的特性：支持JSON/TOML/YAML/HCL/envfile/Javaproperties等多种格式的配置文件；可以设置监听配置文件的修改，修改时自动加载新的配置；从环境变量、命令行选项和io.R......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99