0
  • 聊天消息
  • 系统消息
  • 评论与回复
登录后你可以
  • 下载海量资料
  • 学习在线课程
  • 观看技术视频
  • 写文章/发帖/加入社区
会员中心
创作中心

完善资料让更多小伙伴认识你,还能领取20积分哦,立即完善>

3天内不再提示

GoF设计模式之迭代器模式

元闰子的邀请 来源:元闰子的邀请 作者:元闰子的邀请 2022-08-01 11:22 次阅读

上一篇:【Go实现】实践GoF的23种设计模式:观察者模式

简单的分布式应用系统(示例代码工程):https://github.com/ruanrunxue/Practice-Design-Pattern--Go-Implementation

简介

有时会遇到这样的需求,开发一个模块,用于保存对象;不能用简单的数组、列表,得是红黑树、跳表等较为复杂的数据结构;有时为了提升存储效率或持久化,还得将对象序列化;但必须给客户端提供一个易用的 API允许方便地、多种方式地遍历对象,丝毫不察觉背后的数据结构有多复杂。

346ff082-1143-11ed-ba43-dac502259ad0.jpg

对这样的 API,很适合使用迭代器模式Iterator Pattern)实现。

GoF 对 迭代器模式 的定义如下:

Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

从描述可知,迭代器模式主要用在访问对象集合的场景,能够向客户端隐藏集合的实现细节

Java 的 Collection 家族、C++ 的 STL 标准库,都是使用迭代器模式的典范,它们为客户端提供了简单易用的 API,并且能够根据业务需要实现自己的迭代器,具备很好的可扩展性。

UML 结构

34994266-1143-11ed-ba43-dac502259ad0.jpg

场景上下文

在简单的分布式应用系统(示例代码工程)中,db 模块用来存储服务注册和监控信息,它的主要接口如下:

//demo/db/db.go
packagedb
//Db数据库抽象接口
typeDbinterface{
CreateTable(t*Table)error
CreateTableIfNotExist(t*Table)error
DeleteTable(tableNamestring)error

Query(tableNamestring,primaryKeyinterface{},resultinterface{})error
Insert(tableNamestring,primaryKeyinterface{},recordinterface{})error
Update(tableNamestring,primaryKeyinterface{},recordinterface{})error
Delete(tableNamestring,primaryKeyinterface{})error

...
}

从增删查改接口可以看出,它是一个 key-value 数据库,另外,为了提供类似关系型数据库的按列查询能力,我们又抽象出Table对象:

//demo/db/table.go
packagedb
//Table数据表定义
typeTablestruct{
namestring
recordTypereflect.Type
recordsmap[interface{}]record
}

其中,Table底层用map存储对象数据,但并没有存储对象本身,而是从对象转换而成的recordrecord的实现原理是利用反射机制,将对象的属性名 field 和属性值 value 分开存储,以此支持按列查询能力(一类对象可以类比为一张表):

//demo/db/record.go
packagedb

typerecordstruct{
primaryKeyinterface{}
fieldsmap[string]int//key为属性名,value属性值的索引
values[]interface{}//存储属性值
}
//从对象转换成record
funcrecordFrom(keyinterface{},valueinterface{})(rrecord,eerror){
...//异常处理
vType:=reflect.TypeOf(value)
vVal:=reflect.ValueOf(value)
ifvVal.Type().Kind()==reflect.Pointer{
vType=vType.Elem()
vVal=vVal.Elem()
}
record:=record{
primaryKey:key,
fields:make(map[string]int,vVal.NumField()),
values:make([]interface{},vVal.NumField()),
}
fori:=0;i< vVal.NumField(); i++ {
        fieldType := vType.Field(i)
        fieldVal := vVal.Field(i)
        name := strings.ToLower(fieldType.Name)
        record.fields[name] = i
        record.values[i] = fieldVal.Interface()
    }
    returnrecord,nil
}

当然,客户端并不会察觉 db 模块背后的复杂机制,它们直接使用的仍是对象:

