技术

数据湖 高性能计算与存储 Linux2.1.13网络源代码学习 《大数据经典论文解读》 三驾马车学习 Spark 内存管理及调优 Yarn学习 从Spark部署模式开始讲源码分析 容器狂占内存资源怎么办? 多角度理解一致性 golang io使用及优化模式 Flink学习 c++学习 学习ebpf go设计哲学 ceph学习 学习mesh kvm虚拟化 学习MQ go编译器以及defer实现 学习go 为什么要有堆栈 汇编语言 计算机组成原理 运行时和库 Prometheus client mysql 事务 mysql 事务的隔离级别 mysql 索引 坏味道 学习分布式 学习网络 学习Linux go堆内存分配 golang 系统调用与阻塞处理 Goroutine 调度过程 重新认识cpu mosn有的没的 负载均衡泛谈 单元测试的新解读 《Redis核心技术与实现》笔记 《Prometheus监控实战》笔记 Prometheus 告警学习 calico源码分析 对容器云平台的理解 Prometheus 源码分析 并发的成本 基础设施优化 hashicorp raft源码学习 docker 架构 mosn细节 与微服务框架整合 Java动态代理 编程范式 并发通信模型 《网络是怎样连接的》笔记 go channel codereview gc分析 jvm 线程实现 go打包机制 go interface及反射 如何学习Kubernetes 《编译原理之美》笔记——后端部分 《编译原理之美》笔记——前端部分 Pilot MCP协议分析 go gc 内存管理玩法汇总 软件机制 istio流量管理 Pilot源码分析 golang io 学习Spring mosn源码浅析 MOSN简介 《datacenter as a computer》笔记 学习JVM Tomcat源码分析 Linux可观测性 学习存储 学计算 Gotty源码分析 kubernetes operator kaggle泰坦尼克问题实践 kubernetes扩缩容 神经网络模型优化 直觉上理解深度学习 如何学习机器学习 TIDB源码分析 什么是云原生 Alibaba Java诊断工具Arthas TIDB存储——TIKV 《Apache Kafka源码分析》——简介 netty中的线程池 guava cache 源码分析 Springboot 启动过程分析 Spring 创建Bean的年代变迁 Linux内存管理 自定义CNI IPAM 共识算法 spring redis 源码分析 kafka实践 spring kafka 源码分析 Linux进程调度 让kafka支持优先级队列 Codis源码分析 Redis源码分析 C语言学习 《趣谈Linux操作系统》笔记 docker和k8s安全访问机制 jvm crash分析 Prometheus 学习 Kubernetes监控 容器日志采集 Kubernetes 控制器模型 容器狂占资源怎么办? Kubernetes资源调度——scheduler 时序性数据库介绍及对比 influxdb入门 maven的基本概念 《Apache Kafka源码分析》——server Kubernetes类型系统 源码分析体会 《数据结构与算法之美》——算法新解 Kubernetes源码分析——controller mananger Kubernetes源码分析——apiserver Kubernetes源码分析——kubelet Kubernetes介绍 ansible学习 Kubernetes源码分析——从kubectl开始 jib源码分析之Step实现 jib源码分析之细节 线程排队 跨主机容器通信 jib源码分析及应用 为容器选择一个合适的entrypoint kubernetes yaml配置 《持续交付36讲》笔记 mybatis学习 程序猿应该知道的 无锁数据结构和算法 CNI——容器网络是如何打通的 为什么很多业务程序猿觉得数据结构和算法没用? 串一串一致性协议 当我在说PaaS时,我在说什么 《数据结构与算法之美》——数据结构笔记 PouchContainer技术分享体会 harbor学习 用groovy 来动态化你的代码 精简代码的利器——lombok 学习 《深入剖析kubernetes》笔记 编程语言那些事儿 rxjava3——背压 rxjava2——线程切换 spring cloud 初识 《深入拆解java 虚拟机》笔记 《how tomcat works》笔记 hystrix 学习 rxjava1——概念 Redis 学习 TIDB 学习 如何分发计算 Storm 学习 AQS1——论文学习 Unsafe Spark Stream 学习 linux vfs轮廓 《自己动手写docker》笔记 java8 实践 中本聪比特币白皮书 细读 区块链泛谈 比特币 大杂烩 总纲——如何学习分布式系统 hbase 泛谈 forkjoin 泛谈 看不见摸不着的cdn是啥 《jdk8 in action》笔记 程序猿视角看网络 bgp初识 calico学习 AQS——粗略的代码分析 我们能用反射做什么 web 跨域问题 《clean code》笔记 《Elasticsearch权威指南》笔记 mockito简介及源码分析 2017软件开发小结—— 从做功能到做系统 《Apache Kafka源码分析》——clients dns隐藏的一个坑 《mysql技术内幕》笔记 log4j学习 为什么netty比较难懂? 递归、回溯、动态规划 apollo client源码分析及看待面向对象设计 学习并发 docker运行java项目的常见问题 OpenTSDB 入门 spring事务小结 分布式事务 javascript应用在哪里 《netty in action》读书笔记 netty对http2协议的解析 ssl证书是什么东西 http那些事 苹果APNs推送框架pushy apple 推送那些事儿 编写java框架的几大利器 java内存模型和jvm内存布局 java exception Linux IO学习 netty内存管理 测试环境docker化实践 netty在框架中的使用套路 Nginx简单使用 《Linux内核设计的艺术》小结 Go并发机制及语言层工具 Linux网络源代码学习——数据包的发送与接收 《docker源码分析》小结 docker namespace和cgroup zookeeper三重奏 数据库的一些知识 Spark 泛谈 链式处理的那些套路 netty回顾 Thrift基本原理与实践(二) Thrift基本原理与实践(一) 回调 异步执行抽象——Executor与Future Docker0.1.0源码分析 java gc Jedis源码分析 深度学习泛谈 Linux网络命令操作 JTA与TCC 换个角度看待设计模式 Scala初识 向Hadoop学习NIO的使用 以新的角度看数据结构 并发控制相关的硬件与内核支持 systemd 简介 quartz 源码分析 基于docker搭建测试环境(二) spring aop 实现原理简述 自己动手写spring(八) 支持AOP 自己动手写spring(七) 类结构设计调整 分析log日志 自己动手写spring(六) 支持FactoryBean 自己动手写spring(九) 总结 自己动手写spring(五) bean的生命周期管理 自己动手写spring(四) 整合xml与注解方式 自己动手写spring(三) 支持注解方式 自己动手写spring(二) 创建一个bean工厂 自己动手写spring(一) 使用digester varnish 简单使用 关于docker image的那点事儿 基于docker搭建测试环境 分布式配置系统 JVM执行 git maven/ant/gradle/make使用 再看tcp kv系统 java nio的多线程扩展 《Concurrency Models》笔记 回头看Spring IOC IntelliJ IDEA使用 Java泛型 vagrant 使用 Go常用的一些库 Python初学 Goroutine 调度模型 虚拟网络 《程序员的自我修养》小结 Kubernetes存储 访问Kubernetes上的Service Kubernetes副本管理 Kubernetes pod 组件 Go基础 JVM类加载 硬币和扑克牌问题 LRU实现 virtualbox 使用 ThreadLocal小结 docker快速入门

