import javax.batch.operations.JobStartException; //导入依赖的package包/类
public TCKJobExecutionWrapper startJobAndWaitForResult(String jobName, Properties jobParameters) throws JobStartException, NoSuchJobExecutionException, JobSecurityException, JobExecutionTimeoutException{
	JobExecution terminatedJobExecution = null;
	long executionId = jobOp.start(jobName, jobParameters);

	JobExecutionWaiter waiter = waiterFactory.createWaiter(executionId, jobOp, sleepTime);

	try {
		terminatedJobExecution = waiter.awaitTermination();
	} catch (JobExecutionTimeoutException e) {
		logger.severe(TIMEOUT_MSG);
		Reporter.log(TIMEOUT_MSG);
		throw e;
	}									

	return new TCKJobExecutionWrapper(terminatedJobExecution, jobOp);
}
 

import javax.batch.operations.JobStartException; //导入依赖的package包/类
@Override
public SplitExecutionStatus execute() throws JobRestartException, JobStartException, JobExecutionAlreadyCompleteException, JobExecutionNotMostRecentException, NoSuchJobExecutionException {
	String sourceMethod = "execute";
	if (logger.isLoggable(Level.FINER)) {
		logger.entering(sourceClass, sourceMethod, "Root JobExecution Id = " + rootJobExecutionId);
	}

	// Build all sub jobs from partitioned step
	buildSubJobBatchWorkUnits();

	// kick off the threads
	executeWorkUnits();

	// Deal with the results.
	SplitExecutionStatus status = waitForCompletionAndAggregateStatus();

	if (logger.isLoggable(Level.FINER)) {
		logger.exiting(sourceClass, sourceMethod, status);
	}

	return status;
}
 

import javax.batch.operations.JobStartException; //导入依赖的package包/类
public void startBatches() throws JobSecurityException, JobStartException, NoSuchJobExecutionException {
      JobOperator jobOperator = BatchRuntime.getJobOperator();

      logger.log(Level.INFO, "starting simple");
      Long executionId = jobOperator.start("simple", new Properties());
      JobExecution jobExecution = jobOperator.getJobExecution(executionId);

      logger.log(Level.INFO, "Started simple job with id {0}", jobExecution.getExecutionId());
      logger.log(Level.INFO, "Status simple {0}", jobExecution.getBatchStatus());

//      logger.log(Level.INFO, "starting chunk");
//      Long chunkExecutionId = jobOperator.start("chunk", new Properties());
//      JobExecution chunkJobExecution = jobOperator.getJobExecution(chunkExecutionId);
//
//      logger.log(Level.INFO, "Status chunk {0}", chunkJobExecution.getBatchStatus());
//      logger.log(Level.INFO, "Started chunk job with id {0}", chunkJobExecution.getExecutionId());
   }
 

import javax.batch.operations.JobStartException; //导入依赖的package包/类
public static RuntimeJobExecution startJob(final ServicesManager servicesManager, final String jobXML, final Properties jobParameters) throws JobStartException {
    final JSLJob jobModel = new JobModelResolver().resolveModel(jobXML);
    final ModelNavigator<JSLJob> jobNavigator = getResolvedJobNavigator(jobModel, jobParameters, false);
    final JobContextImpl jobContext = getJobContext(jobNavigator);
    final JobInstance jobInstance = getNewJobInstance(servicesManager, jobNavigator.getRootModelElement().getId(), jobXML);
    final RuntimeJobExecution executionHelper =
            servicesManager.service(PersistenceManagerService.class).createJobExecution(jobInstance, jobParameters, jobContext.getBatchStatus());

    executionHelper.prepareForExecution(jobContext);

    final JobStatusManagerService statusManagerService = servicesManager.service(JobStatusManagerService.class);
    final JobStatus jobStatus = createNewJobStatus(statusManagerService, jobInstance);
    statusManagerService.updateJobStatus(jobStatus);

    return executionHelper;
}
 

