设备会在多种功能码上报数据中携带报警与状态数据，这样数据库保存设备报警与状态数据可能很多，为此修改逻辑，当前实现为一设备一个小时内只保存一条报警与状态数据。

liurunyu

7 天以前 656aa4f953eb52502a6414965e46642c31b6e8ee

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/server/rtuData/TaskSurpport.java

New file
@@ -0,0 +1,134 @@
package com.dy.rtuMw.server.rtuData;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import java.text.ParseException;

/**
 * 部分实现Task
 */
public abstract class TaskSurpport implements Task {

   private static final Logger log = LogManager.getLogger(TaskSurpport.class.getName()) ;
	
   //当前所处理的上行数据所属RTU的地址
   //public String rtuAddr_inRootTk ;//只在根root任务对象上会付此值
   //本节点配置
   protected TaskConfig conf ;
   //根任务
   protected TaskSurpport root ;
   //本任务的子任务
   protected TaskSurpport[] subTasks ;
   //本任务的处理结果
   protected Object[] taskResult ;

   /**
    * 执行节点任务
    * @param data 需要处理的数据
    */
   @Override
   public abstract void execute(Object data) throws ParseException;
	
   /**
    * 任务采用对象池，以便重用任务对象，
    * 重用前要进行对象初始化，清除上次执行任务时遗留的对象属性数据
    * 初始化本任务及所有子任务
    */
   @Override
   public void cleanMeAndSubs() {
      //rtuAddr_inRootTk = null ;
      taskResult = null ;
      if(this.subTasks != null && this.subTasks.length > 0){
         for(int i = 0 ; i < this.subTasks.length; i++){
            this.subTasks[i].cleanMeAndSubs() ;
         }
      }
   }
	
   /**
    * 得到本任务节点处理产生的中间结果，以供本节点所在树枝的下级任务节点及本树枝的左侧（根在上）所有树枝的节点应用本结果
    * @return
    */
   @Override
   public Object[] getMyResults(){
      return taskResult ;
   }
	
   /**
    * 得到指定任务节点处理产生的中间结果，以供本节点所在树枝的下级任务节点及本树枝的左侧（根在上）所有树枝的节点应用本结果
    * @param id 指定任务ID
    * @return
    */
   public Object[] getTaskResults(String id){
      if(root != null){
         return this.getTaskResults(root, id) ;
      }
      return null ;
   }
   private Object[] getTaskResults(TaskSurpport task, String id){ 
      if(task != null && task.conf != null && task.conf.id != null && task.conf.id.equals(id)){
         return task.getMyResults() ;
      }else{
         if(task.subTasks != null && task.subTasks.length > 0){
            Object[] rs = null ;
            for(int i = 0 ; i < task.subTasks.length; i++){
               rs = getTaskResults(task.subTasks[i], id) ;
               if(rs != null){
                  return rs ;
               }
            }
         }
      }
      return null ;
   }

   /**
    * 转下级任务节点处理，首先要实体化所有子节点。
    * @param data 需要处理的数据
    */
   @Override
   public void toNextTasks(Object data) {
      try {
         if(subTasks != null && subTasks.length > 0){
            for(int i = 0 ; i < subTasks.length ; i++){
               if(subTasks[i].conf.enable){
                  subTasks[i].execute(data) ;
               }else{
                  //本节点不起作用，直接进入本节的子节点
                  subTasks[i].toNextTasks(data) ;
               }
            }
         }
      } catch (Exception e) {
         log.error("向下级任务传递工作时出错，" , e);
      }finally{
      }
   }

   /**
    * 转下级某个任务节点处理 
    * @param data 需要处理的数据
    * @param id 指定任务ID
    */
   public void toNextOneTask(Object data, String id){
      try {
         if(subTasks != null && subTasks.length > 0){
            for(int i = 0 ; i < subTasks.length ; i++){
               if(subTasks[i].conf.id.equals(id)){
                  if(subTasks[i].conf.enable){
                     subTasks[i].execute(data) ;
                  }else{
                     //本节点不起作用，直接进入本节的子节点
                     subTasks[i].toNextTasks(data) ;
                  }
               }
            }
         }
      } catch (Exception e) {
         log.error("向指定子任务（" + id + "）传递任务时出错，" , e);
      }finally{
      }
   }

}