架构

controller-runtime细节分析 finops学习 kubevela多集群 kubevela中cue的应用 基于k8s的工作流 容器和CPU那些事儿 kubevela源码分析 数据集管理fluid 应用管理平台kubevela karmada支持crd 多集群及clusternet学习 AutoML和AutoDL 特征平台 实时训练 分布式链路追踪 helm tensorflow原理——python层分析 如何学习tensorflow 数据并行——allreduce 数据并行——ps 机器学习中的python调用c 机器学习训练框架概述 embedding的原理及实践 tensornet源码分析 大模型训练 X的生成——特征工程 tvm tensorflow原理——core层分析 模型演变 《深度学习推荐系统实战》笔记 keras 和 Estimator tensorflow分布式训练 分布式训练的一些问题 基于Volcano的弹性训练 图神经网络 pytorch弹性分布式训练 从混部到统一调度 RNN pytorch分布式训练 CNN 《动手学深度学习》笔记 pytorch与线性回归 多活 volcano特性源码分析 推理服务 kubebuilder 学习 mpi 学习pytorch client-go学习 tensorflow学习 提高gpu 利用率 GPU与容器的结合 GPU入门 AI云平台梳理 tf-operator源码分析 k8s批处理调度 喜马拉雅容器化实践 Kubernetes 实践 学习rpc BFF openkruise学习 可观察性和监控系统 基于Kubernetes选主及应用 《许式伟的架构课》笔记 Admission Controller 与 Admission Webhook 发布平台系统设计 k8s水平扩缩容 Scheduler如何给Node打分 Scheduler扩展 controller 组件介绍 openkruise cloneset学习 controller-runtime源码分析 pv与pvc实现 csi学习 client-go源码分析 kubelet 组件分析 调度实践 Pod是如何被创建出来的? 《软件设计之美》笔记 mecha 架构学习 Kubernetes events学习及应用 CRI 资源调度泛谈 业务系统设计原则 grpc学习 元编程 以应用为中心 istio学习 下一代微服务Service Mesh 《实现领域驱动设计》笔记 概率论 serverless 泛谈 《架构整洁之道》笔记 处理复杂性 那些年追过的并发 服务器端编程 网络通信协议 架构大杂烩 如何学习架构 《反应式设计模式》笔记 项目的演化特点 反应式架构摸索 函数式编程的设计模式 服务化 ddd反模式——CRUD的败笔 研发效能平台 重新看面向对象设计 业务系统设计的一些体会 函数式编程 《左耳听风》笔记 业务程序猿眼中的微服务管理 DDD实践——CQRS 项目隔离——案例研究 《编程的本质》笔记 系统故障排查汇总及教训 平台支持类系统的几个点 代码腾挪的艺术 abtest 系统设计汇总 《从0开始学架构》笔记 初级权限系统设计 领域驱动理念入门 现有上传协议分析 移动网络下的文件上传要注意的几个问题 推送系统的几个基本问题 做配置中心要想好的几个基本问题 不同层面的异步 分层那些事儿 性能问题分析 当我在说模板引擎的时候,我在说什么 用户认证问题 资源的分配与回收——池 消息/任务队列

