public SagaContext(SagaCollaborator sagaCollaborator,
ILogger logger)
{
this._sagaCollaborator = sagaCollaborator;
this._sagaDataConverter = SagaGlobal.CurrentSagaDataConverter;
this._sagaResolver = SagaGlobal.CurrentSagaResolver;
this._logger = logger;
this._sagaSession = null;
}
public SimpleSaga(ILogger logger, ISagaResolver sagaResolver)
{
this._logger = logger;
this._sagaResolver = sagaResolver;
// saga data types改成在这里静态方法注册，把FormType注册，用来找到所有的saga data types
SagaGlobal.BindSagaDataType(typeof(FormType));
AutoBindBranchServices();
}
public CollaboratorSagaWorker(ILogger <CollaboratorSagaWorker> logger,
SagaCollaborator sagaCollaborator,
ISagaResolver branchServiceResolver,
ISagaDataConverter sagaDataConverter)
{
this._logger = logger;
this._sagaCollaborator = sagaCollaborator;
this._branchServiceResolver = branchServiceResolver;
this._sagaDataConverter = sagaDataConverter;
}
public SagaSession(string xid,
SagaCollaborator sagaCollaborator,
ISagaDataConverter sagaDataConverter,
ISagaResolver sagaResolver,
ILogger logger)
{
this._xid = xid;
this._sagaCollaborator = sagaCollaborator;
this._sagaDataConverter = sagaDataConverter;
this._sagaResolver = sagaResolver;
this._logger = logger;
}
public OrderController(ILogger <OrderController> logger,
ICreateOrderSaga createOrderSaga,
CreateOrderSaga realCreateOrderSaga,
OrderServiceImpl orderService,
SagaCollaborator sagaCollaborator,
ISagaDataConverter sagaDataConverter,
ISagaResolver sagaResolver
)
{
this._logger = logger;
this._createOrderSaga = createOrderSaga;
this._realCreateOrderSaga = realCreateOrderSaga;
this._orderService = orderService;
this._sagaCollaborator = sagaCollaborator;
this._sagaDataConverter = sagaDataConverter;
this._sagaResolver = sagaResolver;
}
public CreateOrderSaga(
/* SagaWorker sagaWorker, */
GrpcClientsHolder grpcClientsHolder,
/* 这里注入orderService真实业务对象而不是saga代理对象，是为了避免两次sagaSession.invokeAsync重复注册一段代码为2各branchId */
OrderServiceImpl orderService,
ISagaResolver sagaResolver,
ILogger <CreateOrderSaga> logger)
: base(logger, sagaResolver)
{
// this._sagaWorker = sagaWorker;
this._grpcClientsHolder = grpcClientsHolder;
this._orderService = orderService;
this._sagaResolver = sagaResolver;
this._logger = logger;
// 本saga中服务会自动注入reslver，额外的服务需要手动注入
//_sagaResolver.BindBranch<CreateOrderSagaData>( _orderService.createOrder);
//_sagaResolver.BindBranch<CreateOrderSagaData>(_orderService.cancelOrder);
//_sagaResolver.BindBranch<CreateOrderSagaData>(_orderService.approveOrder);
// 显示定义 sagaDefinition是可选的，如果使用saga server管理动态分支，则不需要显示定义sagaDefinition
sagaDefinition = Step()
//.SetRemoteAction(createOrder)
//.WithCompensation(cancelOrder)
.SetRemoteAction(createOrder)
.Step()
.SetRemoteAction(reserveCustomer)
.WithCompensation(cancelReserveCustomer)
.Step()
.SetRemoteAction(addLockedBalanceToMerchant)
.WithCompensation(cancelAddLockedBalanceToMerchant)
.Step()
.SetRemoteAction(approveOrder)
.Step()
.SetRemoteAction(approveAddLockedBalanceToMerchant)
.Step()
.SetRemoteAction(addOrderHistory)
.WithCompensation(cancelOrderHistory)
.Build(this);
}
// saga的实现类的各满足要求的方法，以及compensable方法（如果还没注册过的话）自动BindBranch，
// 这样避免具体实现类中手动写
public static void AutoBindBranchServices <FormType>(
object instance,
ISagaResolver sagaResolver,
ILogger logger
) where FormType : class, SagaData
{
var sagaTypeInfo = instance.GetType();
var methods = sagaTypeInfo.GetMethods();
foreach (var method in methods)
{
if (!method.IsPublic)
{
continue;
}
if (method.IsStatic)
{
continue;
}
if (method.ReturnType != typeof(Task))
{
continue;
}
var methodParams = method.GetParameters();
if (methodParams.Length != 1 || methodParams[0].ParameterType != typeof(FormType))
{
continue;
}
Func <FormType, Task> func = delegate(FormType form)
{
return(method.Invoke(instance, new object[] { form }) as Task);
};
// var action = DelegateBuilder.BuildDelegate<Func<FormType, Task>>(method, sagaTypeInfo);
var serviceKey = sagaResolver.GetServiceKey(sagaTypeInfo, method.Name);
sagaResolver.BindBranch <FormType>(serviceKey, func);
logger.LogInformation($"saga resolver binded action {func}");
// 如果有compensable注解，要求方法在本类中，并且是public方法
var compensableAttr = Utils.MethodUtils.GetDeclaredAttribute <Compensable>(method, typeof(Compensable));
if (compensableAttr != null)
{
var compensableMethodName = compensableAttr.ActionName;
var compensableMethod = Utils.MethodUtils.GetMethod(sagaTypeInfo, compensableMethodName);
if (compensableMethod == null)
{
throw new MethodAccessException($"Can't find compensable method {compensableMethodName} in saga type {sagaTypeInfo.FullName}");
}
if (!compensableMethod.IsPublic)
{
throw new MethodAccessException($"compensable method {compensableMethodName} in saga type {sagaTypeInfo.FullName} must be public");
}
if (compensableMethod.IsStatic)
{
throw new MethodAccessException($"compensable method {compensableMethodName} in saga type {sagaTypeInfo.FullName} can't be static");
}
if (compensableMethod.ReturnType != typeof(Task))
{
throw new MethodAccessException($"compensable method {compensableMethodName} in saga type {sagaTypeInfo.FullName} has invalid return type");
}
var compensableMethodParams = compensableMethod.GetParameters();
if (compensableMethodParams.Length != 1 || compensableMethodParams[0].ParameterType != typeof(FormType))
{
throw new MethodAccessException($"compensable method {compensableMethodName} in saga type {sagaTypeInfo.FullName} has invalid parameters types");
}
}
}
}
