Golang线程安全的串行和并行命令调度器插件库command的使用

简介

Command是一个Go语言实现的命令模式库，提供了线程安全的串行和并行命令调度器功能。

安装

go get -u github.com/txgruppi/command

测试

go get -u -t github.com/txgruppi/command
cd $GOPATH/src/github.com/txgruppi/command
go test ./...

使用示例

基本命令实现

首先我们需要定义一个实现command.Command接口的结构体：

package main

import (
	"fmt"
	"github.com/txgruppi/command"
)

// MyCommand 自定义命令
type MyCommand struct {
	name string
}

// Execute 实现Command接口
func (c *MyCommand) Execute() error {
	fmt.Printf("Executing command: %s\n", c.name)
	return nil
}

func main() {
	cmd := &MyCommand{name: "test"}
	err := cmd.Execute()
	if err != nil {
		fmt.Printf("Error executing command: %v\n", err)
	}
}

串行调度器使用示例

package main

import (
	"fmt"
	"github.com/txgruppi/command"
)

// SerialCommand 示例命令
type SerialCommand struct {
	id int
}

func (c *SerialCommand) Execute() error {
	fmt.Printf("Serial command %d executed\n", c.id)
	return nil
}

func main() {
	// 创建串行调度器
	serialDispatcher := command.NewSerialDispatcher()

	// 添加命令到调度器
	for i := 0; i < 5; i++ {
		serialDispatcher.Add(&SerialCommand{id: i})
	}

	// 执行所有命令(串行)
	err := serialDispatcher.Dispatch()
	if err != nil {
		fmt.Printf("Error dispatching commands: %v\n", err)
	}
}

并行调度器使用示例

package main

import (
	"fmt"
	"github.com/txgruppi/command"
	"time"
)

// ParallelCommand 示例命令
type ParallelCommand struct {
	id int
}

func (c *ParallelCommand) Execute() error {
	time.Sleep(time.Duration(c.id) * time.Second)
	fmt.Printf("Parallel command %d executed\n", c.id)
	return nil
}

func main() {
	// 创建并行调度器
	parallelDispatcher := command.NewParallelDispatcher()

	// 添加命令到调度器
	for i := 0; i < 5; i++ {
		parallelDispatcher.Add(&ParallelCommand{id: i})
	}

	// 执行所有命令(并行)
	err := parallelDispatcher.Dispatch()
	if err != nil {
		fmt.Printf("Error dispatching commands: %v\n", err)
	}
}

混合使用串行和并行调度器

package main

import (
	"fmt"
	"github.com/txgruppi/command"
)

// MixedCommand 示例命令
type MixedCommand struct {
	name string
}

func (c *MixedCommand) Execute() error {
	fmt.Printf("Executing: %s\n", c.name)
	return nil
}

func main() {
	// 创建主调度器(串行)
	mainDispatcher := command.NewSerialDispatcher()

	// 创建并行子调度器
	parallelDispatcher := command.NewParallelDispatcher()
	parallelDispatcher.Add(&MixedCommand{name: "Parallel 1"})
	parallelDispatcher.Add(&MixedCommand{name: "Parallel 2"})

	// 将并行调度器作为命令添加到主调度器
	mainDispatcher.Add(parallelDispatcher)
	
	// 添加串行命令
	mainDispatcher.Add(&MixedCommand{name: "Serial 1"})
	mainDispatcher.Add(&MixedCommand{name: "Serial 2"})

	// 执行调度
	err := mainDispatcher.Dispatch()
	if err != nil {
		fmt.Printf("Error dispatching commands: %v\n", err)
	}
}

错误处理

package main

import (
	"errors"
	"fmt"
	"github.com/txgruppi/command"
)

// ErrorCommand 会返回错误的命令
type ErrorCommand struct{}

func (c *ErrorCommand) Execute() error {
	return errors.New("example error")
}

func main() {
	dispatcher := command.NewSerialDispatcher()
	dispatcher.Add(&ErrorCommand{})

	err := dispatcher.Dispatch()
	if err != nil {
		fmt.Printf("Received error: %v\n", err)
	}
}

许可证

MIT