标签

controller-runtime细节分析 finops学习 kubevela多集群 kubevela中cue的应用 基于k8s的工作流 容器和CPU那些事儿 kubevela源码分析 数据集管理fluid 应用管理平台kubevela karmada支持crd 多集群及clusternet学习 helm 从混部到统一调度 volcano特性源码分析 kubebuilder 学习 client-go学习 tf-operator源码分析 k8s批处理调度 喜马拉雅容器化实践 Kubernetes 实践 openkruise学习 基于Kubernetes选主及应用 Admission Controller 与 Admission Webhook k8s水平扩缩容 Scheduler如何给Node打分 Scheduler扩展 controller 组件介绍 openkruise cloneset学习 controller-runtime源码分析 pv与pvc实现 csi学习 client-go源码分析 kubelet 组件分析 调度实践 Pod是如何被创建出来的? Kubernetes events学习及应用 CRI 资源调度泛谈 如何学习Kubernetes 以应用为中心 kubernetes operator kubernetes扩缩容 serverless 泛谈 自定义CNI IPAM docker和k8s安全访问机制 Kubernetes监控 Kubernetes 控制器模型 Kubernetes资源调度——scheduler Kubernetes类型系统 Kubernetes源码分析——controller mananger Kubernetes源码分析——apiserver Kubernetes源码分析——kubelet Kubernetes介绍 Kubernetes源码分析——从kubectl开始 kubernetes yaml配置 CNI——容器网络是如何打通的 当我在说PaaS时,我在说什么 《深入剖析kubernetes》笔记 Kubernetes存储 访问Kubernetes上的Service Kubernetes副本管理 Kubernetes pod 组件

go interface及反射

2020年03月13日

前言

interface,接口,restful接口,SQL 也是一种接口

从编码的角度看:Interfaces give programs structure. Interfaces encourage design by composition. You must do your best to understand what could change and use interfaces to decouple.

Go 语言之父 Rob Pike 说过“接口越大,抽象程度越弱”。越偏向业务层,抽象难度就越高。所以Go 标准库小接口(1~3 个方法)占比略高于 Docker 和 Kubernetes 的原因。Go 接口是构建 Go 应用骨架(对应血肉)的重要元素。抽象的时机:在实际真正需要的时候才对程序进行抽象。再通俗一些来讲,就是不要为了抽象而抽象。接口的确可以实现解耦,但它也会引入“抽象”的副作用,或者说接口这种抽象也不是免费的,是有成本的,除了会造成运行效率的下降之外,也会影响代码的可读性。

