缘起

最近阅读 [Offer来了：Java面试核心知识点精讲（框架篇）] (王磊 , 2020.6)
本系列笔记拟采用golang练习之
Talk is cheap, show me the code.

Spring

  1. Spring基于J2EE技术实现了一套轻量级的
  2. Java Web Service系统应用框架。
  3. 它有很多优秀的特性，很多公司都选择把
  4. Spring作为产品或项目的基础开发架构。
  6. Spring的主要特性包括：
  7. 1. 轻量
  8. 2. 控制反转（Inversion of Control, IoC）
  9. 3. 面向容器
  10. 4. 面向切面（AspectOriented Programming, AOP）
  11. 5. 框架灵活
  13. 源码gitee地址：
  14. https://gitee.com/ioly/learning.gooop
  16. 原文链接：
  17. https://my.oschina.net/ioly

目标

  • 参考spring常用注解，使用golang编写“基于注解的静态代码增强器/生成器”
    • 配置： ComponentScan，Configuration, Bean
    • Bean声明：Component, Service, Controller
    • Bean注入：Autowried
    • AOP注解：Before, After, Around, PointCut

子目标（Day 3）

  • 添加ProjectCmd以支持项目定义
  • 添加文本扫描的辅助类：Chars.go, Tokens.go
  • 定义代码生成服务接口ICodingService及其支撑接口

设计

  • command/ProjectCmd: 项目定义指令
  • common/Chars: 字符识别辅助类
  • common/Tokens: 组合文本识别辅助类
  • service/ICodingService: 代码生成服务接口
  • service/iCodingContext: 代码生成上下文
  • service/iCodingState：状态模式下的服务状态
  • service/iCmdRunner：定义指令执行器接口，具体执行拟走责任链模式以便扩展
  • service/tInitialState：默认的服务状态

command/ProjectCmd.go

项目定义指令

  1. package project_cmd
  3. import (
  4.     "errors"
  5.     "fmt"
  6.     "learning/gooop/spring/autogen/command"
  7.     "learning/gooop/spring/autogen/common"
  8.     "os"
  9.     "strings"
  10. )
  12. // ProjectCmd defines a project with name and dir
  13. type ProjectCmd struct {
  14.     name string
  15.     dir string
  16. }
  18. // ProjectCmdBuilder parses cli input and creates a ProjectCmd instance
  19. type ProjectCmdBuilder int
  21. const gProjectCmdPrefix = "project "
  22. var gErrorInvalidProjectCmd = errors.New("invalid project cmd")
  24. func (me *ProjectCmd) String() string {
  25.     return fmt.Sprintf("project %s %s", me.name, me.dir)
  26. }
  28. func (me *ProjectCmd) Apply(ctx command.ICmdContext) error {
  29.     panic("implements me")
  30. }
  32. func (me *ProjectCmdBuilder) Build(line string) (error, command.ICmd) {
  33.     if !common.Tokens.MatchString(line, gProjectCmdPrefix) {
  34.         return nil, nil
  35.     }
  37.     line = strings.TrimSpace(line[len(gProjectCmdPrefix):])
  38.     b,name := common.Tokens.MatchIdentifier(line)
  39.     if !b {
  40.         return gErrorInvalidProjectCmd, nil
  41.     }
  43.     line = line[len(name):]
  44.     b, spaces := common.Tokens.MatchSpaces(line)
  45.     if !b {
  46.         return gErrorInvalidProjectCmd, nil
  47.     }
  49.     line = line[len(spaces):]
  50.     b, dir := common.Tokens.MatchDir(line)
  51.     if !b {
  52.         return gErrorInvalidProjectCmd, nil
  53.     }
  54.     _,e := os.Stat(dir)
  55.     if e != nil {
  56.         return e, nil
  57.     }
  59.     return nil, &ProjectCmd{ name, dir }
  60. }

common/Chars.go

字符识别辅助类

  1. package common
  4. type tChars int
  6. var Chars = new(tChars)
  8. func (me *tChars) IsSpace(it rune) bool {
  9.     switch it {
  10.     case ' ':
  11.         return true
  12.     case '\t':
  13.         return true
  14.     case '\r':
  15.         return true
  16.     case '\n':
  17.         return true
  18.     }
  20.     return false
  21. }
  24. func (me *tChars) Is09(it rune) bool {
  25.     return it >= '0' && it <= '9'
  26. }
  28. func (me *tChars) Is19(it rune) bool {
  29.     return it >= '1' && it <= '9'
  30. }
  32. func (me *tChars) IsLetter(it rune) bool {
  33.     return (it >= 'a' && it <= 'z') || (it >= 'A' && it <= 'Z')
  34. }
  36. func (me *tChars) IsUnderscore(it rune) bool {
  37.     return it == '_'
  38. }
  40. func (me *tChars) IsLB(it rune) bool {
  41.     return it == '('
  42. }
  44. func (me *tChars) IsRB(it rune) bool {
  45.     return it == ')'
  46. }
  48. func (me *tChars) IsChar(it rune, args... rune) bool {
  49.     for _,v := range args {
  50.         if v == it {
  51.             return true
  52.         }
  53.     }
  54.     return false
  55. }
  57. func (me *tChars) IsSQuote(it rune) bool {
  58.     return me.IsChar(it, '\'')
  59. }
  61. func (me *tChars) IsDQuote(it rune) bool {
  62.     return me.IsChar(it, '"')
  63. }
  65. func (me *tChars) IsRSplash(it rune) bool {
  66.     return me.IsChar(it, '\\')
  67. }
  69. func (me *tChars) IsLSplash(it rune) bool {
  70.     return me.IsChar(it, '/')
  71. }

