实践 GoF 的设计模式：迭代器模式

// demo/db/db.gopackage db// Db 数据库抽象接口type Db interface { CreateTable(t *Table) error CreateTableIfNotExist(t *Table) error DeleteTable(tableName string) error Query(tableName string, primaryKey interface{}, result interface{}) error Insert(tableName string, primaryKey interface{}, record interface{}) error Update(tableName string, primaryKey interface{}, record interface{}) error Delete(tableName string, primaryKey interface{}) error ...}

// demo/db/table.gopackage db// Table 数据表定义type Table struct {    name            string recordType reflect.Type    records         map[interface{}]record}

// demo/db/record.gopackage dbtype record struct { primaryKey interface{}    fields     map[string]int // key为属性名，value属性值的索引    values     []interface{} // 存储属性值}// 从对象转换成recordfunc recordFrom(key interface{}, value interface{}) (r record, e error) { ... // 异常处理 vType := reflect.TypeOf(value) vVal := reflect.ValueOf(value) if vVal.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()), } for i := 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() } return record, nil}

type testRegion struct {    Id   int    Name string}func client() { 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)}

// demo/db/table_iterator.gopackage db// 关键点1: 定义迭代器抽象接口，允许后续客户端扩展遍历方式// TableIterator 表迭代器接口type TableIterator interface { HasNext() bool Next(next interface{}) error}// 关键点2: 定义迭代器接口的实现// tableIteratorImpl 迭代器接口公共实现类type tableIteratorImpl struct { // 关键点3: 定义一个集合存储待遍历的记录，这里的记录已经排序好或者随机打散    records []record // 关键点4: 定义一个cursor游标记录当前遍历的位置 cursor  int}// 关键点5: 在HasNext函数中的判断是否已经遍历完所有记录func (r *tableIteratorImpl) HasNext() bool { return r.cursor < len(r.records)}// 关键点6: 在Next函数中取出下一个记录，并转换成客户端期望的对象类型，记得增加cursorfunc (r *tableIteratorImpl) Next(next interface{}) error { record := r.records[r.cursor] r.cursor++ if err := record.convertByValue(next); err != nil { return err } return nil}// 关键点7: 通过工厂方法模式，完成不同类型的迭代器对象创建// TableIteratorFactory 表迭代器工厂type TableIteratorFactory interface { Create(table *Table) TableIterator}// 随机迭代器type randomTableIteratorFactory struct{}func (r *randomTableIteratorFactory) Create(table *Table) TableIterator { var records []record for _, r := range table.records {        records = append(records, r) } rand.Seed(time.Now().UnixNano()) rand.Shuffle(len(records), func(i, j int) {        records[i], records[j] = records[j], records[i] }) return &tableIteratorImpl{        records: records,        cursor: 0, }}// 有序迭代器// Comparator 如果i<j返回true，否则返回falsetype Comparator func(i, j interface{}) bool// sortedTableIteratorFactory 根据主键进行排序，排序逻辑由Comparator定义type sortedTableIteratorFactory struct {    comparator Comparator}func (s *sortedTableIteratorFactory) Create(table *Table) TableIterator { var records []record for _, r := range table.records {        records = append(records, r) } sort.Sort(newRecords(records, s.comparator)) return &tableIteratorImpl{        records: records,        cursor: 0, }}

// demo/db/table.go// Table 数据表定义type Table struct {    name            string recordType reflect.Type    records         map[interface{}]record // 关键点8: 持有迭代器工厂方法接口 iteratorFactory TableIteratorFactory // 默认使用随机迭代器}// 关键点9: 定义Setter方法，提供迭代器工厂的依赖注入func (t *Table) WithTableIteratorFactory(iteratorFactory TableIteratorFactory) *Table { t.iteratorFactory = iteratorFactory return t}// 关键点10: 定义创建迭代器的接口，其中调用迭代器工厂完成实例化func (t *Table) Iterator() TableIterator { return t.iteratorFactory.Create(t)}

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

// demo/db/table_iterator_closure.gopackage db// 关键点1: 定义HasNext和Next函数类型type HasNext func() booltype Next func(interface{}) error// 关键点2: 定义创建迭代器的方法，返回HashNext和Next函数func (t *Table) ClosureIterator() (HasNext, Next) { var records []record for _, r := range t.records {        records = append(records, r) } rand.Seed(time.Now().UnixNano()) rand.Shuffle(len(records), func(i, j int) {        records[i], records[j] = records[j], records[i] }) size := len(records) cursor := 0 // 关键点3: 在迭代器创建方法定义HasNext和Next的实现逻辑 hasNext := func() bool { return cursor < size } next := func(next interface{}) error { record := records[cursor]        cursor++ if err := record.convertByValue(next); err != nil { return err } return nil } return hasNext, next}

func client() { table := NewTable("testRegion").WithType(reflect.TypeOf(new(testRegion))). WithTableIteratorFactory(NewSortedTableIteratorFactory(regionIdComparator)) hasNext, next := table.ClosureIterator() for hasNext() { result := new(testRegion) err := next(result) ...  }}复制

type Record intfunc (r *Record) doSomething() { // ...}type ComplexCollection struct {    records []Record}// 关键点1: 定义迭代器创建方法，返回只能接收的channel类型func (c *ComplexCollection) Iterator() <-chan Record { // 关键点2: 创建一个无缓冲的channel ch := make(chan Record) // 关键点3: 另起一个goroutine往channel写入记录，如果接收端还没开始接收，会阻塞住 go func() { for _, record := range c.records { ch <- record } // 关键点4: 写完后，关闭channel close(ch) }() return ch}

func client() { collection := NewComplexCollection() // 关键点5: 使用时，直接通过for-range来遍历channel读取记录 for record := range collection.Iterator() { record.doSomething() }}复制

// 关键点1: 声明callback函数类型，以Record作为入参
type Callback func(record *Record)
//关键点2: 定义具体的callback函数
func PrintRecord(record *Record) {
fmt.Printf("%+v\n", record)
}
// 关键点3: 定义以callback函数作为入参的迭代器创建方法
func (c *ComplexCollection) Iterator(callback Callback) <-chan Record {
ch := make(chan Record)
go func() {
for _, record := range c.records {
// 关键点4: 遍历记录时，调用callback函数作用在每条记录上
callback(&record)
ch <- record
}
close(ch)
}()
return ch
}
func client() {
collection := NewComplexCollection()
// 关键点5: 创建迭代器时，传入具体的callback函数
for record := range collection.Iterator(PrintRecord) {
record.doSomething()
}
}