org.springframework.batch.core.job

## Class AbstractJob

- java.lang.Object
- - org.springframework.batch.core.job.AbstractJob

- All Implemented Interfaces:
    Job, StepLocator, org.springframework.beans.factory.Aware, org.springframework.beans.factory.BeanNameAware, org.springframework.beans.factory.InitializingBean
  Direct Known Subclasses:
    FlowJob, SimpleJob

      public abstract class AbstractJob
      extends java.lang.Object
      implements Job, StepLocator, org.springframework.beans.factory.BeanNameAware, org.springframework.beans.factory.InitializingBean

  Abstract implementation of the `Job` interface. Common dependencies such as a `JobRepository`, `JobExecutionListener`s, and various configuration parameters are set here. Therefore, common error handling and listener calling activities are abstracted away from implementations.
  Author:
    Lucas Ward, Dave Syer, Mahmoud Ben Hassine

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected static org.apache.commons.logging.Log` | `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AbstractJob()` Default constructor.
    `AbstractJob(java.lang.String name)` Convenience constructor to immediately add name (which is mandatory but not final).

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `afterPropertiesSet()` Assert mandatory properties: `JobRepository`.
    `protected abstract void` | `doExecute(JobExecution execution)` Extension point for subclasses allowing them to concentrate on processing logic and ignore listeners and repository calls.
    `void` | `execute(JobExecution execution)` Run the specified job, handling all listener and repository calls, and delegating the actual processing to `doExecute(JobExecution)`.
    `protected ExitStatus` | `getDefaultExitStatusForFailure(java.lang.Throwable ex, JobExecution execution)` Default mapping from throwable to `ExitStatus`.
    `JobParametersIncrementer` | `getJobParametersIncrementer()` If clients need to generate new parameters for the next execution in a sequence they can use this incrementer.
    `JobParametersValidator` | `getJobParametersValidator()` A validator for the job parameters of a `JobExecution`.
    `protected JobRepository` | `getJobRepository()` Convenience method for subclasses to access the job repository.
    `java.lang.String` | `getName()`
    `abstract Step` | `getStep(java.lang.String stepName)` Retrieve the step with the given name.
    `abstract java.util.Collection<java.lang.String>` | `getStepNames()` Retrieve the step names.
    `protected StepExecution` | `handleStep(Step step, JobExecution execution)` Convenience method for subclasses to delegate the handling of a specific step in the context of the current `JobExecution`.
    `boolean` | `isRestartable()` Flag to indicate if this job can be restarted, at least in principle.
    `void` | `registerJobExecutionListener(JobExecutionListener listener)` Register a single listener for the `JobExecutionListener` callbacks.
    `void` | `setBeanName(java.lang.String name)` Set the name property if it is not already set.
    `void` | `setJobExecutionListeners(JobExecutionListener[] listeners)` Public setter for injecting `JobExecutionListener`s.
    `void` | `setJobParametersIncrementer(JobParametersIncrementer jobParametersIncrementer)` Public setter for the `JobParametersIncrementer`.
    `void` | `setJobParametersValidator(JobParametersValidator jobParametersValidator)` A validator for job parameters.
    `void` | `setJobRepository(JobRepository jobRepository)` Public setter for the `JobRepository` that is needed to manage the state of the batch meta domain (jobs, steps, executions) during the life of a job.
    `void` | `setName(java.lang.String name)` Set the name property.
    `void` | `setRestartable(boolean restartable)` Boolean flag to prevent categorically a job from restarting, even if it has failed previously.
    `java.lang.String` | `toString()`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### logger

          protected static final org.apache.commons.logging.Log logger

  - ### Constructor Detail

    - #### AbstractJob

          public AbstractJob()

      Default constructor.

    - #### AbstractJob

          public AbstractJob(java.lang.String name)

      Convenience constructor to immediately add name (which is mandatory but not final).
      Parameters:
        `name` - name of the job

  - ### Method Detail

    - #### setJobParametersValidator

          public void setJobParametersValidator(JobParametersValidator jobParametersValidator)

      A validator for job parameters. Defaults to a vanilla `DefaultJobParametersValidator`.
      Parameters:
        `jobParametersValidator` - a validator instance

    - #### afterPropertiesSet

          public void afterPropertiesSet()
                                  throws java.lang.Exception

      Assert mandatory properties: `JobRepository`.
      Specified by:
        `afterPropertiesSet` in interface `org.springframework.beans.factory.InitializingBean`
      Throws:
        `java.lang.Exception`
      See Also:
        `InitializingBean.afterPropertiesSet()`

    - #### setBeanName

          public void setBeanName(java.lang.String name)

      Set the name property if it is not already set. Because of the order of the callbacks in a Spring container the name property will be set first if it is present. Care is needed with bean definition inheritance - if a parent bean has a name, then its children need an explicit name as well, otherwise they will not be unique.
      Specified by:
        `setBeanName` in interface `org.springframework.beans.factory.BeanNameAware`
      See Also:
        `BeanNameAware.setBeanName(java.lang.String)`

    - #### setName

          public void setName(java.lang.String name)

      Set the name property. Always overrides the default value if this object is a Spring bean.
      Parameters:
        `name` - the name to be associated with the job.
      See Also:
        `setBeanName(java.lang.String)`

    - #### getName

          public java.lang.String getName()

      Specified by:
        `getName` in interface `Job`

    - #### getStep

          public abstract Step getStep(java.lang.String stepName)

      Retrieve the step with the given name. If there is no Step with the given name, then return null.
      Specified by:
        `getStep` in interface `StepLocator`
      Parameters:
        `stepName` - name of the step
      Returns:
        the Step

    - #### getStepNames

          public abstract java.util.Collection<java.lang.String> getStepNames()

      Retrieve the step names.
      Specified by:
        `getStepNames` in interface `StepLocator`
      Returns:
        the step names

    - #### getJobParametersValidator

          public JobParametersValidator getJobParametersValidator()

      Description copied from interface: `Job`
      A validator for the job parameters of a `JobExecution`. Clients of a Job may need to validate the parameters for a launch, before or during the execution.
      Specified by:
        `getJobParametersValidator` in interface `Job`
      Returns:
        a validator that can be used to check parameter values (never `null`)

    - #### setRestartable

          public void setRestartable(boolean restartable)

      Boolean flag to prevent categorically a job from restarting, even if it has failed previously.
      Parameters:
        `restartable` - the value of the flag to set (default true)

    - #### isRestartable

          public boolean isRestartable()

      Description copied from interface: `Job`
      Flag to indicate if this job can be restarted, at least in principle.
      Specified by:
        `isRestartable` in interface `Job`
      Returns:
        true if this job can be restarted after a failure
      See Also:
        `Job.isRestartable()`

    - #### setJobParametersIncrementer

          public void setJobParametersIncrementer(JobParametersIncrementer jobParametersIncrementer)

      Public setter for the `JobParametersIncrementer`.
      Parameters:
        `jobParametersIncrementer` - the `JobParametersIncrementer` to set

    - #### getJobParametersIncrementer

          @Nullable
          public JobParametersIncrementer getJobParametersIncrementer()

      Description copied from interface: `Job`
      If clients need to generate new parameters for the next execution in a sequence they can use this incrementer. The return value may be `null`, in the case that this job does not have a natural sequence.
      Specified by:
        `getJobParametersIncrementer` in interface `Job`
      Returns:
        in incrementer to be used for creating new parameters

    - #### setJobExecutionListeners

          public void setJobExecutionListeners(JobExecutionListener[] listeners)

      Public setter for injecting `JobExecutionListener`s. They will all be given the listener callbacks at the appropriate point in the job.
      Parameters:
        `listeners` - the listeners to set.

    - #### registerJobExecutionListener

          public void registerJobExecutionListener(JobExecutionListener listener)

      Register a single listener for the `JobExecutionListener` callbacks.
      Parameters:
        `listener` - a `JobExecutionListener`

    - #### setJobRepository

          public void setJobRepository(JobRepository jobRepository)

      Public setter for the `JobRepository` that is needed to manage the state of the batch meta domain (jobs, steps, executions) during the life of a job.
      Parameters:
        `jobRepository` - repository to use during the job execution

    - #### getJobRepository

          protected JobRepository getJobRepository()

      Convenience method for subclasses to access the job repository.
      Returns:
        the jobRepository

    - #### doExecute

          protected abstract void doExecute(JobExecution execution)
                                     throws JobExecutionException

      Extension point for subclasses allowing them to concentrate on processing logic and ignore listeners and repository calls. Implementations usually are concerned with the ordering of steps, and delegate actual step processing to `handleStep(Step, JobExecution)`.
      Parameters:
        `execution` - the current `JobExecution`
      Throws:
        `JobExecutionException` - to signal a fatal batch framework error (not a business or validation exception)

    - #### execute

          public final void execute(JobExecution execution)

      Run the specified job, handling all listener and repository calls, and delegating the actual processing to `doExecute(JobExecution)`.
      Specified by:
        `execute` in interface `Job`
      Parameters:
        `execution` - a `JobExecution`
      Throws:
        `StartLimitExceededException` - if start limit of one of the steps was exceeded
      See Also:
        `Job.execute(JobExecution)`

    - #### handleStep

          protected final StepExecution handleStep(Step step,
                                                   JobExecution execution)
                                            throws JobInterruptedException,
                                                   JobRestartException,
                                                   StartLimitExceededException

      Convenience method for subclasses to delegate the handling of a specific step in the context of the current `JobExecution`. Clients of this method do not need access to the `JobRepository`, nor do they need to worry about populating the execution context on a restart, nor detecting the interrupted state (in job or step execution).
      Parameters:
        `step` - the `Step` to execute
        `execution` - the current `JobExecution`
      Returns:
        the `StepExecution` corresponding to this step
      Throws:
        `JobInterruptedException` - if the `JobExecution` has been interrupted, and in particular if `BatchStatus.ABANDONED` or `BatchStatus.STOPPING` is detected
        `StartLimitExceededException` - if the start limit has been exceeded for this step
        `JobRestartException` - if the job is in an inconsistent state from an earlier failure

    - #### getDefaultExitStatusForFailure

          protected ExitStatus getDefaultExitStatusForFailure(java.lang.Throwable ex,
                                                              JobExecution execution)

      Default mapping from throwable to `ExitStatus`.
      Parameters:
        `ex` - the cause of the failure
        `execution` - the `JobExecution` instance.
      Returns:
        an `ExitStatus`

    - #### toString

          public java.lang.String toString()

      Overrides:
        `toString` in class `java.lang.Object`