Batrix企業能力庫，是京東物流戰略級項目-技術中台架構升級項目的基礎底座。致力於建立企業級業務復用能力平臺，依托能力復用業務框架Batrix，通過通用能力/擴展能力的定義及復用，靈活支持業務差異化場景的快速能力編排組裝，從而通過技術驅動的方式助力業務整體交付吞吐率。本文重點為大家介紹交易域如何使... ...
簡介
Batrix企業能力庫，是京東物流戰略級項目-技術中台架構升級項目的基礎底座。致力於建立企業級業務復用能力平臺，依托能力復用業務框架Batrix，通過通用能力/擴展能力的定義及復用，靈活支持業務差異化場景的快速能力編排組裝，從而通過技術驅動的方式助力業務整體交付吞吐率。
在四層架構(接入層、交易層、履約層、執行層)的背景下，交易平臺組承接交易層的業務邏輯，負責交易場景下的可復用能力開發。當前時間，交易訂單域已沉澱綜合評分超100的能力13個，交易產品域已沉澱綜合評分超100的能力5個。
本文重點為大家介紹交易域如何使用Batrix框架沉澱能力
準備工作
針對能力域建設，需要多方共同參與，業務、產品、研發、測試等缺一不可。一個能力域需要什麼能力，能力內邏輯是什麼，不同能力之間負責的業務邊界是什麼，都需要業務架構師和技術架構師共同商定，需要有一些前置的頂層設計。
業務架構師前期可以由產品側出任，後期一定要有業務側重度參與，需要根據已有的業務沉澱和未來的行業發展規劃共同擬定。
技術架構師由研發出任，負責針對能力的開發進行應用架構設計，保證能力編碼的合理性，需要針對能力擴展性進行把控，為後續的復用打好基礎，和業務架構師共同商定領域上下文的設計。
測試同學主要負責能力質量，在能力建設過程中，難免出現代碼的調整，擴展邏輯的提取和沉澱，這些都需要對已有業務邏輯做回歸驗證，保障能力調整過程中的線上穩定。
能力沉澱是個複雜而又長期的事情，不可能短時間見成效，需要管理者進行預期管理和支持。
能力建設最關鍵的兩個問題：
1、哪些邏輯是能力的基礎邏輯，所有業務都需要執行。如果有個性化需求邏輯怎麼適配。
2、如何復用現有能力。
建設方法
Batrix框架提供標準能力和擴展能力的建設方案：
▪ 標準能力：負責能力的基礎邏輯，所有使用到能力的業務都要執行。提前設計擴展插槽，為後續的能力復用擴展打好基礎。
▪ 擴展能力：針對標準能力內預留的擴展插槽做具體實現，解決個性化邏輯的適配。
Batrix框架提供能力建設的工程實施方案：
▪ BDomainFlowNode：FlowNode是外顯的，能夠獨立提供服務的能力節點，Batrix框架流程編排使用的是以FlowNode為單位的功能編排。簡單邏輯可以直接在FlowNode內開發實現。複雜邏輯由FlowNode調用DomainAbility或者DomainService，進行組合引用，實現能力業務邏輯。
▪ BIDomainService：DomainService開發多個ability的組合業務，儘量不要包含複雜的業務處理，只有簡單的邏輯代碼部分。
▪ BBaseDomainAbility：DomainAbility開發獨立的功能點，功能為公共的基礎功能，每個ability支持一個類型的擴展插槽。擴展插槽的實現，可以開發個性化需求的代碼部分。如果沒有個性化代碼部分，可以不實現擴展點部分代碼。多個ability，由FlowNode或者BIDomainService進行應用組合，提供服務。
▪ BIDomainAbilityExtension：Extension實現SPI定義，開發個性化自定義代碼部分。
建設標準能力，需要對本域內的業務有清晰正確的認識，需要有遠期的規劃。
不同的業務域因業務邏輯不同，所以能力的建設思路會有差異。業務能力的劃分粒度，不同能力之間的邊界很難通過一次設計就固定下來，還需要根據具體場景，持續優化。在建設能力的過程中，根據理解程度的不同，可以大致分為四個階段：
▪ 初期：只知道能力具體負責什麼功能，但不清楚哪些應該屬於通用標準邏輯部分，哪些後期需要擴展，為擴展邏輯預留擴展插槽。針對擴展插槽，不清楚擴展邏輯的入參有哪些，出參有哪些。(未進行過能力域建設過的系統，多數屬於該階段。)
▪ 方案建議****：全部代碼由Extension實現，使用一個FlowNode對外承接調用邏輯，最終由Extension實現業務。如果有個性化邏輯，則使用另一個Extension實現。在後期通過對多個Extension的抽象，分析出哪些是公共邏輯，哪些是個性化邏輯，並把能力進行下一步演化。
▪ 示例****：
public class IntegralOccupyFlowNode extends AbstractDomainFlowNode {
private static final Logger LOGGER = LoggerFactory.getLogger(IntegralOccupyFlowNode.class);
@Resource
private CreateIntegralOccupyAbility createIntegralOccupyAbility;
@Override
public BOutputMessage call(InputMessage inputMessage) {
CallerInfo info = Profiler.registerInfo(this.getClass().getName() + ".call"
, UmpKeyConstants.JDL_OMS_EXPRESS_APP_CODE
, UmpKeyConstants.METHOD_ENABLE_HEART
, UmpKeyConstants.METHOD_ENABLE_TP);
try {
BOutputMessage outputMessage = new BOutputMessage();
if (inputMessage.getBody() == null) {
throw new DomainAbilityException(UnifiedErrorSpec.BasisOrder.INTEGRAL_OCCUPY_FAIL).withCustom("積分占用流程節點執行失敗");
}
ExpressOrderContext expressOrderContext = (ExpressOrderContext) inputMessage.getBody();
outputMessage.setBody(expressOrderContext);
LOGGER.info("積分占用流程節點開始執行");
createIntegralOccupyAbility.execute(expressOrderContext, this);
outputMessage.setCallBackInterface(new BDomainFlowNodeCallBack() {
@Override
public void callBack() {
AbstractDomainAbility releaseAbility = getDomainAbility(expressOrderContext, createErrorIntegralReleaseAbility, modifyErrorIntegralReleaseAbility);
if (releaseAbility != null) {
releaseAbility.execute(expressOrderContext, IntegralOccupyFlowNode.this);
}
LOGGER.info("回退積分任務完成");
}
});
outputMessage.setCallBack(true);
LOGGER.info("積分占用流程節點開始結束");
return outputMessage;
} catch (DomainAbilityException e) {
LOGGER.error("積分占用流程節點執行異常: {}", e.fullMessage());
throw e;
} catch (Exception e) {
Profiler.functionError(info);
LOGGER.error("積分占用流程節點執行異常", e);
throw e;
} finally {
Profiler.registerInfoEnd(info);
}
}
@Override
public String getCode() {
return FlowConstants.EXPRESS_ORDER_INTEGRAL_FLOW_CODE;
}
@Override
public String getName() {
return FlowConstants.EXPRESS_ORDER_INTEGRA_FLOW_NAME;
}
}
@DomainAbility(name = "純配接單領域能力-積分占用活動", parent = DomainConstants.EXPRESS_ORDER_DOMIAN_CODE)
public class CreateIntegralOccupyAbility extends AbstractDomainAbility<ExpressOrderContext, IIntegralExtension> {
private static final Logger LOGGER = LoggerFactory.getLogger(CreateIntegralOccupyAbility.class);
/**
* 積分占用
*
* @param context
* @param bDomainFlowNode
* @throws DomainAbilityException
*/
@Override
public void execute(ExpressOrderContext context, BDomainFlowNode bDomainFlowNode) {
CallerInfo callerInfo = Profiler.registerInfo(this.getClass().getName() + ".execute"
, UmpKeyConstants.JDL_OMS_EXPRESS_APP_CODE
, UmpKeyConstants.METHOD_ENABLE_HEART
, UmpKeyConstants.METHOD_ENABLE_TP);
try {
//根據Batrix配置，獲取擴展點實現
IIntegralExtension extension = this.getMiddleExtensionFast(IIntegralExtension.class,
context,
SimpleReducer.listCollectOf(Objects::nonNull), bDomainFlowNode);
extension.execute(context);
} catch (DomainAbilityException e) {
LOGGER.error("純配接單領域能力-積分占用活動執行異常: {}", e.fullMessage());
throw e;
} catch (Exception e) {
Profiler.functionError(callerInfo);
LOGGER.error("純配接單領域能力-積分占用活動執行異常", e);
throw new DomainAbilityException(UnifiedErrorSpec.BasisOrder.INTEGRAL_OCCUPY_FAIL, e);
} finally {
Profiler.registerInfoEnd(callerInfo);
}
}
@Override
public IIntegralExtension getDefaultExtension() {
return null;
}
}
/**
* 積分占用擴展點
*/
@Extension(code = ExpressOrderProduct.CODE)
public class CreateIntegralOccupyExtension implements IIntegralExtension {
private static final Logger LOGGER = LoggerFactory.getLogger(CreateIntegralOccupyExtension.class);
@Resource
private IntegralFacade integralFacade;
/**
* 積分占用
*
* @param expressOrderContext
* @throws AbilityExtensionException
*/
@Override
public void execute(ExpressOrderContext expressOrderContext) throws AbilityExtensionException {
CallerInfo callerInfo = Profiler.registerInfo(this.getClass().getName() + ".execute"
, UmpKeyConstants.JDL_OMS_EXPRESS_APP_CODE
, UmpKeyConstants.METHOD_ENABLE_HEART
, UmpKeyConstants.METHOD_ENABLE_TP);
try {
LOGGER.info("開始執行接單積分占用擴展點");
ExpressOrderModel orderModel = expressOrderContext.getOrderModel();
if (orderModel.getFinance() == null || orderModel.getFinance().getPoints() == null) {
LOGGER.info("未使用積分，積分占用擴展點執行結束");
return;
}
IntegralFacadeRequest request = new IntegralFacadeRequest();
request.setPin(orderModel.getOperator());
request.setBusinessNo(orderModel.getRefOrderInfoDelegate().getWaybillNo());
Points points = orderModel.getFinance().getPoints();
request.setDeductNumber(points.getRedeemPointsQuantity().getValue().intValue());
request.setRelease(false);
request.setTitle(IntegralOperaterEnum.OCCUPY.getTitle());
integralFacade.operateIntegrals(request);
} catch (InfrastructureException infrastructureException) {
LOGGER.error("接單積分占用擴展點執行異常", infrastructureException);
throw infrastructureException;
} catch (Exception exception) {
Profiler.functionError(callerInfo);
LOGGER.error("接單積分占用擴展點執行異常", exception);
throw new AbilityExtensionException(UnifiedErrorSpec.BasisOrder.INTEGRAL_OCCUPY_FAIL, exception);
} finally {
Profiler.registerInfoEnd(callerInfo);
}
}
}
▪ 前期：清楚能力所負責的業務邏輯，針對業務邏輯清楚的瞭解哪些需要擴展，但為了適配後續業務，不清楚能不能擴展。(交易訂單域處在當前狀態，正在向下一階段演化。)
▪ 方案建議****：針對業務邏輯進行合理的拆分，粗暴些的方式，可以把能力內的邏輯拆分為前中後邏輯，支持在能力核心邏輯的前後進行個性化邏輯擴展實現調用，入參傳入全量領域上下文提供使用。好處在於擴展靈活，方便個性化邏輯開發。壞處在於不好管理，SPI喪失介面隔離原則。
▪ 示例****：
@Service
public class OccupyStockFlowNode extends AbstractDomainFlowNode {
private static final Logger LOGGER = LoggerFactory.getLogger(OccupyStockFlowNode.class);
/**
* 預占庫存
*/
@Resource
private CreateOccupyStockAbility createOccupyStockAbility;
@Resource
private CreateOccupyStockFrontAbility createOccupyStockFrontAbility;
@Resource
private CreateOccupyStockPostAbility createOccupyStockPostAbility;
/**
* 釋放庫存
*/
@Resource
private CreateOccupyStockErrorRollbackAbility createOccupyStockErrorRollbackAbility;
@Resource
private AlarmUtil alarmUtil;
/**
* @param
* @return
* @Description 預占庫存能力流程節點
* @lastModify
*/
@Override
public BOutputMessage call(InputMessage inputMessage) {
CallerInfo info = Profiler.registerInfo(this.getClass().getName() + ".call"
, UmpKeyConstants.JDL_OMS_SUPPLYCHAIN_APP_CODE
, UmpKeyConstants.METHOD_ENABLE_HEART
, UmpKeyConstants.METHOD_ENABLE_TP);
CallerInfo sectionInfo = null, buSectionInfo = null;
try {
SupplyChainOrderContext context = (SupplyChainOrderContext) inputMessage.getBody();
BOutputMessage outputMessage = new BOutputMessage();
outputMessage.setBody(context);
sectionInfo = Profiler.registerInfo(this.getClass().getName() + ".call.section." + ClobOrderUtils.getSectionString(context)
, UmpKeyConstants.JDL_OMS_SUPPLYCHAIN_APP_CODE
, UmpKeyConstants.METHOD_ENABLE_HEART
, UmpKeyConstants.METHOD_ENABLE_TP);
buSectionInfo = Profiler.registerInfo(this.getClass().getName() + ".call.bu." + context.getBusinessIdentity().getBusinessUnit()
+ ".section." + ClobOrderUtils.getSectionString(context)
, UmpKeyConstants.JDL_OMS_SUPPLYCHAIN_APP_CODE
, UmpKeyConstants.METHOD_ENABLE_HEART
, UmpKeyConstants.METHOD_ENABLE_TP);
//前置預占入參處理
createOccupyStockFrontAbility.execute(context, this);
//庫存預占
createOccupyStockAbility.execute(context, this);
//後置預占結果處理
createOccupyStockPostAbility.execute(context, this);
outputMessage.setCallBackInterface(new BDomainFlowNodeCallBack() {
@Override
public void callBack() {
SmartPattern smartPattern = context.getSupplyChainOrderModel().getSmartPattern();
if (smartPattern.hasBeanOccupySuccess()) {
String msg = String.format("客戶單號：%s,訂單號：%s，接單或重新受理失敗，回滾釋放預占庫存", context.getSupplyChainOrderModel().getChannel().getCustomerOrderNo(), context.getSupplyChainOrderModel().orderNo());
LOGGER.info(msg);
Profiler.businessAlarm(UmpKeyConstants.UMP_JDL_OMS_CREATE_PERSIST_FAIL_PDQ_RELEASE_STOCK_ALARM_MONITOR, msg);
createOccupyStockErrorRollbackAbility.execute(context, OccupyStockFlowNode.this);
}
}
});
return outputMessage;
} catch (DomainAbilityException e) {
LOGGER.error("預占庫存能力流程執行異常", e);
SupplyChainOrderContext context = (SupplyChainOrderContext) inputMessage.getBody();
alarmUtil.newAlarm().key(UmpKeyConstants.UMP_JDL_OMS_OCCUPY_STOCK_EXCEPTION_ALARM_MONITOR)
.model(context.getSupplyChainOrderModel())
.alarmMessage("預占庫存能力流程執行異常code：%s，message：%s" , e.code(), e.getMessage())
.alarm();
throw e;
} catch (Exception e) {
Profiler.functionError(info);
if (sectionInfo != null) {
Profiler.functionError(sectionInfo);
}
if (buSectionInfo != null) {
Profiler.functionError(buSectionInfo);
}
LOGGER.error("預占庫存能力流程執行異常", e);
throw e;
} finally {
Profiler.registerInfoEnd(info);
if (sectionInfo != null) {
Profiler.registerInfoEnd(sectionInfo);
}
if (buSectionInfo != null) {
Profiler.registerInfoEnd(buSectionInfo);
}
}
}
}
/**
* @Description: 接單庫存預占前置活動
*/
@DomainAbility(name = "倉配領域能力-接單庫存預占前置活動", parent = DomainConstants.SUPPLY_CHAIN_ORDER_DOMIAN_CODE)
@AbilityScene(businessScenes = {BusinessSceneEnum.CREATE}, isDefault = false)
public class CreateOccupyStockFrontAbility extends OccupyStockFrontAbility {
/**
* log
*/
private static final Logger LOGGER = LoggerFactory.getLogger(CreateOccupyStockFrontAbility.class);
@Override
public void execute(SupplyChainOrderContext supplyChainOrderContext, BDomainFlowNode bDomainFlowNode) throws DomainAbilityException {
CallerInfo callerInfo = UmpUtils.getCallerInfo(this.getClass().getName() , "execute");
try {
//根據Batrix配置，獲取擴展點實現
IOccupyFrontExtensionPlugin extension = this.getMiddleExtensionFast(IOccupyFrontExtensionPlugin.class, supplyChainOrderContext, SimpleReducer.listCollectOf(Objects::nonNull), bDomainFlowNode);
if (extension != null) {
String orderNo = StringUtils.isNotBlank(supplyChainOrderContext.getSupplyChainOrderModel().orderNo()) ? supplyChainOrderContext.getSupplyChainOrderModel().orderNo() : supplyChainOrderContext.getSupplyChainOrderModel().getChannel().getCustomerOrderNo();
IOccupyFrontRequest occupyFrontRequest = new OccupyFrontRequest();
occupyFrontRequest.createWith(supplyChainOrderContext.getSupplyChainOrderModel().getCargoDelegate());
occupyFrontRequest.getExtendProps().put("orderNo", orderNo);
if (LOGGER.isInfoEnabled()) {
LOGGER.info("單號:{},庫存預占前置擴展插件請求入參:{}", orderNo, JSONUtils.beanToJSONDefault(occupyFrontRequest));
}
IOccupyFrontResponse iOccupyFrontResponse = extension.execute(supplyChainOrderContext.getSupplyChainOrderModel().requestProfile(), occupyFrontRequest);
if (LOGGER.isInfoEnabled()) {
LOGGER.info("單號:{},庫存預占前置擴展插件返回結果:{}", orderNo, JSONUtils.beanToJSONDefault(iOccupyFrontResponse));
}
if (!iOccupyFrontResponse.isSuccess()) {
LOGGER.error("庫存預占前置擴展插件異常", iOccupyFrontResponse.getThrowable());
throw new BusinessDomainException(UnifiedErrorSpec.BasisOrder.OCCUPY_STOCK_FAIL).withCustom(iOccupyFrontResponse.getMessage());
}
IStockCargoDelegate iStockCargoDelegate = iOccupyFrontResponse.getStockCargoDelegate();
StockSupportModelCreator stockSupportModelCreator = new StockSupportModelCreator();
stockSupportModelCreator.setCargoInfos(toCargoInfoList(iStockCargoDelegate.getCargoList()));
Integer orderType = Integer.valueOf(supplyChainOrderContext.getSupplyChainOrderModel().getExtendProps().get(IsvExtendFieldNameEnum.ORDER_SELL_MODEL.getCode()));
stockSupportModelCreator.setOrderType(orderType);
stockSupportModelCreator.setBizType(BizTypeEnum.SOO.getCode());
supplyChainOrderContext.getStockSupportModel().complementStockCargoDelegate(this, stockSupportModelCreator);
supplyChainOrderContext.getStockSupportModel().complementOrderType(this, stockSupportModelCreator);
supplyChainOrderContext.getStockSupportModel().complementBizType(this, stockSupportModelCreator);
}
} catch (AbilityExtensionException e) {
LOGGER.error("倉配領域能力-庫存預占前置活動能力執行異常: ", e);
throw e;
} catch (Exception e) {
Profiler.functionError(callerInfo);
LOGGER.error("倉配領域能力-庫存預占前置活動能力執行異常: ", e);
throw new DomainAbilityException(UnifiedErrorSpec.BasisOrder.OCCUPY_STOCK_FAIL, e);
} finally {
Profiler.registerInfoEnd(callerInfo);
}
}
@Override
public IOccupyFrontExtensionPlugin getDefaultExtension() {
return null;
}
}
/**
* @Description: 庫存預占
*/
@DomainAbility(name = "倉配領域能力-接單庫存預占活動", parent = DomainConstants.SUPPLY_CHAIN_ORDER_DOMIAN_CODE)
@AbilityScene(businessScenes = {BusinessSceneEnum.CREATE}, isDefault = false)
public class CreateOccupyStockAbility extends AbstractDomainAbility<SupplyChainOrderContext, IOccupyStockExtension> {
private static final Logger LOGGER = LoggerFactory.getLogger(CreateOccupyStockAbility.class);
/**
* @Description 預占庫存活動能力
*/
@Override
public void execute(SupplyChainOrderContext supplyChainOrderContext, BDomainFlowNode bDomainFlowNode) throws DomainAbilityException {
CallerInfo callerInfo = Profiler.registerInfo(this.getClass().getName() + ".execute"
, UmpKeyConstants.JDL_OMS_SUPPLYCHAIN_APP_CODE
, UmpKeyConstants.METHOD_ENABLE_HEART
, UmpKeyConstants.METHOD_ENABLE_TP);
CallerInfo sectionInfo = Profiler.registerInfo(this.getClass().getName() + ".execute.section." + ClobOrderUtils.getSectionString(supplyChainOrderContext)
, UmpKeyConstants.JDL_OMS_SUPPLYCHAIN_APP_CODE
, UmpKeyConstants.METHOD_ENABLE_HEART
, UmpKeyConstants.METHOD_ENABLE_TP);
try {
//根據Batrix配置，獲取擴展點實現
IOccupyStockExtension extension = this.getMiddleExtensionFast(IOccupyStockExtension.class,
supplyChainOrderContext,
SimpleReducer.listCollectOf(Objects::nonNull), bDomainFlowNode);
extension.execute(supplyChainOrderContext);
} catch (AbilityExtensionException e) {
LOGGER.error("倉配領域能力-接單庫存預占活動能力執行異常: ", e);
throw e;
} catch (Exception e) {
Profiler.functionError(callerInfo);
Profiler.functionError(sectionInfo);
LOGGER.error("倉配領域能力-接單庫存預占活動能力執行異常: ", e);
throw new DomainAbilityException(UnifiedErrorSpec.BasisOrder.OCCUPY_STOCK_FAIL, e);
} finally {
Profiler.registerInfoEnd(callerInfo);
Profiler.registerInfoEnd(sectionInfo);
}
}
}
/**
* @Description: 接單庫存預占後置活動
*/
@DomainAbility(name = "倉配領域能力-接單庫存預占後置活動", parent = DomainConstants.SUPPLY_CHAIN_ORDER_DOMIAN_CODE)
@AbilityScene(businessScenes = {BusinessSceneEnum.CREATE}, isDefault = false)
public class CreateOccupyStockPostAbility extends OccupyStockPostAbility {
private static final Logger LOGGER = LoggerFactory.getLogger(CreateOccupyStockPostAbility.class);
@Override
public void execute(SupplyChainOrderContext supplyChainOrderContext, BDomainFlowNode bDomainFlowNode) {
//根據Batrix配置，獲取擴展點實現
IOccupyPostExtensionPlugin extension = this.getMiddleExtensionFast(IOccupyPostExtensionPlugin.class,
supplyChainOrderContext,
SimpleReducer.listCollectOf(Objects::nonNull), bDomainFlowNode);
if (extension != null) {
String orderNo = StringUtils.isNotBlank(supplyChainOrderContext.getSupplyChainOrderModel().orderNo())
? supplyChainOrderContext.getSupplyChainOrderModel().orderNo() : supplyChainOrderContext.getSupplyChainOrderModel().getChannel().getCustomerOrderNo();
//訂單域貨品信息
ICargoDelegate iCargoDelegate = supplyChainOrderContext.getSupplyChainOrderModel().getCargoDelegate();
//訂單域發貨倉
IWarehouse iWarehouse = supplyChainOrderContext.getSupplyChainOrderModel().getConsignor().getWarehouse();
//訂單域智能策略
ISmartPattern iSmartPattern = supplyChainOrderContext.getSupplyChainOrderModel().getSmartPattern();
//庫存域預占結果
Integer stockOccupyResult = supplyChainOrderContext.getStockSupportModel().getStockOccupyResult();
//庫存域貨品信息
IStockCargoDelegate iStockCargoDelegate = supplyChainOrderContext.getStockSupportModel().getStockCargoDelegate();
//庫存域缺量信息
IStockShortDelegate iStockShortDelegate = supplyChainOrderContext.getStockSupportModel().getStockShortDelegate();
//預占庫房類型
String occupyWarehouseType = supplyChainOrderContext.getStockSupportModel().getOccupyWarehouseType();
//庫存質押結果
Boolean pledgeResult = supplyChainOrderContext.getStockSupportModel().getPledgeResult();
IOccupyPostRequest iOccupyPostRequest = new OccupyPostRequest();
iOccupyPostRequest.getExtendProps().put(BusinessConstants.OCCUPY_WAREHOUSE_TYPE, occupyWarehouseType);
iOccupyPostRequest.createWith(iCargoDelegate, iStockCargoDelegate, iStockShortDelegate, orderNo, stockOccupyResult, iSmartPattern, iWarehouse, pledgeResult);
if (LOGGER.isInfoEnabled()) {
LOGGER.info("單號:{},庫存預占後置擴展插件請求入參:{}", orderNo, JSONUtils.beanToJSONDefault(iOccupyPostRequest));
}
IOccupyPostResponse iOccupyPostResponse = extension.execute(supplyChainOrderContext.getSupplyChainOrderModel().requestProfile(), iOccupyPostRequest);
if (LOGGER.isInfoEnabled()) {
LOGGER.info("單號:{},庫存預占後置擴展插件返回結果:{}", orderNo, JSONUtils.beanToJSONDefault(iOccupyPostResponse));
}
if (!iOccupyPostResponse.isSuccess()) {
LOGGER.error("庫存預占後置擴展插件異常", iOccupyPostResponse.getThrowable());
throw new BusinessDomainException(UnifiedErrorSpec.BasisOrder.OCCUPY_STOCK_FAIL).withCustom(iOccupyPostResponse.getMessage());
}
//預占結果:成功
if (OccupyResultEnum.SUCCESS.getCode().equals(iOccupyPostResponse.getOccupyResult())) {
//獲取預占後處理的貨品信息
ICargoDelegate iOrderCargoDelegate = iOccupyPostResponse.getCargoDelegate();
//根據預占後處理的貨品信息回寫訂單域貨品信息
assembleCargoOccupyStockNum(supplyChainOrderContext, iOrderCargoDelegate);
//回寫訂單域預占結果
assembleOccupyResult(supplyChainOrderContext, OccupyResultEnum.SUCCESS.getCode(), null);
LOGGER.info("單號:{},庫存預占後置擴展插件，預占成功回寫訂單域預占結果和貨品預占數量:{}", orderNo, JSONUtils.beanToJSONDefault(supplyChainOrderContext));
} else if (OccupyResultEnum.STOCK_SHORTAGE.getCode().equals(iOccupyPostResponse.getOccupyResult())) {
// 庫存不足情況處理邏輯
LOGGER.info("單號:{},庫存預占後置擴展插件，庫存不足補全庫存、異常支撐域", orderNo);
handleStockShortage(supplyChainOrderContext);
} else {
handleOtherException(supplyChainOrderContext, iOccupyPostResponse);
//預占結果:目標倉預占失敗
LOGGER.info("單號:{},庫存預占後置擴展插件，目標倉預占失敗，兜底原倉預占", orderNo);
//清空計劃庫房(目標倉)
cleanPlanWarehouse(supplyChainOrderContext);
}
}
}
}
▪ 中期：清楚能力所負責的業務邏輯，針對業務邏輯清楚的瞭解哪些能擴展，哪些不能擴展，針對擴展邏輯所使用的參數欄位，有合理的規劃。(交易產品域處在當前階段。)
▪ 方案建議：針對業務邏輯進行合理的拆分，精細化的方式，針對能力內的邏輯有詳細設計，哪些邏輯能擴展，哪些邏輯必須執行都有規劃，每個Extension方法的出參和入參都有設計。對Extension根據具體邏輯和使用場景，能夠進行本地擴展點調用和遠程擴展點調用等區分。
▪ 示例：
/**
* 產品日曆信息能力點
*/
@Slf4j
@Component
@AbilityNodeUnit(code = "productCalendarNode", name = "產品日曆信息能力點")
public class ProductCalendarNode extends AbstractRequiredAbilityNode {
/**
* 派送開始時間和結束時間的格式
*/
private static final String RECEIVE_TIME_FORMAT = "yyyy-MM-dd HH:mm";
/**
* 開始和結束時間的格式
*/
private static final String TIME_RANGE = "HH:mm";
@Autowired
private AddressStationAbility addressStationAbility;
@Autowired
private SliceDeliveryAcquirer sliceDeliveryAcquirer;
@Autowired
private AbilityCheckProcessor abilityCheckProcessor;
@Override
public boolean paramCheck(InputMessage inputMessage) {
return true;
}
@Override
public void acquireInfo(InputMessage inputMessage) throws Exception {
ProductRequestDto productRequestDto = acquireProductRequestDto(inputMessage);
List<ProductDto> needCheckProductDtoList = new ArrayList<>();
try {
//校驗邏輯
if (productRequestDto.getRequestType() == ProductRequestDto.CHECK_REQUEST_TYPE) {
//獲取需要校驗此能力點的產品列表
needCheckProductDtoList = matchAbilityCode(inputMessage);
}
//供給邏輯
if (productRequestDto.getRequestType() == ProductRequestDto.SUPPLY_REQUEST_TYPE) {
//校驗所有配置了預約派送日曆的產品
needCheckProductDtoList = matchAbilityCodeIgnoreStatus(inputMessage);
}
log.info("[Node][日曆信息能力點]ProductCalendarNode.acquireInfo(),checkProducts:{}", abilityCheckProcessor.getProductNosStr(needCheckProductDtoList));
if (!CollectionUtils.isEmpty(needCheckProductDtoList)) {
//從擴展點返回結果中獲取站點信息完成
addressStationAbility.getAddressStationInfo(inputMessage, this);
//從路由介面獲取日曆信息
sliceDeliveryAcquirer.acquire(needCheckProductDtoList, productRequestDto);
}
} catch (Exception e) {
log.info("[Node][日曆信息能力點]ProductCalendarNode.acquireInfo() exception msg:" + e.getMessage(), e);
}
}
}
/**
* 地址和站點信息獲取能力點
* @date 2022/12/5
*/
@Slf4j
@Component
public class AddressStationAbility extends BBaseDomainAbility<DomainModel, AddressStationCheckService> {
@Autowired
private CalendarAbilityProcessor calendarAbilityProcessor;
@Override
public AddressStationCheckService getDefaultExtension() {
return null;
}
public void getAddressStationInfo(InputMessage inputMessage, BDomainFlowNode bDomainFlowNode) {
BDomainModel bDomainModel = (BDomainModel) inputMessage.getBody();
ProductRequestDto productRequestDto = (ProductRequestDto) bDomainModel;
//獲取Batrix擴展點調用，實際為遠程擴展點
AddressStationCheckService addressStationCheckService = getMiddleExtensionFast(AddressStationCheckService.class, bDomainModel,
SimpleReducer.firstOf((String f) -> f != null), bDomainFlowNode);
//從擴展點返回結果中獲取站點信息完成
if (addressStationCheckService != null) {
AddressStationCheckServiceAdapter addressStationCheckServiceAdapter = new AddressStationCheckServiceAdapter(addressStationCheckService);
//調用擴展點
AddressStationCheckResponse addressStationCheckResponse = addressStationCheckServiceAdapter.check(DtoUtils.createRequestProfile(productRequestDto),
calendarAbilityProcessor.createAddressStationCheckRequest(productRequestDto), productRequestDto);
//解析出參,賦值到ProductRequestDto
calendarAbilityProcessor.parseAddressStationCheckResponse(addressStationCheckResponse, productRequestDto);
}
}
}
/**
* 從路由介面獲取日曆切片
*/
@Slf4j
@Component
public class SliceDeliveryAcquirer {
@Autowired
private CalendarAbilityProcessor calendarAbilityProcessor;
/**
* 獲取日曆切片信息
*/
public void acquire(List<ProductDto> productDtoList, ProductRequestDto productRequestDto) {
boolean getDeliveryInfo = productRequestDto.getEndStationDto().getSupportDaytimeDelivery() != null && productRequestDto.getEndStationDto().getSupportNightDelivery() != null;
if (!getDeliveryInfo) {
log.error("[Ability][日曆信息校驗]ProductCalendarCheckAbility.doAcquireInfo(),從擴展點獲取站點配送能力失敗,停止獲取路由日曆信息");
return;
}
calendarAbilityProcessor.acquireSliceDelivery(productRequestDto, productDtoList);
}
}
/**
* 能力校驗邏輯
*/
@Component
@Slf4j
public class AbilityCheckProcessor {
/**
* 根據業務身份判斷校驗項
*/
@Autowired
private ProductMarkConstant productMarkConstant;
/**
* 驗證該產品是否需要校驗此能力點
* @return true:校驗。false：不校驗
*/
public boolean check(ProductRequestDto productRequestDto, ProductDto productDto, String abilityNo) {
if (productDto == null) {
return false;
}
if (StringUtils.isBlank(productDto.getCode())) {
return true;
}
if (!ProductValidResMsgEnum.SUCCESS.getCode().equals(productDto.getCode())) {
return false;
}
return productMarkConstant.check(productRequestDto.getBusinessUnitEnum(), productDto.getProductNo(), abilityNo);
}
/**
* 驗證該產品主增嵌套關係是否需要校驗此能力點，返回所有需要校驗的ProductDto
*/
public List<ProductDto> check(ProductRequestDto productRequestDto, ProductResultDto productResultDto, String abilityNo) {
List<ProductDto> result = new ArrayList<>();
// 增值產品如果主產品校驗失敗，下麵的增值產品不用校驗。終端攬收不走此邏輯
if (!ProductValidResMsgEnum.SUCCESS.getCode().equals(productResultDto.getMainProductDto().getCode())) {
if (!BusinessSceneEnum.COLLECT.getCode().equals(productRequestDto.getBusinessIdentity().getBusinessScene())) {
return result;
}
}
if (check(productRequestDto, productResultDto.getMainProductDto(), abilityNo)) {
result.add(productResultDto.getMainProductDto());
}
for (ProductDto addValDto : productResultDto.getValueAddedProducts().values()) {
if (check(productRequestDto, addValDto, abilityNo)) {
result.add(addValDto);
}
}
return result;
}
}
▪ 後期：能力本身邏輯、健壯性等都處在較高水平，但能力的使用場景過多，且差異無法抽象統一到一個能力內。
▪ 方案建議：不用強求把所有需求集合到一個能力內，成本和複雜度過高。可以把一個業務能力做拆分，提供2-3個不同模式的技術能力出去，業務使用方根據需要，進一步選擇擴展，融入到業務裡邊。使用2-3個不同的能力模式，覆蓋85%-95%的業務場景，如果依然有極個別的業務無法使用，那針對業務開發個性化能力支持。
如何復用
能力的使用，分幾個層次，相關優先順序如下：
▪ 當需求提出後，經過分析，現有標準能力是否滿足訴求。同一個能力可以有2-3中模式，其中某一個模式滿足需求的話，就可以提供使用。
▪ 現有標準能力不滿足的情況下，評估使用擴展能力是否滿足訴求，從標準能力的不同模式中，選一個最接近需求的進行擴展。
▪ 擴展能力本質上是標準能力和擴展點的組合，標準能力負責通用邏輯的執行，擴展點負責個性化邏輯的執行。業務系統基於穩定性、擴展性的方便考慮，還可以使用遠程擴展點，把擴展邏輯放到獨立的服務上運行。
▪ 如果擴展能力依舊不滿足需求的話，可以新建能力。
▪ 如果分析後發現是能力缺失，則新建標準能力，以備後續業務復用。
▪ 如果分析後發現是小場景需求，可以針對該需求新建自定義能力，只針對該業務場景使用。
確定好使用哪些能力後，可以使用Batrix提供的控制台-神行平臺，進行能力的流程編排，通過能力的編排組合最終形成滿足業務需要的邏輯。如下：
該流程為中小件isv-銷售出-接單流程，由交易訂單域承接，通過流程編排滿足中小件ISV的銷售出庫業務接單邏輯。可以通過對Batrix框架同非同步雙引擎模式的使用，控制能力的同步執行和非同步執行，滿足業務對性能和非同步履約調度的不同訴求。
隨著業務需求的版本迭代，能力也會進行更新替換。如果能力不滿足新的業務使用，則需要對能力進行開發，或者建立新的能力編排進去，替換原有邏輯。如果業務已經沒有使用方，沒有調用量了，則可以刪除流程，進而刪除能力，保障系統工程的長期完整、穩定，降低腐蝕
企業能力共用
當前能力的復用，也僅限於能力所屬的業務域系統。承接需求的吞吐速度取決於能力的Owner的支持速度，但隨著業務複雜度提高，各BP部門需求吞集中到中台部門。中台資源有限，BP基於可復用的中台能力實現擴展點，可抵消一部分對中台資源的依賴。但對能力上的需求，只能採用工程共建的方式解決，長期來講存在很多隱患，功能無法解耦，系統穩定性無法保證。全部依賴中台開發能力的話，中台資源可能會成為交付瓶頸。
所以Batrix企業能力庫支持了能力共用模式，主要為解決如下問題：
▪ 通過能力共用模式，進一步解決資源瓶頸問題。
▪ 通過流程編排按需載入，加速業務交付效率。
基於能力共用模式，前中台協同方式有所調整：
▪ 中台研發：開發可復用、穩定的能力，設計擴展點插槽，發佈能力。
▪ BP研發：基於業務需求，選擇能力進行業務流程編排，通過擴展點實現，補全中台能力不滿足需求的部分。如果中台能力不滿足業務需要，BP可自建能力進行流程編排運行。
▪ 業務應用：業務Owner，通過流程編排把不同能力運行在自己的系統中，負責對外業務的對接維護。中台提供能力的穩定性和復用度建設，維護內部的穩定性，最終提高業務的交付效率。
調整後交易訂單系統架構如下：
應用架構設計，通過中台流量中間件統一收口對外業務請求，通過中台數據中間件統一收口對內數據處理，中間業務應用容器處理一部分適配邏輯，通過Batrix框架進行共用能力調用。
▪ 中台流量中間件：接收業務流量渠道的請求，根據分流屬性 ，把請求路由到不同的業務系統中。
▪ 業務應用容器：
▪ 通過REMOTE層適配對外介面標準
▪ 通過LOCAL層處理轉化對領域服務模型
▪ 通過BATRIX層運行業務能力，按流程編排運行，滿足業務訴求。
▪ 中台數據中間件：處理數據操作請求。
▪ 輔助系統：通過配置中心、監控中心、安全中心輔助系統運行，加速交付效率，提升系統穩定性。
能力共用並不是適用於所有業務和所有能力，他的使用門檻較高，對能力的建設者和業務的使用者都有一些要求。
▪ 能力的建設者要求：
▪ 如何保證提供的能力穩定、高效。
▪ 如何保持必要的基本開發原則。
▪ 能力版本迭代的時候領域上下文如何管理，和現有業務如何相容。
▪ 能力內涉及到下游介面、中間件、數據存儲服務是共用一套，還是隔離開。
▪ 業務的使用者要求：
▪ 如何清晰的知曉所使用的能力內部邏輯，以便運維自己的業務。
▪ 業務異常的情況下，如何快速定位問題點並予以修複。
▪ 業務邏輯開發調試起來體驗較差。
能力治理
能力開發完成後，如果不進行管理，就容易出現能力爆炸。大家都去新建能力，但不進行優化沉澱，依然達不到效果。
根據不同階段，能力的生命周期如下：
▪ 需求承接後可以創建新的能力進行邏輯開發。
▪ 創建能力後需要進行不斷的沉澱優化，具備穩定的服務後才能對外發佈。
▪ 能力開發完成後可以進行流程編排，提供業務運行使用。
▪ 隨著時間推移和版本迭代，能力本身會存在很多冗餘代碼，需要對能力本身進行周期性的沉澱優化，保障能力的穩定性，承接更多的業務。
▪ 如果長期看能力不能在進行優化了，那需要對能力本身廢棄，生成新的能力提供服務。
▪ 舊能力下線，需要在對應的使用流程中進行刪除，刪除對能力有依賴的業務流程引用，最後刪除相關代碼。
如何判斷能力開發的好壞，哪些需要優化，哪些需要清除，邏輯是否能夠通用？
當前Batrix能力治理提供幾個維度衡量：
▪ 調用度：標準能力被流程使用的次數（由標準能力創建出來的擴展能力也算標準能力的使用），復用度越高，表明能力支持的業務越多。
▪ 業務身份覆蓋度：使用能力的的業務身份數量。
▪ 擴展度：由標準能力創建出來的擴展能力數量，該指標需要和復用度綜合來看。復用度越高，擴展度約低，表明能力的通用性越高，不用進行擴展，就可以支持多業務條線。反之，復用度越低，擴展度越高，表明能力的通用邏輯不夠支持業務訴求，需要進行大量的擴展，才能滿足。
▪ 運行度：能力運行次數的量級，運行的次數量級越大，表明支持的業務體量越大，能力越有價值。
▪ 穩定性：能力代碼的變動頻率，變動量越低，說明能力越成熟，越穩定。變動量越高，說明能力不成熟，需要頻繁變動才能滿足業務。
▪ 易用性：是否有文檔能夠描述清楚能力的邏輯。業務系統能不能方便的對能力進行擴展。開發調試業務的過程中，能力是否能夠準確表達業務語義。
▪ 其他待完善
通過以上多個方面綜合評估，可以對能力是否夠好，有一個初步瞭解。針對有問題的能力，可以具體分析原因，進一步進行優化。度量指標目前只考量復用度和擴展度，下一階段會對後續標準進行分析。
當前Batrix企業能力庫已有標準一級業務域共2個，二級業務域4個，非標準業務域4個。共有標準能力520個，其中：
▪ 綜合評分超過200的能力2個。
▪ 綜合評分超過100的能力16個。
▪ 業務身份覆蓋度超15的能力有29個。
▪ 調用度超50的能力有11個。
▪ 調用度超10的能力有110個。
▪ 擴展度超50的能力有4個。
▪ 擴展度超10的能力有29個。
最佳實踐
什麼能力是好能力，很難給出準確的標準，以可度量的綜合評分維度舉例最佳實踐：
1、訂單域-純配基本信息校驗：
▪ 標準能力名稱：基本信息校驗
▪ 負責團隊：交易平臺組-訂單中心
▪ 綜合評分：235.3
▪ 業務身份覆蓋度：19
▪ 調用度：126
▪ 擴展度：55
▪ 運行度：5
▪ 說明：純配基本信息校驗能力負責交易訂單純配業務的基本校驗邏輯，從設計角度觸發，所有條線業務都需要進行最基本的數據校驗處理，只是或多或少、複雜度的問題。能力邊界清晰，職責明確，代碼結構簡潔。個性化邏輯可以通過擴展點處理，基於不同訴求，共有55個不同的擴展點實現，最終滿足業務邏輯的全量支持。
2、產品域-產品主增關係能力點：
▪ 標準能力名稱：產品主增關係能力點
▪ 負責團隊：交易平臺組-產品中心
▪ 綜合評分：138
▪ 業務身份覆蓋度：32
▪ 調用度：36
▪ 擴展度：0
▪ 運行度：4
▪ 說明：產品主增關係能力負責產品域主產品和增值產品相關邏輯計算，為產品供給校驗介面必選能力，所有業務邏輯必須執行。統一了各個業務線的產品主增模型結構，是產品域核心能力。能力邊界清晰，職責明確。代碼結構簡潔，當前不支持擴展邏輯，如果後續如果有擴展需求，可以直接將代碼重構成Abiliey和Extension的組合，支持個性化擴展邏輯使用。
結語
能力建設是中長期的事情，相對來講難以量化，作為技術中台架構升級戰略項目的相關係統，我們的能力建設成果，希望通過業務的口碑，通過BP的使用及落地效果，對業務戰略和規劃的影響力，用技術驅動導致的業務線損益呈現來衡量。
本文通過交易域能力建設的實踐，總結能力建設方法，為大家建設自己能力提供借鑒意義。
作者：京東物流 史建剛
來源：京東雲開發者社區 自猿其說Tech 轉載請註明來源