import javax.batch.operations.JobStartException; //导入依赖的package包/类
public static RuntimeJobExecution startPartition(final ServicesManager servicesManager, final JSLJob jobModel, final Properties jobParameters) throws JobStartException {
    final ModelNavigator<JSLJob> jobNavigator = getResolvedJobNavigator(jobModel, jobParameters, true);
    final JobContextImpl jobContext = getJobContext(jobNavigator);

    final JobInstance jobInstance = getNewSubJobInstance(servicesManager, jobNavigator.getRootModelElement().getId());

    final RuntimeJobExecution executionHelper =
            servicesManager.service(PersistenceManagerService.class).createJobExecution(jobInstance, jobParameters, jobContext.getBatchStatus());

    executionHelper.prepareForExecution(jobContext);

    final JobStatusManagerService statusManagerService = servicesManager.service(JobStatusManagerService.class);
    final JobStatus jobStatus = createNewJobStatus(statusManagerService, jobInstance);
    statusManagerService.updateJobStatus(jobStatus);

    return executionHelper;
}
 

import javax.batch.operations.JobStartException; //导入依赖的package包/类
private long startInternal(final String jobXMLName, final Properties jobParameters) throws JobStartException, JobSecurityException {
    final StringWriter jobParameterWriter = new StringWriter();
    if (jobParameters != null) {
        try {
            jobParameters.store(jobParameterWriter, "Job parameters on start: ");
        } catch (IOException e) {
            jobParameterWriter.write("Job parameters on start: not printable");
        }
    } else {
        jobParameterWriter.write("Job parameters on start = null");
    }

    final String jobXML = xmlLoaderService.loadJSL(jobXMLName);
    final InternalJobExecution execution = kernelService.startJob(jobXML, jobParameters);
    return execution.getExecutionId();
}
 

import javax.batch.operations.JobStartException; //导入依赖的package包/类
@Override
public long triggerJob(String jobName) throws BatchException {
    LOGGER.info("Starting execution of JOB {}", jobName);

    Properties jobParameters = getJobParameters(jobName);

    storeJobContent(jobName);
    try {
        return jsrJobOperator.start(jobName, jobParameters);
    } catch (JobStartException | JobSecurityException e) {
        throw new BatchException(ApplicationErrors.JOB_TRIGGER_FAILED, e,
                e.getMessage());
    }
}
 

import javax.batch.operations.JobStartException; //导入依赖的package包/类
private long startInternal(String jobXMLName, Properties jobParameters)	throws JobStartException, JobSecurityException {

		StringWriter jobParameterWriter = new StringWriter();
		if (jobParameters != null) {
			try {
				jobParameters.store(jobParameterWriter, "Job parameters on start: ");
			} catch (IOException e) {
				jobParameterWriter.write("Job parameters on start: not printable");
			}
		} else {
			jobParameterWriter.write("Job parameters on start = null");
		}

		if (logger.isLoggable(Level.FINE)) {            
			logger.fine("JobOperator start, with jobXMLName = " + jobXMLName + "\n" + jobParameterWriter.toString());
		}

		String jobXML = jobXMLLoaderService.loadJSL(jobXMLName);

		long executionId = 0;

		if (logger.isLoggable(Level.FINE)) {            
			int concatLen = jobXML.length() > 200 ? 200 : jobXML.length();
			logger.fine("Starting job: " + jobXML.substring(0, concatLen) + "... truncated ...");
		}

		IJobExecution execution = batchKernel.startJob(jobXML, jobParameters);
		executionId = execution.getExecutionId();

		if (logger.isLoggable(Level.FINE)) {
			logger.fine("Started job with instanceId: " + execution.getInstanceId() + ", executionId: " + executionId);
		}

		return executionId;
	}
 

import javax.batch.operations.JobStartException; //导入依赖的package包/类
private void buildSubJobBatchWorkUnits() throws JobRestartException, JobStartException, JobExecutionAlreadyCompleteException, JobExecutionNotMostRecentException  {
	synchronized (subJobs) {		
		//check if we've already issued a stop
		if (jobExecutionImpl.getJobContext().getBatchStatus().equals(BatchStatus.STOPPING)){
			logger.fine("Step already in STOPPING state, exiting from buildSubJobBatchWorkUnits() before beginning execution");
			return;
		}

		for (int instance = 0; instance < partitions; instance++) {
			subJobs.add(PartitionedStepBuilder.buildPartitionSubJob(jobExecutionImpl.getJobContext(), stepContext, step, instance));
		}

		PartitionsBuilderConfig config = new PartitionsBuilderConfig(subJobs, partitionProperties, analyzerStatusQueue, finishedWorkQueue, jobExecutionImpl.getExecutionId());
		// Then build all the subjobs but do not start them yet
		if (executionType == ExecutionType.RESTART_NORMAL) {				
			parallelBatchWorkUnits = batchKernel.buildOnRestartParallelPartitions(config);
		} else { 	
			// This case includes RESTART_OVERRIDE and RESTART_AFTER_COMPLETION.
			//
			// So we're just going to create new "subjob" job instances in the DB in these cases, 
			// and we'll have to make sure we're dealing with the correct ones, say in a subsequent "normal" restart
			// (of the current execution which is itself a restart)
			parallelBatchWorkUnits = batchKernel.buildNewParallelPartitions(config);
		}

		// NOTE:  At this point I might not have as many work units as I had partitions, since some may have already completed.
	}
}
 