深入剖析对 Go 的成功作出巨大贡献的设计决策

  1. Go 不定义类,但允许将方法绑定到任何类型,包括结构、数组、slice、map 甚至是整数等基本类型。它没有类型的层次结构;我们认为继承往往会使程序在成长过程中更难适应。相反,Go 鼓励类型的组合。Go 通过其接口类型提供了面向对象的多态性。
  2. 避免接口和实现之间的显式关联允许 Go 程序员定义小的、灵活的、通常是 ad hoc 接口,而不是将它们用作复杂类型层次结构中的基础块。它鼓励在开发过程中捕获关系和操作,而不需要提前计划和定义它们。这尤其有助于大型程序,在这些程序中,刚开始开发时,最终的结构更加难以看清。无需声明实现的方式鼓励使用精确的、一种或两种方法的接口,例如 Writer、Reader、Stringer(类似于 Java 的 toString 方法)等,这些接口遍布标准库。PS: 写代码的时候,觉得A这里可能会扩展,就定一个interface 先用着(可能只有一个方法),觉得BC需要扩展也类似,后续实现上,如果ABC 可以联动,就定义一个struct 实现ABC,也可以定义一个struct 实现A,另一个struct 实现BC。一段程序确定的逻辑写成代码,不确定的逻辑留出interface,自由实现和扩展。从这个视角看,interface 是扩展的手段,而不是在设计阶段就充分使用。

如何让 Go 反射变快 未读

Go 自定义类型系统

鸭子类型

Go 的类型系统不太常见,而且非常简单。内建类型包括结构体、函数和接口。 任何实现了接口的方法的类型都可以称为实现了该接口。类型可以被隐式的从表达式中推导, 而且不需要被显式的指定。 有关接口的特殊处理以及隐式的类型推导使得 Go 看起来像是一种轻量级的动态类型语言。

鸭子类型,是动态编程语言的一种对象推断策略,它更关注对象能如何被使用,而不是对象的类型本身。Go 语言作为一门现代静态语言,是有后发优势的。它引入了动态语言的便利,同时又会进行静态语言的类型检查。 Go是如何判断实现了interface鸭子类型使得开发者可以不使用继承体系来灵活地实现一些“约定”,尤其是使得混合不同来源、使用不同对象继承体系的代码成为可能。

万字长文复盘导致Go语言成功的那些设计决策避免接口和实现之间的显式关联,允许Go程序员定义小型、灵活以及临时性的接口,而不是将它们作为复杂类型层次结构的基础构件。它鼓励捕捉开发过程中出现的关系和操作,而不是需要提前计划和定义它们。这对大型程序尤其有帮助,因为在刚开始开发时,最终的结构是很难看清楚的。初次学习Go的开发者常常担心一个类型会意外地实现一个接口。虽然很容易建立起这样的假设,但在实践中,不太可能为两个不兼容的操作选择相同的名称和签名,而且我们从未在实际的Go程序中看到这种情况发生。

struct

我们编写程序的目的就是与真实世界交互,解决真实世界的问题,帮助真实世界提高运行效率与改善运行质量。所以我们就需要对真实世界事物体的重要属性进行提炼,并映射到程序世界中,这就是所谓的对真实世界的抽象。不同的数据类型具有不同的抽象能力,比如整数类型 int 可以用来抽象一个真实世界物体的长度,string 类型可以用来抽象真实世界物体的名字,等等。但是光有这些类型的抽象能力还不够,我们还缺少一种通用的、对实体对象进行聚合抽象的能力。你可以回想一下,我们目前可以用学过的各种类型抽象出书名、书的页数以及书的索引,但有没有一种类型,可以抽象出聚合了上述属性的“书”这个实体对象呢?有的。在 Go 中,提供这种聚合抽象能力的类型是结构体类型,也就是 struct。

结构体类型 在内存中布局是非常紧凑的,Go 为它分配的内存都用来存储字段了,没有被 Go 编译器插入的额外字段。但结构体字段实际上可能并不是紧密相连的,中间可能存在“缝隙”,是内存对齐的要求 Go 编译器插入的“填充物(Padding)。为什么会出现内存对齐的要求呢?这是出于对处理器存取数据效率的考虑。

interface

深度解密Go语言之关于 interface 的 10 个问题

一个语言的类型系统 经常需要 一个“地位超然”的类型,可以表示任何类型,比如void* 或者 Object, 但真正在使用这个 类型的变量时,需要判断其真实类型,在类型转换后才能使用,所以会有类型断言的需求。

