#190: Rework of devon4j-batch module (#191)

maihacke · web-flow · commit be1dfcc96ca1 · 2020-02-11T15:07:44.000+01:00
diff --git a/documentation/guide-batch-layer.asciidoc b/documentation/guide-batch-layer.asciidoc
@@ -45,7 +45,7 @@ It is a typical design decision you have to take when designing your specific ba
 
 == Project structure and packaging
 
-Batches will be implememented in a separate maven module to keep the application core free of batch dependencies. The batch module includes a dependency to the application core-module to allow reuse of the use cases, DAOs etc.
+Batches will be implemented in a separate Maven module to keep the application core free of batch dependencies. The batch module includes a dependency to the application core-module to allow reuse of the use cases, DAOs etc.
 Additionally the batch module has dependencies to the required spring batch jars:
 
 [source,xml]
@@ -197,7 +197,7 @@ E.g. the state will be running, despite the process crashed sometime ago.
 For that cases you have to change the status of the execution in the database.
 
 === CLI-Tool
-Devonfw provides a simple cli-tool to manage the executing status of your jobs.
+Devonfw provides a easy to use cli-tool to manage the executing status of your jobs.
 The tool is implemented in the devonfw module `devon4j-batch-tool`. It will provide a runnable jar, which may be used as follows:
 
 List names of all previous executed jobs::
@@ -212,8 +212,6 @@ Show help::
 As you can the each invocation includes the jdbc connection string to your database.
 This means that you have to make sure that the corresponding DB driver is in the classpath (the prepared jar only contains H2).
 
-
-
 == Tipps & tricks
 
 === Identifying job parameters
diff --git a/modules/batch/src/main/java/com/devonfw/module/batch/common/base/SpringBootBatchCommandLine.java b/modules/batch/src/main/java/com/devonfw/module/batch/common/base/SpringBootBatchCommandLine.java
@@ -4,9 +4,12 @@
 import java.util.List;
 import java.util.Set;
 
+import javax.inject.Inject;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.batch.core.BatchStatus;
+import org.springframework.batch.core.Job;
 import org.springframework.batch.core.JobExecution;
 import org.springframework.batch.core.JobParameters;
 import org.springframework.batch.core.configuration.JobLocator;
@@ -15,36 +18,77 @@
 import org.springframework.batch.core.launch.JobExecutionNotRunningException;
 import org.springframework.batch.core.launch.JobLauncher;
 import org.springframework.batch.core.launch.JobOperator;
+import org.springframework.batch.core.launch.NoSuchJobException;
 import org.springframework.batch.core.launch.support.CommandLineJobRunner;
-import org.springframework.beans.factory.NoSuchBeanDefinitionException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
 import org.springframework.boot.ExitCodeGenerator;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.WebApplicationType;
 import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.util.StringUtils;
 
 /**
- * Launcher for launching batch jobs from the command line when Spring Boot is used. Similar to the
- * {@link CommandLineJobRunner}, which does not work very well with Spring Boot.
- * <p>
- * Do not use this class if Spring Boot is not used!
- * <p>
- * It expects the full class name of the Spring Boot configuration class to be used as first argument, the class/XML
- * file for configuring the job as second argument and the job name as third.<br>
+ * Launcher for launching batch jobs from the command line when Spring Boot is used. It is somewhat similar to the
+ * {@link CommandLineJobRunner}. The main difference is, that this launcher disables the web-app for the spring context.
+ *
+ * It expects the full class name of the Spring Boot configuration class to be used as first argument and the jobs
+ * beanname as the second.<br>
  * Moreover parameters can be specified as further arguments (convention: key1=value1 key2=value2 ...).
  * <p>
  * Example:<br>
- * java com.devonfw.module.batch.common.base.SpringBootBatchCommandLine
- * com.devonfw.gastronomy.restaurant.SpringBootBatchApp classpath:config/app/batch/beans-productimport.xml
- * productImportJob drinks.file=file:import/drinks.csv date(date)=2015/12/20
+ * {@code java -jar my-app-batch-bootified.jar com.devonfw.application.example.SpringBootApp myJob param=value...}
+ * </p>
  * <p>
  * For stopping all running executions of a job, use the -stop option.
- * <p>
+ *
  * Example:<br>
- * java com.devonfw.module.batch.common.base.SpringBootBatchCommandLine
- * com.devonfw.gastronomy.restaurant.SpringBootBatchApp classpath:config/app/batch/beans-productimport.xml
- * productImportJob -stop
+ * {@code  java -jar my-app-batch-bootified.jar com.devonfw.application.example.SpringBootApp myJob -stop}
+ * </p>
+ * <p>
+ * To make that work expect that the batchs is deployed in form of a "bootified" jar, whith this class here als the
+ * start-class. For that you have to add the following snipped to your pom.xml:
+ *
+ * <pre>
+ * {@code
+ <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+        <configuration>
+          <excludes>
+            <exclude>config/application.properties</exclude>
+          </excludes>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-maven-plugin</artifactId>
+        <configuration>
+          <mainClass>com.devonfw.module.batch.common.base.SpringBootBatchCommandLine</mainClass>
+          <classifier>bootified</classifier>
+        </configuration>
+        <executions>
+          <execution>
+            <goals>
+              <goal>repackage</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+ * }
+ * </pre>
+ * </p>
+ * <p>
+ *
+ * @deprecated Since spring batch and spring boot are nicely integrated it is possible to start batches without any
+ *             custom launcher. This is documented in the current devonfw batch documentation. This launcher is no
+ *             longer required and will be removed in one of the next releases.
  */
