// demo/db/table.go
package db
// Table 数据表定义
type Table struct {
    name            string
    metadata        map[string]int // key为属性名，value属性值的索引, 对应到record上存储
    records         map[interface{}]record
 iteratorFactory TableIteratorFactory // 默认使用随机迭代器
}

// demo/db/table_visitor.go
package db
// 关键点1: 定义表查询的访问者抽象接口，允许后续扩展查询方式
type TableVisitor interface {
 // 关键点2: Visit方法以Element作为入参，这里的Element为Table对象
 Visit(table *Table) ([]interface{}, error)
}
// 关键点3: 定义Visitor抽象接口的实现对象，这里FieldEqVisitor实现按列等值查询逻辑
type FieldEqVisitor struct {
    field string
    value interface{}
}
// 关键点4: 为FieldEqVisitor定义Visit方法，实现具体的等值查询逻辑
func (f *FieldEqVisitor) Visit(table *Table) ([]interface{}, error) {
 result := make([]interface{}, 0)
 idx, ok := table.metadata[f.field]
 if !ok {
 return nil, ErrRecordNotFound
 }
 for _, r := range table.records {
 if reflect.DeepEqual(r.values[idx], f.value) {
            result = append(result, r)
 }
 }
 if len(result) == 0 {
 return nil, ErrRecordNotFound
 }
 return result, nil
}
func NewFieldEqVisitor(field string, value interface{}) *FieldEqVisitor {
 return &FieldEqVisitor{
        field: field,
        value: value,
 }
}
// demo/db/table.go
package db
type Table struct {...}
// 关键点5: 为Element定义Accept方法，入参为Visitor接口
func (t *Table) Accept(visitor TableVisitor) ([]interface{}, error) {
 return visitor.Visit(t)
}

func client() {
 table := NewTable("testRegion").WithType(reflect.TypeOf(new(testRegion)))
 table.Insert(1, &testRegion{Id: 1, Name: "beijing"})
 table.Insert(2, &testRegion{Id: 2, Name: "beijing"})
 table.Insert(3, &testRegion{Id: 3, Name: "guangdong"})
 visitor := NewFieldEqVisitor("name", "beijing")
    result, err := table.Accept(visitor)
 if err != nil {
 t.Error(err)
 }
 if len(result) != 2 {
 t.Errorf("visit failed, want 2, got %d", len(result))
 }
}

// demo/db/table_visitor_func.go
package db
// 关键点1: 定义一个访问者函数类型
type TableVisitorFunc func(table *Table) ([]interface{}, error)
// 关键点2: 定义工厂方法，工厂方法返回的是一个访问者函数，实现了具体的访问逻辑
func NewFieldEqVisitorFunc(field string, value interface{}) TableVisitorFunc {
 return func(table *Table) ([]interface{}, error) {
 result := make([]interface{}, 0)
 idx, ok := table.metadata[field]
 if !ok {
 return nil, ErrRecordNotFound
 }
 for _, r := range table.records {
 if reflect.DeepEqual(r.values[idx], value) {
                result = append(result, r)
 }
 }
 if len(result) == 0 {
 return nil, ErrRecordNotFound
 }
 return result, nil
 }
}
// 关键点3: 为Element定义Accept方法，入参为Visitor函数类型
func (t *Table) AcceptFunc(visitorFunc TableVisitorFunc) ([]interface{}, error) {
 return visitorFunc(t)
}

func client() {
 table := NewTable("testRegion").WithType(reflect.TypeOf(new(testRegion)))
 table.Insert(1, &testRegion{Id: 1, Name: "beijing"})
 table.Insert(2, &testRegion{Id: 2, Name: "beijing"})
 table.Insert(3, &testRegion{Id: 3, Name: "guangdong"})
    result, err := table.AcceptFunc(NewFieldEqVisitorFunc("name", "beijing"))
 if err != nil {
 t.Error(err)
 }
 if len(result) != 2 {
 t.Errorf("visit failed, want 2, got %d", len(result))
 }
}

// demo/service/registry/model/service_profile.go
package model
// ServiceProfileRecord 存储在数据库里的类型
type ServiceProfileRecord struct {
    Id       string // 服务ID
    Type     ServiceType // 服务类型
    Status   ServiceStatus // 服务状态
    Ip       string // 服务IP
    Port     int // 服务端口
 RegionId string // 服务所属regionId
    Priority int // 服务优先级，范围0～100，值越低，优先级越高
    Load     int // 服务负载，负载越高表示服务处理的业务压力越大
}

// demo/service/registry/model/service_profile.go
package model
type ServiceProfileVisitor struct {
 svcId string
 svcType ServiceType
}
func (s *ServiceProfileVisitor) Visit(table *db.Table) ([]interface{}, error) {
 var result []interface{}
 // 通过迭代器来遍历Table的所有数据
 iter := table.Iterator()
 for iter.HasNext() {
 profile := new(ServiceProfileRecord)
 if err := iter.Next(profile); err != nil {
 return nil, err
 }
 // 先匹配ServiceId，如果一致则无须匹配ServiceType
 if profile.Id != "" && profile.Id == s.svcId {
            result = append(result, profile)
 continue
 }
 // ServiceId匹配不上，再匹配ServiceType
 if profile.Type != "" && profile.Type == s.svcType {
            result = append(result, profile)
 }
 }
 return result, nil
}