func xx(p interface){
    if  v,ok := p.(string);ok{
        xxx
    }
    switch v:=p.(type){
        case int:
        case string:
    }
}

类型嵌入

类型嵌入的本质,就是嵌入类型的方法集合并入到新接口类型的方法集合中,并且,接口类型只能嵌入接口类型。可以是任意自定义类型或接口类型。结构体类型可以嵌入任意自定义类型或接口类型。

type S struct { 
	io.Reader
}

类型嵌入这种看似“继承”的机制,实际上是一种组合的思想。更具体点,它是一种组合中的代理(delegate)模式,S 只是一个代理(delegate),对外它提供了它可以代理的所有方法,如例子中的 Read 方法。当外界发起对 S 的 Read 方法的调用后,Go 会首先查看结构体自身是否实现了该方法,如果实现了,Go 就会优先使用结构体自己实现的方法。如果没有实现,那么 Go 就会查找结构体中的嵌入字段的方法集合中,是否包含了这个方法。将该调用委派给它内部的 Reader 实例来实际执行 Read 方法。

interface 底层实现

eface 和 iface

Go Data Structures: InterfacesLanguages with methods typically fall into one of two camps: prepare tables for all the method calls statically (as in C++ and Java), or do a method lookup at each call (as in Smalltalk and its many imitators, JavaScript and Python included) and add fancy caching to make that call efficient. Go sits halfway between the two: it has method tables but computes them at runtime. I don’t know whether Go is the first language to use this technique, but it’s certainly not a common one.

接口类型变量在运行时表示为 eface 和 iface:Go 使用 iface 结构体表示包含方法的接口;使用 eface(empty iface?) 结构体表示不包含任何方法的 interface{} 类型。

// $GOROOT/src/runtime/runtime2.go
type iface struct {
    tab  *itab			// iface 除了要存储动态类型信息之外,还要存储接口本身的信息(接口的类型信息、方法列表信息等)以及动态类型所实现的方法的信息,因此 iface 的第一个字段指向一个itab类型结构。
    data unsafe.Pointer	// 指向当前赋值给该接口类型变量的动态类型变量的值。
}
// $GOROOT/src/runtime/runtime2.go
type itab struct {
    inter *interfacetype	// 这个接口类型自身的信息
    _type *_type			// 接口类型变量的动态类型的信息
    hash  uint32 // copy of _type.hash. Used for type switches.
    _     [4]byte
    fun   [1]uintptr 		// 动态类型已实现的接口方法的调用地址数组
}
// $GOROOT/src/runtime/type.go
type interfacetype struct {
    typ     _type		// 接口类型自身的信息
    pkgpath name		// 包路径名
    mhdr    []imethod	// 接口方法集合
}

type eface struct {
    _type *_type		// eface 表示的空接口类型并没有方法列表,因此它的第一个指针字段指向一个_type类型结构,这个结构为该接口类型变量的动态类型的信息
    data  unsafe.Pointer	// 指向当前赋值给该接口类型变量的动态类型变量的值。
}

虽然 eface 和 iface 的第一个字段有所差别,但 tab 和 _type 可以统一看作是动态类型的类型信息。Go 语言中每种类型都会有唯一的 _type 信息,无论是内置原生类型,还是自定义类型都有。Go 运行时会为程序内的全部类型建立只读的共享 _type 信息表(类似于java的 kclass?),因此拥有相同动态类型的同类接口类型变量的 _type/tab 信息是相同的。

运行时类型结构(类似于jvm的kclass?)

type _type struct {
	size       uintptr
	ptrdata    uintptr // size of memory prefix holding all pointers
	hash       uint32
	tflag      tflag
	align      uint8
	fieldAlign uint8
	kind       uint8 // 类型
	// function for comparing objects of this type (ptr to object A, ptr to object B) -> ==?
	equal func(unsafe.Pointer, unsafe.Pointer) bool
	// gcdata stores the GC type data for the garbage collector. If the KindGCProg bit is set in kind, gcdata is a GC program. Otherwise it is a ptrmask bitmap. See mbitmap.go for details.
	gcdata    *byte
	str       nameOff
	ptrToThis typeOff
}

eface 内部结构

type Binary uint64
func main() {
	b := Binary(200)
	any := (interface{})(b)
	fmt.Println(any)
}

