Go 重构案例分享：订单创建逻辑重构

背景：从 PHP (Laravel) 到 Go 的模式迁移

•原 PHP (Laravel) 实现思路：核心模式： “行为管道” (Behavior Pipeline)。如何工作： 将订单创建拆分成多个独立的小任务 (如：请求限流、素材验证、创建订单、调用支付、埋点)。每个任务是一个实现了特定接口 (BehaviorOrderCreateInterface) 的类。执行过程： 将这些任务类注册到一个列表中。创建订单时，按顺序执行列表里每个任务的 handle 方法。状态共享： 每个任务在执行时，能访问和修改同一个“订单创建服务”对象 (OrderCreateService)，通过它传递数据和状态（比如订单创建后，埋点任务需要用到订单ID）。异常处理： 使用 try-catch 捕获异常并进行事务回滚。

makeOrder 创建订单方法

/**
     * 生成订单
     * @param $params
     * @return string[]
     * @date 2023/6/6 13:30
     * @throws \Exception
     */
    public function makeOrder($params): array
    {
        $db = DB::connection(DbEnum::MYSQL_RELEBOOK);
        $db->beginTransaction();

        try {
            $data = (new OrderCreateService($params))->registerBehavior(
                function () {
                    return new RequestLimit();
                },
                function () {
                    return new ResValidate();
                },
                function () {
                    return new Order();
                },
                function () {
                    return new Payment();
                },
                function () {
                    return new OrderBuried();
                },
            )->create();

            $db->commit();

            return $data;
        } catch (\LogicException $logicException) {
            $db->rollback();
            // 异常code码（CODE_117006008）返回素材信息，不直接抛异常
            if ($logicException->getCode() == RelebookUserCodeEnum::CODE_117006008) {
                $data = collect(json_decode($logicException->getMessage()))->toArray();
                $data['order_no'] = '';
                $data['pay_url'] = '';
                return $data;
            }
            throw new \LogicException($logicException->getMessage(), $logicException->getCode());
        } catch (\Exception $exception) {
            $db->rollback();
            throw new \Exception($exception->getMessage(), intval($exception->getCode()));
        }
    }

BehaviorOrderCreateInterface 接口

interface BehaviorOrderCreateInterface
{
    public function handle(OrderCreateService $orderCreateService);

}

OrderCreateService 订单创建服务

class OrderCreateService
{

    public array $params;

    public array $params;
    /** 素材信息 **/
    public array $res;
    /**订单信息 **/
    public array $order_info;
    /**子订单信息 **/
    public array $subOrders;
    /**购物车信息 **/
    public array $cartItem;
    /**支付服务 **/
    public PaymentInterface $paymentService;
    /**支付信息 **/
    public array $payment;

    /**
     * @var array|\Closure[]
     */
    private array $behaviorList = [];

    public function __construct($params)
    {
        $this->params = $params;
    }

    /**
     * 订单创建行为注册
     * @param \Closure ...$callback
     * @return $this
     * @date 2023/6/29 13:58
     */
    public function registerBehavior(\Closure ...$callback): static
    {
        $this->behaviorList = array_merge($this->behaviorList,$callback);
        return $this;
    }

 /**
     * 创建订单
     * @return mixed
     * @date 2023/6/29 14:21
     */
    public function create()
    {
        $this->params['order_type'] = PayEnum::ORDER_TYPE_RES;

        // A、执行订单创建行为
        foreach ($this->behaviorList as $behavior) {
            $behavior()->handle($this);
        }

        // B、订单返回数据
        $this->data = array_merge($this->data, $this->payment);
        $this->data['order_type'] = $this->params['order_type'];
        $this->data['cash_type'] = $this->params['cash_type'];
        $this->data['order_no'] = $this->order_info['order_no'];
        $this->data['pay_url'] = $this->payment['pay_url'];
        $this->data['type'] = RelebookUserOrder::ORDER_CREATE_STATUS_SUCCESS;
        $this->data['res'] = [];

        return $this->data;
    }

}

Go 重构的挑战与解决方案

•挑战 1：状态共享 (Go 没有类属性)问题： Go 没有类的概念，不同的小任务（函数/方法）不能直接共享一个“服务对象”的状态。解决方案： 引入 DTO (Data Transfer Object)。DTO 是什么？ 一个专门用来在不同部分之间传递数据的结构体。它就像是一个共享的“数据盒子”。作用： 将所有小任务需要共享的数据（请求参数、中间结果、最终响应、错误信息）都定义在这个结构体 (OrderBehaviorDTO) 里。如何工作： 每个小任务接收这个 DTO 指针作为参数，从中读取需要的数据，并将自己产生的结果写回到 DTO 中。这样，后续的任务就能访问到前面任务写入的数据。

•挑战 2：异常处理 (Go 没有 try-catch)问题： Go 通常通过函数返回 error 值来处理错误，不能像 PHP 那样在任意地方 throw 并被外层 catch。解决方案：在 DTO 中加入专门的错误字段 (Err)。每个小任务在执行过程中，如果遇到错误，不直接 panic 或抛异常，而是将错误信息设置到 DTO 的 Err 字段 (或 Response.Code/ErrMsg) 中，然后返回 DTO。主流程 (Handle 方法) 检查每个任务执行后 DTO 中的错误状态。一旦发现错误，立即终止后续任务并返回错误响应。

Go 实现的核心逻辑 (简化说明)

1.定义 DTO 结构体 (OrderBehaviorDTO): 包含所有需要流转的数据（输入参数、支付结果、订单信息、错误码等）。

2.定义任务接口 (BehaviorOrderCreateInterface): 要求所有小任务都必须实现一个 Handle(*OrderBehaviorDTO) *OrderBehaviorDTO 方法。