import javax.batch.operations.JobStartException; //导入依赖的package包/类
@Override
public IJobExecution startJob(String jobXML, Properties jobParameters) throws JobStartException {
	String method = "startJob";

	if (logger.isLoggable(Level.FINER)) {
		logger.entering(sourceClass, method, new Object[] { jobXML, jobParameters != null ? jobParameters : "<null>" });
	}

	RuntimeJobExecution jobExecution = JobExecutionHelper.startJob(jobXML, jobParameters);

	// TODO - register with status manager

	if (logger.isLoggable(Level.FINE)) {
		logger.fine("JobExecution constructed: " + jobExecution);
	}

	BatchWorkUnit batchWork = new BatchWorkUnit(this, jobExecution);
	registerCurrentInstanceAndExecution(jobExecution, batchWork.getController());

	executorService.executeTask(batchWork, null);

	if (logger.isLoggable(Level.FINER)) {
		logger.exiting(sourceClass, method, jobExecution);
	}

	return jobExecution.getJobOperatorJobExecution();
}
 

import javax.batch.operations.JobStartException; //导入依赖的package包/类
/**
 * Build a list of batch work units and set them up in STARTING state but don't start them yet.
 */

@Override
public List<BatchPartitionWorkUnit> buildNewParallelPartitions(PartitionsBuilderConfig config) 
		throws JobRestartException, JobStartException {

	List<JSLJob> jobModels = config.getJobModels();
	Properties[] partitionPropertiesArray = config.getPartitionProperties();

	List<BatchPartitionWorkUnit> batchWorkUnits = new ArrayList<BatchPartitionWorkUnit>(jobModels.size());

	int instance = 0;
	for (JSLJob parallelJob  : jobModels){
		Properties partitionProps = (partitionPropertiesArray == null) ? null : partitionPropertiesArray[instance];    			

		if (logger.isLoggable(Level.FINER)) {
			logger.finer("Starting execution for jobModel = " + parallelJob.toString());
		}
		RuntimeJobExecution jobExecution = JobExecutionHelper.startPartition(parallelJob, partitionProps);
		jobExecution.setPartitionInstance(instance);

		if (logger.isLoggable(Level.FINE)) {
			logger.fine("JobExecution constructed: " + jobExecution);
		}
		BatchPartitionWorkUnit batchWork = new BatchPartitionWorkUnit(this, jobExecution, config);

		registerCurrentInstanceAndExecution(jobExecution, batchWork.getController());
		
		batchWorkUnits.add(batchWork);
		instance++;
	}

	return batchWorkUnits;
}
 

import javax.batch.operations.JobStartException; //导入依赖的package包/类
/**
 * Build a list of batch work units and set them up in STARTING state but don't start them yet.
 */

@Override
public List<BatchPartitionWorkUnit> buildNewParallelPartitions(final PartitionsBuilderConfig config, final JobContextImpl jc, final StepContextImpl sc)
    throws JobRestartException, JobStartException {

    final List<JSLJob> jobModels = config.getJobModels();
    final Properties[] partitionPropertiesArray = config.getPartitionProperties();
    final List<BatchPartitionWorkUnit> batchWorkUnits = new ArrayList<BatchPartitionWorkUnit>(jobModels.size());

    int instance = 0;
    for (final JSLJob parallelJob : jobModels) {
        final Properties partitionProps = (partitionPropertiesArray == null) ? null : partitionPropertiesArray[instance];
        final RuntimeJobExecution jobExecution = JobExecutionHelper.startPartition(servicesManager, parallelJob, partitionProps);
        jobExecution.inheritJobContext(jc);
        jobExecution.setPartitionInstance(instance);

        final BatchPartitionWorkUnit batchWork = new BatchPartitionWorkUnit(jobExecution, config, servicesManager);
        batchWork.inheritStepContext(sc);

        registerCurrentInstanceAndExecution(jobExecution, batchWork.getController());

        batchWorkUnits.add(batchWork);
        instance++;
    }

    return batchWorkUnits;
}
 

