扫二维码与项目经理沟通
我们在微信上24小时期待你的声音
解答本文疑问/技术咨询/运营咨询/技术建议/互联网交流
本篇内容介绍了“编写golang编写注解的静态代码增强器/生成器的方法”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！
创新互联，为您提供成都网站建设公司、网站制作、网站营销推广、网站开发设计，对服务成都酒店设计等多个行业拥有丰富的网站建设及推广经验。创新互联网站建设公司成立于2013年,提供专业网站制作报价服务,我们深知市场的竞争激烈，认真对待每位客户，为客户提供赏心悦目的作品。 与客户共同发展进步，是我们永远的责任！
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编写“基于注解的静态代码增强器/生成器”
因为struct/field/method的扫描是关键，因此今天针对这块做了单元测试
common/Tokens.go：修复MatchBasicType方法的正则匹配bug。其实func类型的DataType也没考虑到，但现在暂时可以用type alias规避，先不追求完美吧。
scanner/IStructScanner.go: 修复若干细节, 并添加返回类型的扫描
scanner/IStructScanner_test.go：struct扫描器的单元测试
修复MatchBasicType方法的正则匹配bug。其实func类型的DataType也没考虑到，但现在暂时可以用type alias规避，先不追求完美吧。
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 ok, t := me.MatchRegexp(s, "^"+it+`(\s+|$)`); ok {
return true, strings.TrimSpace(t)
}
}
return false, ""
}修复若干细节, 并添加返回类型的扫描
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
vStructs := []*domain.StructInfo{nil}
for lineNO, line := range file.CleanLines {
if bInStruct {
// end?
if gStructEndRegexp.MatchString(line) {
me.scanMethod(vStructs[0], lineNO+1)
file.AppendStruct(vStructs[0])
bInStruct = false
vStructs[0] = nil
continue
}
// in struct block
ok, fname, ftype := me.scanField(line)
if ok {
vStructs[0].AppendField(lineNO, fname, ftype)
}
} else {
// not in struck block
// matching start?
if gStructStartRegexp.MatchString(line) {
bInStruct = true
ss := gStructStartRegexp.FindStringSubmatch(line)
vStructs[0] = domain.NewStructInfo()
vStructs[0].LineNO = lineNO
vStructs[0].CodeFile = file
vStructs[0].Name = ss[1]
continue
}
}
}
}
func (me *tStructScanner) scanField(line string) (ok bool, fldName string, fldType string) {
if !gFieldStartRegexp.MatchString(line) {
return false, "", ""
}
t := line
s1 := gFieldStartRegexp.FindString(t)
fldName = strings.TrimSpace(s1)
t = t[len(s1):]
b2, s2 := common.Tokens.MatchDataType(t)
if !b2 {
return false, "", ""
}
fldType = strings.TrimSpace(s2)
return true, fldName, fldType
}
func (me *tStructScanner) scanMethod(stru *domain.StructInfo, fromLineNO int) {
for i, limit := fromLineNO, len(stru.CodeFile.CleanLines); i < limit; i++ {
line := stru.CodeFile.CleanLines[i]
if !gMethodStartRegex.MatchString(line) {
continue
}
ss := gMethodStartRegex.FindStringSubmatch(line)
// 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 := strings.TrimSpace(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:]
}
b4, s4 := common.Tokens.MatchRegexp(t, `^\s*\)`)
if !b4 {
return errors.New("expecting right bracket"), ""
}
offset += len(s4)
return nil, s[0:offset]
}
func (me *tStructScanner) scanReturnArgs(method *domain.MethodInfo, s string) error {
// no args?
if gMethodEndRegexp.MatchString(s) {
return nil
}
// args start
t := s
b1, s1 := common.Tokens.MatchRegexp(t, `\s*\(\s*`)
if !b1 {
return errors.New("expecting left bracket")
}
t = t[len(s1):]
// unnamed args?
b2, s2 := common.Tokens.MatchDataType(t)
if b2 {
t = t[len(s2):]
method.AppendUnnamedReturn(s2)
// more unnamed args?
for {
b3, s3 := common.Tokens.MatchRegexp(t, `^\s*,\s*`)
if !b3 {
break
}
t = t[len(s3):]
b4, s4 := common.Tokens.MatchDataType(t)
if !b4 {
return errors.New("expecting data type")
}
t = t[len(s4):]
method.AppendUnnamedReturn(s4)
}
} else {
// named args?
for {
// name
b3, s3 := common.Tokens.MatchIdentifier(t)
if !b3 {
return errors.New("expecting identifier")
}
t = t[len(s3):]
// \s+
b4, s4 := common.Tokens.MatchSpaces(t)
if !b4 {
return errors.New("expecting spaces")
}
t = t[len(s4):]
// type
b5, s5 := common.Tokens.MatchDataType(t)
if !b5 {
return errors.New("expecting data type")
}
t = t[len(s5):]
// more?
b6, s6 := common.Tokens.MatchRegexp(t, `^\s*,\s*`)
if b6 {
// yes more
t = t[len(s6):]
} else {
// no more
break
}
}
}
// arguments end
b7, _ := common.Tokens.MatchRegexp(t, `^\s*\)\s*`)
if !b7 {
return errors.New("expecting end of arguments")
}
return nil
}
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 gMethodEndRegexp = regexp.MustCompile(`^\s*\{`)
var DefaultStructScanner IStructScanner = new(tStructScanner)struct扫描器的单元测试
package scanner
import (
"encoding/json"
"learning/gooop/spring/autogen/domain"
"strings"
"testing"
)
func Test_StructScan(t *testing.T) {
s := `type _mystruct struct {`
t.Log(gStructStartRegexp.MatchString(s))
code := `
type StructInfo struct {
LineNO int
Name string
CodeFile *CodeFileInfo
Fields []*FieldInfo
Methods []*MethodInfo
Annotations []*AnnotationInfo
}
func NewStructInfo() *StructInfo {
it := new(StructInfo)
it.Fields = []*FieldInfo{}
it.Methods = []*MethodInfo{}
it.Annotations = []*AnnotationInfo{}
return it
}
func (me *StructInfo) AppendField(lineNO int, name string, dataType string) {
fld := NewFieldInfo()
fld.Struct = me
fld.LineNO = lineNO
fld.Name = name
fld.DataType = dataType
me.Fields = append(me.Fields, fld)
}
func (me *StructInfo) AppendMethod(method *MethodInfo) {
me.Methods = append(me.Methods, method)
}
func (me *StructInfo) AppendAnnotation(ant *AnnotationInfo) {
me.Annotations = append(me.Annotations, ant)
}`
file := domain.NewCodeFileInfo()
file.CleanLines = strings.Split(code, "\n")
DefaultStructScanner.ScanStruct(file)
file.CleanLines = nil
j, e := json.MarshalIndent(file.Structs, "", " ")
if e != nil {
panic(e)
}
t.Log(string(j))
}API server listening at: [::]:36077
=== RUN Test_StructScan
IStructScanner_test.go:12: true
IStructScanner_test.go:58: [
{
"LineNO": 1,
"Name": "StructInfo",
"Fields": [
{
"LineNO": 2,
"Name": "LineNO",
"DataType": "int",
"Annotations": []
},
{
"LineNO": 3,
"Name": "Name",
"DataType": "string",
"Annotations": []
},
{
"LineNO": 4,
"Name": "CodeFile",
"DataType": "*CodeFileInfo",
"Annotations": []
},
{
"LineNO": 5,
"Name": "Fields",
"DataType": "[]*FieldInfo",
"Annotations": []
},
{
"LineNO": 6,
"Name": "Methods",
"DataType": "[]*MethodInfo",
"Annotations": []
},
{
"LineNO": 7,
"Name": "Annotations",
"DataType": "[]*AnnotationInfo",
"Annotations": []
}
],
"Methods": [
{
"LineNO": 0,
"Name": "AppendField",
"Arguments": [
{
"Name": "lineNO",
"DataType": "int"
},
{
"Name": "name",
"DataType": "string"
},
{
"Name": "dataType",
"DataType": "string"
}
],
"Annotations": [],
"Returns": []
},
{
"LineNO": 0,
"Name": "AppendMethod",
"Arguments": [
{
"Name": "method",
"DataType": "*MethodInfo"
}
],
"Annotations": [],
"Returns": []
},
{
"LineNO": 0,
"Name": "AppendAnnotation",
"Arguments": [
{
"Name": "ant",
"DataType": "*AnnotationInfo"
}
],
"Annotations": [],
"Returns": []
}
],
"Annotations": []
}
]
--- PASS: Test_StructScan (0.01s)
PASS
Debugger finished with exit code 0“编写golang编写注解的静态代码增强器/生成器的方法”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注创新互联网站，小编将为大家输出更多高质量的实用文章！
我们在微信上24小时期待你的声音
解答本文疑问/技术咨询/运营咨询/技术建议/互联网交流
微信二维码
移动版官网