typetestRegionstruct{
Idint
Namestring
}
funcclient(){
mdb:=db.MemoryDbInstance()
tableName:="testRegion"
table:=NewTable(tableName).WithType(reflect.TypeOf(new(testRegion)))
mdb.CreateTable(table)
mdb.Insert(tableName,"region1",&testRegion{Id:0,Name:"region-1"})
result:=new(testRegion)
mdb.Query(tableName,"region1",result)
}
34ad92b6-1143-11ed-ba43-dac502259ad0.jpg

另外,除了上述按 Key 查询接口,我们还想提供全表查询接口,有随机和有序 2 种表记录遍历方式,并且支持客户端自己扩展遍历方式。下面使用迭代器模式来实现该需求。

代码实现

这里并没有按照标准的 UML 结构去实现,而是结合工厂方法模式来解决公共代码的复用问题:

34c41cc0-1143-11ed-ba43-dac502259ad0.jpg
//demo/db/table_iterator.go
packagedb

//关键点1:定义迭代器抽象接口,允许后续客户端扩展遍历方式
//TableIterator表迭代器接口
typeTableIteratorinterface{
HasNext()bool
Next(nextinterface{})error
}

//关键点2:定义迭代器接口的实现
//tableIteratorImpl迭代器接口公共实现类
typetableIteratorImplstruct{
//关键点3:定义一个集合存储待遍历的记录,这里的记录已经排序好或者随机打散
records[]record
//关键点4:定义一个cursor游标记录当前遍历的位置
cursorint
}

//关键点5:在HasNext函数中的判断是否已经遍历完所有记录
func(r*tableIteratorImpl)HasNext()bool{
returnr.cursor< len(r.records)
}

//关键点6:在Next函数中取出下一个记录,并转换成客户端期望的对象类型,记得增加cursor
func(r*tableIteratorImpl)Next(nextinterface{})error{
record:=r.records[r.cursor]
r.cursor++
iferr:=record.convertByValue(next);err!=nil{
returnerr
}
returnnil
}

//关键点7:通过工厂方法模式,完成不同类型的迭代器对象创建
//TableIteratorFactory表迭代器工厂
typeTableIteratorFactoryinterface{
Create(table*Table)TableIterator
}

//随机迭代器
typerandomTableIteratorFactorystruct{}
func(r*randomTableIteratorFactory)Create(table*Table)TableIterator{
varrecords[]record
for_,r:=rangetable.records{
records=append(records,r)
}
rand.Seed(time.Now().UnixNano())
rand.Shuffle(len(records),func(i,jint){
records[i],records[j]=records[j],records[i]
})
return&tableIteratorImpl{
records:records,
cursor:0,
}
}

//有序迭代器
//Comparator如果i
typeComparatorfunc(i,jinterface{})bool
//sortedTableIteratorFactory根据主键进行排序,排序逻辑由Comparator定义
typesortedTableIteratorFactorystruct{
comparatorComparator
}
func(s*sortedTableIteratorFactory)Create(table*Table)TableIterator{
varrecords[]record
for_,r:=rangetable.records{
records=append(records,r)
}
sort.Sort(newRecords(records,s.comparator))
return&tableIteratorImpl{
records:records,
cursor:0,
}
}

最后,为Table对象引入TableIterator

//demo/db/table.go

//Table数据表定义
typeTablestruct{
namestring
recordTypereflect.Type
recordsmap[interface{}]record
//关键点8:持有迭代器工厂方法接口
iteratorFactoryTableIteratorFactory//默认使用随机迭代器
}
//关键点9:定义Setter方法,提供迭代器工厂的依赖注入
func(t*Table)WithTableIteratorFactory(iteratorFactoryTableIteratorFactory)*Table{
t.iteratorFactory=iteratorFactory
returnt
}
//关键点10:定义创建迭代器的接口,其中调用迭代器工厂完成实例化
func(t*Table)Iterator()TableIterator{
returnt.iteratorFactory.Create(t)
}

客户端这样使用:

funcclient(){
table:=NewTable("testRegion").WithType(reflect.TypeOf(new(testRegion))).
WithTableIteratorFactory(NewSortedTableIteratorFactory(regionIdComparator))
iter:=table.Iterator()
foriter.HashNext(){
next:=new(testRegion)
err:=iter.Next(next)
...
}
}

