Example usage for org.springframework.batch.core.launch.support CommandLineJobRunner message

Introduction

In this page you can find the example usage for org.springframework.batch.core.launch.support CommandLineJobRunner message.

Prototype

String message

To view the source code for org.springframework.batch.core.launch.support CommandLineJobRunner message.

Click Source Link

Usage

From source file:org.springframework.batch.core.launch.support.CommandLineJobRunner.java

@SuppressWarnings("resource")
int start(String jobPath, String jobIdentifier, String[] parameters, Set<String> opts) {

    ConfigurableApplicationContext context = null;

    try {//from  w ww . ja  v  a  2  s . c  o m
        try {
            context = new AnnotationConfigApplicationContext(Class.forName(jobPath));
        } catch (ClassNotFoundException cnfe) {
            context = new ClassPathXmlApplicationContext(jobPath);
        }

        context.getAutowireCapableBeanFactory().autowireBeanProperties(this,
                AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, false);

        Assert.state(launcher != null, "A JobLauncher must be provided.  Please add one to the configuration.");
        if (opts.contains("-restart") || opts.contains("-next")) {
            Assert.state(jobExplorer != null,
                    "A JobExplorer must be provided for a restart or start next operation.  Please add one to the configuration.");
        }

        String jobName = jobIdentifier;

        JobParameters jobParameters = jobParametersConverter
                .getJobParameters(StringUtils.splitArrayElementsIntoProperties(parameters, "="));
        Assert.isTrue(parameters == null || parameters.length == 0 || !jobParameters.isEmpty(),
                "Invalid JobParameters " + Arrays.asList(parameters)
                        + ". If parameters are provided they should be in the form name=value (no whitespace).");

        if (opts.contains("-stop")) {
            List<JobExecution> jobExecutions = getRunningJobExecutions(jobIdentifier);
            if (jobExecutions == null) {
                throw new JobExecutionNotRunningException(
                        "No running execution found for job=" + jobIdentifier);
            }
            for (JobExecution jobExecution : jobExecutions) {
                jobExecution.setStatus(BatchStatus.STOPPING);
                jobRepository.update(jobExecution);
            }
            return exitCodeMapper.intValue(ExitStatus.COMPLETED.getExitCode());
        }

        if (opts.contains("-abandon")) {
            List<JobExecution> jobExecutions = getStoppedJobExecutions(jobIdentifier);
            if (jobExecutions == null) {
                throw new JobExecutionNotStoppedException(
                        "No stopped execution found for job=" + jobIdentifier);
            }
            for (JobExecution jobExecution : jobExecutions) {
                jobExecution.setStatus(BatchStatus.ABANDONED);
                jobRepository.update(jobExecution);
            }
            return exitCodeMapper.intValue(ExitStatus.COMPLETED.getExitCode());
        }

        if (opts.contains("-restart")) {
            JobExecution jobExecution = getLastFailedJobExecution(jobIdentifier);
            if (jobExecution == null) {
                throw new JobExecutionNotFailedException(
                        "No failed or stopped execution found for job=" + jobIdentifier);
            }
            jobParameters = jobExecution.getJobParameters();
            jobName = jobExecution.getJobInstance().getJobName();
        }

        Job job = null;
        if (jobLocator != null) {
            try {
                job = jobLocator.getJob(jobName);
            } catch (NoSuchJobException e) {
            }
        }
        if (job == null) {
            job = (Job) context.getBean(jobName);
        }

        if (opts.contains("-next")) {
            JobParameters nextParameters = getNextJobParameters(job);
            Map<String, JobParameter> map = new HashMap<String, JobParameter>(nextParameters.getParameters());
            map.putAll(jobParameters.getParameters());
            jobParameters = new JobParameters(map);
        }

        JobExecution jobExecution = launcher.run(job, jobParameters);
        return exitCodeMapper.intValue(jobExecution.getExitStatus().getExitCode());

    } catch (Throwable e) {
        String message = "Job Terminated in error: " + e.getMessage();
        logger.error(message, e);
        CommandLineJobRunner.message = message;
        return exitCodeMapper.intValue(ExitStatus.FAILED.getExitCode());
    } finally {
        if (context != null) {
            context.close();
        }
    }
}

---

From source file:org.springframework.batch.core.launch.support.CommandLineJobRunner.java

/**
 * Launch a batch job using a {@link CommandLineJobRunner}. Creates a new
 * Spring context for the job execution, and uses a common parent for all
 * such contexts. No exception are thrown from this method, rather
 * exceptions are logged and an integer returned through the exit status in
 * a {@link JvmSystemExiter} (which can be overridden by defining one in the
 * Spring context).<br>/*from  w  w w  . jav a  2 s  . c o  m*/
 * Parameters can be provided in the form key=value, and will be converted
 * using the injected {@link JobParametersConverter}.
 *
 * @param args
 * <ul>
 * <li>-restart: (optional) if the job has failed or stopped and the most
 * should be restarted. If specified then the jobIdentifier parameter can be
 * interpreted either as the name of the job or the id of the job execution
 * that failed.</li>
 * <li>-next: (optional) if the job has a {@link JobParametersIncrementer}
 * that can be used to launch the next in a sequence</li>
 * <li>jobPath: the xml application context containing a {@link Job}
 * <li>jobIdentifier: the bean id of the job or id of the failed execution
 * in the case of a restart.
 * <li>jobParameters: 0 to many parameters that will be used to launch a
 * job.
 * </ul>
 * <p>
 * The options (<code>-restart, -next</code>) can occur anywhere in the
 * command line.
 * </p>
 */
public static void main(String[] args) throws Exception {

    CommandLineJobRunner command = new CommandLineJobRunner();

    List<String> newargs = new ArrayList<String>(Arrays.asList(args));

    try {
        if (System.in.available() > 0) {
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            String line = " ";
            while (line != null) {
                if (!line.startsWith("#") && StringUtils.hasText(line)) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Stdin arg: " + line);
                    }
                    newargs.add(line);
                }
                line = reader.readLine();
            }
        }
    } catch (IOException e) {
        logger.warn("Could not access stdin (maybe a platform limitation)");
        if (logger.isDebugEnabled()) {
            logger.debug("Exception details", e);
        }
    }

    Set<String> opts = new HashSet<String>();
    List<String> params = new ArrayList<String>();

    int count = 0;
    String jobPath = null;
    String jobIdentifier = null;

    for (String arg : newargs) {
        if (VALID_OPTS.contains(arg)) {
            opts.add(arg);
        } else {
            switch (count) {
            case 0:
                jobPath = arg;
                break;
            case 1:
                jobIdentifier = arg;
                break;
            default:
                params.add(arg);
                break;
            }
            count++;
        }
    }

    if (jobPath == null || jobIdentifier == null) {
        String message = "At least 2 arguments are required: JobPath/JobClass and jobIdentifier.";
        logger.error(message);
        CommandLineJobRunner.message = message;
        command.exit(1);
        return;
    }

    String[] parameters = params.toArray(new String[params.size()]);

    int result = command.start(jobPath, jobIdentifier, parameters, opts);
    command.exit(result);
}

---