common/Tokens.go

组合文本识别辅助类

  1. package common
  3. import (
  4.     "regexp"
  5.     "strings"
  6.     "sync"
  7. )
  9. type tTokens struct {
  10.     cache map[string]*regexp.Regexp
  11.     rwmutex *sync.RWMutex
  12. }
  14. var Tokens = newTokensLib()
  16. func newTokensLib() *tTokens {
  17.     it := new(tTokens)
  18.     it.init()
  19.     return it
  20. }
  22. func (me *tTokens) init() {
  23.     me.cache = make(map[string]*regexp.Regexp)
  24.     me.rwmutex = new(sync.RWMutex)
  25. }
  27. func (me *tTokens) MatchString(s string, p string) bool {
  28.     return strings.HasPrefix(s, p)
  29. }
  31. func (me *tTokens) MatchRegexp(s string, p string) (bool, string) {
  32.     me.rwmutex.RLock()
  33.     r,ok := me.cache[p]
  34.     me.rwmutex.RUnlock()
  36.     if !ok {
  37.         me.rwmutex.Lock()
  38.         if r,ok = me.cache[p];!ok {
  39.             r,_ = regexp.Compile(p)
  40.         }
  41.         me.rwmutex.Unlock()
  42.     }
  44.     if r == nil {
  45.         return false, ""
  46.     }
  48.     if !r.MatchString(s) {
  49.         return false, ""
  50.     }
  52.     return true, r.FindString(s)
  53. }
  55. func (me *tTokens) MatchIdentifier(s string) (bool, string) {
  56.     return me.MatchRegexp(s, "^[_a-zA-Z]\\w{0,99}}")
  57. }
  59. func (me *tTokens) MatchSpaces(s string) (bool, string) {
  60.     return me.MatchRegexp(s, "^\\s+")
  61. }
  63. func (me *tTokens) MatchDir(s string) (bool, string) {
  64.     b,s := me.MatchRegexp(s, "^([a-zA-Z]\\:)?([\\\\/][^\\s/:*?<>|\\\"\\\\]+)+[\\/]?")
  65.     if b {
  66.         return b,s
  67.     }
  69.     b,s = me.MatchRegexp(s, "^\\\"([a-zA-Z]\\:)?([\\\\/][^/:*?<>|\\\"\\\\]+)+[\\/]?\\\"")
  70.     if b {
  71.         return b,s
  72.     }
  74.     b,s = me.MatchRegexp(s, "^'([a-zA-Z]\\:)?([\\\\/][^'/:*?<>|\\\"\\\\]+)+[\\/]?'")
  75.     if b {
  76.         return b,s
  77.     }
  79.     return false, ""
  80. }

service/ICodingService.go

代码生成服务接口

  1. package service
  3. type ICodingService interface {
  4.     iCmdRunner
  6.     State() iCodingState
  7.     Start()
  8. }

service/iCodingContext.go

代码生成上下文

  1. package service
  3. // iCodingContext provides context info for iCodingState instance
  4. type iCodingContext interface {
  5.     HandleStateChanged(state iCodingState)
  6. }

service/iCodingState.go

状态模式下的服务状态

  1. package service
  3. type iCodingState interface {
  4.     iCmdRunner
  5. }

service/iCmdRunner.go

定义指令执行器接口，具体执行拟走责任链模式以便扩展

  1. package service
  3. import "learning/gooop/spring/autogen/command"
  5. // iCmdRunner runs a user cmd
  6. type iCmdRunner interface {
  7.     Run(cmd command.ICmd) error
  8. }

service/tInitialState.go

默认的服务状态

  1. package service
  3. import (
  4.     "errors"
  5.     "learning/gooop/spring/autogen/command"
  6. )
  8. // tInitialState is the default state for a coding service
  9. // it will only accept ProjectCmd
  10. type tInitialState struct {
  11.     context iCodingContext
  12. }
  14. func newInitialState(c iCodingContext) iCodingState {
  15.     it := new(tInitialState)
  16.     it.init(c)
  17.     return it
  18. }
  20. func (me *tInitialState) init(c iCodingContext) {
  21.     me.context = c
  22. }
  24. var gErrorProjectDefineRequired = errors.New("project not defined: project <name> <dir>")
  27. func (me *tInitialState) Run(cmd command.ICmd) error {
  28.     panic("implement me")
  29. }

（未完待续）