总结实现迭代器模式的几个关键点:

  1. 定义迭代器抽象接口,目的是提供客户端自扩展能力,通常包含HashNext()Next()两个方法,上述例子为TableIterator
  2. 定义迭代器接口的实现类,上述例子为tableIteratorImpl,这里主要起到了 Java/C++ 等带继承特性语言中,基类的作用,目的是复用代码。
  3. 在实现类中持有待遍历的记录集合,通常是已经排序好或随机打散后的,上述例子为tableIteratorImpl.records
  4. 在实现类中持有游标值,记录当前遍历的位置,上述例子为tableIteratorImpl.cursor
  5. HashNext()方法中判断是否已经遍历完所有记录。
  6. Next()方法中取出下一个记录,并转换成客户端期望的对象类型,取完后增加游标值。
  7. 通过工厂方法模式,完成不同类型的迭代器对象创建,上述例子为TableIteratorFactory接口,以及它的实现,randomTableIteratorFactorysortedTableIteratorFactory
  8. 在待遍历的对象中,持有迭代器工厂方法接口,上述例子为Table.iteratorFactory
  9. 为对象定义 Setter 方法,提供迭代器工厂的依赖注入,上述例子为Table.WithTableIteratorFactory()方法。
  10. 为对象定义创建迭代器的接口,上述例子为Table.Iterator()方法。

其中,7~9 步是结合工厂方法模式实现时的特有步骤,如果你的迭代器实现中没有用到工厂方法模式,可以省略这几步。

扩展

Go 风格的实现

前面的实现,是典型的面向对象风格,下面以随机迭代器为例,给出一个 Go 风格的实现:

//demo/db/table_iterator_closure.go
packagedb

//关键点1:定义HasNext和Next函数类型
typeHasNextfunc()bool
typeNextfunc(interface{})error

//关键点2:定义创建迭代器的方法,返回HashNext和Next函数
func(t*Table)ClosureIterator()(HasNext,Next){
varrecords[]record
for_,r:=ranget.records{
records=append(records,r)
}
rand.Seed(time.Now().UnixNano())
rand.Shuffle(len(records),func(i,jint){
records[i],records[j]=records[j],records[i]
})
size:=len(records)
cursor:=0
//关键点3:在迭代器创建方法定义HasNext和Next的实现逻辑
hasNext:=func()bool{
returncursor< size
    }
    next := func(nextinterface{})error{
record:=records[cursor]
cursor++
iferr:=record.convertByValue(next);err!=nil{
returnerr
}
returnnil
}
returnhasNext,next
}

客户端这样用:

funcclient(){
table:=NewTable("testRegion").WithType(reflect.TypeOf(new(testRegion))).
WithTableIteratorFactory(NewSortedTableIteratorFactory(regionIdComparator))
hasNext,next:=table.ClosureIterator()
forhasNext(){
result:=new(testRegion)
err:=next(result)
...
}
}

Go 风格的实现,利用了函数闭包的特点,把原本在迭代器实现的逻辑,放到了迭代器创建方法上。相比面向对象风格,省掉了迭代器抽象接口和实现对象的定义,看起来更加的简洁。

总结几个实现关键点:

  1. 声明HashNextNext的函数类型,等同于迭代器抽象接口的作用。
  2. 定义迭代器创建方法,返回类型为HashNextNext,上述例子为ClosureIterator()方法。
  3. 在迭代器创建方法内,定义HasNextNext的具体实现,利用函数闭包来传递状态(recordscursor)。

基于 channel 的实现

我们还能基于 Go 语言中的 channel 来实现迭代器模式,因为前文的 db 模块应用场景并不适用,所以另举一个简单的例子:

typeRecordint

func(r*Record)doSomething(){
//...
}

typeComplexCollectionstruct{
records[]Record
}

//关键点1:定义迭代器创建方法,返回只能接收的channel类型
func(c*ComplexCollection)Iterator()<-chanRecord{
//关键点2:创建一个无缓冲的channel
ch:=make(chanRecord)
//关键点3:另起一个goroutine往channel写入记录,如果接收端还没开始接收,会阻塞住
gofunc(){
for_,record:=rangec.records{
ch<- record
        }
    //关键点4:写完后,关闭channel
close(ch)
}()
returnch
}

