规则引擎（Rule Engine）设计与 Go 实战笔记

package ruleengine

import (
	"fmt"
	"reflect"
	"strings"
	"sync"
)

// Operator 比较操作符
type Operator string

const (
	OpEq       Operator = "="
	OpNe       Operator = "!="
	OpGt       Operator = ">"
	OpGte      Operator = ">="
	OpLt       Operator = "<"
	OpLte      Operator = "<="
	OpContains Operator = "CONTAINS"
)

// LogicOperator 逻辑操作符
type LogicOperator string

const (
	LogicAnd LogicOperator = "AND"
	LogicOr  LogicOperator = "OR"
)

// Condition 单个条件（原子节点）
type Condition struct {
	Field    string      `json:"field"`    // Fact 中的字段 key
	Operator Operator    `json:"operator"` // 比较操作符
	Value    interface{} `json:"value"`    // 期望目标值
}

// Evaluate 校验单个条件
func (c *Condition) Evaluate(fact map[string]interface{}) bool {
	val, exists := fact[c.Field]
	if !exists {
		return false
	}

	switch c.Operator {
	case OpEq:
		return reflect.DeepEqual(val, c.Value)
	case OpNe:
		return !reflect.DeepEqual(val, c.Value)
	case OpGt:
		return toFloat64(val) > toFloat64(c.Value)
	case OpGte:
		return toFloat64(val) >= toFloat64(c.Value)
	case OpLt:
		return toFloat64(val) < toFloat64(c.Value)
	case OpLte:
		return toFloat64(val) <= toFloat64(c.Value)
	case OpContains:
		str, ok := val.(string)
		substr, ok2 := c.Value.(string)
		return ok && ok2 && strings.Contains(str, substr)
	default:
		return false
	}
}

// RuleNode 表达式节点（可以包含直接条件或子节点逻辑树）
type RuleNode struct {
	Logic      LogicOperator `json:"logic,omitempty"`      // AND / OR
	Conditions []Condition   `json:"conditions,omitempty"` // 单条件列表
	Children   []RuleNode    `json:"children,omitempty"`   // 嵌套子节点
}

// Evaluate 递归求值表达式树
func (n *RuleNode) Evaluate(fact map[string]interface{}) bool {
	// 如果是组合逻辑节点 (AND / OR)
	if n.Logic == LogicOr {
		for _, c := range n.Conditions {
			if c.Evaluate(fact) {
				return true
			}
		}
		for _, child := range n.Children {
			if child.Evaluate(fact) {
				return true
			}
		}
		return false
	}

	// 默认使用 AND 逻辑
	for _, c := range n.Conditions {
		if !c.Evaluate(fact) {
			return false
		}
	}
	for _, child := range n.Children {
		if !child.Evaluate(fact) {
			return false
		}
	}
	return true
}

// Action 规则命中后的触发动作函数
type Action func(fact map[string]interface{}) interface{}

// Rule 规则对象
type Rule struct {
	ID       string   `json:"id"`
	Name     string   `json:"name"`
	Priority int      `json:"priority"` // 优先级，越大越优先
	RootNode RuleNode `json:"root_node"`
	ActionFn Action   `json:"-"`
}

// Engine 规则引擎（包含线程安全的热更新与执行）
type Engine struct {
	mu    sync.RWMutex
	rules map[string]*Rule
}

func NewEngine() *Engine {
	return &Engine{
		rules: make(map[string]*Rule),
	}
}

// RegisterRule 注册/更新规则（支持热加载）
func (e *Engine) RegisterRule(rule *Rule) {
	e.mu.Lock()
	defer e.mu.Unlock()
	e.rules[rule.ID] = rule
}

// RemoveRule 卸载规则
func (e *Engine) RemoveRule(ruleID string) {
	e.mu.Lock()
	defer e.mu.Unlock()
	delete(e.rules, ruleID)
}

// Execute 传入 Fact 数据，触发匹配的规则
func (e *Engine) Execute(fact map[string]interface{}) map[string]interface{} {
	e.mu.RLock()
	defer e.mu.RUnlock()

	results := make(map[string]interface{})

	for _, rule := range e.rules {
		if rule.RootNode.Evaluate(fact) {
			if rule.ActionFn != nil {
				results[rule.ID] = rule.ActionFn(fact)
			} else {
				results[rule.ID] = "MATCHED"
			}
		}
	}
	return results
}

// 辅助数值转换函数
func toFloat64(val interface{}) float64 {
	switch v := val.(type) {
	case int:
		return float64(v)
	case int64:
		return float64(v)
	case float64:
		return v
	case float32:
		return float64(v)
	default:
		return 0
	}
}

package main

import (
	"fmt"
	"ruleengine"
)

func main() {
	// 1. 初始化规则引擎
	engine := ruleengine.NewEngine()

	// 2. 配置规则：VIP大额订单打折规则 ( (Amount >= 1000 AND UserLevel == 3) OR UserTags CONTAINS "VIP" )
	discountRule := &ruleengine.Rule{
		ID:       "rule_discount_001",
		Name:     "大额 VIP 订单打折规则",
		Priority: 10,
		RootNode: ruleengine.RuleNode{
			Logic: ruleengine.LogicOr,
			Children: []ruleengine.RuleNode{
				{
					Logic: ruleengine.LogicAnd,
					Conditions: []ruleengine.Condition{
						{Field: "amount", Operator: ruleengine.OpGte, Value: 1000},
						{Field: "user_level", Operator: ruleengine.OpEq, Value: 3},
					},
				},
			},
			Conditions: []ruleengine.Condition{
				{Field: "user_tag", Operator: ruleengine.OpContains, Value: "VIP"},
			},
		},
		ActionFn: func(fact map[string]interface{}) interface{} {
			amount := fact["amount"].(int)
			discountAmount := float64(amount) * 0.8
			return fmt.Sprintf("匹配成功！原价 %d，享8折优惠，现价: %.2f", amount, discountAmount)
		},
	}

	// 3. 注册规则到引擎
	engine.RegisterRule(discountRule)

	// 4. 输入 Fact 事实对象模拟测试
	fact1 := map[string]interface{}{
		"amount":     1200,
		"user_level": 3,
		"user_tag":   "NORMAL",
	}

	fact2 := map[string]interface{}{
		"amount":     200,
		"user_level": 1,
		"user_tag":   "NORMAL",
	}

	fmt.Println("--- 测试 Fact 1 (满足大额VIP) ---")
	res1 := engine.Execute(fact1)
	for ruleID, res := range res1 {
		fmt.Printf("[%s]: %v\n", ruleID, res)
	}

	fmt.Println("\n--- 测试 Fact 2 (不满足规则) ---")
	res2 := engine.Execute(fact2)
	if len(res2) == 0 {
		fmt.Println("未命中任何规则")
	}
}