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 轉載請註明來源