客户端这样使用:

funcclient(){
collection:=NewComplexCollection()
//关键点5:使用时,直接通过for-range来遍历channel读取记录
forrecord:=rangecollection.Iterator(){
record.doSomething()
}
}

总结实现基于 channel 的迭代器模式的几个关键点:

  1. 定义迭代器创建方法,返回一个只能接收的 channel。
  2. 在迭代器创建方法中,定义一个无缓冲的 channel。
  3. 另起一个 goroutine 往 channel 中写入记录。如果接收端没有接收,会阻塞住。
  4. 写完后,关闭 channel。
  5. 客户端使用时,直接通过 for-range 遍历 channel 读取记录即可。

带有 callback 函数的实现

还可以在创建迭代器时,传入一个 callback 函数,在迭代器返回记录前,先调用 callback 函数对记录进行一些操作。

比如,在基于 channel 的实现例子中,可以增加一个 callback 函数,将每个记录打印出来:

//关键点1:声明callback函数类型,以Record作为入参
typeCallbackfunc(record*Record)
//关键点2:定义具体的callback函数
funcPrintRecord(record*Record){
fmt.Printf("%+v
",record)
}
//关键点3:定义以callback函数作为入参的迭代器创建方法
func(c*ComplexCollection)Iterator(callbackCallback)<-chanRecord{
ch:=make(chanRecord)
gofunc(){
for_,record:=rangec.records{
//关键点4:遍历记录时,调用callback函数作用在每条记录上
callback(&record)
ch<- record
        }
        close(ch)
}()
returnch
}

funcclient(){
collection:=NewComplexCollection()
//关键点5:创建迭代器时,传入具体的callback函数
forrecord:=rangecollection.Iterator(PrintRecord){
record.doSomething()
}
}

总结实现带有 callback 的迭代器模式的几个关键点:

  1. 声明 callback 函数类型,以 Record 作为入参。
  2. 定义具体的 callback 函数,比如上述例子中打印记录的PrintRecord函数。
  3. 定义迭代器创建方法,以 callback 函数作为入参。
  4. 迭代器内,遍历记录时,调用 callback 函数作用在每条记录上。
  5. 客户端创建迭代器时,传入具体的 callback 函数。

典型应用场景

  • 对象集合/存储类模块,并希望向客户端隐藏模块背后的复杂数据结构。

  • 希望支持客户端自扩展多种遍历方式。

优缺点

优点

  • 隐藏模块背后复杂的实现机制,为客户端提供一个简单易用的接口

  • 支持扩展多种遍历方式,具备较强的可扩展性,符合开闭原则

  • 遍历算法和数据存储分离,符合单一职责原则

缺点

  • 容易滥用,比如给简单的集合类型实现迭代器接口,反而使代码更复杂。
  • 相比于直接遍历集合,迭代器效率要更低一些,因为涉及到更多对象的创建,以及可能的对象拷贝。
  • 需要时刻注意在迭代器遍历过程中,由原始集合发生变更引发的并发问题。一种解决方法是,在创建迭代器时,拷贝一份原始数据(TableIterator就这么实现),但存在效率低、内存占用大的问题。

与其他模式的关联

迭代器模式通常会与工厂方法模式一起使用,如前文实现。

文章配图

可以在用Keynote画出手绘风格的配图中找到文章的绘图方法。

审核编辑:汤梓红


声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容侵权或者其他违规问题,请联系本站处理。 举报投诉
  • 设计模式
    +关注

    关注

    0

    文章

    53

    浏览量

    8620
  • 迭代器
    +关注

    关注

    0

    文章

    43

    浏览量

    4296

原文标题:【Go实现】实践GoF的23种设计模式:迭代器模式

文章出处:【微信号:yuanrunzi,微信公众号:元闰子的邀请】欢迎添加关注!文章转载请注明出处。

收藏 人收藏

    评论

    相关推荐

    谈谈Python 中的迭代模式

    年,Design Patterns - Elements of Reusable Object-Oriented Software)中,它提出了23种设计模式迭代模式就是其中的一种
    发表于 11-23 13:10 772次阅读
    谈谈Python 中的<b class='flag-5'>迭代</b><b class='flag-5'>器</b><b class='flag-5'>模式</b>

    关于国产MCU GOF32F103C8T6 软硬件通用

    GOF32F103X8和GOF32F103XB标准型MCU系列使用高性能的ARM Cortex-M3 32 位的RISC内核,工作频率为72MHz,内置高速存储(高达128K字节的闪存和20K字节
    发表于 04-19 09:50

    Command模式与动态语言

    Gof的设计模式中,有一个模式引起的争议比较大,有很多人甚至认为这个模式应该排除在OO模式之外,原因在于它不具有OO的特性
    发表于 06-22 10:20 981次阅读
    Command<b class='flag-5'>模式</b>与动态语言

    Modbus ASCII 模式通訊程序

    C语言编写的台达变频Modbus ASCII 模式通訊程序
    发表于 12-02 10:25 6次下载

    Proteus定时_计数0的CTC模式应用

    Proteus定时_计数0的CTC模式应用,很好的Proteus了,快来下载不学习吧。
    发表于 04-18 15:34 0次下载

    Proteus定时_计数0的快速PWM模式应用

    Proteus定时_计数0的快速PWM模式应用,很好的Proteus了,快来下载不学习吧
    发表于 04-18 15:34 0次下载

    Proteus定时_计数1的CTC模式应用

    Proteus定时_计数1的CTC模式应用,很好的Proteus了,快来下载不学习吧。
    发表于 04-18 15:34 0次下载

    Proteus定时_计数2的CTC模式应用

    Proteus定时_计数2的CTC模式应用,很好的Proteus了,快来下载不学习吧。
    发表于 04-18 15:34 0次下载

    算法与数据结构——迭代模式

    第三章为算法与数据结构,本文为3.4 迭代模式
    的头像 发表于 09-20 17:09 4904次阅读
    算法与数据结构——<b class='flag-5'>迭代</b><b class='flag-5'>器</b><b class='flag-5'>模式</b>

    嵌入式软件设计设计模式

    文章目录前言1.设计模式适配器模式2.设计模式单例模式3.设计
    发表于 10-21 11:07 9次下载
    嵌入式软件设计<b class='flag-5'>之</b>设计<b class='flag-5'>模式</b>

    GoF设计模式访问者模式

    访问者模式的目的是,解耦数据结构和算法,使得系统能够在不改变现有代码结构的基础上,为对象新增一种新的操作。
    的头像 发表于 10-08 11:05 657次阅读

    GoF设计模式代理模式

    它是一个使用率非常高的设计模式,在现实生活中,也是很常见。比如,演唱会门票黄牛。假设你需要看一场演唱会,但官网上门票已经售罄,于是就当天到现场通过黄牛高价买了一张。在这个例子中,黄牛就相当于演唱会门票的代理,在正式渠道无法购买门票的情况下,你通过代理完成了该目标。
    的头像 发表于 10-17 09:45 881次阅读

    迭代模式在UVM中的应用有哪些

    行为型设计模式数量较多,上一篇介绍了模板模式和策略模式,下面对迭代模式进行介绍,挖掘其在UVM中的应用。
    的头像 发表于 08-14 17:15 570次阅读
    <b class='flag-5'>迭代</b><b class='flag-5'>模式</b>在UVM中的应用有哪些

    实践GoF的23种设计模式:备忘录模式

    相对于代理模式、工厂模式等设计模式,备忘录模式(Memento)在我们日常开发中出镜率并不高,除了应用场景的限制之外,另一个原因,可能是备忘录模式
    的头像 发表于 11-25 09:05 503次阅读
    实践<b class='flag-5'>GoF</b>的23种设计<b class='flag-5'>模式</b>:备忘录<b class='flag-5'>模式</b>

    实践GoF的23种设计模式:解释模式

    解释模式(Interpreter Pattern)应该是 GoF 的 23 种设计模式中使用频率最少的一种了,它的应用场景较为局限。
    的头像 发表于 04-01 11:01 600次阅读
    实践<b class='flag-5'>GoF</b>的23种设计<b class='flag-5'>模式</b>:解释<b class='flag-5'>器</b><b class='flag-5'>模式</b>