背景:从 PHP (Laravel) 到 Go 的模式迁移
- 原 PHP (Laravel) 实现思路:核心模式: "行为管道" (Behavior Pipeline)。
- 如何工作: 将订单创建拆分成多个独立的小任务 (如:请求限流、素材验证、创建订单、调用支付、埋点)。每个任务是一个实现了特定接口 (BehaviorOrderCreateInterface) 的类。
- 执行过程: 将这些任务类注册到一个列表中。创建订单时,按顺序执行列表里每个任务的 handle 方法。
- 状态共享: 每个任务在执行时,能访问和修改同一个"订单创建服务"对象 (OrderCreateService),通过它传递数据和状态(比如订单创建后,埋点任务需要用到订单ID)。
- 异常处理: 使用 try-catch 捕获异常并进行事务回滚。
makeOrder 创建订单方法
PHP
/**
* 生成订单
* @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 接口
PHP
interface BehaviorOrderCreateInterface
{
public function handle(OrderCreateService $orderCreateService);
}
OrderCreateService 订单创建服务
PHP
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 实现的核心逻辑 (简化说明)
- 定义 DTO 结构体 (OrderBehaviorDTO): 包含所有需要流转的数据(输入参数、支付结果、订单信息、错误码等)。
- 定义任务接口 (BehaviorOrderCreateInterface): 要求所有小任务都必须实现一个 Handle(*OrderBehaviorDTO) *OrderBehaviorDTO 方法。
- 创建主服务 (MakeOrderService):初始化时创建 DTO。将需要执行的小任务 (如 OrderValidate, OrderCreate, OrderPayment, OrderBuried) 添加到任务列表 (Behavior 切片)。
- 执行主流程 (Handle 方法):按顺序遍历任务列表,调用每个任务的 Handle 方法,并传入 同一个 DTO 指针。每个任务从 DTO 读数据,处理业务,把结果写回 DTO。检查每个任务执行后 DTO 中的错误状态,遇错即停。
- 组装最终响应: 所有任务成功后,从 DTO 中提取所需数据,组装成最终的订单创建响应 (OrderMakeResponse)。
关键优势 (使用 DTO + 接口模式)
* 解耦清晰: 每个小任务只依赖 DTO 接口,不直接依赖其他任务的具体实现。 * 状态管理: DTO 作为唯一的、明确的数据交换通道,解决了 Go 中跨函数/方法状态共享的问题。 * 灵活可扩展: 添加新任务只需实现接口并注册到列表即可。 * 错误处理适配 Go 习惯: 通过返回值和 DTO 中的错误状态显式处理错误,符合 Go 的 error 处理哲学。
实现代码:
1.定义DTO结构体内容
// OrderBehaviorDTO 用于解耦在不同结构体(服务)里面传递的数据结构体
GO
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
php
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方法
go
func (*OrderLogic) OrderMake(ctx context.Context, in *order.OrderMakeRequest) (*order.OrderMakeResponse, error) {
// 订单请求限制
if utils.SlidingWindowRateLimiter(utils.GetLimitKey(ctx, "make_order"), 1, time.Second*1) != 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结构体内容
go
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
}