+@Deprecated
 public class SpringBootBatchCommandLine {
 
   private static final Logger LOG = LoggerFactory.getLogger(SpringBootBatchCommandLine.class);
@@ -59,12 +103,16 @@ public static enum Operation {
     STOP
   };
 
+  @Inject
   private JobLauncher launcher;
 
+  @Inject
   private JobLocator locator;
 
-  private JobParametersConverter parametersConverter;
+  @Autowired(required = false) // Use Autowired here, since @Inject does not support required = false.
+  private JobParametersConverter parametersConverter = new DefaultJobParametersConverter();;
 
+  @Inject
   private JobOperator operator;
 
   /**
@@ -73,22 +121,18 @@ public static enum Operation {
    */
   public static void main(String[] args) throws Exception {
 
-    if (args.length < 3) {
+    if (args.length < 2) {
 
       handleIncorrectParameters();
       return;
     }
 
-    List<String> configurations = new ArrayList<>(2);
-    configurations.add(args[0]);
-    configurations.add(args[1]);
-
     List<String> parameters = new ArrayList<>();
 
     Operation op = Operation.START;
-    if (args.length > 3 && args[3].equalsIgnoreCase("-stop")) {
+    if (args.length > 2 && args[2].equalsIgnoreCase("-stop")) {
 
-      if (args.length > 4) {
+      if (args.length > 3) {
 
         handleIncorrectParameters();
         return;
@@ -97,29 +141,25 @@ public static void main(String[] args) throws Exception {
       op = Operation.STOP;
     } else {
 
-      for (int i = 3; i < args.length; i++) {
+      for (int i = 2; i < args.length; i++) {
 
         parameters.add(args[i]);
       }
     }
 
-    new SpringBootBatchCommandLine().execute(op, configurations, args[2], parameters);
+    new SpringBootBatchCommandLine().execute(op, args[0], args[1], parameters);
   }
 
   private static void handleIncorrectParameters() {
 
     LOG.error("Incorrect parameters.");
     LOG.info("Usage:");
-    LOG.info("java com.devonfw.module.batch.common.base.SpringBootBatchCommandLine"
-        + " <SpringBootConfiguration> <BatchJobConfiguration>" + " <JobName> param1=value1 param2=value2 ...");
+    LOG.info(
+        "java -jar my-app-batch-bootified.jar <SpringBootConfiguration> <JobName> param1=value1 param2=value2 ...");
     LOG.info("For stopping all running executions of a batch job:");
-    LOG.info("java com.devonfw.module.batch.common.base.BatchCommandLine"
-        + " <SpringBootConfiguration> <BatchJobConfiguration>" + " <JobName> -stop");
+    LOG.info("java -jar my-app-batch-bootified.jar <SpringBootConfiguration> <JobName> -stop");
     LOG.info("Example:");
-    LOG.info("java com.devonfw.module.batch.common.base.SpringBootBatchCommandLine"
-        + " com.devonfw.gastronomy.restaurant.SpringBootBatchApp"
-        + " classpath:config/app/batch/beans-productimport.xml" + " productImportJob drinks.file=file:import/drinks.csv"
-        + " date(date)=2015/12/20");
+    LOG.info("java com.devonfw.application.example.SpringBootApp exportJob pathToFile=myfile.csv");
   }
 
   /**
@@ -134,50 +174,32 @@ protected int getReturnCode(JobExecution jobExecution) {
       return 1;
   }
 
-  private void findBeans(ConfigurableApplicationContext ctx) {
-
-    this.launcher = ctx.getBean(JobLauncher.class);
-    this.locator = ctx.getBean(JobLocator.class); // supertype of JobRegistry
-    this.operator = ctx.getBean(JobOperator.class);
-    try {
-
-      this.parametersConverter = ctx.getBean(JobParametersConverter.class);
-    } catch (NoSuchBeanDefinitionException e) {
-
-      this.parametersConverter = new DefaultJobParametersConverter();
-    }
-  }
-
   /**
    * Initialize the application context and execute the operation.
    * <p>
    * The application context is closed after the operation has finished.
    *
    * @param operation The operation to start.
-   * @param configurations The sources of bean configurations (either JavaConfig classes or XML files).
+   * @param configuration The sources of app context configuration.
    * @param jobName The name of the job to launch/stop.
    * @param parameters The parameters (key=value).
    * @throws Exception in case of an error.
    */
-  @SuppressWarnings("deprecation")
-  public void execute(Operation operation, List<String> configurations, String jobName, List<String> parameters)
+  public void execute(Operation operation, String configuration, String jobName, List<String> parameters)
       throws Exception {
 
-    // get sources of configuration
-    Class<?>[] configurationClasses = new Class[configurations.size()];
-    for (int i = 0; i < configurations.size(); i++) {
-
-      configurationClasses[i] = Class.forName(configurations.get(i));
-    }
-
-    SpringApplication app = new SpringApplication(configurationClasses);
+    SpringApplication app = new SpringApplication(Class.forName(configuration));
 
     // no (web) server needed
     app.setWebApplicationType(WebApplicationType.NONE);
 
     // start the application
     ConfigurableApplicationContext ctx = app.run(new String[0]);
 
+    // start injection for properties of this class (here), by manually invoking autowiring for the new context.
+    ctx.getAutowireCapableBeanFactory().autowireBeanProperties(this, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE,
+        false);
+
     switch (operation) {
       case START:
         startBatch(ctx, jobName, parameters);
@@ -197,15 +219,22 @@ private void startBatch(ConfigurableApplicationContext ctx, String jobName, List
     JobExecution jobExecution = null;
     try {
 
-      findBeans(ctx);
-
       JobParameters params = this.parametersConverter
           .getJobParameters(StringUtils.splitArrayElementsIntoProperties(parameters.toArray(new String[] {}), "="));
 
       // execute the batch
-      // the JobOperator would require special logic for a restart, so we
-      // are using the JobLauncher directly here
-      jobExecution = this.launcher.run(this.locator.getJob(jobName), params);
+      Job job = null;
+      if (this.locator != null) {
+        try {
+          job = this.locator.getJob(jobName);
+        } catch (NoSuchJobException e) {
+        }
+      }
+      if (job == null) {
+        job = (Job) ctx.getBean(jobName);
+      }
+
+      jobExecution = this.launcher.run(job, params);
 
     } finally {
 
@@ -245,8 +274,6 @@ private void stopBatch(ConfigurableApplicationContext ctx, String jobName) throw
     int returnCode = 0;
     try {
 
-      findBeans(ctx);
-
       Set<Long> runningJobExecutionIDs = this.operator.getRunningExecutions(jobName);
       if (runningJobExecutionIDs.isEmpty()) {
 
diff --git a/modules/batch/src/main/java/com/devonfw/module/batch/common/impl/JobLauncherWithAdditionalRestartCapabilities.java b/modules/batch/src/main/java/com/devonfw/module/batch/common/impl/JobLauncherWithAdditionalRestartCapabilities.java
@@ -7,6 +7,7 @@
 import org.springframework.batch.core.JobParametersIncrementer;
 import org.springframework.batch.core.JobParametersInvalidException;
 import org.springframework.batch.core.launch.JobLauncher;
+import org.springframework.batch.core.launch.support.RunIdIncrementer;
 import org.springframework.batch.core.launch.support.SimpleJobLauncher;
 import org.springframework.batch.core.repository.JobExecutionAlreadyRunningException;
 import org.springframework.batch.core.repository.JobInstanceAlreadyCompleteException;
@@ -21,7 +22,10 @@
  * the 'run.id' parameter). It is actually just a convenience functionality so that the one starting batches does not
  * have to change the parameters manually.
  *
+ * @deprecated Using springs {@link RunIdIncrementer} is sufficient for most use cases.
+ *
  */
+@Deprecated
 public class JobLauncherWithAdditionalRestartCapabilities extends SimpleJobLauncher {
 
   private JobRepository jobRepository;
@@ -39,8 +43,8 @@ public JobExecution run(final Job job, JobParameters jobParameters) throws JobEx
         // analogous to SimpleJobRepository#createJobExecution
         JobExecution jobExecution = this.jobRepository.getLastJobExecution(job.getName(), jobParameters);
         if (jobExecution.isRunning()) {
-          throw new JobExecutionAlreadyRunningException("A job execution for this job is already running: "
-              + jobExecution.getJobInstance());
+          throw new JobExecutionAlreadyRunningException(
+              "A job execution for this job is already running: " + jobExecution.getJobInstance());
         }
         BatchStatus status = jobExecution.getStatus();
         if (status == BatchStatus.COMPLETED || status == BatchStatus.ABANDONED) {
