[batch-simple] Spring Batch using Spring Boot Java Configuration

batch-simple-jc/.gitignore

@@ -0,0 +1,4 @@
+/build/
+/*.iml
+/bin
+target

batch-simple-jc/README.md

@@ -0,0 +1,132 @@
+Spring XD Simple Batch Sample
+=============================
+
+In this *Hello World* example for *Spring XD* you will create a minimal code-based Job. This Job does no processing, only printing out `Hello Spring XD!` as well as any Job parameters that were passed into the Job so as to focus only on the mechanics of the compilation and copying of artifacts into the Spring XD installation directory.
+
+## Requirements
+
+In order for the sample to run you will need to have installed:
+
+* Spring XD 1.1.0.RELEASE or higher ([Instructions](https://github.com/SpringSource/spring-xd/wiki/Getting-Started))
+
+## Code Tour
+
+The processing actions that are part of a Step in a batch Job are pluggable.  The plug-in point for a Step is known as a [Tasklet](http://static.springsource.org/spring-batch/apidocs/org/springframework/batch/core/step/tasklet/Tasklet.html).  In this example we create a tasklet by implementing the Tasklet interface.  Take a look at the [source code](https://github.com/spring-projects/spring-xd-samples/blob/master/batch-simple/src/main/java/org/springframework/springxd/samples/batch/HelloSpringXDTasklet.java) as well as its incorporation into a [Job definition](https://github.com/spring-projects/spring-xd-samples/blob/master/batch-simple/src/main/resources/spring-module.xml) inside an XML file. Note that the XML file must contain a single Job.
+
+## Building with Maven
+
+Build the sample simply by executing:
+
+	$ mvn clean package
+
+The project's [pom][] declares `spring-xd-module-parent` as its parent. This adds the dependencies needed to compile and test the module and also configures the [Spring Boot Maven Plugin][] to package the module as an uber-jar, packaging any dependencies that are not already provided by the Spring XD container. In this case there are no additional dependencies so the artifact is built as a common jar. See the [Modules][] section in the Spring XD Reference for more details on module packaging.
+
+## Building with Gradle
+
+	$./gradlew clean bootRepackage
+
+The project's [build.gradle][] applies the `spring-xd-module` plugin, providing analagous build and packaging support for gradle. This plugin also applies the [Spring Boot Gradle Plugin][] as well as the [propdeps plugin][]. 
+
+
+## Running the Sample
+
+Now your sample is ready to be executed. Start your *Spring XD* singlenode server:
+
+	xd/bin>$ ./xd-singlenode
+
+	 _____                           __   _______
+	/  ___|          (-)             \ \ / /  _  \
+	\ `--. _ __  _ __ _ _ __   __ _   \ V /| | | |
+	 `--. \ '_ \| '__| | '_ \ / _` |  / ^ \| | | |
+	/\__/ / |_) | |  | | | | | (_| | / / \ \ |/ /
+	\____/| .__/|_|  |_|_| |_|\__, | \/   \/___/
+	      | |                  __/ |
+	      |_|                 |___/
+	1.1.0.BUILD-SNAPSHOT             eXtreme Data
+
+
+	Started container : SingleNodeApplication
+	Documentation: https://github.com/SpringSource/spring-xd/wiki
+	...
+
+Now start the *Spring XD Shell* in a separate window:
+
+	shell/bin>$ ./xd-shell
+
+	 _____                           __   _______
+	/  ___|          (-)             \ \ / /  _  \
+	\ `--. _ __  _ __ _ _ __   __ _   \ V /| | | |
+	 `--. \ '_ \| '__| | '_ \ / _` |  / ^ \| | | |
+	/\__/ / |_) | |  | | | | | (_| | / / \ \ |/ /
+	\____/| .__/|_|  |_|_| |_|\__, | \/   \/___/
+	      | |                  __/ |
+	      |_|                 |___/
+	eXtreme Data
+	1.1.0.BUILD-SNAPSHOT | Admin Server Target: http://localhost:9393
+	Welcome to the Spring XD shell. For assistance hit TAB or type "help".
+	xd:>
+
+First install the module using the `module upload` command:
+
+	xd:>module upload --type job --name myjob --file [path-to]/springxd-batch-simple-jc-1.0.0.BUILD-SNAPSHOT.jar
+
+You will now create a new Batch Job Stream using the *Spring XD Shell*:
+
+	xd:>job create --name helloSpringXD --definition "myjob --message=SpringXD"
+
+The UI is located on the machine where xd-singlenode is running and will show you the jobs that can be deployed. The UI is located at:
+
+* **http://localhost:9393/admin-ui**
+
+Alternatively, you can deploy it using the command line
+
+	xd:>job deploy helloSpringXD
+
+And then launch the job
+
+	xd:>job launch helloSpringXD
+
+You should see a message in the log output from the XD container:
+
+	Hello Spring XD!
+	The following 1 Job Parameter(s) is/are present:
+	Parameter name: random; isIdentifying: true; type: STRING; value: 0.07119643877192872
+
+You can also experiment with Job parameters:
+
+	job launch helloSpringXD --params {"myStringParameter":"foobar","-secondParam(long)":"123456"}
+
+	Hello SpringXD
+	The following 3 Job Parameter(s) is/are present:
+	Parameter name: secondParam; isIdentifying: false; type: LONG; value: 123456
+	Parameter name: myStringParameter; isIdentifying: true; type: STRING; value: foobar
+	Parameter name: random; isIdentifying: true; type: STRING; value: 0.06893349621991496
+	12:04:18,384  INFO http-nio-9393-exec-5 support.SimpleJobLauncher:135 - Job: [FlowJob: [name=helloSpringXD.job]] completed with the following parameters: [{secondParam=123456, myStringParameter=foobar, random=0.06893349621991496}] and the following status: [COMPLETED]
+
+## Throwing Exceptions
+
+You can trigger an exception by providing a parameter named `throwError` with a String value of `true`.
+
+## Adding Variables to the Step Execution Context
+
+Any parameters that start with `context` will be added to the Step Execution Context.
+E.g. if you add a parameter named `contextHello` with a String value of `World`,
+the variable `contextHello` will be added to the Step Execution Context. You can
+verify the context using the **Admin UI** and drilling to the Step Execution Details
+via the *Executions* tab.
+
+## Job Repository
+
+In this example the state of the Job execution is stored in an HSQLDB database embedded inside the single node server. Please refer to the Spring XD documentation if you would like to store this data in another database.
+
+## To run batch job with multiple steps
+
+Follow the instructions in the module's [xml] configuration to have batch job with multiple steps
+
+[xml]: https://github.com/spring-projects/spring-xd-samples/blob/master/batch-simple/src/main/resources/config/spring-module.xml
+[pom]: https://github.com/spring-projects/spring-xd-samples/blob/master/batch-simple/pom.xml
+[build.gradle]: https://github.com/spring-projects/spring-xd-samples/blob/master/batch-simple/build.gradle
+[Spring Boot Maven Plugin]: http://docs.spring.io/spring-boot/docs/current/reference/html/build-tool-plugins-maven-plugin.html
+[Spring Boot Gradle Plugin]: http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/html/build-tool-plugins-gradle-plugin.html
+[propdeps plugin]: https://github.com/spring-projects/gradle-plugins/tree/master/propdeps-plugin
+[Modules]: http://docs.spring.io/spring-xd/docs/current/reference/html/#modules

batch-simple-jc/build.gradle

@@ -0,0 +1,16 @@
+/*
+NOTE: This configuration is convenient for maintaining shared configuration across multiple projects in the samples repo. 
+If copying this example, it may be simpler to declare the  
+required configuration inline. 
+*/
+buildscript {
+   apply from: '../sample-modules-parent/buildscript.gradle', 
+   to: buildscript
+}
+apply from: '../sample-modules-parent/build.gradle'
+apply plugin: 'spring-xd-module'
+
+description = "Batch Simple Example using Java Configuration"
+
+sourceCompatibility = 1.6
+targetCompatibility = 1.6

batch-simple-jc/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Sun Jan 25 13:12:53 EST 2015
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-1.12-bin.zip

batch-simple-jc/gradlew

@@ -0,0 +1,164 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched.
+if $cygwin ; then
+    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+fi
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >&-
+APP_HOME="`pwd -P`"
+cd "$SAVED" >&-
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"