1 简介

本文简介管道-过滤器和数据仓储架构风格的异同和示例。

	适用功能			管道-过滤器							数据仓储
	交互方式		组件通过管道相互连接，					数据通过中心仓储存储和管理，
    		数据流动按顺序通过过滤器逐步处理，			多个组件可直接访问数据仓储，
           每个过滤器独立完成特定任务。				通过查询和操作进行数据交互。

	数据结构		数据流是主要结构，					数据以关系型或非关系型结构存储在仓储中，
    			通常以简单的流式数据或消息格式传递，		支持复杂的查询操作，
            避免组件间的复杂依赖。						数据结构通常稳定但复杂。
	
	控制结构		数据驱动，数据触发流程，				中心化控制，组件通过直接操作仓储
            过滤器按顺序执行，数据流动决定控制流。  读写操作外部控制逻辑驱动数据更新访问。
	
	扩展方法		添加新的过滤器模块或管道可以扩展功能，
    				但需要确保数据格式一致性。	     增加新的数据表、索引或数据访问组件实现
					，系统易于分离和组合					适合复杂的数据分析和查询场景。

2 实现管道-过滤器架构：订单管理

每个状态是一个过滤器。
数据流在过滤器之间按顺序传递，每个过滤器处理特定状态。
实现代码

	// Order represents an order with its state
	type Order struct {
		ID     string
		Status string
	}

	// Filter represents a processing step in the pipeline
	type Filter interface {
		Process(order Order) Order
	}

	// CreatedFilter handles orders in the "Created" state
	type CreatedFilter struct{}

	func (f *CreatedFilter) Process(order Order) Order {
		if order.Status == "Created" {
			fmt.Println("Processing: Created -> InDelivery")
			order.Status = "InDelivery"
		}
		return order
	}

	// InDeliveryFilter handles orders in the "InDelivery" state
	type InDeliveryFilter struct{}

	func (f *InDeliveryFilter) Process(order Order) Order {
		if order.Status == "InDelivery" {
			fmt.Println("Processing: InDelivery -> PendingConfirmation")
			order.Status = "PendingConfirmation"
		}
		return order
	}

	// PendingConfirmationFilter handles orders in the "PendingConfirmation" state
	type PendingConfirmationFilter struct{}

	func (f *PendingConfirmationFilter) Process(order Order) Order {
		if order.Status == "PendingConfirmation" {
			fmt.Println("Processing: PendingConfirmation -> Completed")
			order.Status = "Completed"
		}
		return order
	}

	// Pipeline represents the pipeline of filters
	type Pipeline struct {
		filters []Filter
	}

	func (p *Pipeline) AddFilter(filter Filter) {
		p.filters = append(p.filters, filter)
	}

	func (p *Pipeline) Process(order Order) Order {
		for _, filter := range p.filters {
			order = filter.Process(order)
		}
		return order
	}

	func main() {
		order := Order{ID: "12345", Status: "Created"}

		pipeline := &Pipeline{}
		pipeline.AddFilter(&CreatedFilter{})
		pipeline.AddFilter(&InDeliveryFilter{})
		pipeline.AddFilter(&PendingConfirmationFilter{})

		finalOrder := pipeline.Process(order)
		fmt.Printf("Final Order: %+v\n", finalOrder)
	}

3 实现数据仓储架构：订单管理

示例说明，数据存储在中心化仓储。
操作通过函数直接更新仓储状态。
实现代码

	// Order represents an order
	type Order struct {
		ID     string
		Status string
	}

	// OrderRepository is the central data warehouse for orders
	type OrderRepository struct {
		orders map[string]*Order
	}

	func NewOrderRepository() *OrderRepository {
		return &OrderRepository{orders: make(map[string]*Order)}
	}

	func (r *OrderRepository) AddOrder(order *Order) {
		r.orders[order.ID] = order
	}

	func (r *OrderRepository) UpdateStatus(orderID string, newStatus string) error {
		order, exists := r.orders[orderID]
		if !exists {
			return fmt.Errorf("order not found")
		}
		order.Status = newStatus
		return nil
	}

	func (r *OrderRepository) GetOrder(orderID string) (*Order, error) {
		order, exists := r.orders[orderID]
		if !exists {
			return nil, fmt.Errorf("order not found")
		}
		return order, nil
	}

	func main() {
		repo := NewOrderRepository()

		// Add a new order
		order := &Order{ID: "12345", Status: "Created"}
		repo.AddOrder(order)

		// Update order statuses
		repo.UpdateStatus("12345", "InDelivery")
		repo.UpdateStatus("12345", "PendingConfirmation")
		repo.UpdateStatus("12345", "Completed")

		// Retrieve and display the order
		finalOrder, err := repo.GetOrder("12345")
		if err != nil {
			fmt.Println("Error:", err)
		} else {
			fmt.Printf("Final Order: %+v\n", finalOrder)
		}
	}

4 比较与选择

管道-过滤器架构:

更适合需要顺序处理的数据流应用。
模块化强，易于添加新过滤器。
控制逻辑分散，每个过滤器独立。

数据仓储架构:

更适合中心化存储和管理的复杂业务逻辑。
数据访问统一，易于扩展查询功能。
适合多组件并发操作和复杂数据关系管理。

在订单状态管理场景中，选择架构取决于具体需求。如果业务流程复杂且需多步骤顺序执行，可选用管道-过滤器；
若涉及多组件数据访问和复杂查询，则推荐数据仓储。