关于通过java调用datax,返回任务执行的方法

public static void entry(final string[] args) throws throwable {
 options options = new options();
 options.addoption("job", true, "job config.");
 options.addoption("jobid", true, "job unique id.");
 options.addoption("mode", true, "job runtime mode.");

 basicparser parser = new basicparser();
 commandline cl = parser.parse(options, args);

 string jobpath = cl.getoptionvalue("job");

 // 如果用户没有明确指定jobid, 则 datax.py 会指定 jobid 默认值为-1
 string jobidstring = cl.getoptionvalue("jobid");
 runtime_mode = cl.getoptionvalue("mode");

 configuration configuration = configparser.parse(jobpath);

 long jobid;
 if (!"-1".equalsignorecase(jobidstring)) {
  jobid = long.parselong(jobidstring);
 } else {
  // only for dsc & ds & datax 3 update
  string dscjoburlpatternstring = "/instance/(\\d{1,})/config.xml";
  string dsjoburlpatternstring = "/inner/job/(\\d{1,})/config";
  string dstaskgroupurlpatternstring = "/inner/job/(\\d{1,})/taskgroup/";
  list<string> patternstringlist = arrays.aslist(dscjoburlpatternstring,
   dsjoburlpatternstring, dstaskgroupurlpatternstring);
  jobid = parsejobidfromurl(patternstringlist, jobpath);
 }

 boolean isstandalonemode = "standalone".equalsignorecase(runtime_mode);
 if (!isstandalonemode && jobid == -1) {
  // 如果不是 standalone 模式，那么 jobid 一定不能为-1
  throw dataxexception.asdataxexception(frameworkerrorcode.config_error, "非 standalone 模式必须在 url 中提供有效的 jobid.");
 }
 configuration.set(coreconstant.datax_core_container_job_id, jobid);

 //打印vminfo
 vminfo vminfo = vminfo.getvminfo();
 if (vminfo != null) {
  log.info(vminfo.tostring());
 }

 log.info("\n" + engine.filterjobconfiguration(configuration) + "\n");

 log.debug(configuration.tojson());

 configurationvalidate.dovalidate(configuration);
 engine engine = new engine();
 engine.start(configuration);
 }

@override
 public void start() {
 log.info("datax jobcontainer starts job.");

 boolean hasexception = false;
 boolean isdryrun = false;
 try {
  this.starttimestamp = system.currenttimemillis();
  isdryrun = configuration.getbool(coreconstant.datax_job_setting_dryrun, false);
  if (isdryrun) {
  log.info("jobcontainer starts to do precheck ...");
  this.precheck();
  } else {
  userconf = configuration.clone();
  log.debug("jobcontainer starts to do prehandle ...");
  this.prehandle();

  log.debug("jobcontainer starts to do init ...");
  this.init();
  log.info("jobcontainer starts to do prepare ...");
  this.prepare();
  log.info("jobcontainer starts to do split ...");
  this.totalstage = this.split();
  log.info("jobcontainer starts to do schedule ...");
  this.schedule();
  log.debug("jobcontainer starts to do post ...");
  this.post();

  log.debug("jobcontainer starts to do posthandle ...");
  this.posthandle();
  log.info("datax jobid [{}] completed successfully.", this.jobid);

  this.invokehooks();
  }
 } catch (throwable e) {
  log.error("exception when job run", e);

  hasexception = true;

  if (e instanceof outofmemoryerror) {
  this.destroy();
  system.gc();
  }


  if (super.getcontainercommunicator() == null) {
  // 由于 containercollector 是在 scheduler() 中初始化的，所以当在 scheduler() 之前出现异常时，需要在此处对 containercollector 进行初始化

  abstractcontainercommunicator tempcontainercollector;
  // standalone
  tempcontainercollector = new standalonejobcontainercommunicator(configuration);

  super.setcontainercommunicator(tempcontainercollector);
  }

  communication communication = super.getcontainercommunicator().collect();
  // 汇报前的状态，不需要手动进行设置
  // communication.setstate(state.failed);
  communication.setthrowable(e);
  communication.settimestamp(this.endtimestamp);

  communication tempcomm = new communication();
  tempcomm.settimestamp(this.starttransfertimestamp);

  communication reportcommunication = communicationtool.getreportcommunication(communication, tempcomm, this.totalstage);
  super.getcontainercommunicator().report(reportcommunication);

  throw dataxexception.asdataxexception(
   frameworkerrorcode.runtime_error, e);
 } finally {
  if (!isdryrun) {

  this.destroy();
  this.endtimestamp = system.currenttimemillis();
  if (!hasexception) {
   //最后打印cpu的平均消耗，gc的统计
   vminfo vminfo = vminfo.getvminfo();
   if (vminfo != null) {
   vminfo.getdelta(false);
   log.info(vminfo.totalstring());
   }

   log.info(perftrace.getinstance().summarizenoexception());
   this.logstatistics();
  }
  }
 }
 }

