手撸golang 仿spring ioc/aop 之3

手撸golang 仿spring ioc/aop 之3

缘起

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

Spring

Spring基于J2EE技术实现了一套轻量级的
Java Web Service系统应用框架。
它有很多优秀的特性,很多公司都选择把
Spring作为产品或项目的基础开发架构。

Spring的主要特性包括:
1. 轻量
2. 控制反转(Inversion of Control, IoC)
3. 面向容器
4. 面向切面(AspectOriented Programming, AOP)
5. 框架灵活

源码gitee地址:
https://gitee.com/ioly/learning.gooop

原文链接:
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

项目定义指令

package project_cmd

import (
    "errors"
    "fmt"
    "learning/gooop/spring/autogen/command"
    "learning/gooop/spring/autogen/common"
    "os"
    "strings"
)

// ProjectCmd defines a project with name and dir
type ProjectCmd struct {
    name string
    dir string
}

// ProjectCmdBuilder parses cli input and creates a ProjectCmd instance
type ProjectCmdBuilder int

const gProjectCmdPrefix = "project "
var gErrorInvalidProjectCmd = errors.New("invalid project cmd")

func (me *ProjectCmd) String() string {
    return fmt.Sprintf("project %s %s", me.name, me.dir)
}

func (me *ProjectCmd) Apply(ctx command.ICmdContext) error {
    panic("implements me")
}

func (me *ProjectCmdBuilder) Build(line string) (error, command.ICmd) {
    if !common.Tokens.MatchString(line, gProjectCmdPrefix) {
        return nil, nil
    }

    line = strings.TrimSpace(line[len(gProjectCmdPrefix):])
    b,name := common.Tokens.MatchIdentifier(line)
    if !b {
        return gErrorInvalidProjectCmd, nil
    }

    line = line[len(name):]
    b, spaces := common.Tokens.MatchSpaces(line)
    if !b {
        return gErrorInvalidProjectCmd, nil
    }

    line = line[len(spaces):]
    b, dir := common.Tokens.MatchDir(line)
    if !b {
        return gErrorInvalidProjectCmd, nil
    }
    _,e := os.Stat(dir)
    if e != nil {
        return e, nil
    }

    return nil, &ProjectCmd{ name, dir }
}

common/Chars.go

字符识别辅助类

package common


type tChars int

var Chars = new(tChars)

func (me *tChars) IsSpace(it rune) bool {
    switch it {
    case ' ':
        return true
    case '\t':
        return true
    case '\r':
        return true
    case '\n':
        return true
    }

    return false
}


func (me *tChars) Is09(it rune) bool {
    return it >= '0' && it <= '9'
}

func (me *tChars) Is19(it rune) bool {
    return it >= '1' && it <= '9'
}

func (me *tChars) IsLetter(it rune) bool {
    return (it >= 'a' && it <= 'z') || (it >= 'A' && it <= 'Z')
}

func (me *tChars) IsUnderscore(it rune) bool {
    return it == '_'
}

func (me *tChars) IsLB(it rune) bool {
    return it == '('
}

func (me *tChars) IsRB(it rune) bool {
    return it == ')'
}

func (me *tChars) IsChar(it rune, args... rune) bool {
    for _,v := range args {
        if v == it {
            return true
        }
    }
    return false
}

func (me *tChars) IsSQuote(it rune) bool {
    return me.IsChar(it, '\'')
}

func (me *tChars) IsDQuote(it rune) bool {
    return me.IsChar(it, '"')
}

func (me *tChars) IsRSplash(it rune) bool {
    return me.IsChar(it, '\\')
}

func (me *tChars) IsLSplash(it rune) bool {
    return me.IsChar(it, '/')
}

common/Tokens.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()

    if !ok {
        me.rwmutex.Lock()
        if r,ok = me.cache[p];!ok {
            r,_ = regexp.Compile(p)
        }
        me.rwmutex.Unlock()
    }

    if r == nil {
        return false, ""
    }

    if !r.MatchString(s) {
        return false, ""
    }

    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
    }

    b,s = me.MatchRegexp(s, "^\\\"([a-zA-Z]\\:)?([\\\\/][^/:*?<>|\\\"\\\\]+)+[\\/]?\\\"")
    if b {
        return b,s
    }

    b,s = me.MatchRegexp(s, "^'([a-zA-Z]\\:)?([\\\\/][^'/:*?<>|\\\"\\\\]+)+[\\/]?'")
    if b {
        return b,s
    }

    return false, ""
}

service/ICodingService.go

代码生成服务接口

package service

type ICodingService interface {
    iCmdRunner

    State() iCodingState
    Start()
}

service/iCodingContext.go

代码生成上下文

package service

// iCodingContext provides context info for iCodingState instance
type iCodingContext interface {
    HandleStateChanged(state iCodingState)
}

service/iCodingState.go

状态模式下的服务状态

package service

type iCodingState interface {
    iCmdRunner
}

service/iCmdRunner.go

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

package service

import "learning/gooop/spring/autogen/command"

// iCmdRunner runs a user cmd
type iCmdRunner interface {
    Run(cmd command.ICmd) error
}

service/tInitialState.go

默认的服务状态

package service

import (
    "errors"
    "learning/gooop/spring/autogen/command"
)

// tInitialState is the default state for a coding service
// it will only accept ProjectCmd
type tInitialState struct {
    context iCodingContext
}

func newInitialState(c iCodingContext) iCodingState {
    it := new(tInitialState)
    it.init(c)
    return it
}

func (me *tInitialState) init(c iCodingContext) {
    me.context = c
}

var gErrorProjectDefineRequired = errors.New("project not defined: project  ")


func (me *tInitialState) Run(cmd command.ICmd) error {
    panic("implement me")
}

(未完待续)

你可能感兴趣的:(手撸golang 仿spring ioc/aop 之3)