缘起

最近阅读 [Spring Boot技术内幕: 架构设计与实现原理] (朱智胜 , 2020.6)
本系列笔记拟采用golang练习之
Talk is cheap, show me the code.

Spring

  1. Spring的主要特性：
  2. 1. 控制反转（Inversion of Control, IoC）
  3. 2. 面向容器
  4. 3. 面向切面（AspectOriented Programming, AOP）
  6. 源码gitee地址：
  7. https://gitee.com/ioly/learning.gooop
  9. 原文链接：
  10. https://my.oschina.net/ioly

目标

  • 参考spring boot常用注解，使用golang编写“基于注解的静态代码增强器/生成器”

子目标（Day 7）

  • 今天继续the hard part：struct/field/method元素的扫描
    • common/Tokens.go：添加数据类型的词法解析支持
    • scanner/IStructScanner.go: 结构体扫描器的接口及实现

common/Tokens.go

添加数据类型的词法解析支持：

  • 分别解析基本类型/自定义类型/指针类型/数组类型/map类型
  • 自定义类型需要注意排除’map’关键字
  • 指针，数组和map类型都是复合类型，需递归解析 ```go package common

import ( “regexp” “strings” “sync” )

type tTokens struct { cache map[string]regexp.Regexp rwmutex sync.RWMutex }

var Tokens = newTokensLib()

func newTokensLib() *tTokens { it := new(tTokens) it.init() return it }

func (me tTokens) init() { me.cache = make(map[string]regexp.Regexp) me.rwmutex = new(sync.RWMutex) }

func (me *tTokens) MatchString(s string, p string) bool { return strings.HasPrefix(s, p) }

func (me *tTokens) MatchRegexp(s string, p string) (bool, string) { me.rwmutex.RLock() r, ok := me.cache[p] me.rwmutex.RUnlock()

  1. if !ok {
  2.     me.rwmutex.Lock()
  3.     if r, ok = me.cache[p]; !ok {
  4.         r, _ = regexp.Compile(p)
  5.     }
  6.     me.rwmutex.Unlock()
  7. }
  9. if r == nil {
  10.     return false, ""
  11. }
  13. if !r.MatchString(s) {
  14.     return false, ""
  15. }
  17. return true, r.FindString(s)

}

func (me *tTokens) MatchIdentifier(s string) (bool, string) { return me.MatchRegexp(s, “^[_a-zA-Z]\w{0,99}”) }

func (me *tTokens) MatchSpaces(s string) (bool, string) { return me.MatchRegexp(s, “^\s+”) }

func (me tTokens) MatchDir(s string) (bool, string) { b, s := me.MatchRegexp(s, “^([a-zA-Z]\:)?([\\/][^\s/:?<>|\\”\\]+)+[\/]?”) if b { return b, s }

  1. b, s = me.MatchRegexp(s, "^\\\"([a-zA-Z]\\:)?([\\\\/][^/:*?<>|\\\"\\\\]+)+[\\/]?\\\"")
  2. if b {
  3.     return b, s
  4. }
  6. b, s = me.MatchRegexp(s, "^'([a-zA-Z]\\:)?([\\\\/][^'/:*?<>|\\\"\\\\]+)+[\\/]?'")
  7. if b {
  8.     return b, s
  9. }
  11. return false, ""

}

func (me *tTokens) MatchDataType(s string) (bool, string) { if ok,t := me.MatchBasicType(s);ok { return true, t }

  1. if ok,t := me.MatchCustomType(s);ok {
  2.     return true, t
  3. }
  5. if ok,t := me.MatchPointerType(s);ok {
  6.     return true, t
  7. }
  9. if ok,t := me.MatchArrayType(s);ok {
  10.     return true, t
  11. }
  13. if ok,t := me.MatchMapType(s);ok {
  14.     return true, t
  15. }
  17. return false, ""

}

func (me *tTokens) MatchBasicType(s string) (bool, string) { list := []string { “int”, “string”, “bool”, “byte”, “int32”, “int64”, “uint32”, “uint64”, “float32”, “float64”, “int8”, “uint8”, “int16”, “uint16”, “time.Time”, } for _,it := range list { if me.MatchString(s, it) { return true, it } }

  1. return false, ""

}

func (me *tTokens) MatchCustomType(s string) (bool, string) { t := s b1, s1 := me.MatchRegexp(t, ^\w+\.) if b1 { t = t[len(s1):] }

  1. b2, s2 := me.MatchRegexp(t, `^\w+`)
  2. if !b2 {
  3.     return false, ""
  4. }
  5. if s2 == "map" {
  6.     // map is reserved word
  7.     return false, ""
  8. }
  10. return true, s1 + s2

}

func (me tTokens) MatchPointerType(s string) (bool, string) { t := s if t[0] != ‘‘ { return false,”” } t = t[1:]

  1. b, s := me.MatchDataType(t)
  2. if !b {
  3.     return false, ""
  4. }
  6. return true, "*" + s

}

func (me tTokens) MatchArrayType(s string) (bool, string) { t := s b1, s1 := me.MatchRegexp(s, `^[\s\d\s]\s*`) if !b1 { return false, “” } t = t[len(s1):]

  1. b2, s2 := me.MatchDataType(t)
  2. if !b2 {
  3.     return false, ""
  4. }
  5. return true, s1 + s2

}

func (me *tTokens) MatchMapType(s string) (bool, string) { t := s s1 := “map” if !me.MatchString(t, s1) { return false, “” } t = t[len(s1):]

  1. b2, s2 := me.MatchRegexp(t, `^\s*\[\s*`)
  2. if !b2 {
  3.     return false, ""
  4. }
  5. t = t[len(s2):]
  7. b3,s3 := me.MatchDataType(t)
  8. if !b3 {
  9.     return false, ""
  10. }
  11. t = t[len(s3):]
  13. b4, s4 := me.MatchRegexp(t, `^\s*\]\s*`)
  14. if !b4 {
  15.     return false, ""
  16. }
  17. t = t[len(s4):]
  19. b5, s5 := me.MatchDataType(t)
  20. if !b5 {
  21.     return false, ""
  22. }
  24. return true, s1 + s2 + s3 + s4 + s5

}

  2. <a name="lREZ3"></a>
  3. # scanner/IStructScanner.go
  4. 结构体扫描器的接口及实现
  5. ```go
  6. package scanner
  8. import (
  9.     "errors"
  10.     "learning/gooop/spring/autogen/common"
  11.     "learning/gooop/spring/autogen/domain"
  12.     "regexp"
  13.     "strings"
  14. )
  16. type IStructScanner interface {
  17.     ScanStruct(file *domain.CodeFileInfo)
  18. }
  20. type tStructScanner int
  22. func (me *tStructScanner) ScanStruct(file *domain.CodeFileInfo) {
  23.     bInStruct := false
  24.     var stru *domain.StructInfo
  25.     for lineNO,line := range file.CleanLines {
  26.         if bInStruct {
  27.             // end?
  28.             if gStructEndRegexp.MatchString(line) {
  29.                 bInStruct = false
  31.                 me.scanMethod(stru, lineNO + 1)
  32.                 stru = nil
  33.                 continue
  34.             }
  35.         }
  37.         // start?
  38.         if gStructStartRegexp.MatchString(line) {
  39.             bInStruct = true
  40.             ss := gStructStartRegexp.FindAllString(line, -1)
  42.             stru := domain.NewStructInfo()
  43.             stru.LineNO = lineNO
  44.             stru.CodeFile = file
  45.             stru.Name = ss[1]
  46.             continue
  47.         }
  49.         // in struct block
  50.         ok,fname,ftype := me.scanField(line)
  51.         if ok {
  52.             stru.AppendField(lineNO, fname, ftype)
  53.         }
  54.     }
  55. }
  58. func (me *tStructScanner) scanField(line string) (ok bool, fldName string, fldType string) {
  59.     if !gFieldStartRegexp.MatchString(line) {
  60.         return false, "",""
  61.     }
  63.     fldName = strings.TrimSpace(gFieldStartRegexp.FindString(line))
  64.     fldType = strings.TrimSpace(line[len(fldName):])
  65.     return true, fldName, fldType
  66. }
  69. func (me *tStructScanner) scanMethod(stru *domain.StructInfo, fromLineNO int) {
  70.     for i,max := fromLineNO, len(stru.CodeFile.CleanLines);i <= max;i++ {
  71.         line := stru.CodeFile.CleanLines[i]
  72.         if !gMethodStartRegex.MatchString(line) {
  73.             continue
  74.         }
  77.         ss := gMethodStartRegex.FindAllString(line, -1)
  79.         // declare
  80.         declare := ss[0]
  81.         offset := len(declare)
  83.         // receiver
  84.         receiver := ss[1]
  85.         if receiver != stru.Name {
  86.             continue
  87.         }
  88.         method := domain.NewMethodInfo()
  90.         // name
  91.         method.Name = ss[2]
  93.         // method input args
  94.         e,args := me.scanMethodArgs(method, strings.TrimSpace(line[offset:]))
  95.         if e != nil {
  96.             panic(e)
  97.         }
  98.         offset += len(args)
  100.         // method return args
  101.         e = me.scanReturnArgs(method, strings.TrimSpace(line[offset:]))
  102.         if e != nil {
  103.             panic(e)
  104.         }
  106.         // end scan method
  107.         stru.AppendMethod(method)
  108.     }
  109. }
  111. func (me *tStructScanner) scanMethodArgs(method *domain.MethodInfo, s string) (error, string) {
  112.     t := s
  113.     offset := 0
  114.     for {
  115.         // name
  116.         b1, s1 := common.Tokens.MatchRegexp(t, `\w+(\s*,\s*\w+)\s+`)
  117.         if !b1 {
  118.             break
  119.         }
  120.         argNames := s1
  121.         offset += len(s1)
  122.         t = s[offset:]
  124.         // data type
  125.         b2, s2 := common.Tokens.MatchDataType(t)
  126.         if !b2 {
  127.             return gInvalidMethodArgs, ""
  128.         }
  129.         argDataType := s2
  130.         offset += len(s2)
  131.         t = s[offset:]
  133.         for _,it := range strings.Split(argNames, ",") {
  134.             method.AppendArgument(it, argDataType)
  135.         }
  137.         // ,\s+
  138.         b3, s3 := common.Tokens.MatchRegexp(t, `\s*,\s*`)
  139.         if !b3 {
  140.             break
  141.         }
  142.         offset += len(s3)
  143.         t = s[offset:]
  144.     }
  146.     return nil, s[0:offset]
  147. }
  149. func (me *tStructScanner) scanReturnArgs(method *domain.MethodInfo, s string) error {
  150.     // todo: fixme
  151.     panic("implements me")
  152. }
  155. var gStructStartRegexp = regexp.MustCompile(`^\s*type\s+(\w+)\s+struct\s+\{`)
  156. var gStructEndRegexp = regexp.MustCompile(`^\s*}`)
  157. var gFieldStartRegexp = regexp.MustCompile(`^\s*\w+\s+`)
  158. var gMethodStartRegex = regexp.MustCompile(`\s*func\s+\(\s*\w+\s+\*?(\w+)\s*\)\s+(\w+)\s*\(`)
  159. var gInvalidMethodArgs = errors.New("invalid method arguments")
  162. var DefaultStructScanner IStructScanner = new(tStructScanner)

（未完待续）