缘起

最近阅读 [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 9）

  • struct解析清楚了，接着解析注解就比较容易了
    • scanner/IStructScanner.go：修复scanMethod()和scanAnnotation()的细节问题
    • scanner/IAnnotationScanner.go：注解扫描接口及默认实现。注解的属性支持双引号和重音号字符串。
    • scanner/IAnnotationScanner_test.go：针对注解信息的单元测试

scanner/IAnnotationScanner.go

注解扫描接口及默认实现。注解的属性支持双引号和重音号字符串。

  1. package scanner
  3. import (
  4.     "errors"
  5.     "learning/gooop/spring/autogen/common"
  6.     "learning/gooop/spring/autogen/domain"
  7.     "regexp"
  8.     "strings"
  9. )
  11. type IAnnotationScanner interface {
  12.     ScanAnnotations(s *domain.StructInfo)
  13. }
  15. type tAnnotationScanner int
  17. func (me *tAnnotationScanner) ScanAnnotations(s *domain.StructInfo) {
  18.     me.scanStructAnnotation(s)
  19.     me.scanFieldAnnotation(s)
  20.     me.scanMethodAnnotation(s)
  21. }
  23. func (me *tAnnotationScanner) scanStructAnnotation(s *domain.StructInfo) {
  24.     for i := s.LineNO - 1; i >= 0; i-- {
  25.         if !me.matchAnnotation(s, i) {
  26.             break
  27.         }
  29.         code := s.CodeFile.RawLines[i]
  30.         e, a := me.parseAnnotation(code)
  31.         if e != nil {
  32.             panic(e)
  33.         }
  34.         s.AppendAnnotation(a)
  35.     }
  36. }
  38. func (me *tAnnotationScanner) scanFieldAnnotation(s *domain.StructInfo) {
  39.     for _, fld := range s.Fields {
  40.         for i := fld.LineNO - 1; i >= 0; i-- {
  41.             if !me.matchAnnotation(s, i) {
  42.                 break
  43.             }
  45.             code := s.CodeFile.RawLines[i]
  46.             e, a := me.parseAnnotation(code)
  47.             if e != nil {
  48.                 panic(e)
  49.             }
  50.             fld.AppendAnnotation(a)
  51.         }
  52.     }
  53. }
  55. func (me *tAnnotationScanner) scanMethodAnnotation(s *domain.StructInfo) {
  56.     for _, method := range s.Methods {
  57.         for i := method.LineNO - 1; i >= 0; i-- {
  58.             if !me.matchAnnotation(s, i) {
  59.                 break
  60.             }
  62.             code := s.CodeFile.RawLines[i]
  63.             e, a := me.parseAnnotation(code)
  64.             if e != nil {
  65.                 panic(e)
  66.             }
  67.             method.AppendAnnotation(a)
  68.         }
  69.     }
  70. }
  72. func (me *tAnnotationScanner) matchAnnotation(s *domain.StructInfo, lineNO int) bool {
  73.     line := s.CodeFile.RawLines[lineNO]
  74.     return gAnnotationStartRegexp.MatchString(line)
  75. }
  77. func (me *tAnnotationScanner) parseAnnotation(line string) (error, *domain.AnnotationInfo) {
  78.     ss := gAnnotationStartRegexp.FindStringSubmatch(line)
  79.     if len(ss) <= 0 {
  80.         return nil, nil
  81.     }
  82.     a := domain.NewAnnotationInfo()
  84.     // name
  85.     declare := ss[0]
  86.     a.Name = ss[1]
  88.     // properties
  89.     t := line[len(declare):]
  90.     for {
  91.         // space*
  92.         b1, s1 := common.Tokens.MatchSpaces(t)
  93.         if b1 {
  94.             t = t[len(s1):]
  95.         }
  97.         // key
  98.         b2, s2 := common.Tokens.MatchIdentifier(t)
  99.         if !b2 {
  100.             break
  101.         }
  102.         t = t[len(s2):]
  104.         // =
  105.         b31, s31 := common.Tokens.MatchSpaces(t)
  106.         if b31 {
  107.             t = t[len(s31):]
  108.         }
  109.         b32 := common.Tokens.MatchString(t, "=")
  110.         if !b32 {
  111.             return errors.New("expecting ="), nil
  112.         } else {
  113.             t = t[1:]
  114.         }
  115.         b33, s33 := common.Tokens.MatchSpaces(t)
  116.         if b33 {
  117.             t = t[len(s33):]
  118.         }
  120.         // value
  121.         b4, s4, i4 := me.parsePropertyValue(t)
  122.         if !b4 {
  123.             return errors.New("expecting attribute value"), nil
  124.         } else {
  125.             t = t[i4:]
  126.             a.AppendAttribute(s2, s4)
  127.         }
  128.     }
  130.     return nil, a
  131. }
  133. func (me *tAnnotationScanner) parsePropertyValue(s string) (bool, string, int) {
  134.     // quoted string by ""
  135.     b2, s2 := common.Tokens.MatchRegexp(s, `^"((\\")|[^"])*"`)
  136.     if b2 {
  137.         return true, me.removeDoubleQuote(s2), len(s2)
  138.     }
  140.     // quoted string by ``
  141.     b3, s3 := common.Tokens.MatchRegexp(s, "^`[^`]+`")
  142.     if b3 {
  143.         return true, s3[1 : len(s3)-1], len(s3)
  144.     }
  146.     // simple string
  147.     b4, s4 := common.Tokens.MatchRegexp(s, `^\S+`)
  148.     if b4 {
  149.         return true, s4, len(s4)
  150.     }
  152.     return false, "", 0
  153. }
  155. func (me *tAnnotationScanner) removeDoubleQuote(s string) string {
  156.     s = s[1 : len(s)-1]
  157.     arrSpecialChars := [][]string{
  158.         {`\r`, "\r"},
  159.         {`\n`, "\n"},
  160.         {`\t`, "\t"},
  161.         {`\"`, "\""},
  162.         {`\\`, "\\"},
  163.         {`\v`, "\v"},
  164.     }
  166.     for _, it := range arrSpecialChars {
  167.         s = strings.ReplaceAll(s, it[0], it[1])
  168.     }
  169.     return s
  170. }
  172. var gAnnotationStartRegexp = regexp.MustCompile(`^//\s*@(\w+)\s*`)
  174. var DefaultAnnotationScanner = new(tAnnotationScanner)

scanner/IAnnotationScanner_test.go

针对注解信息的单元测试

  1. package scanner
  3. import (
  4.     "encoding/json"
  5.     "learning/gooop/spring/autogen/domain"
  6.     "strings"
  7.     "testing"
  8. )
  10. func Test_AnnotationScanner(t *testing.T) {
  11.     code := `
  12. // @RestController path=/order scope=singleton
  13. type StructInfo struct {
  14.     LineNO      int
  15.     Name        string
  16.     CodeFile    *CodeFileInfo
  17.     Fields      []*FieldInfo
  18.     Methods     []*MethodInfo
  19.     Annotations []*AnnotationInfo
  20. }
  22. func NewStructInfo() *StructInfo {
  23.     it := new(StructInfo)
  24.     it.Fields = []*FieldInfo{}
  25.     it.Methods = []*MethodInfo{}
  26.     it.Annotations = []*AnnotationInfo{}
  27.     return it
  28. }
  30. // @GetMapping path=/AppendField
  31. func (me *StructInfo) AppendField(lineNO int, name string, dataType string) error {
  32.     fld := NewFieldInfo()
  33.     fld.Struct = me
  34.     fld.LineNO = lineNO
  35.     fld.Name = name
  36.     fld.DataType = dataType
  37.     me.Fields = append(me.Fields, fld)
  38.     return nil
  39. }
  41. // @GetMapping path="/AppendMethod"
  42. func (me *StructInfo) AppendMethod(method *MethodInfo) (error, string) {
  43.     me.Methods = append(me.Methods, method)
  44.     return nil, ""
  45. }
  47. // @PostMapping path=/AppendAnnotation
  48. func (me *StructInfo) AppendAnnotation(ant *AnnotationInfo) (e error, s string) {
  49.     me.Annotations = append(me.Annotations, ant)
  50.     return nil, ""
  51. }`
  52.     file := domain.NewCodeFileInfo()
  53.     file.CleanLines = strings.Split(code, "\n")
  54.     file.RawLines = file.CleanLines
  56.     DefaultStructScanner.ScanStruct(file)
  57.     for _, it := range file.Structs {
  58.         DefaultAnnotationScanner.ScanAnnotations(it)
  59.         j, e := json.MarshalIndent(it, "", "  ")
  60.         if e != nil {
  61.             t.Fatal(e)
  62.         }
  63.         t.Log(string(j))
  64.     }
  65. }

测试输出

  1. API server listening at: [::]:41281
  2. === RUN   Test_AnnotationScanner
  3.     IAnnotationScanner_test.go:63: {
  4.           "LineNO": 2,
  5.           "Name": "StructInfo",
  6.           "Fields": [
  7.             {
  8.               "LineNO": 3,
  9.               "Name": "LineNO",
  10.               "DataType": "int",
  11.               "Annotations": []
  12.             },
  13.             {
  14.               "LineNO": 4,
  15.               "Name": "Name",
  16.               "DataType": "string",
  17.               "Annotations": []
  18.             },
  19.             {
  20.               "LineNO": 5,
  21.               "Name": "CodeFile",
  22.               "DataType": "*CodeFileInfo",
  23.               "Annotations": []
  24.             },
  25.             {
  26.               "LineNO": 6,
  27.               "Name": "Fields",
  28.               "DataType": "[]*FieldInfo",
  29.               "Annotations": []
  30.             },
  31.             {
  32.               "LineNO": 7,
  33.               "Name": "Methods",
  34.               "DataType": "[]*MethodInfo",
  35.               "Annotations": []
  36.             },
  37.             {
  38.               "LineNO": 8,
  39.               "Name": "Annotations",
  40.               "DataType": "[]*AnnotationInfo",
  41.               "Annotations": []
  42.             }
  43.           ],
  44.           "Methods": [
  45.             {
  46.               "LineNO": 20,
  47.               "Name": "AppendField",
  48.               "Arguments": [
  49.                 {
  50.                   "Name": "lineNO",
  51.                   "DataType": "int"
  52.                 },
  53.                 {
  54.                   "Name": "name",
  55.                   "DataType": "string"
  56.                 },
  57.                 {
  58.                   "Name": "dataType",
  59.                   "DataType": "string"
  60.                 }
  61.               ],
  62.               "Annotations": [
  63.                 {
  64.                   "Name": "GetMapping",
  65.                   "Attributes": [
  66.                     {
  67.                       "Key": "path",
  68.                       "Value": "/AppendField"
  69.                     }
  70.                   ]
  71.                 }
  72.               ],
  73.               "Returns": [
  74.                 {
  75.                   "Name": "",
  76.                   "DataType": "error"
  77.                 }
  78.               ]
  79.             },
  80.             {
  81.               "LineNO": 31,
  82.               "Name": "AppendMethod",
  83.               "Arguments": [
  84.                 {
  85.                   "Name": "method",
  86.                   "DataType": "*MethodInfo"
  87.                 }
  88.               ],
  89.               "Annotations": [
  90.                 {
  91.                   "Name": "GetMapping",
  92.                   "Attributes": [
  93.                     {
  94.                       "Key": "path",
  95.                       "Value": "/AppendMethod"
  96.                     }
  97.                   ]
  98.                 }
  99.               ],
  100.               "Returns": [
  101.                 {
  102.                   "Name": "",
  103.                   "DataType": "error"
  104.                 },
  105.                 {
  106.                   "Name": "",
  107.                   "DataType": "string"
  108.                 }
  109.               ]
  110.             },
  111.             {
  112.               "LineNO": 37,
  113.               "Name": "AppendAnnotation",
  114.               "Arguments": [
  115.                 {
  116.                   "Name": "ant",
  117.                   "DataType": "*AnnotationInfo"
  118.                 }
  119.               ],
  120.               "Annotations": [
  121.                 {
  122.                   "Name": "PostMapping",
  123.                   "Attributes": [
  124.                     {
  125.                       "Key": "path",
  126.                       "Value": "/AppendAnnotation"
  127.                     }
  128.                   ]
  129.                 }
  130.               ],
  131.               "Returns": [
  132.                 {
  133.                   "Name": "e",
  134.                   "DataType": "error"
  135.                 }
  136.               ]
  137.             }
  138.           ],
  139.           "Annotations": [
  140.             {
  141.               "Name": "RestController",
  142.               "Attributes": [
  143.                 {
  144.                   "Key": "path",
  145.                   "Value": "/order"
  146.                 },
  147.                 {
  148.                   "Key": "scope",
  149.                   "Value": "singleton"
  150.                 }
  151.               ]
  152.             }
  153.           ]
  154.         }
  155. --- PASS: Test_AnnotationScanner (0.01s)
  156. PASS
  158. Debugger finished with exit code 0

（未完待续）