对标运算加try捕获未知异常

src/main/java/com/keymobile/indicators/akka/actor/indicators/BeforeCompareUnitCalActor.java

@@ -10,6 +10,7 @@ import com.keymobile.indicators.constant.Constants;
 import com.keymobile.indicators.model.entity.indicators.CompareUnitCalLog;
 import com.keymobile.indicators.service.hytobacco.CompareUnitCalLogService;
 import com.keymobile.indicators.utils.LogManager;
+import com.netflix.discovery.converters.jackson.EurekaXmlJacksonCodec;
 import org.apache.commons.lang.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -51,6 +52,7 @@ public class BeforeCompareUnitCalActor extends AbstractActor{
 
 	@Override
 	public Receive createReceive() {
+		try {
 		return receiveBuilder()
 				.match(StartCompareUnitCalMsg.class,beforeCompareUnitCalMsg -> {
 					List<CompareUnitDef> compareUnitDefs = beforeCompareUnitCalMsg.getCompareInitDefs();
@@ -88,7 +90,7 @@ public class BeforeCompareUnitCalActor extends AbstractActor{
 							}
 							if(!currentCompareUnitDef.isEmpty()) {
 								currentDate = currentCompareUnitDef.get(0).getDate();
-								
+
 								if("0".equals(isTest)) {
 									logger.info("进行date:"+currentDate+" 的对标单元试运行计算.....");
 								}else {
@@ -108,10 +110,10 @@ public class BeforeCompareUnitCalActor extends AbstractActor{
 							if("1".equals(isTest)) {//正式对标单元运算才进行报表数据生成
 								Map<String,String> compareObjMap = new HashMap<>();
 								logger.info("进行date:"+currentDate+" 指标本期同期报表数据和考核指标报表数据2数据整合");
-								
+
 								//整合考核指标报表数据2
 								for(CompareUnitDef unitDef : currentCompareUnitDef) {
-									if(StringUtils.isNotBlank(unitDef.getIndIds()) && 
+									if(StringUtils.isNotBlank(unitDef.getIndIds()) &&
 											StringUtils.isNotBlank(unitDef.getCompareObjs())) {
 										//用map整合对标机构
 										List<String> compareObjsList =Arrays
@@ -122,31 +124,31 @@ public class BeforeCompareUnitCalActor extends AbstractActor{
 										//整合指标本期同期报表数据
 										indicatorsReportService.dealReportOne(
 												unitDef.getCompareId(), Arrays.asList(unitDef.getIndIds().split(",")),
-												Arrays.asList(unitDef.getCompareObjs().split(",")), 
+												Arrays.asList(unitDef.getCompareObjs().split(",")),
 												unitDef.getDate(), code);
-										
+
 										//整合考核指标报表数据2
 										indicatorsReportService.dealDriveIndReportTwoData(
 												unitDef.getCompareId(), Arrays.asList(unitDef.getIndIds().split(",")),
 												Arrays.asList(unitDef.getCompareObjs().split(",")), unitDef.getDate(),code);
 									}
 								}
-								
+
 								//整合基础项本期同期报表数据
 								logger.info("进行date:"+currentDate+" 基础项本期同期报表数据整合");
 								if(!compareObjMap.isEmpty()) {
 									List<String> compareObjs = new ArrayList<String>(compareObjMap.keySet());
 									indicatorsReportService.dealBaseIndReportOneData(currentDate, compareObjs, code);
 								}
-								
+
 								//整合考核指标报表数据3
 								logger.info("进行date:"+currentDate+" 指标报表3数据整合");
 								//删除历史数据
-								indicatorsReportService.deleteReportThreeDataByParam(currentDate, 
+								indicatorsReportService.deleteReportThreeDataByParam(currentDate,
 										new ArrayList<String>(compareObjMap.keySet()),code);
 								for(CompareUnitDef unitDef : currentCompareUnitDef) {
 									indicatorsReportService.dealDriveIndReportThreeData(
-											unitDef.getCompareId(), Arrays.asList(unitDef.getIndIds().split(",")), 
+											unitDef.getCompareId(), Arrays.asList(unitDef.getIndIds().split(",")),
 											unitDef.getDate(),code);
 								}
 							}
@@ -156,6 +158,12 @@ public class BeforeCompareUnitCalActor extends AbstractActor{
 								if(compCalLog!=null) {
 									compCalLog.setEndTime(System.currentTimeMillis()+"");
 									compCalLog.setRunStatus("1");
+									String logInfo = compCalLog.getLogInfo();
+									if(StringUtils.isBlank(logInfo)){
+										logInfo = "没异常";
+									}
+									logInfo = "整体试运算成功-运算过程:"+logInfo;
+									compCalLog.setLogInfo(logInfo);
 									compareUnitCalLogService.saveOrUndate(compCalLog);
 								}
 								LogManager.logInfo(Constants.LOG_INDICATOR_UNIT_CAL_API,"完成对标单元id:{},日期:{}  的试运行计算",compCalLogId,currentDate );
@@ -164,18 +172,34 @@ public class BeforeCompareUnitCalActor extends AbstractActor{
 								if(compCalLog!=null) {
 									compCalLog.setEndTime(System.currentTimeMillis()+"");
 									compCalLog.setRunStatus("1");
-									if(compCalLog.getStatus()==1){
-										compCalLog.setLogInfo("运算成功");
+									String logInfo = compCalLog.getLogInfo();
+									if(StringUtils.isBlank(logInfo)){
+										logInfo = "没异常";
 									}
+									logInfo = "整体运算成功-运算过程:"+logInfo;
+									compCalLog.setLogInfo(logInfo);
 									compareUnitCalLogService.saveOrUndate(compCalLog);
 								}
-								LogManager.logInfo(Constants.LOG_INDICATOR_UNIT_CAL_API,"完成对标单元id:{},日期:{}  的试运行计算",compCalLogId,currentDate );
+								LogManager.logInfo(Constants.LOG_INDICATOR_UNIT_CAL_API,"完成对标单元id:{},日期:{}  的正式运行计算",compCalLogId,currentDate );
 								logger.info("本期同期对标单元计算完成");
 							}
 						}
 					}
 				})
 				.build();
+		}catch (Exception e){
+			e.printStackTrace();
+
+			CompareUnitCalLog compCalLog = compareUnitCalLogService.findById(compCalLogId);
+			if(compCalLog!=null){
+				compCalLog.setEndTime(System.currentTimeMillis()+"");
+				compCalLog.setRunStatus("1");
+				compCalLog.setStatus(0);
+				compCalLog.setLogInfo("运算失败");
+				compareUnitCalLogService.saveOrUndate(compCalLog);
+			}
+		}
+		return null;
 	}
 
 }

src/main/java/com/keymobile/indicators/akka/actor/indicators/CompareUnitCalActor.java

@@ -65,6 +65,8 @@ public class CompareUnitCalActor extends AbstractActor{
 
 	@Override
 	public Receive createReceive() {
+		try {
+
 		return receiveBuilder()
 				.match(CompareUnitCalMsg.class,compareUnitCalMsg -> {
 					CompareUnitDef compareUnitDef = compareUnitCalMsg.getCompareUnitDef();
@@ -75,7 +77,7 @@ public class CompareUnitCalActor extends AbstractActor{
 					objScoreRuleId = compareUnitDef.getObjScoreRuleId();
 					code = compareUnitCalMsg.getCode();
 					isTest = compareUnitCalMsg.getIsTest();
-					
+					compCalLogId = compareUnitCalMsg.getCompCalLogId();
 //					//新增运行日志记录
 //					CompareUnitCalLog compCalLog = new CompareUnitCalLog(compareId,date,
 //							System.currentTimeMillis()+"","0");
@@ -85,7 +87,7 @@ public class CompareUnitCalActor extends AbstractActor{
 //					compCalLog.setType(isTest);
 					//保存
 			//		Integer compCalLogId = compareUnitCalLogService.saveOrUndate(compCalLog);
-					 compCalLogId = compareUnitCalMsg.getCompCalLogId();
+
 					//获取对标对象
 					String compareObjsString = compareUnitDef.getCompareObjs();
 					//获取对标指标
@@ -161,5 +163,18 @@ public class CompareUnitCalActor extends AbstractActor{
 					}
 				})
 				.build();
+		}catch (Exception e){
+			e.printStackTrace();
+
+			CompareUnitCalLog compCalLog = compareUnitCalLogService.findById(compCalLogId);
+			if(compCalLog!=null){
+				compCalLog.setEndTime(System.currentTimeMillis()+"");
+				compCalLog.setRunStatus("1");
+				compCalLog.setStatus(0);
+				compCalLog.setLogInfo("运算失败");
+				compareUnitCalLogService.saveOrUndate(compCalLog);
+			}
+		}
+		return null;
 	}
 }

src/main/java/com/keymobile/indicators/akka/actor/indicators/DriveIndIdCalActor.java

@@ -6,6 +6,8 @@ import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 
+import com.keymobile.indicators.model.entity.indicators.CompareUnitCalLog;
+import com.keymobile.indicators.service.hytobacco.CompareUnitCalLogService;
 import org.apache.commons.lang.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -41,7 +43,8 @@ public class DriveIndIdCalActor extends AbstractActor{
 	private DriveIndDefService driveIndDefService = SpringUtil.getBean(DriveIndDefService.class);
 	
 	private IndicatorsReportService indiReportService = SpringUtil.getBean(IndicatorsReportService.class);
-	
+
+	private CompareUnitCalLogService compareUnitCalLogService = SpringUtil.getBean(CompareUnitCalLogService.class);
 	private int numberOfConfirm = 0;//定义返回确认消息的子actor
 	
 	private int compareObjSize = 0;//对标对象个数
@@ -58,6 +61,8 @@ public class DriveIndIdCalActor extends AbstractActor{
 	
 	private String isTest;
 
+	private Integer compCalLogId;
+
 	private final ActorRef compareUnitCalActor;//定义父actor
 	
 	static public Props props(ActorRef compareUnitCalActor) {
@@ -70,179 +75,195 @@ public class DriveIndIdCalActor extends AbstractActor{
 	
 	@Override
 	public Receive createReceive() {
-		return receiveBuilder()
-				.match(DriveIndIdCalMsg.class,driveIndIdCalMsg -> {
-					String compareId = driveIndIdCalMsg.getCompareId();
-					String indId = driveIndIdCalMsg.getIndId();
-					List<String> compareObjs = driveIndIdCalMsg.getCompareObj();
-					Integer date = driveIndIdCalMsg.getDate();
-					firstExe = driveIndIdCalMsg.getFirstExe();
-					averageObj = driveIndIdCalMsg.getAverageObj();
-					compareObjSize = compareObjs.size();
-					code = driveIndIdCalMsg.getCode();
-					isTest = driveIndIdCalMsg.getIsTest();
-					
-					//日志记录id
-					Integer compCalLogId = driveIndIdCalMsg.getCompCalLogId();
-					
-					for(String compareObj : compareObjs) {
-						List<DimValue> dimValueList = new ArrayList<>();
-						DimValue dimCompareObj = new DimValue("dim1",compareObj,"varchar");
-						DimValue dimDateObj = new DimValue("dim2",date,"number");
-						dimValueList.add(dimCompareObj);
-						dimValueList.add(dimDateObj);
-						
-						DriveIndIdObjCalMsg driveIndIdObjCalMsg = new DriveIndIdObjCalMsg(compareId,
-								indId,compareObj,date,dimValueList,compCalLogId,
-								driveIndIdCalMsg.getCode(),driveIndIdCalMsg.getIsTest());
-						ActorRef driveIndIdObjCalActor = this.getContext()
-								.actorOf(Props.create(DriveIndIdObjCalActor.class,
-										()->new DriveIndIdObjCalActor(getSelf())));
-						driveIndIdObjCalActor.tell(driveIndIdObjCalMsg, getSelf());
-					}
-				})
-				.match(CalIndAverageAndRankMsg.class,calIndAverageAndRankMsg -> {
-					String value = calIndAverageAndRankMsg.getDriveIndValue();
-					String id = String.valueOf(calIndAverageAndRankMsg.getId());
-					String indType = calIndAverageAndRankMsg.getIndType();//指标类型：正向    反向
-					Integer scoreCardId = calIndAverageAndRankMsg.getScoreCardId();//评分卡id
-					Integer compCalLogId = calIndAverageAndRankMsg.getCompCalLogId();//记录日志id
-					if(!"-1".equals(id)) {
-						valueMap.put(id, value);
-						compareObjs.add(calIndAverageAndRankMsg.getCompareObj());
-					}
-					if (++numberOfConfirm >= compareObjSize) {//子actor全部返回
-						if(!valueMap.isEmpty() && !compareObjs.isEmpty()) {
-							//如果是先执行且没有平均分参考对象的,则不进行平均分和排名计算
-							if("1".equals(firstExe) && StringUtils.isBlank(averageObj)) {
-								//发送确认信息给父actor
-								FirstExeConfirmMsg firstExeConfirmMsg = new FirstExeConfirmMsg(1,"",compCalLogId);
-								compareUnitCalActor.tell(firstExeConfirmMsg, ActorRef.noSender());
-							}else {
-								String actualAverage = "0.0";//实际平均分
-								if(StringUtils.isNotBlank(averageObj)) {
-									if("0".equals(isTest)) {
-										TestDriveIndCalResultDef provinceDriveIndCalResult = 
-												testDriveIndCalResultService.findCompareObjInfo(
-												calIndAverageAndRankMsg.getDriveIndId(), 
-												calIndAverageAndRankMsg.getDate(),
-												averageObj,code);
-										if(provinceDriveIndCalResult!=null) {
-											//获取实际平均分
-											actualAverage = provinceDriveIndCalResult.getValue();
-										}
-									}else {
-										DriveIndCalResultDef provinceDriveIndCalResult = 
-												driveIndCalResultService.findCompareObjInfo(
-												calIndAverageAndRankMsg.getDriveIndId(), 
-												calIndAverageAndRankMsg.getDate(),
-												averageObj,code);
-										if(provinceDriveIndCalResult!=null) {
-											//获取实际平均分
-											actualAverage = provinceDriveIndCalResult.getValue();
+		Receive receive = null;
+		try {
+
+			receive= receiveBuilder()
+					.match(DriveIndIdCalMsg.class, driveIndIdCalMsg -> {
+						String compareId = driveIndIdCalMsg.getCompareId();
+						String indId = driveIndIdCalMsg.getIndId();
+						List<String> compareObjs = driveIndIdCalMsg.getCompareObj();
+						Integer date = driveIndIdCalMsg.getDate();
+						firstExe = driveIndIdCalMsg.getFirstExe();
+						averageObj = driveIndIdCalMsg.getAverageObj();
+						compareObjSize = compareObjs.size();
+						code = driveIndIdCalMsg.getCode();
+						isTest = driveIndIdCalMsg.getIsTest();
+
+						//日志记录id
+						 compCalLogId = driveIndIdCalMsg.getCompCalLogId();
+
+						for (String compareObj : compareObjs) {
+							List<DimValue> dimValueList = new ArrayList<>();
+							DimValue dimCompareObj = new DimValue("dim1", compareObj, "varchar");
+							DimValue dimDateObj = new DimValue("dim2", date, "number");
+							dimValueList.add(dimCompareObj);
+							dimValueList.add(dimDateObj);
+
+							DriveIndIdObjCalMsg driveIndIdObjCalMsg = new DriveIndIdObjCalMsg(compareId,
+									indId, compareObj, date, dimValueList, compCalLogId,
+									driveIndIdCalMsg.getCode(), driveIndIdCalMsg.getIsTest());
+							ActorRef driveIndIdObjCalActor = this.getContext()
+									.actorOf(Props.create(DriveIndIdObjCalActor.class,
+											() -> new DriveIndIdObjCalActor(getSelf())));
+							driveIndIdObjCalActor.tell(driveIndIdObjCalMsg, getSelf());
+						}
+					})
+					.match(CalIndAverageAndRankMsg.class, calIndAverageAndRankMsg -> {
+						String value = calIndAverageAndRankMsg.getDriveIndValue();
+						String id = String.valueOf(calIndAverageAndRankMsg.getId());
+						String indType = calIndAverageAndRankMsg.getIndType();//指标类型：正向    反向
+						Integer scoreCardId = calIndAverageAndRankMsg.getScoreCardId();//评分卡id
+						Integer compCalLogId = calIndAverageAndRankMsg.getCompCalLogId();//记录日志id
+						if (!"-1".equals(id)) {
+							valueMap.put(id, value);
+							compareObjs.add(calIndAverageAndRankMsg.getCompareObj());
+						}
+						if (++numberOfConfirm >= compareObjSize) {//子actor全部返回
+							if (!valueMap.isEmpty() && !compareObjs.isEmpty()) {
+								//如果是先执行且没有平均分参考对象的,则不进行平均分和排名计算
+								if ("1".equals(firstExe) && StringUtils.isBlank(averageObj)) {
+									//发送确认信息给父actor
+									FirstExeConfirmMsg firstExeConfirmMsg = new FirstExeConfirmMsg(1, "", compCalLogId);
+									compareUnitCalActor.tell(firstExeConfirmMsg, ActorRef.noSender());
+								} else {
+									String actualAverage = "0.0";//实际平均分
+									if (StringUtils.isNotBlank(averageObj)) {
+										if ("0".equals(isTest)) {
+											TestDriveIndCalResultDef provinceDriveIndCalResult =
+													testDriveIndCalResultService.findCompareObjInfo(
+															calIndAverageAndRankMsg.getDriveIndId(),
+															calIndAverageAndRankMsg.getDate(),
+															averageObj, code);
+											if (provinceDriveIndCalResult != null) {
+												//获取实际平均分
+												actualAverage = provinceDriveIndCalResult.getValue();
+											}
+										} else {
+											DriveIndCalResultDef provinceDriveIndCalResult =
+													driveIndCalResultService.findCompareObjInfo(
+															calIndAverageAndRankMsg.getDriveIndId(),
+															calIndAverageAndRankMsg.getDate(),
+															averageObj, code);
+											if (provinceDriveIndCalResult != null) {
+												//获取实际平均分
+												actualAverage = provinceDriveIndCalResult.getValue();
+											}
 										}
 									}
-								}
-								//算组内平均数
-								String average = driveIndDefService.calGroupAverage(
-										calIndAverageAndRankMsg.getIndFormula(), compareObjs,
-										calIndAverageAndRankMsg.getDate(),code);
-								//算组内排名
-								Map<String,Integer> rankValue = CalculateUtils.rankValue(valueMap, indType);
-								List<DriveIndCalResultDef> dataList = new ArrayList<>();
-								List<TestDriveIndCalResultDef> testDataList = new ArrayList<>();
-								//填充平均数和排名到考核结果中
-								for(Entry<String,Integer> entry : rankValue.entrySet()) {
-									if("0".equals(isTest)) {
-										//根据id获取指标值结果
-										TestDriveIndCalResultDef driveIndCalResult = testDriveIndCalResultService.
-												findById(Integer.parseInt(entry.getKey()));
-										if(driveIndCalResult!=null) {
-											driveIndCalResult.setAverage(average);
-											driveIndCalResult.setRank(entry.getValue());
-											driveIndCalResult.setActualAverage(actualAverage);
-											testDataList.add(driveIndCalResult);
-										}
-									}else {
-										//根据id获取指标值结果
-										DriveIndCalResultDef driveIndCalResult = driveIndCalResultService.
-												findById(Integer.parseInt(entry.getKey()));
-										if(driveIndCalResult!=null) {
-											driveIndCalResult.setAverage(average);
-											driveIndCalResult.setRank(entry.getValue());
-											driveIndCalResult.setActualAverage(actualAverage);
-											dataList.add(driveIndCalResult);
+									//算组内平均数
+									String average = driveIndDefService.calGroupAverage(
+											calIndAverageAndRankMsg.getIndFormula(), compareObjs,
+											calIndAverageAndRankMsg.getDate(), code);
+									//算组内排名
+									Map<String, Integer> rankValue = CalculateUtils.rankValue(valueMap, indType);
+									List<DriveIndCalResultDef> dataList = new ArrayList<>();
+									List<TestDriveIndCalResultDef> testDataList = new ArrayList<>();
+									//填充平均数和排名到考核结果中
+									for (Entry<String, Integer> entry : rankValue.entrySet()) {
+										if ("0".equals(isTest)) {
+											//根据id获取指标值结果
+											TestDriveIndCalResultDef driveIndCalResult = testDriveIndCalResultService.
+													findById(Integer.parseInt(entry.getKey()));
+											if (driveIndCalResult != null) {
+												driveIndCalResult.setAverage(average);
+												driveIndCalResult.setRank(entry.getValue());
+												driveIndCalResult.setActualAverage(actualAverage);
+												testDataList.add(driveIndCalResult);
+											}
+										} else {
+											//根据id获取指标值结果
+											DriveIndCalResultDef driveIndCalResult = driveIndCalResultService.
+													findById(Integer.parseInt(entry.getKey()));
+											if (driveIndCalResult != null) {
+												driveIndCalResult.setAverage(average);
+												driveIndCalResult.setRank(entry.getValue());
+												driveIndCalResult.setActualAverage(actualAverage);
+												dataList.add(driveIndCalResult);
+											}
 										}
 									}
-								}
-								if("0".equals(isTest)) {
-									//批量保存修改
-									testDriveIndCalResultService.batchSaveOrUpdate(testDataList);
-									//批量保存修改
-									testDataList.clear();
-								}else {
-									//批量保存修改
-									driveIndCalResultService.batchSaveOrUpdate(dataList);
-									//批量保存修改//批量保存修改
-									dataList.clear();
-								}
-								//根据评分卡算指标分数
-								for(Entry<String,Integer> entry : rankValue.entrySet()) {
-									if("0".equals(isTest)) {
-										//根据id获取指标值结果
-										TestDriveIndCalResultDef driveIndCalResult = testDriveIndCalResultService.
-												findById(Integer.parseInt(entry.getKey()));
-										if(driveIndCalResult!=null) {
-											//计算分数
-											Map<String,String> scoreMap = indScorecardService.calculateIndiScore(
-													driveIndCalResult.getIndId(), driveIndCalResult.getDate(),
-													driveIndCalResult.getCompareObj(), scoreCardId,
-													driveIndCalResult.getCompareId(),compareObjs,code);
-											driveIndCalResult.setScore(scoreMap.get("score"));
-											driveIndCalResult.setImproveScore(scoreMap.get("improveScore"));
-											testDataList.add(driveIndCalResult);
-										}
-									}else {
-										//根据id获取指标值结果
-										DriveIndCalResultDef driveIndCalResult = driveIndCalResultService.
-												findById(Integer.parseInt(entry.getKey()));
-										if(driveIndCalResult!=null) {
-											//计算分数
-											Map<String,String> scoreMap = indScorecardService.calculateIndiScore(
-													driveIndCalResult.getIndId(), driveIndCalResult.getDate(),
-													driveIndCalResult.getCompareObj(), scoreCardId,
-													driveIndCalResult.getCompareId(),compareObjs,code);
-											driveIndCalResult.setScore(scoreMap.get("score"));
-											driveIndCalResult.setImproveScore(scoreMap.get("improveScore"));
-											dataList.add(driveIndCalResult);
+									if ("0".equals(isTest)) {
+										//批量保存修改
+										testDriveIndCalResultService.batchSaveOrUpdate(testDataList);
+										//批量保存修改
+										testDataList.clear();
+									} else {
+										//批量保存修改
+										driveIndCalResultService.batchSaveOrUpdate(dataList);
+										//批量保存修改//批量保存修改
+										dataList.clear();
+									}
+									//根据评分卡算指标分数
+									for (Entry<String, Integer> entry : rankValue.entrySet()) {
+										if ("0".equals(isTest)) {
+											//根据id获取指标值结果
+											TestDriveIndCalResultDef driveIndCalResult = testDriveIndCalResultService.
+													findById(Integer.parseInt(entry.getKey()));
+											if (driveIndCalResult != null) {
+												//计算分数
+												Map<String, String> scoreMap = indScorecardService.calculateIndiScore(
+														driveIndCalResult.getIndId(), driveIndCalResult.getDate(),
+														driveIndCalResult.getCompareObj(), scoreCardId,
+														driveIndCalResult.getCompareId(), compareObjs, code);
+												driveIndCalResult.setScore(scoreMap.get("score"));
+												driveIndCalResult.setImproveScore(scoreMap.get("improveScore"));
+												testDataList.add(driveIndCalResult);
+											}
+										} else {
+											//根据id获取指标值结果
+											DriveIndCalResultDef driveIndCalResult = driveIndCalResultService.
+													findById(Integer.parseInt(entry.getKey()));
+											if (driveIndCalResult != null) {
+												//计算分数
+												Map<String, String> scoreMap = indScorecardService.calculateIndiScore(
+														driveIndCalResult.getIndId(), driveIndCalResult.getDate(),
+														driveIndCalResult.getCompareObj(), scoreCardId,
+														driveIndCalResult.getCompareId(), compareObjs, code);
+												driveIndCalResult.setScore(scoreMap.get("score"));
+												driveIndCalResult.setImproveScore(scoreMap.get("improveScore"));
+												dataList.add(driveIndCalResult);
+											}
 										}
-									}		
-								}
-								if("0".equals(isTest)) {
-									//批量保存修改
-									testDriveIndCalResultService.batchSaveOrUpdate(testDataList);
-									//清空list
-									testDataList.clear();
-								}else {
-									//批量保存修改
-									driveIndCalResultService.batchSaveOrUpdate(dataList);
-									//整合本期同期报表数据
-									//indiReportService.dealReportOneDatas(dataList);
-									//清空list
-									dataList.clear();
+									}
+									if ("0".equals(isTest)) {
+										//批量保存修改
+										testDriveIndCalResultService.batchSaveOrUpdate(testDataList);
+										//清空list
+										testDataList.clear();
+									} else {
+										//批量保存修改
+										driveIndCalResultService.batchSaveOrUpdate(dataList);
+										//整合本期同期报表数据
+										//indiReportService.dealReportOneDatas(dataList);
+										//清空list
+										dataList.clear();
+									}
+
+									//发送确认信息给父actor
+									FirstExeConfirmMsg firstExeConfirmMsg = new FirstExeConfirmMsg(1, "", compCalLogId);
+									compareUnitCalActor.tell(firstExeConfirmMsg, ActorRef.noSender());
 								}
-								
+							} else {
 								//发送确认信息给父actor
-								FirstExeConfirmMsg firstExeConfirmMsg = new FirstExeConfirmMsg(1,"",compCalLogId);
+								FirstExeConfirmMsg firstExeConfirmMsg = new FirstExeConfirmMsg(0, "", compCalLogId);
 								compareUnitCalActor.tell(firstExeConfirmMsg, ActorRef.noSender());
 							}
-						}else {
-							//发送确认信息给父actor
-							FirstExeConfirmMsg firstExeConfirmMsg = new FirstExeConfirmMsg(0,"",compCalLogId);
-							compareUnitCalActor.tell(firstExeConfirmMsg, ActorRef.noSender());
 						}
-					}
-				})
-				.build();
+					})
+					.build();
+		}catch (Exception e){
+			e.printStackTrace();
+
+			CompareUnitCalLog compCalLog = compareUnitCalLogService.findById(compCalLogId);
+			if(compCalLog!=null){
+				compCalLog.setEndTime(System.currentTimeMillis()+"");
+				compCalLog.setRunStatus("1");
+				compCalLog.setStatus(0);
+				compCalLog.setLogInfo("运算失败");
+				compareUnitCalLogService.saveOrUndate(compCalLog);
+			}
+		}
+		return receive;
 	}
 }

src/main/java/com/keymobile/indicators/akka/actor/indicators/DriveIndIdObjCalActor.java

@@ -33,6 +33,7 @@ import com.keymobile.indicators.utils.SpringUtil;
 import akka.actor.AbstractActor;
 import akka.actor.ActorRef;
 import akka.actor.Props;
+import org.springframework.data.redis.core.script.ReactiveScriptExecutor;
 
 public class DriveIndIdObjCalActor extends AbstractActor{
 	private Logger logger = LoggerFactory.getLogger(DriveIndIdObjCalActor.class);
@@ -90,67 +91,72 @@ public class DriveIndIdObjCalActor extends AbstractActor{
 	
 	@Override
 	public Receive createReceive() {
-		return receiveBuilder()
-				.match(DriveIndIdObjCalMsg.class, driveIndIdObjCalMsg -> {
-					compareId = driveIndIdObjCalMsg.getCompareId();
-					compareObj = driveIndIdObjCalMsg.getCompareObj();
-					date = driveIndIdObjCalMsg.getDate();
-					driveIndId = driveIndIdObjCalMsg.getIndId();
-					//日志记录id
-					compCalLogId = driveIndIdObjCalMsg.getCompCalLogId();
-					code = driveIndIdObjCalMsg.getCode();
-					isTest = driveIndIdObjCalMsg.getIsTest();
-					
-					List<String> indIdList = new ArrayList<>();//定义存储从考核指标公式解析出来的基础指标id
-					
-					DriveIndDef driveIndDef = driveIndDefService.getById(driveIndId);
-					if(driveIndDef==null) {
-						logger.info("DriveIndDef:"+driveIndId+" is not exist.");
-						//返回父actor信息
-						CalIndAverageAndRankMsg driveIndAverageAndRankMsg = 
-								new CalIndAverageAndRankMsg(-1,
-										compareId,driveIndId,compareObj,date,"NaN",
-										unit,indType,scoreCardId,averageDriveIndFormula,compCalLogId);
-						driveIndIdCalActor.tell(driveIndAverageAndRankMsg,ActorRef.noSender());
-					}else {
-						unit = driveIndDef.getIndUnit();//指标单位
-						indType = driveIndDef.getIndRule();//指标类型：正向    反向
-						scoreCardId = driveIndDef.getIndCalScoreRule();//指标评分规则
-						
-						//获取考核指标的公式
-						driveIndFormula = driveIndDef.getIndFormat();
-						averageDriveIndFormula = driveIndDef.getIndFormat();//定义用于返回父actor算平均分用的公式
-						
-						Pattern p = Pattern.compile("(\\[[^\\]]*\\])");
-						Matcher m = p.matcher(driveIndFormula);
-						while(m.find()){
-							indIdList.add(m.group().substring(1, m.group().length()-1));
-						}
-						//获取公式中的基础指标id
-						indIdSize =indIdList.size();
-						if(!indIdList.isEmpty()) {
-							for(String indId : indIdList) {
-								GetBaseIndValueMsg getBaseIndValueMsg = new GetBaseIndValueMsg(
-										indId,driveIndIdObjCalMsg.getDimValues(),
-										driveIndIdObjCalMsg.getCode());
-								ActorRef getBaseIndValueActor = this.getContext()
-										.actorOf(Props.create(GetBaseIndValueActor.class,
-												()->new GetBaseIndValueActor()));
-								getBaseIndValueActor.tell(getBaseIndValueMsg, getSelf());
+		Receive receive = null;
+		try {
+			receive = receiveBuilder()
+					.match(DriveIndIdObjCalMsg.class, driveIndIdObjCalMsg -> {
+						compareId = driveIndIdObjCalMsg.getCompareId();
+						compareObj = driveIndIdObjCalMsg.getCompareObj();
+						date = driveIndIdObjCalMsg.getDate();
+						driveIndId = driveIndIdObjCalMsg.getIndId();
+						//日志记录id
+						compCalLogId = driveIndIdObjCalMsg.getCompCalLogId();
+						code = driveIndIdObjCalMsg.getCode();
+						isTest = driveIndIdObjCalMsg.getIsTest();
+
+						List<String> indIdList = new ArrayList<>();//定义存储从考核指标公式解析出来的基础指标id
+
+						DriveIndDef driveIndDef = driveIndDefService.getById(driveIndId);
+						if (driveIndDef == null) {
+							logger.info("DriveIndDef:" + driveIndId + " is not exist.");
+							//返回父actor信息
+							CalIndAverageAndRankMsg driveIndAverageAndRankMsg =
+									new CalIndAverageAndRankMsg(-1,
+											compareId, driveIndId, compareObj, date, "NaN",
+											unit, indType, scoreCardId, averageDriveIndFormula, compCalLogId);
+							driveIndIdCalActor.tell(driveIndAverageAndRankMsg, ActorRef.noSender());
+						} else {
+							unit = driveIndDef.getIndUnit();//指标单位
+							indType = driveIndDef.getIndRule();//指标类型：正向    反向
+							scoreCardId = driveIndDef.getIndCalScoreRule();//指标评分规则
+
+							//获取考核指标的公式
+							driveIndFormula = driveIndDef.getIndFormat();
+							averageDriveIndFormula = driveIndDef.getIndFormat();//定义用于返回父actor算平均分用的公式
+
+							Pattern p = Pattern.compile("(\\[[^\\]]*\\])");
+							Matcher m = p.matcher(driveIndFormula);
+							while (m.find()) {
+								indIdList.add(m.group().substring(1, m.group().length() - 1));
+							}
+							//获取公式中的基础指标id
+							indIdSize = indIdList.size();
+							if (!indIdList.isEmpty()) {
+								for (String indId : indIdList) {
+									GetBaseIndValueMsg getBaseIndValueMsg = new GetBaseIndValueMsg(
+											indId, driveIndIdObjCalMsg.getDimValues(),
+											driveIndIdObjCalMsg.getCode());
+									//传入日志id
+									getBaseIndValueMsg.setCompCalLogId(compCalLogId);
+
+									ActorRef getBaseIndValueActor = this.getContext()
+											.actorOf(Props.create(GetBaseIndValueActor.class,
+													() -> new GetBaseIndValueActor()));
+									getBaseIndValueActor.tell(getBaseIndValueMsg, getSelf());
+								}
 							}
 						}
-					}
-				})
-				.match(BaseIndValueMsg.class,baseIndValueMsg->{
-					//根据日志记录id获取日志
-					CompareUnitCalLog compCalLog = null;
-					if(compCalLogId!=null) {
-						compCalLog = compareUnitCalLogService.findById(compCalLogId);
-					}
-					if(baseIndValueMsg.getIsFinish()==0) {
-						//日志填充
+					})
+					.match(BaseIndValueMsg.class, baseIndValueMsg -> {
+						//根据日志记录id获取日志
+						CompareUnitCalLog compCalLog = null;
+						if (compCalLogId != null) {
+							compCalLog = compareUnitCalLogService.findById(compCalLogId);
+						}
+						if (baseIndValueMsg.getIsFinish() == 0) {
+							//日志填充
 
-						if(compCalLog!=null) {
+							if (compCalLog != null) {
 //							String logInfo = compCalLog.getLogInfo();
 //							compCalLog.setStatus(0);
 //							if(StringUtils.isNotBlank(logInfo)) {
@@ -159,33 +165,34 @@ public class DriveIndIdObjCalActor extends AbstractActor{
 //							}else {
 //								compCalLog.setLogInfo(baseIndValueMsg.getConfirmMessage()+"</n>");
 //							}
-							compCalLog.setLogInfo("运算失败：指标为空");
+								compCalLog.setStatus(0);
+								compCalLog.setLogInfo("运算过程：有指标为空");
+							}
+							logger.info("日志信息::{}，日志id{}", baseIndValueMsg.getConfirmMessage(), compCalLogId);
 						}
-						logger.info("日志信息::{}，日志id{}",baseIndValueMsg.getConfirmMessage(),compCalLogId);
-					}
-					String indValue = baseIndValueMsg.getValue();
-					//如果指标值返回空值
-					if(StringUtils.isBlank(indValue)) {
-						indValue="0.00";
-					}
-					try {
-						if(indValue.indexOf(".")<0) {
-							indValue += ".00";
+						String indValue = baseIndValueMsg.getValue();
+						//如果指标值返回空值
+						if (StringUtils.isBlank(indValue)) {
+							indValue = "0.00";
 						}
-						driveIndFormula = driveIndFormula.replace("["+baseIndValueMsg.getIndId()+"]", 
-								indValue);
-						//替换公式中的基础指标id为确定指标值
-						//env.put(baseIndValueMsg.getIndId(), Double.valueOf(indValue));
-					}catch(Exception e) {
-						e.printStackTrace();
-						logger.error("driveIndId:"+driveIndId+";"+
-						"formula:"+driveIndFormula+";"+
-						"errorValue:"+indValue+";"+"paramEnv:"+env);
-						//日志记录
-						//运算失败
-						if(compCalLog!=null){
-							compCalLog.setStatus(0);
-							//String logInfo = compCalLog.getLogInfo();
+						try {
+							if (indValue.indexOf(".") < 0) {
+								indValue += ".00";
+							}
+							driveIndFormula = driveIndFormula.replace("[" + baseIndValueMsg.getIndId() + "]",
+									indValue);
+							//替换公式中的基础指标id为确定指标值
+							//env.put(baseIndValueMsg.getIndId(), Double.valueOf(indValue));
+						} catch (Exception e) {
+							e.printStackTrace();
+							logger.error("driveIndId:" + driveIndId + ";" +
+									"formula:" + driveIndFormula + ";" +
+									"errorValue:" + indValue + ";" + "paramEnv:" + env);
+							//日志记录
+							//运算失败
+							if (compCalLog != null) {
+								compCalLog.setStatus(0);
+								//String logInfo = compCalLog.getLogInfo();
 //							if(StringUtils.isNotBlank(logInfo)) {
 //								logInfo+="替换公式值出错：driveIndId:"+driveIndId+";"+
 //										"formula:"+driveIndFormula+";"+
@@ -196,71 +203,71 @@ public class DriveIndIdObjCalActor extends AbstractActor{
 //										"formula:"+driveIndFormula+";"+
 //										"errorValue:"+indValue+";"+"paramEnv:"+env+"</n>");
 //							}
-							compCalLog.setLogInfo("运算公式出错");
-							//保存日志
-							compareUnitCalLogService.saveOrUndate(compCalLog);
-						}
+								compCalLog.setLogInfo("运算公式出错");
+								//保存日志
+								compareUnitCalLogService.saveOrUndate(compCalLog);
+							}
 
 
-					}
-					confirmList.add(baseIndValueMsg.getIsFinish());
-					if (++numberOfConfirm >= indIdSize) {//子actor全部返回
-						if(!confirmList.contains(0)) {//取所有基础指标值没错
-							//进行考核指标值计算
-							try {
-								String driveIndValue = AviatorEvaluator.execute(driveIndFormula).toString();
-								//保留四位小数
-								if(!driveIndValue.equals("NaN") && !driveIndValue.equals("Infinite")) {
-									driveIndValue = String.format("%.4f",
-											new BigDecimal(Double.valueOf(driveIndValue)));
-								}
-								if("0".equals(isTest)) {//试运行
-									//判断结果表中是否已存在该结果数据，存在则覆盖
-									TestDriveIndCalResultDef driveIndCalResult = testDriveIndCalResultService.
-											findCalResultDataIsExist(compareId, compareObj, driveIndId, date, code);
-									if(driveIndCalResult==null) {
-										driveIndCalResult = new TestDriveIndCalResultDef(compareId,
-												driveIndId,compareObj,date,driveIndValue,unit,
-												"1","1","admin",code,baseIndValueMsg.getCompareObjDesc());
-									}else {
-										driveIndCalResult.setCode(code);
-										driveIndCalResult.setUnit(unit);
-										driveIndCalResult.setValue(driveIndValue);
-										driveIndCalResult.setLastUpdateTime(DateUtils.formatDate(new Date(), "yyyy-MM-dd HH:mm:ss"));
+						}
+						confirmList.add(baseIndValueMsg.getIsFinish());
+						if (++numberOfConfirm >= indIdSize) {//子actor全部返回
+							if (!confirmList.contains(0)) {//取所有基础指标值没错
+								//进行考核指标值计算
+								try {
+									String driveIndValue = AviatorEvaluator.execute(driveIndFormula).toString();
+									//保留四位小数
+									if (!driveIndValue.equals("NaN") && !driveIndValue.equals("Infinite")) {
+										driveIndValue = String.format("%.4f",
+												new BigDecimal(Double.valueOf(driveIndValue)));
 									}
-									//保存进考核指标结果表中
-									testDriveIndCalResultService.saveOrUpdate(driveIndCalResult);
-									//返回指标值回去算平均值和排名
-									CalIndAverageAndRankMsg driveIndAverageAndRankMsg = 
-											new CalIndAverageAndRankMsg(driveIndCalResult.getId(),
-													compareId,driveIndId,compareObj,date,driveIndValue,
-													unit,indType,scoreCardId,averageDriveIndFormula,compCalLogId);
-									driveIndIdCalActor.tell(driveIndAverageAndRankMsg,ActorRef.noSender());
-								}else {
-									//判断结果表中是否已存在该结果数据，存在则覆盖
-									DriveIndCalResultDef driveIndCalResult = driveIndCalResultService.
-											findCalResultDataIsExist(compareId, compareObj, driveIndId, date, code);
-									if(driveIndCalResult==null) {
-										driveIndCalResult = new DriveIndCalResultDef(compareId,
-												driveIndId,compareObj,date,driveIndValue,unit,
-												"1","1","admin",code,baseIndValueMsg.getCompareObjDesc());
-									}else {
-										driveIndCalResult.setCode(code);
-										driveIndCalResult.setUnit(unit);
-										driveIndCalResult.setValue(driveIndValue);
-										driveIndCalResult.setLastUpdateTime(DateUtils.formatDate(new Date(), "yyyy-MM-dd HH:mm:ss"));
+									if ("0".equals(isTest)) {//试运行
+										//判断结果表中是否已存在该结果数据，存在则覆盖
+										TestDriveIndCalResultDef driveIndCalResult = testDriveIndCalResultService.
+												findCalResultDataIsExist(compareId, compareObj, driveIndId, date, code);
+										if (driveIndCalResult == null) {
+											driveIndCalResult = new TestDriveIndCalResultDef(compareId,
+													driveIndId, compareObj, date, driveIndValue, unit,
+													"1", "1", "admin", code, baseIndValueMsg.getCompareObjDesc());
+										} else {
+											driveIndCalResult.setCode(code);
+											driveIndCalResult.setUnit(unit);
+											driveIndCalResult.setValue(driveIndValue);
+											driveIndCalResult.setLastUpdateTime(DateUtils.formatDate(new Date(), "yyyy-MM-dd HH:mm:ss"));
+										}
+										//保存进考核指标结果表中
+										testDriveIndCalResultService.saveOrUpdate(driveIndCalResult);
+										//返回指标值回去算平均值和排名
+										CalIndAverageAndRankMsg driveIndAverageAndRankMsg =
+												new CalIndAverageAndRankMsg(driveIndCalResult.getId(),
+														compareId, driveIndId, compareObj, date, driveIndValue,
+														unit, indType, scoreCardId, averageDriveIndFormula, compCalLogId);
+										driveIndIdCalActor.tell(driveIndAverageAndRankMsg, ActorRef.noSender());
+									} else {
+										//判断结果表中是否已存在该结果数据，存在则覆盖
+										DriveIndCalResultDef driveIndCalResult = driveIndCalResultService.
+												findCalResultDataIsExist(compareId, compareObj, driveIndId, date, code);
+										if (driveIndCalResult == null) {
+											driveIndCalResult = new DriveIndCalResultDef(compareId,
+													driveIndId, compareObj, date, driveIndValue, unit,
+													"1", "1", "admin", code, baseIndValueMsg.getCompareObjDesc());
+										} else {
+											driveIndCalResult.setCode(code);
+											driveIndCalResult.setUnit(unit);
+											driveIndCalResult.setValue(driveIndValue);
+											driveIndCalResult.setLastUpdateTime(DateUtils.formatDate(new Date(), "yyyy-MM-dd HH:mm:ss"));
+										}
+										//保存进考核指标结果表中
+										driveIndCalResultService.saveOrUpdate(driveIndCalResult);
+										//返回指标值回去算平均值和排名
+										CalIndAverageAndRankMsg driveIndAverageAndRankMsg =
+												new CalIndAverageAndRankMsg(driveIndCalResult.getId(),
+														compareId, driveIndId, compareObj, date, driveIndValue,
+														unit, indType, scoreCardId, averageDriveIndFormula, compCalLogId);
+										driveIndIdCalActor.tell(driveIndAverageAndRankMsg, ActorRef.noSender());
 									}
-									//保存进考核指标结果表中
-									driveIndCalResultService.saveOrUpdate(driveIndCalResult);
-									//返回指标值回去算平均值和排名
-									CalIndAverageAndRankMsg driveIndAverageAndRankMsg = 
-											new CalIndAverageAndRankMsg(driveIndCalResult.getId(),
-													compareId,driveIndId,compareObj,date,driveIndValue,
-													unit,indType,scoreCardId,averageDriveIndFormula,compCalLogId);
-									driveIndIdCalActor.tell(driveIndAverageAndRankMsg,ActorRef.noSender());
-								}
-							} catch (Exception e) {
-								//判断结果表中是否已存在该结果数据，存在则覆盖
+								} catch (Exception e) {
+									//判断结果表中是否已存在该结果数据，存在则覆盖
 //									DriveIndCalResultDef driveIndCalResult = driveIndCalResultService.
 //											findCalResultDataIsExist(compareId, compareObj, driveIndId, date);
 //									if(driveIndCalResult==null) {
@@ -274,10 +281,10 @@ public class DriveIndIdObjCalActor extends AbstractActor{
 //										driveIndCalResult.setLastUpdateTime(DateUtils.formatDate(new Date(), "yyyy-MM-dd HH:mm:ss"));
 //									}
 //									driveIndCalResultService.saveOrUpdate(driveIndCalResult);
-								
-								logger.error("driveIndId:"+driveIndId+";"+
-										"paramEnv:"+env+";formula:"+driveIndFormula);
-								//日志记录
+
+									logger.error("driveIndId:" + driveIndId + ";" +
+											"paramEnv:" + env + ";formula:" + driveIndFormula);
+									//日志记录
 //								String logInfo = compCalLog.getLogInfo();
 //								if(StringUtils.isNotBlank(logInfo)) {
 //									logInfo+="计算考核指标出错：driveIndId:"+driveIndId+";"+
@@ -288,33 +295,45 @@ public class DriveIndIdObjCalActor extends AbstractActor{
 //											"paramEnv:"+env+";formula:"+driveIndFormula+"</n>");
 //								}
 
+									//保存日志
+									if (compCalLog != null) {
+										compCalLog.setLogInfo("计算考核指标出错");
+										compCalLog.setStatus(0);
+										compareUnitCalLogService.saveOrUndate(compCalLog);
+									}
+									//表示计算错误，不生成考核结果
+									CalIndAverageAndRankMsg driveIndAverageAndRankMsg =
+											new CalIndAverageAndRankMsg(-1,
+													compareId, driveIndId, compareObj, date, "NaN",
+													unit, indType, scoreCardId, averageDriveIndFormula, compCalLogId);
+									driveIndIdCalActor.tell(driveIndAverageAndRankMsg, ActorRef.noSender());
+								}
+							} else {
+								//返回考核指标因为考核指标公式中的数据项不存在而导致的计算错误标识
 								//保存日志
-								if(compCalLog!=null) {
-									compCalLog.setLogInfo("计算考核指标出错");
-									compCalLog.setStatus(0);
+								if (compCalLog != null) {
 									compareUnitCalLogService.saveOrUndate(compCalLog);
 								}
-								//表示计算错误，不生成考核结果
-								CalIndAverageAndRankMsg driveIndAverageAndRankMsg = 
+								CalIndAverageAndRankMsg driveIndAverageAndRankMsg =
 										new CalIndAverageAndRankMsg(-1,
-												compareId,driveIndId,compareObj,date,"NaN",
-												unit,indType,scoreCardId,averageDriveIndFormula,compCalLogId);
-								driveIndIdCalActor.tell(driveIndAverageAndRankMsg,ActorRef.noSender());
+												compareId, driveIndId, compareObj, date, "NaN",
+												unit, indType, scoreCardId, averageDriveIndFormula, compCalLogId);
+								driveIndIdCalActor.tell(driveIndAverageAndRankMsg, ActorRef.noSender());
 							}
-						}else {
-							//返回考核指标因为考核指标公式中的数据项不存在而导致的计算错误标识
-                            //保存日志
-							if(compCalLog!=null) {
-								compareUnitCalLogService.saveOrUndate(compCalLog);
-							}
-							CalIndAverageAndRankMsg driveIndAverageAndRankMsg = 
-									new CalIndAverageAndRankMsg(-1,
-											compareId,driveIndId,compareObj,date,"NaN",
-											unit,indType,scoreCardId,averageDriveIndFormula,compCalLogId);
-							driveIndIdCalActor.tell(driveIndAverageAndRankMsg,ActorRef.noSender());
 						}
-					}
-				})
-				.build();
+					})
+					.build();
+		}catch (Exception e){
+			e.printStackTrace();
+			CompareUnitCalLog compCalLog = compareUnitCalLogService.findById(compCalLogId);
+			if(compCalLog!=null){
+				compCalLog.setEndTime(System.currentTimeMillis()+"");
+				compCalLog.setRunStatus("1");
+				compCalLog.setStatus(0);
+				compCalLog.setLogInfo("运算失败");
+				compareUnitCalLogService.saveOrUndate(compCalLog);
+			}
+		}
+		return receive;
 	}
 }

src/main/java/com/keymobile/indicators/akka/actor/indicators/GetBaseIndValueActor.java

@@ -4,6 +4,8 @@ import java.util.Map;
 
 import com.keymobile.indicators.akka.message.indicators.BaseIndValueMsg;
 import com.keymobile.indicators.akka.message.indicators.GetBaseIndValueMsg;
+import com.keymobile.indicators.model.entity.indicators.CompareUnitCalLog;
+import com.keymobile.indicators.service.hytobacco.CompareUnitCalLogService;
 import com.keymobile.indicators.service.hytobacco.IndicatorsValueService;
 import com.keymobile.indicators.utils.SpringUtil;
 
@@ -13,37 +15,60 @@ public class GetBaseIndValueActor extends AbstractActor{
 	
 	private IndicatorsValueService indicatorsValueService = SpringUtil.getBean(IndicatorsValueService.class);
 
+	private CompareUnitCalLogService compareUnitCalLogService = SpringUtil.getBean(CompareUnitCalLogService.class);
+
+
+	private Integer compCalLogId = null;
 	@Override
 	public Receive createReceive() {
-		return receiveBuilder()
-				.match(GetBaseIndValueMsg.class,getBaseIndValueMsg -> {
-					//根据维度值和基础指标id获取指标值
-					Map<String,Object> indValueMap = indicatorsValueService.getIndicatorsValue(
-							getBaseIndValueMsg.getIndId(), getBaseIndValueMsg.getDimValue(), 
-							getBaseIndValueMsg.getCode());
-					if(indValueMap!=null) {
-						if(indValueMap.get("value")==null) {//如果指标值为空，返回失败结果
+
+		Receive receive = null;
+		try {
+
+			receive= receiveBuilder()
+					.match(GetBaseIndValueMsg.class, getBaseIndValueMsg -> {
+						//根据维度值和基础指标id获取指标值
+						compCalLogId = getBaseIndValueMsg.getCompCalLogId();
+
+						Map<String, Object> indValueMap = indicatorsValueService.getIndicatorsValue(
+								getBaseIndValueMsg.getIndId(), getBaseIndValueMsg.getDimValue(),
+								getBaseIndValueMsg.getCode());
+						if (indValueMap != null) {
+							if (indValueMap.get("value") == null) {//如果指标值为空，返回失败结果
+								//返回指标值结果
+								getSender().tell(new BaseIndValueMsg(getBaseIndValueMsg.getIndId()
+										, null, indValueMap.get("compareObjDesc").toString(), 0,
+										"获取指标id：" +
+												getBaseIndValueMsg.getIndId() + ";维度：" +
+												getBaseIndValueMsg.getDimValue().get(0).getDimvalue() + "," +
+												getBaseIndValueMsg.getDimValue().get(1).getDimvalue() + " 的指标值为空;"), getSelf());
+							} else {
+								getSender().tell(new BaseIndValueMsg(getBaseIndValueMsg.getIndId()
+										, indValueMap.get("value").toString(),
+										indValueMap.get("compareObjDesc").toString(), 1, ""), getSelf());
+							}
+						} else {
 							//返回指标值结果
-							getSender().tell(new BaseIndValueMsg(getBaseIndValueMsg.getIndId()
-									,null,indValueMap.get("compareObjDesc").toString(),0,
-									"获取指标id："+
-											getBaseIndValueMsg.getIndId()+";维度："+
-											getBaseIndValueMsg.getDimValue().get(0).getDimvalue()+","+
-											getBaseIndValueMsg.getDimValue().get(1).getDimvalue()+" 的指标值为空;"),getSelf());
-						}else {
-							getSender().tell(new BaseIndValueMsg(getBaseIndValueMsg.getIndId()
-									,indValueMap.get("value").toString(),
-									indValueMap.get("compareObjDesc").toString(),1,""),getSelf());
+							getSender().tell(new BaseIndValueMsg(getBaseIndValueMsg.getIndId(), null, null,
+									0, "无法获取指标id：" +
+									getBaseIndValueMsg.getIndId() + ";维度：" +
+									getBaseIndValueMsg.getDimValue().get(0).getDimvalue() + "," +
+									getBaseIndValueMsg.getDimValue().get(1).getDimvalue() + " 的指标值;"), getSelf());
 						}
-					}else {
-						//返回指标值结果
-						getSender().tell(new BaseIndValueMsg(getBaseIndValueMsg.getIndId(),null,null,
-								0,"无法获取指标id："+
-								getBaseIndValueMsg.getIndId()+";维度："+
-								getBaseIndValueMsg.getDimValue().get(0).getDimvalue()+","+
-								getBaseIndValueMsg.getDimValue().get(1).getDimvalue()+" 的指标值;"),getSelf());
-					}
-				})
-				.build();
+					})
+					.build();
+		}catch (Exception e){
+			e.printStackTrace();
+
+			CompareUnitCalLog compCalLog = compareUnitCalLogService.findById(compCalLogId);
+			if(compCalLog!=null){
+				compCalLog.setEndTime(System.currentTimeMillis()+"");
+				compCalLog.setRunStatus("1");
+				compCalLog.setStatus(0);
+					compCalLog.setLogInfo("运算失败");
+				compareUnitCalLogService.saveOrUndate(compCalLog);
+			}
+		}
+		return receive;
 	}
 }

src/main/java/com/keymobile/indicators/akka/actor/indicators/StartCompareUnitCalActor.java

@@ -63,156 +63,171 @@ public class StartCompareUnitCalActor extends AbstractActor{
 	
 	@Override
 	public Receive createReceive() {
-		return receiveBuilder()
-				.match(StartCompareUnitCalMsg.class,startCompareUnitCalMsg -> {
-					code = startCompareUnitCalMsg.getCode();
-					isTest = startCompareUnitCalMsg.getIsTest();
-					String user = startCompareUnitCalMsg.getUser();
-					 compCalLogId = startCompareUnitCalMsg.getCompCalLogId();
-					List<CompareUnitDef> compareUnitDefs = startCompareUnitCalMsg.getCompareInitDefs();
-					//将对标单元进行分类，需要先执行的先开始进行对标计算
+		Receive receive = null;
+		try {
+			receive =  receiveBuilder()
+					.match(StartCompareUnitCalMsg.class, startCompareUnitCalMsg -> {
+						code = startCompareUnitCalMsg.getCode();
+						isTest = startCompareUnitCalMsg.getIsTest();
+						String user = startCompareUnitCalMsg.getUser();
+						compCalLogId = startCompareUnitCalMsg.getCompCalLogId();
+						List<CompareUnitDef> compareUnitDefs = startCompareUnitCalMsg.getCompareInitDefs();
+						//将对标单元进行分类，需要先执行的先开始进行对标计算
 
 
-					for(CompareUnitDef unitDef : compareUnitDefs) {
-						if("1".equals(unitDef.getFirstExe())) {
-							firstExeList.add(unitDef);
-						}else {
-							afterExeList.add(unitDef);
-						}
-						//单位评分规则不为空的对标单元加到calTypeExeList中
-						if(unitDef.getObjScoreRuleId()!=null) {
-							//ScoreRule scoreRule = scoreRuleServer.getById(unitDef.getObjScoreRuleId());
-							//if(scoreRule!=null) {
+						for (CompareUnitDef unitDef : compareUnitDefs) {
+							if ("1".equals(unitDef.getFirstExe())) {
+								firstExeList.add(unitDef);
+							} else {
+								afterExeList.add(unitDef);
+							}
+							//单位评分规则不为空的对标单元加到calTypeExeList中
+							if (unitDef.getObjScoreRuleId() != null) {
+								//ScoreRule scoreRule = scoreRuleServer.getById(unitDef.getObjScoreRuleId());
+								//if(scoreRule!=null) {
 								//if(scoreRule.getCalType()!=null && !"0".equals(scoreRule.getCalType())) {
-									calTypeExeList.add(unitDef);
+								calTypeExeList.add(unitDef);
 								//}
-							//}
-						}
-					}
-					firstExeUnitSize = firstExeList.size();
-					afterExeUnitSize = afterExeList.size();
-					if(!firstExeList.isEmpty()) {
-						for(CompareUnitDef unitDef : firstExeList) {
-							CompareUnitCalMsg compareUnitCalMsg = new CompareUnitCalMsg(unitDef,
-									startCompareUnitCalMsg.getCode(),
-									startCompareUnitCalMsg.getIsTest());
-							//运算者
-							compareUnitCalMsg.setUser(user);
-							compareUnitCalMsg.setCompCalLogId(compCalLogId);
-
-							ActorRef compareUnitCalActor = this.getContext()
-									.actorOf(Props.create(CompareUnitCalActor.class,
-											()->new CompareUnitCalActor(getSelf())));
-							compareUnitCalActor.tell(compareUnitCalMsg, getSelf());
+								//}
+							}
 						}
-					}else {
-						if(!afterExeList.isEmpty()) {
-							for(CompareUnitDef unitDef : afterExeList) {
+						firstExeUnitSize = firstExeList.size();
+						afterExeUnitSize = afterExeList.size();
+						if (!firstExeList.isEmpty()) {
+							for (CompareUnitDef unitDef : firstExeList) {
 								CompareUnitCalMsg compareUnitCalMsg = new CompareUnitCalMsg(unitDef,
 										startCompareUnitCalMsg.getCode(),
 										startCompareUnitCalMsg.getIsTest());
+								//运算者
+								compareUnitCalMsg.setUser(user);
 								compareUnitCalMsg.setCompCalLogId(compCalLogId);
+
 								ActorRef compareUnitCalActor = this.getContext()
 										.actorOf(Props.create(CompareUnitCalActor.class,
-												()->new CompareUnitCalActor(getSelf())));
+												() -> new CompareUnitCalActor(getSelf())));
 								compareUnitCalActor.tell(compareUnitCalMsg, getSelf());
 							}
-						}else {
-							//发送确认消息给父actor
-							CurrentCompUnitExeMsg currentCompUnitExeMsg = new CurrentCompUnitExeMsg(1,"");
-							beforeCompareUnitActor.tell(currentCompUnitExeMsg, ActorRef.noSender());
-							if("0".equals(isTest)) {
-								logger.info("对标单元试运行计算完成");
-							}else {
-								logger.info("对标单元计算完成");
+						} else {
+							if (!afterExeList.isEmpty()) {
+								for (CompareUnitDef unitDef : afterExeList) {
+									CompareUnitCalMsg compareUnitCalMsg = new CompareUnitCalMsg(unitDef,
+											startCompareUnitCalMsg.getCode(),
+											startCompareUnitCalMsg.getIsTest());
+									compareUnitCalMsg.setCompCalLogId(compCalLogId);
+									ActorRef compareUnitCalActor = this.getContext()
+											.actorOf(Props.create(CompareUnitCalActor.class,
+													() -> new CompareUnitCalActor(getSelf())));
+									compareUnitCalActor.tell(compareUnitCalMsg, getSelf());
+								}
+							} else {
+								//发送确认消息给父actor
+								CurrentCompUnitExeMsg currentCompUnitExeMsg = new CurrentCompUnitExeMsg(1, "");
+								beforeCompareUnitActor.tell(currentCompUnitExeMsg, ActorRef.noSender());
+								if ("0".equals(isTest)) {
+									logger.info("对标单元试运行计算完成");
+								} else {
+									logger.info("对标单元计算完成");
+								}
 							}
 						}
-					}
-				})
-				.match(FirstExeConfirmMsg.class, firstExeConfirmMsg -> {
-					if (++numberOfConfirm >= firstExeUnitSize) {//全部先执行的子actor全部返回
-						//再执行后执行的actor
-						if(!afterExeList.isEmpty()) {
-							for(CompareUnitDef unitDef : afterExeList) {
-								CompareUnitCalMsg compareUnitCalMsg = new CompareUnitCalMsg(unitDef,
-										code,isTest);
-								compareUnitCalMsg.setCompCalLogId(compCalLogId);
-								ActorRef compareUnitCalActor = this.getContext()
-										.actorOf(Props.create(CompareUnitCalActor.class,
-												()->new CompareUnitCalActor(getSelf())));
-								compareUnitCalActor.tell(compareUnitCalMsg, getSelf());
-							}
-							if("0".equals(isTest)) {
-								logger.info("进行后执行对标单元试运行计算....");
-							}else {
-								logger.info("进行后执行对标单元计算....");
+					})
+					.match(FirstExeConfirmMsg.class, firstExeConfirmMsg -> {
+						if (++numberOfConfirm >= firstExeUnitSize) {//全部先执行的子actor全部返回
+							//再执行后执行的actor
+							if (!afterExeList.isEmpty()) {
+								for (CompareUnitDef unitDef : afterExeList) {
+									CompareUnitCalMsg compareUnitCalMsg = new CompareUnitCalMsg(unitDef,
+											code, isTest);
+									compareUnitCalMsg.setCompCalLogId(compCalLogId);
+									ActorRef compareUnitCalActor = this.getContext()
+											.actorOf(Props.create(CompareUnitCalActor.class,
+													() -> new CompareUnitCalActor(getSelf())));
+									compareUnitCalActor.tell(compareUnitCalMsg, getSelf());
+								}
+								if ("0".equals(isTest)) {
+									logger.info("进行后执行对标单元试运行计算....");
+								} else {
+									logger.info("进行后执行对标单元计算....");
+								}
+							} else {
+								if (!calTypeExeList.isEmpty()) {
+									if ("0".equals(isTest)) {
+										logger.info("计算试运行对标单元单位评分......");
+									} else {
+										logger.info("计算对标单元单位评分......");
+									}
+									for (CompareUnitDef unitDef : calTypeExeList) {
+										//试运行
+										if ("0".equals(isTest)) {
+											testScoreRuleServer.testCalObjScore(unitDef.getCompareId(),
+													Arrays.asList(unitDef.getIndIds().split(",")),
+													Arrays.asList(unitDef.getCompareObjs().split(",")),
+													unitDef.getDate(), unitDef.getObjScoreRuleId(), code);
+										} else {
+											scoreRuleServer.calObjScore(unitDef.getCompareId(),
+													Arrays.asList(unitDef.getIndIds().split(",")),
+													Arrays.asList(unitDef.getCompareObjs().split(",")),
+													unitDef.getDate(), unitDef.getObjScoreRuleId(), code);
+										}
+									}
+								}
+								//发送确认消息给父actor
+								CurrentCompUnitExeMsg currentCompUnitExeMsg = new CurrentCompUnitExeMsg(1, "");
+								beforeCompareUnitActor.tell(currentCompUnitExeMsg, ActorRef.noSender());
+								if ("0".equals(isTest)) {
+									logger.info("对标单元试运行计算完成");
+								} else {
+									logger.info("对标单元计算完成");
+								}
 							}
-						}else {
-							if(!calTypeExeList.isEmpty()) {
-								if("0".equals(isTest)) {
+						}
+					})
+					.match(AfterExeConfirmMsg.class, afterExeConfirmMsg -> {
+						if (++numberOfAfterConfirm >= afterExeUnitSize) {//全部后执行的子actor全部返回
+							if (!calTypeExeList.isEmpty()) {
+								if ("0".equals(isTest)) {
 									logger.info("计算试运行对标单元单位评分......");
-								}else {
+								} else {
 									logger.info("计算对标单元单位评分......");
 								}
-								for(CompareUnitDef unitDef : calTypeExeList) {
+								for (CompareUnitDef unitDef : calTypeExeList) {
 									//试运行
-									if("0".equals(isTest)) {
-										testScoreRuleServer.testCalObjScore(unitDef.getCompareId(), 
-												Arrays.asList(unitDef.getIndIds().split(",")), 
-												Arrays.asList(unitDef.getCompareObjs().split(",")), 
-												unitDef.getDate(), unitDef.getObjScoreRuleId(),code);
-									}else {
-										scoreRuleServer.calObjScore(unitDef.getCompareId(), 
-												Arrays.asList(unitDef.getIndIds().split(",")), 
-												Arrays.asList(unitDef.getCompareObjs().split(",")), 
-												unitDef.getDate(), unitDef.getObjScoreRuleId(),code);
+									if ("0".equals(isTest)) {
+										testScoreRuleServer.testCalObjScore(unitDef.getCompareId(),
+												Arrays.asList(unitDef.getIndIds().split(",")),
+												Arrays.asList(unitDef.getCompareObjs().split(",")),
+												unitDef.getDate(), unitDef.getObjScoreRuleId(), code);
+									} else {
+										scoreRuleServer.calObjScore(unitDef.getCompareId(),
+												Arrays.asList(unitDef.getIndIds().split(",")),
+												Arrays.asList(unitDef.getCompareObjs().split(",")),
+												unitDef.getDate(), unitDef.getObjScoreRuleId(), code);
 									}
 								}
 							}
 							//发送确认消息给父actor
-							CurrentCompUnitExeMsg currentCompUnitExeMsg = new CurrentCompUnitExeMsg(1,"");
+							CurrentCompUnitExeMsg currentCompUnitExeMsg = new CurrentCompUnitExeMsg(1, "");
 							beforeCompareUnitActor.tell(currentCompUnitExeMsg, ActorRef.noSender());
-							if("0".equals(isTest)) {
+							if ("0".equals(isTest)) {
 								logger.info("对标单元试运行计算完成");
-							}else {
+							} else {
 								logger.info("对标单元计算完成");
 							}
 						}
-					}
-				})
-				.match(AfterExeConfirmMsg.class, afterExeConfirmMsg -> {
-					if (++numberOfAfterConfirm >= afterExeUnitSize) {//全部后执行的子actor全部返回
-						if(!calTypeExeList.isEmpty()) {
-							if("0".equals(isTest)) {
-								logger.info("计算试运行对标单元单位评分......");
-							}else {
-								logger.info("计算对标单元单位评分......");
-							}
-							for(CompareUnitDef unitDef : calTypeExeList) {
-								//试运行
-								if("0".equals(isTest)) {
-									testScoreRuleServer.testCalObjScore(unitDef.getCompareId(), 
-											Arrays.asList(unitDef.getIndIds().split(",")), 
-											Arrays.asList(unitDef.getCompareObjs().split(",")), 
-											unitDef.getDate(), unitDef.getObjScoreRuleId(),code);
-								}else {
-									scoreRuleServer.calObjScore(unitDef.getCompareId(), 
-											Arrays.asList(unitDef.getIndIds().split(",")), 
-											Arrays.asList(unitDef.getCompareObjs().split(",")), 
-											unitDef.getDate(), unitDef.getObjScoreRuleId(),code);
-								}
-							}
-						}
-						//发送确认消息给父actor
-						CurrentCompUnitExeMsg currentCompUnitExeMsg = new CurrentCompUnitExeMsg(1,"");
-						beforeCompareUnitActor.tell(currentCompUnitExeMsg, ActorRef.noSender());
-						if("0".equals(isTest)) {
-							logger.info("对标单元试运行计算完成");
-						}else {
-							logger.info("对标单元计算完成");
-						}
-					}
-				})
-				.build();
+					})
+					.build();
+		}catch (Exception e){
+			e.printStackTrace();
+
+			CompareUnitCalLog compCalLog = compareUnitCalLogService.findById(compCalLogId);
+			if(compCalLog!=null){
+				compCalLog.setEndTime(System.currentTimeMillis()+"");
+				compCalLog.setRunStatus("1");
+				compCalLog.setStatus(0);
+				compCalLog.setLogInfo("运算失败");
+				compareUnitCalLogService.saveOrUndate(compCalLog);
+			}
+		}
+		return receive;
 	}
 }

src/main/java/com/keymobile/indicators/akka/message/indicators/GetBaseIndValueMsg.java

@@ -17,13 +17,23 @@ public class GetBaseIndValueMsg implements Serializable{
 	private List<DimValue> dimValue = new ArrayList<>();//维度值
 	
 	private String code;
-	
+
+	private Integer compCalLogId;
+
 	public GetBaseIndValueMsg(String indId,List<DimValue> dimValue,String code) {
 		this.indId = indId;
 		this.dimValue.addAll(dimValue);
 		this.code = code;
 	}
-	
+
+	public Integer getCompCalLogId() {
+		return compCalLogId;
+	}
+
+	public void setCompCalLogId(Integer compCalLogId) {
+		this.compCalLogId = compCalLogId;
+	}
+
 	public List<DimValue> getDimValue() {
 		return dimValue;
 	}