Java tutorial
/* * Copyright 2006-2018 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * https://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.springframework.batch.core; import java.io.IOException; import java.io.ObjectInputStream; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.Date; import java.util.HashSet; import java.util.LinkedHashSet; import java.util.List; import java.util.Set; import java.util.concurrent.CopyOnWriteArrayList; import org.springframework.batch.item.ExecutionContext; import org.springframework.lang.Nullable; /** * Batch domain object representing the execution of a job. * * @author Lucas Ward * @author Michael Minella * @author Mahmoud Ben Hassine * @author Dimitrios Liapis * */ @SuppressWarnings("serial") public class JobExecution extends Entity { private final JobParameters jobParameters; private JobInstance jobInstance; private volatile Collection<StepExecution> stepExecutions = Collections.synchronizedSet(new LinkedHashSet<>()); private volatile BatchStatus status = BatchStatus.STARTING; private volatile Date startTime = null; private volatile Date createTime = new Date(System.currentTimeMillis()); private volatile Date endTime = null; private volatile Date lastUpdated = null; private volatile ExitStatus exitStatus = ExitStatus.UNKNOWN; private volatile ExecutionContext executionContext = new ExecutionContext(); private transient volatile List<Throwable> failureExceptions = new CopyOnWriteArrayList<>(); private final String jobConfigurationName; public JobExecution(JobExecution original) { this.jobParameters = original.getJobParameters(); this.jobInstance = original.getJobInstance(); this.stepExecutions = original.getStepExecutions(); this.status = original.getStatus(); this.startTime = original.getStartTime(); this.createTime = original.getCreateTime(); this.endTime = original.getEndTime(); this.lastUpdated = original.getLastUpdated(); this.exitStatus = original.getExitStatus(); this.executionContext = original.getExecutionContext(); this.failureExceptions = original.getFailureExceptions(); this.jobConfigurationName = original.getJobConfigurationName(); this.setId(original.getId()); this.setVersion(original.getVersion()); } /** * Because a JobExecution isn't valid unless the job is set, this * constructor is the only valid one from a modeling point of view. * * @param job the job of which this execution is a part * @param id {@link Long} that represents the id for the JobExecution. * @param jobParameters {@link JobParameters} instance for this JobExecution. * @param jobConfigurationName {@link String} instance that represents the * job configuration name (used with JSR-352). */ public JobExecution(JobInstance job, Long id, @Nullable JobParameters jobParameters, String jobConfigurationName) { super(id); this.jobInstance = job; this.jobParameters = jobParameters == null ? new JobParameters() : jobParameters; this.jobConfigurationName = jobConfigurationName; } public JobExecution(JobInstance job, JobParameters jobParameters, String jobConfigurationName) { this(job, null, jobParameters, jobConfigurationName); } public JobExecution(Long id, JobParameters jobParameters, String jobConfigurationName) { this(null, id, jobParameters, jobConfigurationName); } /** * Constructor for transient (unsaved) instances. * * @param job the enclosing {@link JobInstance} * @param jobParameters {@link JobParameters} instance for this JobExecution. */ public JobExecution(JobInstance job, JobParameters jobParameters) { this(job, null, jobParameters, null); } public JobExecution(Long id, JobParameters jobParameters) { this(null, id, jobParameters, null); } public JobExecution(Long id) { this(null, id, null, null); } public JobParameters getJobParameters() { return this.jobParameters; } public Date getEndTime() { return endTime; } public void setJobInstance(JobInstance jobInstance) { this.jobInstance = jobInstance; } public void setEndTime(Date endTime) { this.endTime = endTime; } public Date getStartTime() { return startTime; } public void setStartTime(Date startTime) { this.startTime = startTime; } public BatchStatus getStatus() { return status; } /** * Set the value of the status field. * * @param status the status to set */ public void setStatus(BatchStatus status) { this.status = status; } /** * Upgrade the status field if the provided value is greater than the * existing one. Clients using this method to set the status can be sure * that they don't overwrite a failed status with an successful one. * * @param status the new status value */ public void upgradeStatus(BatchStatus status) { this.status = this.status.upgradeTo(status); } /** * Convenience getter for for the id of the enclosing job. Useful for DAO * implementations. * * @return the id of the enclosing job */ public Long getJobId() { if (jobInstance != null) { return jobInstance.getId(); } return null; } /** * @param exitStatus {@link ExitStatus} instance to be used for job execution. */ public void setExitStatus(ExitStatus exitStatus) { this.exitStatus = exitStatus; } /** * @return the exitCode */ public ExitStatus getExitStatus() { return exitStatus; } /** * @return the Job that is executing. */ public JobInstance getJobInstance() { return jobInstance; } /** * Accessor for the step executions. * * @return the step executions that were registered */ public Collection<StepExecution> getStepExecutions() { return Collections.unmodifiableList(new ArrayList<>(stepExecutions)); } /** * Register a step execution with the current job execution. * @param stepName the name of the step the new execution is associated with * @return {@link StepExecution} an empty {@code StepExecution} associated with this * {@code JobExecution}. */ public StepExecution createStepExecution(String stepName) { StepExecution stepExecution = new StepExecution(stepName, this); this.stepExecutions.add(stepExecution); return stepExecution; } /** * Test if this {@link JobExecution} indicates that it is running. It should * be noted that this does not necessarily mean that it has been persisted * as such yet. * * @return true if the end time is null and the start time is not null */ public boolean isRunning() { return startTime != null && endTime == null; } /** * Test if this {@link JobExecution} indicates that it has been signalled to * stop. * @return true if the status is {@link BatchStatus#STOPPING} */ public boolean isStopping() { return status == BatchStatus.STOPPING; } /** * Signal the {@link JobExecution} to stop. Iterates through the associated * {@link StepExecution}s, calling {@link StepExecution#setTerminateOnly()}. * */ public void stop() { for (StepExecution stepExecution : stepExecutions) { stepExecution.setTerminateOnly(); } status = BatchStatus.STOPPING; } /** * Sets the {@link ExecutionContext} for this execution * * @param executionContext the context */ public void setExecutionContext(ExecutionContext executionContext) { this.executionContext = executionContext; } /** * Returns the {@link ExecutionContext} for this execution. The content is * expected to be persisted after each step completion (successful or not). * * @return the context */ public ExecutionContext getExecutionContext() { return executionContext; } /** * @return the time when this execution was created. */ public Date getCreateTime() { return createTime; } /** * @param createTime creation time of this execution. */ public void setCreateTime(Date createTime) { this.createTime = createTime; } public String getJobConfigurationName() { return this.jobConfigurationName; } /** * Package private method for re-constituting the step executions from * existing instances. * @param stepExecution execution to be added */ void addStepExecution(StepExecution stepExecution) { stepExecutions.add(stepExecution); } /** * Get the date representing the last time this JobExecution was updated in * the JobRepository. * * @return Date representing the last time this JobExecution was updated. */ public Date getLastUpdated() { return lastUpdated; } /** * Set the last time this JobExecution was updated. * * @param lastUpdated {@link Date} instance to mark job execution's lastUpdated attribute. */ public void setLastUpdated(Date lastUpdated) { this.lastUpdated = lastUpdated; } public List<Throwable> getFailureExceptions() { return failureExceptions; } /** * Add the provided throwable to the failure exception list. * * @param t {@link Throwable} instance to be added failure exception list. */ public synchronized void addFailureException(Throwable t) { this.failureExceptions.add(t); } /** * Return all failure causing exceptions for this JobExecution, including * step executions. * * @return List<Throwable> containing all exceptions causing failure for * this JobExecution. */ public synchronized List<Throwable> getAllFailureExceptions() { Set<Throwable> allExceptions = new HashSet<>(failureExceptions); for (StepExecution stepExecution : stepExecutions) { allExceptions.addAll(stepExecution.getFailureExceptions()); } return new ArrayList<>(allExceptions); } /** * Deserialize and ensure transient fields are re-instantiated when read * back. * * @param stream instance of {@link ObjectInputStream}. * * @throws IOException thrown if error occurs during read. * @throws ClassNotFoundException thrown if class is not found. */ private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException { stream.defaultReadObject(); failureExceptions = new ArrayList<>(); } /* * (non-Javadoc) * * @see org.springframework.batch.core.domain.Entity#toString() */ @Override public String toString() { return super.toString() + String.format( ", startTime=%s, endTime=%s, lastUpdated=%s, status=%s, exitStatus=%s, job=[%s], jobParameters=[%s]", startTime, endTime, lastUpdated, status, exitStatus, jobInstance, jobParameters); } /** * Add some step executions. For internal use only. * @param stepExecutions step executions to add to the current list */ public void addStepExecutions(List<StepExecution> stepExecutions) { if (stepExecutions != null) { this.stepExecutions.removeAll(stepExecutions); this.stepExecutions.addAll(stepExecutions); } } }