如果把 C 变成 C++， 那么 C 就消失了。
引子
在云原生时代，Go 变成了一门受人关注的编程语言。个人觉得，对于 Java 业务开发人员来说，熟悉一门接近系统级别的编程语言，还是有必要的。多熟悉下系统级别的原理机制，而不是局限于应用层的框架和库的使用上，对程序员来说，也是一件有益的事情。何况，谁能说，云原生不会是下一波技术浪潮呢？
之前写过一篇， “Go语言初尝”，算是尝个鲜，现在公司开始转 Go，需要正儿八经深入学习一下。
定义类
Go 定义类的形式与 C 语言定义结构体很相似，连关键字 struct 都是一样的，不愧是对 C 情有独钟！
Go 定义类：
define.go
package define
type FlowResult struct {
Code int
}
C 定义结构体：
struct Books {
char title[50];
char author[50];
char subject[100];
int book_id;
} book;
注意到 Code 是首字母大写。这涉及到 Go 可见性的一条规则：
- package A 里的首字母大写的成员变量或成员方法，对所有包可见，相当于 public 变量或方法；
- package A 里的首字母小写的成员变量或成员方法，对 package A 之外的其它包不可见。
比如，可以在 package main 里创建 FlowResult 的对象：
package main
import (
"fmt"
"github.com/qt/eventflow/pkg/define"
)
func testConstruct() {
result := &define.FlowResult{ 200 }
fmt.Println(result)
}
如果把 Code 改成 code，同样的代码会报错：
implicit assignment of unexported field 'code' in define.FlowResult literal
一般来说，写过 Java 的童鞋倾向于将字段对外不可见（private），如下：
package compos
type AgentDetection struct {
eventId string
agentId string
osType int
}
这时候，在 package compos 之外的其它包是无法如下面初始化的，报错同上。
package main
import (
"fmt"
"github.com/qt/eventflow/pkg/compos"
)
agent := &compos.AgentDetection{ "eventId", "agentId", 1 }
// error : implicit assignment of unexported field 'eventId' in compos.AgentDetection literal
那么，怎么创建 AgentDetection 对象呢？虽然在 package compos 外的其它包里无法如上创建，但在 package compos 里是可以这么创建的（这是 Go 提供的默认构造器）。 可以在 compos 里提供一个方法包装一下。注意到，返回值是 *AgentDetection，而赋值是 &AgentDetection。你能猜到为什么返回指针吗？
package compos
func (AgentDetection) Instanceof(agentId string, osType int) *AgentDetection {
eventId := strconv.Itoa(int((time.Now().Unix()))) + strconv.Itoa(getRandomInt())
return &AgentDetection{ eventId, agentId, osType}
}
在其它包里使用如下：
package main
detection := compos.AgentDetection{}.Instanceof("agentId", 1)
fmt.Println(detection)
注意，如果把 Instanceof 改成 instanceof ，就会报错：
compos.AgentDetection{}.instanceof undefined (cannot refer to unexported field or method instanceof)
默认构造器
Java 只提供了无参的默认构造器。Go 提供了丰富的默认构造器。从上面例子可以看到，即使并没有声明一个 AgentDetection(eventId, agentId, osType)，也可以直接通过 &AgentDetection{eventId, agentId, osType} 来创建一个 AgentDetection 对象。
Go 还提供了自动的命名构造器，如下所示，仅对 agentId, osType 赋值。运行后可知，仅对 agentId, osType 赋值，而 eventId 是 空字符串。
func (AgentDetection) InstanceByNaming(agentId string, osType int) *AgentDetection {
return &AgentDetection{ agentId:agentId, osType: osType}
}
detection2 := compos.AgentDetection{}.InstanceByNaming("agentId", 1)
fmt.Println(detection2)
fmt.Println("eventId: " + detection2.GetEventId())
空对象
compos.AgentDetection{} 是什么含义？这会创建一个空的 AgentDetection 对象，然后用这个对象去创建一个有值的对象。
empty := compos.AgentDetection{}
fmt.Println(reflect.TypeOf(empty)) // print : compos.AgentDetection
啊，这样岂不是创建了两个对象？可以这样：
var emp compos.AgentDetection
demp := emp.Instanceof("agentId", 1)
fmt.Printf("demp: %v\n", demp)
fmt.Println(emp)
fmt.Println(reflect.TypeOf(emp))
咦？竟然没有出现类似 NPE 的异常？实际上，即使声明为 var emp compos.AgentDetection， emp 也并不是 nil， 而是一个空对象。猜猜下面分别打印什么 ？
func testEmptyObject() {
var emp compos.AgentDetection
p1 := &emp
demp := emp.Instanceof("agentId", 1)
fmt.Printf("demp: %v\n", demp)
fmt.Println(emp)
fmt.Println(reflect.TypeOf(emp))
var emp2 compos.AgentDetection
p2 := &emp2
fmt.Println("compare reference to empty agentDetection")
compareObj(emp, emp2)
fmt.Println("compare pointers to empty agentDetection")
compareAgentDetection(p1, p2)
emp3 := &compos.AgentDetection{}
emp4 := &compos.AgentDetection{}
fmt.Println("compare pointers to empty2 agentDetection")
compareAgentDetection(emp3, emp4)
}
func compareObj(o1 interface{}, o2 interface{}) {
fmt.Printf("o1: %v\n", o1)
fmt.Printf("o2: %v\n", o2)
fmt.Printf("o1-p: %p\n", o1)
fmt.Printf("o2-p: %p\n", o2)
fmt.Printf("&o1: %v\n", &o1)
fmt.Printf("&o2: %v\n", &o2)
fmt.Printf("o1 == o2: %v\n", (o1 == o2))
fmt.Printf("&o1 == &o2: %v\n", &o1 == &o2)
}
func compareAgentDetection(adp1 *compos.AgentDetection, adp2 *compos.AgentDetection) {
fmt.Printf("adp1: %v\n", adp1)
fmt.Printf("adp2: %v\n", adp2)
fmt.Printf("adp1-p: %p\n", adp1)
fmt.Printf("adp2-p: %p\n", adp2)
fmt.Printf("*adp1: %v\n", *adp1)
fmt.Printf("*adp2: %v\n", *adp2)
fmt.Printf("&adp1: %v\n", &adp1)
fmt.Printf("&adp2: %v\n", &adp2)
fmt.Printf("adp1 == adp2: %v\n", (adp1 == adp2))
fmt.Printf("&adp1 == &adp2: %v\n", &adp1 == &adp2)
fmt.Printf("*adp1 == *adp2: %v\n", *adp1 == *adp2)
}
好像陷入了一个鸡生蛋还是蛋生鸡的问题。要调用 Instanceof 方法去创建一个对象，首先得有这样一个对象？其实解决这个问题的办法有两种：
- 把 Instanceof 变成一个普通的函数，而不是 AgentDetection 的方法；
- 将 Instanceof 变成一个工厂类 AgentDetectionFactory 的方法。
采用第一种方式，定义一个 NewAgentDetection 可见的方法，
func NewAgentDetection(agentId string, osType int) *AgentDetection {
eventId := strconv.Itoa(int((time.Now().Unix()))) + strconv.Itoa(getRandomInt())
return &AgentDetection{ eventId, agentId, osType}
}
然后在 package main 里就可以这样初始化：
detection3 := compos.NewAgentDetection("agentId", 1)
fmt.Printf("d3: %v\n", detection3)
采用第二种方法，定义一个关联的工厂类 AgentDetectionFactory：
type AgentDetectionFactory struct {
}
func (*AgentDetectionFactory) Instanceof(agentId string, osType int) *AgentDetection {
eventId := strconv.Itoa(int((time.Now().Unix()))) + strconv.Itoa(getRandomInt())
return &AgentDetection{ eventId, agentId, osType}
}
func (*AgentDetectionFactory) InstanceByNaming(agentId string, osType int) *AgentDetection {
return &AgentDetection{ agentId:agentId, osType: osType}
}
func testFactoryMethod() {
adf := &compos.AgentDetectionFactory{}
detection := adf.Instanceof("agentId", 2)
fmt.Printf( "detection from factory method: %v\n", detection)
}
单例
像 AgentDetectionFactory 这样的类，在 Java 中是典型的单例。那么，在 Go 里怎么实现单例呢？ 在网上摘抄的（DCL 思想）：
var (
facLock *sync.Mutex = &sync.Mutex{}
adf *AgentDetectionFactory
)
func GetAgentFactoryInstance() *AgentDetectionFactory {
if adf == nil {
facLock.Lock()
defer facLock.Unlock()
if adf == nil {
adf = &AgentDetectionFactory{}
fmt.Println("Empty single instance...")
}
}
return adf
}
做个简单的测试。猜猜下面分别打印什么 ？
func testSingleton() {
adf := compos.GetAgentFactoryInstance()
adf2 := compos.GetAgentFactoryInstance()
compare(adf, adf2)
}
func compare(p1 *compos.AgentDetectionFactory, p2 *compos.AgentDetectionFactory) {
fmt.Printf("adf: %v\n", p1)
fmt.Printf("adf2: %v\n", p2)
fmt.Printf("adf-p: %p\n", p1)
fmt.Printf("adf2-p: %p\n", p2)
fmt.Printf("*adf: %v\n", *p1)
fmt.Printf("*adf2: %v\n", *p2)
fmt.Printf("&adf: %v\n", &p1)
fmt.Printf("&adf2: %v\n", &p2)
fmt.Printf("adf == adf2: %v\n", (p1 == p2))
fmt.Printf("&adf == &adf2: %v\n", &p1 == &p2)
fmt.Printf("*adf == *adf2: %v\n", *p1 == *p2)
}
类的方法
实际上，前面已经给出了类的方法定义，有两种形式，如下所示：
func (AgentDetection) InstanceByNaming(agentId string, osType int) *AgentDetection {
return &AgentDetection{ agentId:agentId, osType: osType}
}
func (*AgentDetectionFactory) Instanceof(agentId string, osType int) *AgentDetection {
eventId := strconv.Itoa(int((time.Now().Unix()))) + strconv.Itoa(getRandomInt())
return &AgentDetection{ eventId, agentId, osType}
}
一个是前面不带星号的，一个是前面带星号的。有什么区别呢 ？ 如果不涉及接口，看上去都是没问题的：
func testClassMethod() {
withoutStar := compos.AgentDetection{}
ad := withoutStar.Instanceof("agentId111", 1)
fmt.Printf("ad: %v\n", ad)
withoutStar2 := &compos.AgentDetection{}
ad2 := withoutStar2.Instanceof("agentId222", 1)
fmt.Printf("ad: %v\n", ad2)
withStar := compos.AgentDetectionFactory{}
ad3 := withStar.Instanceof("agentId333", 1)
fmt.Printf("ad3: %v\n", ad3)
withStar2 := &compos.AgentDetectionFactory{}
ad4 := withStar2.Instanceof("agentId444", 1)
fmt.Printf("ad4: %v\n", ad4)
}
接口
终于谈到接口了。事情稍微变得有趣了些。 接口定义也比较简单：
type FlowComponent interface {
GetName() string
Process(context *Context) (result define.FlowResult, error error)
}
但类如何去实现接口呢？ 这就涉及到关于接口的一个重要争论：
- 显式地说明实现关系，比如 Java 的 implements ；
- 实现指定的行为接口即可，比如 Go 。
即： 如果会游泳的动物具备 CanSwim { swim() }， 那么任何 实现了 swim() 方法的类都是 CanSwim 对象，而无需显式指定与 CanSwim 的关系。CanSwim 对于谁实现了它一无所知，但是 Java 的接口可以知道谁实现了它。比如：
func (hcc HostCompletionComponent) GetName() string {
return "compos.HostCompletionComponent"
}
func (hcc HostCompletionComponent) Process(context *Context) (result define.FlowResult, error error) {
event := context.GetEventData()
err := (*event).SetOsType(-1)
if err != nil {
return define.FlowResult{define.TERMINAL}, err
}
fmt.Println(*event)
return define.FlowResult{define.CONTINUE}, nil
}
type DetectionSaver struct {
}
func (saver DetectionSaver) Process(ctx *Context) (result define.FlowResult, error error) {
event := ctx.GetEventData()
fmt.Printf("save detection. eventId: %s", (*event).GetEventId())
return define.FlowResult{200}, nil
}
func (hcc DetectionSaver) GetName() string {
return "compos.DetectionSaver"
}
使用：
// 直接赋值
fc := &compos.HostCompletionComponent{}
saver := &compos.DetectionSaver{}
fc.Process(ctx)
saver.Process(ctx)
// 数组赋值
components := [...]compos.FlowComponent{&compos.HostCompletionComponent{}, &compos.DetectionSaver{} }
for _, comp := range components {
res, err := comp.Process(ctx)
if err != nil {
fmt.Println(err)
}
if res.Code == define.TERMINAL {
panic("Flow terminated")
}
}
HostCompletionComponent, DetectionSaver 都可以做成单例的。
完整程序
下面是一个较为完整的小程序，基本涵盖了 Go 的常用必知必会的语言特性。
目录结构
eventflow-go
cmd
main.go
pkg
define
define.go
compos
components.go
yaml
readyaml.go
configs
eventflow.yml
define.go
package define
const (
CONTINUE = 200
TERMINAL = -1
)
type IllegalArgumentError struct {
Msg string
Err error
}
func (e *IllegalArgumentError) Error() string {
return e.Msg
}
type FlowResult struct {
Code int
}
// Do not need declared explicitly
//func NewFlowResult(code int) FlowResult {
// return FlowResult{code}
//}
type EventData interface {
GetData() interface{}
GetType() string
GetEventId() string
SetOsType(i int) error
}
components.go
package compos
import (
"fmt"
"math/rand"
"reflect"
"strconv"
"sync"
"time"
"github.com/qt/eventflow/pkg/define"
)
type AgentDetection struct {
eventId string
agentId string
osType int
}
func getRandomInt() int {
nanotime := int64(time.Now().Nanosecond())
rand.Seed(nanotime)
return rand.Int()
}
func (AgentDetection) Instanceof(agentId string, osType int) *AgentDetection {
eventId := strconv.Itoa(int((time.Now().Unix()))) + strconv.Itoa(getRandomInt())
return &AgentDetection{ eventId, agentId, osType}
}
func (AgentDetection) InstanceByNaming(agentId string, osType int) *AgentDetection {
return &AgentDetection{ agentId:agentId, osType: osType}
}
func NewAgentDetection(agentId string, osType int) *AgentDetection {
eventId := strconv.Itoa(int((time.Now().Unix()))) + strconv.Itoa(getRandomInt())
return &AgentDetection{ eventId, agentId, osType}
}
func (detection *AgentDetection) GetData() interface{} {
return detection
}
func (detection *AgentDetection) GetType() string {
return "Detection"
}
func (detection *AgentDetection) GetEventId() string {
return detection.eventId
}
func (detection *AgentDetection) GetAgentId() string {
return detection.agentId
}
func (detection *AgentDetection) SetOsType(osType int) (err error) {
if osType != 1 && osType != 2 {
return &define.IllegalArgumentError{"invalid parameter", nil}
}
(*detection).osType = osType
return nil
}
type AgentDetectionFactory struct {
}
func (*AgentDetectionFactory) Instanceof(agentId string, osType int) *AgentDetection {
eventId := strconv.Itoa(int((time.Now().Unix()))) + strconv.Itoa(getRandomInt())
return &AgentDetection{ eventId, agentId, osType}
}
func (*AgentDetectionFactory) InstanceByNaming(agentId string, osType int) *AgentDetection {
return &AgentDetection{ agentId:agentId, osType: osType}
}
var (
facLock *sync.Mutex = &sync.Mutex{}
adf *AgentDetectionFactory
)
func GetAgentFactoryInstance() *AgentDetectionFactory {
if adf == nil {
facLock.Lock()
defer facLock.Unlock()
if adf == nil {
adf = &AgentDetectionFactory{}
fmt.Println("AgentDetectionFactory single instance...")
}
}
return adf
}
type Context struct {
event *define.EventData
}
func (ctx Context) New(e *define.EventData) *Context {
return &Context{ e }
}
// Do not need declared explicitly
//func NewContext(event *EventData) *Context {
// return &Context{event }
//}
func (ctx *Context) GetEventData() *define.EventData {
return ctx.event
}
const (
HostCompletionComponentName = iota
DetectionSaverName
)
type FlowComponent interface {
GetName() string
Process(context *Context) (result define.FlowResult, error error)
}
func getName(o interface{}) string {
return fmt.Sprintf("%v", reflect.TypeOf(o))
}
type HostCompletionComponent struct {
}
func (hcc HostCompletionComponent) GetName() string {
return getName(hcc)
}
func (hcc HostCompletionComponent) Process(context *Context) (result define.FlowResult, error error) {
event := context.GetEventData()
err := (*event).SetOsType(1)
if err != nil {
return define.FlowResult{define.TERMINAL}, err
}
fmt.Println(*event)
return define.FlowResult{define.CONTINUE}, nil
}
type DetectionSaver struct {
}
func (saver DetectionSaver) Process(ctx *Context) (result define.FlowResult, error error) {
event := ctx.GetEventData()
fmt.Printf("save detection. eventId: %s\n", (*event).GetEventId())
return define.FlowResult{200}, nil
}
func (saver DetectionSaver) GetName() string {
return getName(saver)
}
type Empty struct {
}
func (Empty) Process(ctx *Context) (result define.FlowResult, error error) {
return define.FlowResult{200}, nil
}
func (empty Empty) GetName() string {
return getName(empty)
}
var (
lock *sync.Mutex = &sync.Mutex{}
hostComponent *HostCompletionComponent
detectionSaverComponent *DetectionSaver
empty *Empty
componentFactory *ComponentFactory
)
func GetHostCompletionComponentInstance() *HostCompletionComponent {
if hostComponent == nil {
lock.Lock()
defer lock.Unlock()
if hostComponent == nil {
hostComponent = &HostCompletionComponent{}
fmt.Println("HostCompletionComponent single instance...")
}
}
return hostComponent
}
func GetDetectionSaverComponentInstance() *DetectionSaver {
if detectionSaverComponent == nil {
lock.Lock()
defer lock.Unlock()
if detectionSaverComponent == nil {
detectionSaverComponent = &DetectionSaver{}
fmt.Println("DetectionSaver single instance...")
}
}
return detectionSaverComponent
}
func GetEmptyInstance() *Empty {
if empty == nil {
lock.Lock()
defer lock.Unlock()
if empty == nil {
empty = &Empty{}
fmt.Println("Empty single instance...")
}
}
return empty
}
type ComponentFactory struct {
}
func GetComponentFactoryInstance() *ComponentFactory {
if componentFactory == nil {
lock.Lock()
defer lock.Unlock()
if componentFactory == nil {
componentFactory = &ComponentFactory{}
fmt.Println("ComponentFactory single instance...")
}
}
return componentFactory
}
func (*ComponentFactory) Instanceof(compName int) FlowComponent {
switch compName {
case HostCompletionComponentName:
return GetHostCompletionComponentInstance()
case DetectionSaverName:
return GetDetectionSaverComponentInstance()
default:
return GetEmptyInstance()
}
}
var componentMap = map[string]FlowComponent {}
func (*ComponentFactory) Init() {
hcc := GetHostCompletionComponentInstance()
componentMap[hcc.GetName()] = hcc
saver := GetDetectionSaverComponentInstance()
componentMap[saver.GetName()] = saver
}
func (*ComponentFactory) GetByName(name string) FlowComponent {
return componentMap[name]
}
func MapValue(ints []int, f func(i int) FlowComponent) []FlowComponent {
result := make([]FlowComponent, len(ints))
for i, v := range ints {
result[i] = f(v)
}
return result
}
func Exec(components []FlowComponent, ctx *Context) (err error) {
for _, comp := range components {
res, err := comp.Process(ctx)
if err != nil {
fmt.Println(err)
return err
}
if res.Code == define.TERMINAL {
panic("Flow terminated")
}
}
return nil
}
main.go
package main
import (
"fmt"
"github.com/qt/eventflow/pkg/compos"
"github.com/qt/eventflow/pkg/define"
"github.com/qt/eventflow/pkg/yaml"
"reflect"
)
func main() {
//testBasic()
testComponentExecution()
}
func testBasic() {
testPublicMemberConstruct()
testPrivateMemberConstruct()
testFactoryMethod()
testEmptyObject()
testSingleton()
testClassMethod()
testReadYaml()
}
func testPublicMemberConstruct() {
result := &define.FlowResult{ 200 }
fmt.Println(result)
fmt.Println(reflect.TypeOf(result))
}
func testPrivateMemberConstruct() {
//agent := &compos.AgentDetection{ "eventId", "agentId", 1 }
//error: implicit assignment of unexported field 'eventId' in compos.AgentDetection literal
empty := compos.AgentDetection{}
fmt.Println(empty)
fmt.Println(reflect.TypeOf(empty))
detection := compos.AgentDetection{}.Instanceof("agentId", 1)
fmt.Printf("d: %v\n", detection)
detection2 := compos.AgentDetection{}.InstanceByNaming("agentId", 1)
fmt.Printf("d2: %v\n", detection2)
fmt.Println("eventId: " + detection2.GetEventId())
detection3 := compos.NewAgentDetection("agentId", 1)
fmt.Printf("d3: %v\n", detection3)
}
func testFactoryMethod() {
adf := compos.GetAgentFactoryInstance()
detection := adf.Instanceof("agentId", 2)
fmt.Printf( "detection from factory method: %v\n", detection)
}
func testEmptyObject() {
var emp compos.AgentDetection
p1 := &emp
demp := emp.Instanceof("agentId", 1)
fmt.Printf("demp: %v\n", demp)
fmt.Println(emp)
fmt.Println(reflect.TypeOf(emp))
var emp2 compos.AgentDetection
p2 := &emp2
fmt.Println("compare reference to empty agentDetection")
compareObj(emp, emp2)
fmt.Println("compare pointers to empty agentDetection")
compareAgentDetection(p1, p2)
emp3 := &compos.AgentDetection{}
emp4 := &compos.AgentDetection{}
fmt.Println("compare pointers to empty2 agentDetection")
compareAgentDetection(emp3, emp4)
}
func compareObj(o1 interface{}, o2 interface{}) {
fmt.Printf("o1: %v\n", o1)
fmt.Printf("o2: %v\n", o2)
fmt.Printf("o1-p: %p\n", o1)
fmt.Printf("o2-p: %p\n", o2)
fmt.Printf("&o1: %v\n", &o1)
fmt.Printf("&o2: %v\n", &o2)
fmt.Printf("o1 == o2: %v\n", (o1 == o2))
fmt.Printf("&o1 == &o2: %v\n", &o1 == &o2)
}
func compareAgentDetection(adp1 *compos.AgentDetection, adp2 *compos.AgentDetection) {
fmt.Printf("adp1: %v\n", adp1)
fmt.Printf("adp2: %v\n", adp2)
fmt.Printf("adp1-p: %p\n", adp1)
fmt.Printf("adp2-p: %p\n", adp2)
fmt.Printf("*adp1: %v\n", *adp1)
fmt.Printf("*adp2: %v\n", *adp2)
fmt.Printf("&adp1: %v\n", &adp1)
fmt.Printf("&adp2: %v\n", &adp2)
fmt.Printf("adp1 == adp2: %v\n", (adp1 == adp2))
fmt.Printf("&adp1 == &adp2: %v\n", &adp1 == &adp2)
fmt.Printf("*adp1 == *adp2: %v\n", *adp1 == *adp2)
}
func testSingleton() {
adf := compos.GetAgentFactoryInstance()
adf2 := compos.GetAgentFactoryInstance()
compare(adf, adf2)
}
func compare(p1 *compos.AgentDetectionFactory, p2 *compos.AgentDetectionFactory) {
fmt.Printf("adf: %v\n", p1)
fmt.Printf("adf2: %v\n", p2)
fmt.Printf("adf-p: %p\n", p1)
fmt.Printf("adf2-p: %p\n", p2)
fmt.Printf("*adf: %v\n", *p1)
fmt.Printf("*adf2: %v\n", *p2)
fmt.Printf("&adf: %v\n", &p1)
fmt.Printf("&adf2: %v\n", &p2)
fmt.Printf("adf == adf2: %v\n", (p1 == p2))
fmt.Printf("&adf == &adf2: %v\n", &p1 == &p2)
fmt.Printf("*adf == *adf2: %v\n", *p1 == *p2)
}
func testClassMethod() {
withoutStar := compos.AgentDetection{}
ad := withoutStar.Instanceof("agentId111", 1)
fmt.Printf("ad: %v\n", ad)
withoutStar2 := &compos.AgentDetection{}
ad2 := withoutStar2.Instanceof("agentId222", 1)
fmt.Printf("ad: %v\n", ad2)
withStar := compos.AgentDetectionFactory{}
ad3 := withStar.Instanceof("agentId333", 1)
fmt.Printf("ad3: %v\n", ad3)
withStar2 := &compos.AgentDetectionFactory{}
ad4 := withStar2.Instanceof("agentId444", 1)
fmt.Printf("ad4: %v\n", ad4)
}
func testReadYaml() {
yaml.ReadYaml()
}
func testComponentExecution() {
//ctx := &compos.Context{ &event } //Cannot assign a value to the unexported field 'event'
detection := compos.AgentDetection{}.Instanceof("agentId", 1)
var event define.EventData = detection
ctx := compos.Context{}.New(&event)
cf := compos.GetComponentFactoryInstance()
cf.Init()
ch := make(chan int, 4)
defer close(ch)
go func() {
ch <- 0
ch <- 1
ch <- 2
ch <- 3
ch <- -1
}()
for {
select {
case msg := <- ch:
if (msg == 0) {
execDirect(ctx)
}
if (msg == 1) {
execRange(ctx)
}
if (msg == 2) {
execRange2(ctx, cf)
}
if (msg == 3) {
execByArrange(ctx, cf)
}
if (msg == -1) {
return
}
}
}
}
func execDirect(ctx *compos.Context) {
fmt.Println("execDirect")
fc := &compos.HostCompletionComponent{}
saver := &compos.DetectionSaver{}
fc.Process(ctx)
saver.Process(ctx)
}
func execRange(ctx *compos.Context) {
fmt.Println("execRange")
components := [...]compos.FlowComponent{&compos.HostCompletionComponent{}, &compos.DetectionSaver{} }
for _, comp := range components {
res, err := comp.Process(ctx)
if err != nil {
fmt.Println(err)
}
if res.Code == define.TERMINAL {
panic("Flow terminated")
}
}
}
func execRange2(ctx *compos.Context, cf *compos.ComponentFactory) {
fmt.Println("execRange2")
components := compos.MapValue([]int { compos.HostCompletionComponentName, compos.DetectionSaverName}, cf.Instanceof)
compos.Exec(components, ctx)
}
func execByArrange(ctx *compos.Context, cf *compos.ComponentFactory) {
fmt.Println("execByArrange")
flow := yaml.Read("./configs/eventflow.yml")
components := make([]compos.FlowComponent, 2)
for _, f := range flow.Flows {
fmt.Println(f.BizTypes)
for i, c := range f.ComponentConfigs {
if trueComp := cf.GetByName(c.Name) ; trueComp != nil {
components[i] = trueComp
}
}
}
compos.Exec(components, ctx)
}
readyaml.go
package yaml
import (
"fmt"
"gopkg.in/yaml.v3"
"io/ioutil"
"log"
)
type CommonConfig struct {
eventType string `yaml:"eventType"`
EventSourceType string `yaml:"eventSourceType"`
Model string `yaml:"model"`
Way string `yaml:"way"`
OriginParamType string `yaml:"originParamType"`
BuilderType string `yaml:"builderType"`
ComponentParamType string `yaml:"componentParamType"`
}
type ComponentConfig struct {
Name string `yaml:"name"`
}
type Flow struct {
BizTypes []string `yaml:"bizTypes"`
CommonConfig CommonConfig `yaml:"commonConfig"`
ComponentConfigs []ComponentConfig `yaml:"componentConfigs"`
}
type EventFlow struct {
Version string `yaml:"version"`
Flows []Flow `yaml:"flows"`
}
func Read(filename string) EventFlow {
ef := EventFlow{}
yamlFile, err := ioutil.ReadFile(filename)
if err != nil {
fmt.Println(err.Error())
}
//fmt.Println(string(yamlFile))
err2 := yaml.Unmarshal(yamlFile, &ef)
if err2 != nil {
log.Fatalf("error: %v", err2)
}
return ef
}
func ReadYaml() {
ef := Read("./configs/eventflow.yml")
fmt.Println(ef)
for _, f := range ef.Flows {
fmt.Println(f.BizTypes)
fmt.Println(f.CommonConfig)
for _, c := range f.ComponentConfigs {
fmt.Println(c.Name)
}
}
}
eventflow.yaml
version: 1.0
flows:
- bizTypes:
- 'common'
commonConfig:
eventType: 'create'
eventSourceType: 'agent_event'
model: 'EVENTFLOW'
way: 'SERIAL'
originParamType: 'compos.AgentDetection'
builderType: 'compos.ContextBuilder'
componentParamType: 'compos.Context'
componentConfigs:
- name: 'compos.HostCompletionComponent'
- name: 'compos.DetectionSaver'