import javax.batch.operations.JobStartException; //导入依赖的package包/类
public static RuntimeFlowInSplitExecution startFlowInSplit(final ServicesManager servicesManager, final JSLJob jobModel) throws JobStartException {
    final ModelNavigator<JSLJob> jobNavigator = getResolvedJobNavigator(jobModel, null, true);
    final JobContextImpl jobContext = getJobContext(jobNavigator);
    final JobInstance jobInstance = getNewSubJobInstance(servicesManager, jobNavigator.getRootModelElement().getId());
    final RuntimeFlowInSplitExecution executionHelper =
            servicesManager.service(PersistenceManagerService.class).createFlowInSplitExecution(jobInstance, jobContext.getBatchStatus());

    executionHelper.prepareForExecution(jobContext);

    final JobStatusManagerService statusManagerService = servicesManager.service(JobStatusManagerService.class);
    final JobStatus jobStatus = createNewJobStatus(statusManagerService, jobInstance);
    statusManagerService.updateJobStatus(jobStatus);

    return executionHelper;
}
 

import javax.batch.operations.JobStartException; //导入依赖的package包/类
@Override
public SplitExecutionStatus execute()
        throws JobRestartException, JobStartException, JobExecutionAlreadyCompleteException, JobExecutionNotMostRecentException, NoSuchJobExecutionException {
    // Build all sub jobs from partitioned step
    buildSubJobBatchWorkUnits();

    // kick off the threads
    executeWorkUnits();

    // Deal with the results.
    return waitForCompletionAndAggregateStatus();
}
 

import javax.batch.operations.JobStartException; //导入依赖的package包/类
private void buildSubJobBatchWorkUnits() throws JobRestartException, JobStartException, JobExecutionAlreadyCompleteException, JobExecutionNotMostRecentException {
    synchronized (subJobs) {
        //check if we've already issued a stop
        if (jobExecutionImpl.getJobContext().getBatchStatus().equals(BatchStatus.STOPPING)) {
            return;
        }

        for (int instance = 0; instance < partitions; instance++) {
            subJobs.add(PartitionedStepBuilder.buildPartitionSubJob(jobExecutionImpl.getInstanceId(), jobExecutionImpl.getJobContext(), step, instance));
        }

        PartitionsBuilderConfig config =
                new PartitionsBuilderConfig(subJobs, partitionProperties, analyzerStatusQueue, completedWorkQueue, jobExecutionImpl.getExecutionId());
        // Then build all the subjobs but do not start them yet
        if (executionType == ExecutionType.RESTART_NORMAL) {
            parallelBatchWorkUnits = kernelService.buildOnRestartParallelPartitions(config, jobExecutionImpl.getJobContext(), stepContext);
        } else {
            // This case includes RESTART_OVERRIDE and RESTART_AFTER_COMPLETION.
            //
            // So we're just going to create new "subjob" job instances in the DB in these cases,
            // and we'll have to make sure we're dealing with the correct ones, say in a subsequent "normal" restart
            // (of the current execution which is itself a restart)
            parallelBatchWorkUnits = kernelService.buildNewParallelPartitions(config, jobExecutionImpl.getJobContext(), stepContext);
        }

        // NOTE:  At this point I might not have as many work units as I had partitions, since some may have already completed.
    }
}
 

import javax.batch.operations.JobStartException; //导入依赖的package包/类
private void startBatch(String batchName, HttpServletRequest req, HttpServletResponse resp) {
    Properties jobProperties = extractJobProperties(req, resp);
    if (jobProperties == null) { return; }

    try {
        long jobId = jobOperator.start(batchName, jobProperties);
        reportSuccess(jobId, resp, null);
    } catch (JobStartException jobStartException) {
        StringBuilder msg = new StringBuilder("Error while starting job ");
        msg.append(batchName).append('\n');
        appendExceptionMsg(msg, jobStartException);
        reportFailure(NO_JOB_ID, resp, msg.toString());
    }
}
 

import javax.batch.operations.JobStartException; //导入依赖的package包/类
public TCKJobExecutionWrapper startJobWithoutWaitingForResult(String jobName, Properties jobParameters) throws JobStartException, NoSuchJobExecutionException, JobSecurityException {
	Long execID = (Long)jobOp.start(jobName, jobParameters);
	JobExecution jobExecution = jobOp.getJobExecution(execID);
	return new TCKJobExecutionWrapper(jobExecution, jobOp);
}
 