3.创建主服务 (MakeOrderService):初始化时创建 DTO。将需要执行的小任务 (如 OrderValidate, OrderCreate, OrderPayment, OrderBuried) 添加到任务列表 (Behavior 切片)。

4.执行主流程 (Handle 方法):按顺序遍历任务列表，调用每个任务的 Handle 方法，并传入 同一个 DTO 指针。每个任务从 DTO 读数据，处理业务，把结果写回 DTO。检查每个任务执行后 DTO 中的错误状态，遇错即停。

5.组装最终响应： 所有任务成功后，从 DTO 中提取所需数据，组装成最终的订单创建响应 (OrderMakeResponse)。

关键优势 (使用 DTO + 接口模式)

•解耦清晰： 每个小任务只依赖 DTO 接口，不直接依赖其他任务的具体实现。

•状态管理： DTO 作为唯一的、明确的数据交换通道，解决了 Go 中跨函数/方法状态共享的问题。

•灵活可扩展： 添加新任务只需实现接口并注册到列表即可。

•错误处理适配 Go 习惯： 通过返回值和 DTO 中的错误状态显式处理错误，符合 Go 的 error 处理哲学。

实现代码：

1.定义DTO结构体内容

// OrderBehaviorDTO 用于解耦在不同结构体(服务)里面传递的数据结构体

type OrderBehaviorDTO struct {

Params *order.OrderMakeRequest // 请求参数

Response *order.OrderMakeResponse // 响应参数

UserId int // 用户id

Uid string // uid

CartItem []relebook.LlRelebookCartItem // 子服务查询产生的购物车信息

Res map[int32]relebook.LlRelebookRes // 子服务查询产生的素材信息

Orders OrderInfos // 子服务创建的订单信息 -用于埋点

PayResult payment.PayResult // 支付子服务产生的支付信息 -用于埋点

Err Errer

}

// 响应参数的proto

message OrderMakeResponse {

string order_no = 1;

string pay_url = 2;

string payment_intent_id = 3;

string client_secret = 4;

int32 order_type = 5;

int32 cash_type = 6;

int32 type = 7;

repeated Empty res = 8;

// 异常码和返回消息

int32 code = 9;

string err_msg = 10;

}

1.将订单限流功能抽离成限流组件

2.执行 orderService.NewMakeOrder方法 实例化订单创建服务并注入DTO结构体然后调用.Handle方法

func (OrderLogic) OrderMake(ctx context.Context, in order.OrderMakeRequest) (order.OrderMakeResponse, error) {

// 订单请求限制

if utils.SlidingWindowRateLimiter(utils.GetLimitKey(ctx, "make_order"), 1, time.Second1) != nil {

result := &order.OrderMakeResponse{}

result.Code = code.CODE_117001011

result.ErrMsg = lang.OperatingLimit

return result, nil

}

// 开始执行业务

return orderService.NewMakeOrder(&dto.OrderBehaviorDTO{

Params: in,

Response: &order.OrderMakeResponse{},

UserId: cast.ToInt(trace.GetUserId(ctx)),

Uid: in.Uid,

}).Handle()

}

MakeOrderService结构体内容

type MakeOrderService struct {
	payService payment.PaymentInterface // 支付服务接口
	resInfos   map[int32]relebook.LlRelebookRes // 订单支付的素材
	resDAOImpl dao.ResDAOImpl // 素材表DAO封装的查询集合
	userId     int // 用户id
	Dto        *dto.OrderBehaviorDTO // DTO
	Behavior   []BehaviorOrderCreateInterface // 行为单元
}

type BehaviorOrderCreateInterface interface {
	Handle(Dto *dto.OrderBehaviorDTO) *dto.OrderBehaviorDTO
}

func (m *MakeOrderService) SetBehavior(behavior BehaviorOrderCreateInterface) *MakeOrderService {
	m.Behavior = append(m.Behavior, behavior)
	return m
}

func NewMakeOrder(Dto *dto.OrderBehaviorDTO) *MakeOrderService {
	service, _ := payment.GetPaymentService(int(Dto.Params.CashType))
	return &MakeOrderService{
		payService: service,
		Dto:        Dto,
	}
}
func (m *MakeOrderService) Handle() (*order.OrderMakeResponse, error) {
	// 支付验签
	if err := m.payService.Validate(payment.PaymentParams{}); err != nil {
		m.Dto.Response.Code = code.CODE_117001001
		m.Dto.Response.ErrMsg = err.Error()
		return m.Dto.Response, nil
	}
	//设置需要写入的服务
	m.SetBehavior(new(behavior_create.OrderValidate)).
		SetBehavior(new(behavior_create.OrderCreate)).
		SetBehavior(new(behavior_create.OrderPayment)).
		SetBehavior(new(behavior_create.OrderBuried))
	// 执行服务
	for _, behavior := range m.Behavior {
		if behavior.Handle(m.Dto).Response.Code != 0 {
			return m.Dto.Response, nil
		}
	}
	// 执行完成后
	m.Dto.Response.ClientSecret = m.Dto.PayResult.ClientSecret
	m.Dto.Response.PayUrl = m.Dto.PayResult.PaymentIntentId
	m.Dto.Response.PayUrl = m.Dto.PayResult.PayUrl
	m.Dto.Response.OrderType = m.Dto.Params.OrderType
	m.Dto.Response.CashType = m.Dto.Params.CashType
	m.Dto.Response.OrderNo = m.Dto.Orders.OrderInfo.OrderNo
	m.Dto.Response.Type = relebook.ORDER_CREATE_STATUS_SUCCESS

	return m.Dto.Response, nil
}