您好,登录后才能下订单哦!
密码登录
登录注册
点击 登录注册 即表示同意《亿速云用户服务条款》
本篇内容主要讲解“怎么用golang编写基于注解的静态代码增强器/生成器”,感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷,实用性强。下面就让小编来带大家学习“怎么用golang编写基于注解的静态代码增强器/生成器”吧!
Spring的主要特性: 1. 控制反转(Inversion of Control, IoC) 2. 面向容器 3. 面向切面(AspectOriented Programming, AOP) 源码gitee地址: https://gitee.com/ioly/learning.gooop 原文链接: https://my.oschina.net/ioly
参考spring boot常用注解,使用golang编写“基于注解的静态代码增强器/生成器”
今天继续the hard part:struct/field/method元素的扫描
common/Tokens.go:添加数据类型的词法解析支持
scanner/IStructScanner.go: 结构体扫描器的接口及实现
添加数据类型的词法解析支持:
分别解析基本类型/自定义类型/指针类型/数组类型/map类型
自定义类型需要注意排除'map'关键字
指针,数组和map类型都是复合类型,需递归解析
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, "" } func (me *tTokens) MatchDataType(s string) (bool, string) { if ok,t := me.MatchBasicType(s);ok { return true, t } if ok,t := me.MatchCustomType(s);ok { return true, t } if ok,t := me.MatchPointerType(s);ok { return true, t } if ok,t := me.MatchArrayType(s);ok { return true, t } if ok,t := me.MatchMapType(s);ok { return true, t } 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 } } return false, "" } func (me *tTokens) MatchCustomType(s string) (bool, string) { t := s b1, s1 := me.MatchRegexp(t, `^\w+\.`) if b1 { t = t[len(s1):] } b2, s2 := me.MatchRegexp(t, `^\w+`) if !b2 { return false, "" } if s2 == "map" { // map is reserved word return false, "" } return true, s1 + s2 } func (me *tTokens) MatchPointerType(s string) (bool, string) { t := s if t[0] != '*' { return false,"" } t = t[1:] b, s := me.MatchDataType(t) if !b { return false, "" } 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):] b2, s2 := me.MatchDataType(t) if !b2 { return false, "" } 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):] b2, s2 := me.MatchRegexp(t, `^\s*\[\s*`) if !b2 { return false, "" } t = t[len(s2):] b3,s3 := me.MatchDataType(t) if !b3 { return false, "" } t = t[len(s3):] b4, s4 := me.MatchRegexp(t, `^\s*\]\s*`) if !b4 { return false, "" } t = t[len(s4):] b5, s5 := me.MatchDataType(t) if !b5 { return false, "" } return true, s1 + s2 + s3 + s4 + s5 }
结构体扫描器的接口及实现
package scanner import ( "errors" "learning/gooop/spring/autogen/common" "learning/gooop/spring/autogen/domain" "regexp" "strings" ) type IStructScanner interface { ScanStruct(file *domain.CodeFileInfo) } type tStructScanner int func (me *tStructScanner) ScanStruct(file *domain.CodeFileInfo) { bInStruct := false var stru *domain.StructInfo for lineNO,line := range file.CleanLines { if bInStruct { // end? if gStructEndRegexp.MatchString(line) { bInStruct = false me.scanMethod(stru, lineNO + 1) stru = nil continue } } // start? if gStructStartRegexp.MatchString(line) { bInStruct = true ss := gStructStartRegexp.FindAllString(line, -1) stru := domain.NewStructInfo() stru.LineNO = lineNO stru.CodeFile = file stru.Name = ss[1] continue } // in struct block ok,fname,ftype := me.scanField(line) if ok { stru.AppendField(lineNO, fname, ftype) } } } func (me *tStructScanner) scanField(line string) (ok bool, fldName string, fldType string) { if !gFieldStartRegexp.MatchString(line) { return false, "","" } fldName = strings.TrimSpace(gFieldStartRegexp.FindString(line)) fldType = strings.TrimSpace(line[len(fldName):]) return true, fldName, fldType } func (me *tStructScanner) scanMethod(stru *domain.StructInfo, fromLineNO int) { for i,max := fromLineNO, len(stru.CodeFile.CleanLines);i <= max;i++ { line := stru.CodeFile.CleanLines[i] if !gMethodStartRegex.MatchString(line) { continue } ss := gMethodStartRegex.FindAllString(line, -1) // declare declare := ss[0] offset := len(declare) // receiver receiver := ss[1] if receiver != stru.Name { continue } method := domain.NewMethodInfo() // name method.Name = ss[2] // method input args e,args := me.scanMethodArgs(method, strings.TrimSpace(line[offset:])) if e != nil { panic(e) } offset += len(args) // method return args e = me.scanReturnArgs(method, strings.TrimSpace(line[offset:])) if e != nil { panic(e) } // end scan method stru.AppendMethod(method) } } func (me *tStructScanner) scanMethodArgs(method *domain.MethodInfo, s string) (error, string) { t := s offset := 0 for { // name b1, s1 := common.Tokens.MatchRegexp(t, `\w+(\s*,\s*\w+)\s+`) if !b1 { break } argNames := s1 offset += len(s1) t = s[offset:] // data type b2, s2 := common.Tokens.MatchDataType(t) if !b2 { return gInvalidMethodArgs, "" } argDataType := s2 offset += len(s2) t = s[offset:] for _,it := range strings.Split(argNames, ",") { method.AppendArgument(it, argDataType) } // ,\s+ b3, s3 := common.Tokens.MatchRegexp(t, `\s*,\s*`) if !b3 { break } offset += len(s3) t = s[offset:] } return nil, s[0:offset] } func (me *tStructScanner) scanReturnArgs(method *domain.MethodInfo, s string) error { // todo: fixme panic("implements me") } var gStructStartRegexp = regexp.MustCompile(`^\s*type\s+(\w+)\s+struct\s+\{`) var gStructEndRegexp = regexp.MustCompile(`^\s*}`) var gFieldStartRegexp = regexp.MustCompile(`^\s*\w+\s+`) var gMethodStartRegex = regexp.MustCompile(`\s*func\s+\(\s*\w+\s+\*?(\w+)\s*\)\s+(\w+)\s*\(`) var gInvalidMethodArgs = errors.New("invalid method arguments") var DefaultStructScanner IStructScanner = new(tStructScanner)
到此,相信大家对“怎么用golang编写基于注解的静态代码增强器/生成器”有了更深的了解,不妨来实际操作一番吧!这里是亿速云网站,更多相关内容可以进入相关频道进行查询,关注我们,继续学习!
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。