iface 内部结构

type Binary uint64
func (i Binary) String() string {
	return strconv.FormatUint(i.Get(), 10)
}
func (i Binary) Get() uint64 {
	return uint64(i)
}
func main() {
	b := Binary(200)
	any := Stringer(b)
	fmt.Println(any)
}

装箱

Interface values are represented as a two-word pair giving a pointer to information about the type stored in the interface and a pointer to the associated data. Assigning b to an interface value of type Stringer sets both words of the interface value.一个结构体实现了一个接口,把这个结构体变量赋值给这个接口变量,就是赋值这个接口变量里的俩指针,就完成了数据和实现的绑定。

Note that the itable corresponds to the interface type, not the dynamic type. In terms of our example, the itable for Stringer holding type Binary lists the methods used to satisfy Stringer, which is just String: Binary’s other methods (Get) make no appearance in the itable.itable(Stringer,Binary) 的方法表只包含 String 方法不包含 Get 方法。

any := Stringer(b) 用伪代码表示 就是

创建 iface struct for any
创建 itab struct 
tab := getSymAddr(`go.itab.main.Binary,main.Stringer`).(*itab)
tab.inter = getSymAddr(`type.main.Stringer`).(*interfacetype)
tab._type = getSymAddr(`type.main.Binary`).(*_type)
tab.fun[0] = getSymAddr(`main.(*Binary).String`).(uintptr)

any.String() 相当于 any.tab->fun[0]

接口类型变量赋值是一个“装箱”的过程,实际就是创建一个 eface 或 iface 的过程(PS:any 赋值就是给iface赋值,只不过我们没有显式定义 iface 而已,被隐藏掉了)。在将动态类型变量赋值给接口类型变量语句对应的汇编代码中,我们看到了convT2E和convT2I两个 runtime 包的函数。convT2E 用于将任意类型转换为一个 eface,convT2I 用于将任意类型转换为一个 iface。两个函数的实现逻辑相似,主要思路就是根据传入的类型信息(convT2E 的 _type 和 convT2I 的 tab._type)分配一块内存空间,并将 elem 指向的数据拷贝到这块内存空间中,最后传入的类型信息作为返回值结构中的类型信息,返回值结构中的数据指针(data)指向新分配的那块内存空间。

// $GOROOT/src/runtime/iface.go
func convT2E(t *_type, elem unsafe.Pointer) (e eface) {
    if raceenabled {
        raceReadObjectPC(t, elem, getcallerpc(), funcPC(convT2E))
    }
    if msanenabled {
        msanread(elem, t.size)
    }
    x := mallocgc(t.size, t, true)
    typedmemmove(t, x, elem)
    e._type = t
    e.data = x
    return
}
func convT2I(tab *itab, elem unsafe.Pointer) (i iface) {
    t := tab._type
    if raceenabled {
        raceReadObjectPC(t, elem, getcallerpc(), funcPC(convT2I))
    }
    if msanenabled {
        msanread(elem, t.size)
    }
    x := mallocgc(t.size, t, true)
    typedmemmove(t, x, elem)
    i.tab = tab
    i.data = x
    return
}

不过,装箱操作是由 Go 编译器和运行时共同完成的,有一定的性能开销,因此 Go 也在不断对装箱操作进行优化,包括对常见类型如整型、字符串、切片等提供系列快速转换函数。这些函数去除了 typedmemmove 操作,增加了零值快速返回等特性。同时 Go 建立了 staticuint64s 区域,对 255 以内的小整数值进行装箱操作时不再分配新内存,而是利用 staticuint64s 区域的内存空间。PS: 有点Java的意思了。

C++ 和 Go 在定义接口方式上的不同,也导致了底层实现上的不同。C++ 通过虚函数表来实现基类调用派生类的函数;而 Go 通过 itab 中的 fun 字段来实现接口变量调用实体类型的函数。C++ 中的虚函数表是在编译期生成的;而 Go 的 itab 中的 fun 字段是在运行期间动态生成的。

interface{} 不是任意类型

Go 语言设计与实现-接口

package main
type TestStruct struct{}
func NilOrNot(v interface{}) bool {
	return v == nil
}
func main() {
	var s *TestStruct
	fmt.Println(s == nil)      // #=> true
	fmt.Println(NilOrNot(s))   // #=> false
}