private void logstatistics() {
 long totalcosts = (this.endtimestamp - this.starttimestamp) / 1000;
 long transfercosts = (this.endtransfertimestamp - this.starttransfertimestamp) / 1000;
 if (0l == transfercosts) {
  transfercosts = 1l;
 }

 if (super.getcontainercommunicator() == null) {
  return;
 }

 communication communication = super.getcontainercommunicator().collect();
 communication.settimestamp(this.endtimestamp);

 communication tempcomm = new communication();
 tempcomm.settimestamp(this.starttransfertimestamp);

 communication reportcommunication = communicationtool.getreportcommunication(communication, tempcomm, this.totalstage);

 // 字节速率
 long bytespeedpersecond = communication.getlongcounter(communicationtool.read_succeed_bytes)
  / transfercosts;

 long recordspeedpersecond = communication.getlongcounter(communicationtool.read_succeed_records)
  / transfercosts;

 reportcommunication.setlongcounter(communicationtool.byte_speed, bytespeedpersecond);
 reportcommunication.setlongcounter(communicationtool.record_speed, recordspeedpersecond);

 super.getcontainercommunicator().report(reportcommunication);


 log.info(string.format(
  "\n" + "%-26s: %-18s\n" + "%-26s: %-18s\n" + "%-26s: %19s\n"
   + "%-26s: %19s\n" + "%-26s: %19s\n" + "%-26s: %19s\n"
   + "%-26s: %19s\n",
  "任务启动时刻",
  dateformat.format(starttimestamp),

  "任务结束时刻",
  dateformat.format(endtimestamp),

  "任务总计耗时",
  string.valueof(totalcosts) + "s",
  "任务平均流量",
  strutil.stringify(bytespeedpersecond)
   + "/s",
  "记录写入速度",
  string.valueof(recordspeedpersecond)
   + "rec/s", "读出记录总数",
  string.valueof(communicationtool.gettotalreadrecords(communication)),
  "读写失败总数",
  string.valueof(communicationtool.gettotalerrorrecords(communication))
 ));

 log.info("task-total-info:" + dateformat.format(starttimestamp) + "|" +
  dateformat.format(endtimestamp) + "|" +
  string.valueof(totalcosts) + "|" +
  strutil.stringify(bytespeedpersecond) + "|" +
  string.valueof(recordspeedpersecond) + "|" +
  string.valueof(communicationtool.gettotalreadrecords(communication)) + "|" +
  string.valueof(communicationtool.gettotalerrorrecords(communication))
 );

 if (communication.getlongcounter(communicationtool.transformer_succeed_records) > 0
  || communication.getlongcounter(communicationtool.transformer_failed_records) > 0
  || communication.getlongcounter(communicationtool.transformer_filter_records) > 0) {
  log.info(string.format(
   "\n" + "%-26s: %19s\n" + "%-26s: %19s\n" + "%-26s: %19s\n",
   "transformer成功记录总数",
   communication.getlongcounter(communicationtool.transformer_succeed_records),

   "transformer失败记录总数",
   communication.getlongcounter(communicationtool.transformer_failed_records),

   "transformer过滤记录总数",
   communication.getlongcounter(communicationtool.transformer_filter_records)
  ));
 }
 }

public class dataxresult {
 //任务启动时刻
 private long starttimestamp;
 //任务结束时刻
 private long endtimestamp;
 //任务总时耗
 private long totalcosts;
 //任务平均流量
 private long bytespeedpersecond;
 //记录写入速度
 private long recordspeedpersecond;
 //读出记录总数
 private long totalreadrecords;
 //读写失败总数
 private long totalerrorrecords;
 //成功记录总数
 private long transformersucceedrecords;
 // 失败记录总数
 private long transformerfailedrecords;
 // 过滤记录总数
 private long transformerfilterrecords;
 //字节数
 private long readsucceedbytes;
 //转换开始时间
 private long endtransfertimestamp;
 //转换结束时间
 private long starttransfertimestamp;
 //转换总耗时
 private long transfercosts;

private dataxresult logstatistics(dataxresult resultmsg) {
 long totalcosts = (this.endtimestamp - this.starttimestamp) / 1000;
 long transfercosts = (this.endtransfertimestamp - this.starttransfertimestamp) / 1000;
 if (0l == transfercosts) {
  transfercosts = 1l;
 }
 if (super.getcontainercommunicator() == null) {
  return resultmsg;
 }
 communication communication = super.getcontainercommunicator().collect();
 long bytespeedpersecond = communication.getlongcounter(communicationtool.read_succeed_bytes)
  / transfercosts;
 long recordspeedpersecond = communication.getlongcounter(communicationtool.read_succeed_records)
  / transfercosts;
  
 return resultmsg.getresultmsg(starttimestamp,
  endtimestamp,
  totalcosts,
  bytespeedpersecond,
  recordspeedpersecond,
  communication.getlongcounter(communicationtool.transformer_succeed_records),
  communication.getlongcounter(communicationtool.transformer_failed_records),
  communication.getlongcounter(communicationtool.transformer_filter_records),
  communication.getlongcounter(communicationtool.transformer_failed_records),
  communication.getlongcounter(communicationtool.transformer_filter_records),
  communication.getlongcounter(communicationtool.read_succeed_bytes),
  this.endtransfertimestamp,
  this.starttransfertimestamp,
  transfercosts
 );


 }

@override
 public dataxresult start(dataxresult dataxresult) {
 ...
 dataxresult result = new dataxresult();
 result = logstatistics(dataxresult);
 ...
 return result;
 }

 public dataxresult mockstart(configuration allconf) {

 ...
 dataxresult dataxresult = new dataxresult();
 return container.start(dataxresult);
 }

public class test {

 public static void main(string[] args) {
 string[] datxargs = {"-job", coreconstant.datax_home + "\\job\\job2.json", "-mode", "standalone", "-jobid", "-1"};
 try {
  dataxresult dataxresult= engine.mockentry(datxargs);
 } catch (throwable e) {
  e.printstacktrace();
 }

 }
}