import javax.batch.operations.JobStartException; //导入依赖的package包/类
/**
 * Processes requests for both HTTP <code>GET</code> and <code>POST</code>
 * methods.
 * 
 * @param request
 *            servlet request
 * @param response
 *            servlet response
 * @throws ServletException
 *             if a servlet-specific error occurs
 * @throws IOException
 *             if an I/O error occurs
 */
protected void processRequest(HttpServletRequest request,
		HttpServletResponse response) throws ServletException, IOException {
	response.setContentType("text/html;charset=UTF-8");
	try (PrintWriter out = response.getWriter()) {
		out.println("<html>");
		out.println("<head>");
		out.println("<title>Servlet Execute Job</title>");
		out.println("</head>");
		out.println("<body>");
		out.println("<h1>Servlet TestServlet at "
				+ request.getContextPath() + "</h1>");
		out.println("About to start the job<br>");
		JobOperator jo = BatchRuntime.getJobOperator();
		out.println("Got the job operator: " + jo + "<br>");

		Properties props = new Properties();
		props.put("csvDatasFileName",
				request.getParameter("tt"));

		long jid = jo.start("loadHistoryJob", props);
		out.println("Job submitted: " + jid + "<br>");
		out.println(jo.getJobInstanceCount("loadHistoryJob")
				+ " job instance found<br/>");
		JobExecution je = jo.getJobExecution(jid);

		// jo.abandon(jid);
		out.println("Job created on: " + je.getCreateTime() + "<br>");
		out.println("Job started on: " + je.getStartTime() + "<br>");
		out.println("Found: " + jo.getJobNames().size() + " jobs<br>");
		for (String j : jo.getJobNames()) {
			out.println("--> " + j + "<br>");
		}

		out.println("<br><br><a href=\"/\">Home</a>  - <a href=\"./list\">All players.</a>");
		out.println("</body>");
		out.println("</html>");
	} catch (JobStartException | JobSecurityException ex) {
		Logger.getLogger(ExecuteJobServlet.class.getName()).log(Level.SEVERE,
				"erreur jobs", ex);
	}
}
 

import javax.batch.operations.JobStartException; //导入依赖的package包/类
public static RuntimeJobExecution startJob(String jobXML, Properties jobParameters) throws JobStartException {
	logger.entering(CLASSNAME, "startJob", new Object[]{jobXML, jobParameters==null ? "<null>" : jobParameters});

	JSLJob jobModel = ModelResolverFactory.createJobResolver().resolveModel(jobXML); 

	ModelNavigator<JSLJob> jobNavigator = getResolvedJobNavigator(jobModel, jobParameters, false);

	JobContextImpl jobContext = getJobContext(jobNavigator);

	JobInstance jobInstance = getNewJobInstance(jobNavigator.getRootModelElement().getId(), jobXML);

	RuntimeJobExecution executionHelper = 
			_persistenceManagementService.createJobExecution(jobInstance, jobParameters, jobContext.getBatchStatus());

	executionHelper.prepareForExecution(jobContext);

	JobStatus jobStatus = createNewJobStatus(jobInstance);
	_jobStatusManagerService.updateJobStatus(jobStatus);

	logger.exiting(CLASSNAME, "startJob", executionHelper);

	return executionHelper;
}
 

import javax.batch.operations.JobStartException; //导入依赖的package包/类
public static RuntimeFlowInSplitExecution startFlowInSplit(JSLJob jobModel) throws JobStartException{
	logger.entering(CLASSNAME, "startFlowInSplit", jobModel);

	ModelNavigator<JSLJob> jobNavigator = getResolvedJobNavigator(jobModel, null, false);
	JobContextImpl jobContext = getJobContext(jobNavigator);
	
	JobInstance jobInstance = getNewSubJobInstance(jobNavigator.getRootModelElement().getId());

	RuntimeFlowInSplitExecution executionHelper = 
			_persistenceManagementService.createFlowInSplitExecution(jobInstance, jobContext.getBatchStatus());

	executionHelper.prepareForExecution(jobContext);

	JobStatus jobStatus = createNewJobStatus(jobInstance);
	_jobStatusManagerService.updateJobStatus(jobStatus);

	logger.exiting(CLASSNAME, "startFlowInSplit", executionHelper);
	return executionHelper;
}