出现上述现象的原因是 —— 调用 NilOrNot 函数时发生了隐式的类型转换,除了向方法传入参数之外,变量的赋值也会触发隐式类型转换。在类型转换时,*TestStruct 类型会转换成 interface{} 类型,转换后的变量(eface struct)不仅包含转换前的变量,还包含变量的类型信息 TestStruct,所以转换后的变量与 nil 不相等。

变量的赋值、向方法传入参数会触发隐式类型转换,类型转换的情况比较多:

  1. 同一类型的转换,比如int64与int
  2. 某类型与字符串的转换,这个有专门的包
  3. 字符串与字符/short数组的转换,比如string与[]uint8
  4. 具体类型转换成接口类型。

类型断言是,一个大类型,比如interface{},怀疑它可能是字符串,则可以xxx.(string)

等值比较操作

而接口类型变量的 data 部分则是指向一个动态分配的内存空间,这个内存空间存储的是赋值给接口类型变量的动态类型变量的值。也就是说,我们判断两个接口类型变量是否相同,只需要判断 _type/tab 是否相同,以及 data 指针指向的内存空间所存储的数据值是否相同就可以了。这里要注意不是 data 指针的值相同噢。在创建 eface 时一般会为 data 重新分配新内存空间,将动态类型变量的值复制到这块内存空间,并将 data 指针指向这块内存空间。因此我们多数情况下看到的 data 指针值都是不同的。

由于 eface 和 iface 是 runtime 包中的非导出结构体定义,我们不能直接在包外使用,所以也就无法直接访问到两个结构体中的数据。不过,Go 语言提供了 println 预定义函数,可以用来输出 eface 或 iface 的两个指针字段的值。在编译阶段,编译器会根据要输出的参数的类型将 println 替换为特定的函数,这些函数都定义在$GOROOT/src/runtime/print.go文件中,而针对 eface 和 iface 类型的打印函数实现如下:

// $GOROOT/src/runtime/print.go
func printeface(e eface) {
    print("(", e._type, ",", e.data, ")")
}

func printiface(i iface) {
    print("(", i.tab, ",", i.data, ")")
}

反射

Golang 中反射的应用与理解反射,就是能够在运行时更新变量和检查变量的值、调用变量的方法和变量支持的内在操作,而不需要在编译时就知道这些变量的具体类型。这种机制被称为反射。Golang 的基础类型是静态的(也就是指定 int、string 这些的变量,它的 type 是 static type),在创建变量的时候就已经确定,反射主要与 Golang 的 interface 类型相关(它的 type 是 concrete type),只有运行时 interface 类型才有反射一说。当程序运行时, 我们获取到一个 interface 变量, 程序应该如何知道当前变量的类型,和当前变量的值呢?当然我们可以有预先定义好的指定类型, 但是如果有一个场景是我们需要编写一个函数,能够处理一类共性逻辑的场景,但是输入类型很多,或者根本不知道接收参数的类型是什么,或者可能是没约定好;也可能是传入的类型很多,这些类型并不能统一表示。这时反射就会用的上了,典型的例子如:json.Marshal。在 Golang 中为我们提供了两个方法,分别是 reflect.ValueOf 和 reflect.TypeOf,见名知意这两个方法分别能帮我们获取到对象的值和类型。Valueof 返回的是 Reflect.Value 对象,是一个 struct,而 typeof 返回的是 Reflect.Type 是一个接口。我们只需要简单的使用这两个进行组合就可以完成多种功能。

深度解密GO语言之反射反射的本质是程序在运行期探知对象的类型信息和内存结构(泛化一点说,就是我想知道某个指针对应的内存里有点什么),不用反射能行吗?可以的!使用汇编语言,直接和内层打交道,什么信息不能获取?但是,当编程迁移到高级语言上来之后,就不行了!就只能通过反射来达到此项技能。

reflect 包里定义了一个接口reflect.Type和一个结构体reflect.Value,它们提供很多函数来获取存储在接口里的类型信息,反射包中的所有方法基本都是围绕着 Type 和 Value 这两个类型设计的。reflect.Type 主要提供关于类型相关的信息,所以它和 _type 关联比较紧密; reflect.Value 则结合 _type 和 data 两者,因此程序员可以获取甚至改变类型的值。

TypeOf

TypeOf 函数用来提取一个接口中值的类型信息。由于它的输入参数是一个空的 interface{},调用此函数时,实参会先被转化为 interface{} 类型。这样,实参的类型信息、方法集、值信息都存储到 interface{} 变量里了。

func TypeOf(i interface{}) Type{
    eface := *(*emptyInterface)(unsafe.Pointer(&i))
    return toType(eface.typ)
}
func toType(t *rtype) Type {
	if t == nil {
		return nil
	}
	return t
}

ValueOf

reflect.Value 表示 interface{} 里存储的实际变量,它能提供实际变量的各种信息。相关的方法常常是需要结合类型信息和值信息。例如,如果要提取一个结构体的字段信息,那就需要用到 _type (具体到这里是指 structType) 类型持有的关于结构体的字段信息、偏移信息,以及 *data 所指向的内容 —— 结构体的实际值。

func ValueOf(i interface{}) Value {
	if i == nil {
		return Value{}
	}
	escapes(i)
	return unpackEface(i)
}
func unpackEface(i interface{}) Value {
	e := (*emptyInterface)(unsafe.Pointer(&i))
	t := e.typ
	if t == nil {
		return Value{}
	}
	f := flag(t.Kind())
	if ifaceIndir(t) {
		f |= flagIndir
	}
	return Value{t, e.word, f}
}

通过 Type() 方法和 Interface() 方法可以打通 interface、 Type、 Value 三者。Type() 方法也可以返回变量的类型信息,与 reflect.TypeOf() 函数等价。Interface() 方法可以将 Value 还原成原来的 interface。

  1. 按名字访问结构的成员 reflect.ValueOf(e).FieldByName("Name")
  2. 按名字访问结构的方法 reflect.ValueOf(e).methodByName("updateAge").Call(args)

三大定律

反射建立在类型系统之上,以java 视角来表述的话,反射为程序提供了部分操作 jvm 数据的能力。

  1. Reflection goes from interface value to reflection object. 我们能将 Go 语言的 interface{} 变量转换成反射对象。为什么是从 interface{} 变量到反射对象?当我们执行 reflect.ValueOf(1) 时,虽然看起来是获取了基本类型 int 对应的反射类型,但是由于 reflect.TypeOfreflect.ValueOf 两个方法的入参都是 interface{} 类型,所以在方法执行的过程中发生了类型转换。
  2. Reflection goes from reflection object to interface value. 我们可以从反射对象可以获取 interface{} 变量(Interface() 方法)。
  3. To modify a reflection object, the value must be settable.如果需要操作一个反射变量,那么它必须是可设置的。PS: 可设置 ==> 可以找到原变量地址 ==> go 是值传递 ==> reflect.ValueOf(引用) 反射变量 Value 必须要 hold 住原变量的地址才行

与java 对比

hotspot 内部c++对java 对象的表示

java中的反射,设计思路是,先类型后值。意思是,无论如何,都是先找到属性和方法的描述,然后根据描述来获取属性的值、调用方法的执行。要进行这样的操作,入口都是由类的描述开始。

Class cls = obj.getClass(); 
Constructor constructor = cls.getConstructor(); 
Method[] methods = cls.getDeclaredFields();

golang设计思路为,值和类型划分的非常清晰,两条腿走路。Go 没有类的概念,并且结构体只包含了已声明的字段。因此,我们需要借助“reflection”包来获得所需的信息

  java go
获取对象的类型/表示 getClass() objType := reflect.TypeOf(obj)
获取对象的值/表示 不支持 objValue := reflect.ValueOf(obj)
获取属性描述 getClass().getField("fieldName") objType.Field(index)
获取属性的值 field.get(obj) objValue.Filed(index).Interface()
获取方法的描述 getClass().getMethod("methodName") objType.Method(index)
方法调用 method.invoke(obj, args) objValue.Method(index).Call(args)

在java中,通过类的描述,来获得method,由于该method是属于类级别的,所以,调用时,需要传入参数obj和args;而golang中,method是对象级别的,所以,调用时,不需要参数obj,只需要args。

其它

我们经常看到结构体字段后面,会跟一个反引号括起来的键值对字符串,格式是:key:"value",并且可以使用多个,中间用空格隔开,信息内容是任意定义的。这种语法在Golang中叫做标签Tag,类似其他语言中的注解(Annotation),可以通过Golang的反射机制(reflect.StructTag)来解析。