In part1 of the blog, I talked about WebSphere Feature Pack for Modern Batch. In part 2, I will introduce Spring Batch framework. Spring batch framework was developed as a standard-based way to implement common batch patterns in Java.

Spring Batch architecture consists of following layers:

Application: This consists of your custom code and configuration of your batch jobs.
Core: This layer contains the core elements of framework including Job and Step interface as well as JobLauncher and JobParameters.
Infrastructure:  This layer deals with reading and writing to files and databases.

Note: Spring Batch framework does not include a scheduler. You will need to use external schedulers like cron or Quartz for scheduling jobs at a given time.

Main Components of a Spring Batch Application

Job Repository: Component provided by infrastructure to store job execution data.
Job Launcher: Component provided by  infrastructure to start executing a job.
Job: Application component representing a batch job.
Step: A phase in a job, a job usually consists of multiple steps in a sequence.
Tasklet: A transactional  process that occurs in a step.
Item: A record read from a data source or a record written to a data source.
Chunk: A certain sized group of items. This is used for chunk processing.
Item Reader: Component responsible for reading items from data source.
Item Writer: Component responsible for writing items to data source.
Item Processor: Component responsible for processing an item before output.

What is a Spring Batch Job?

A batch job in Spring Batch is composed of a sequence of steps configured in XML configuration file. It is easier to develop, maintain, and test a batch job that is divided into multiple steps. Spring Batch framework allows for control flow decisions based on step completed, failed, or any other custom logic like checking a table in database.

Links for further information:

Spring Batch Framework
User’s Guide

Recently I had to create a download servlet which allowed users to download pdf, excel, or  power point files stored in DB2 database as Blob. Whoever designed the database did not include a mime type column in the database so I had to figure out the file type. After looking at files in a binary editor, I was able to figure out the magic marker and then I used Blob.position() method from java.sql.Blob. Below is a code I used to detect file types from Blob:

/**
 * Returns file type (.pdf, .doc, .xls, or .ppt) from a Blob
 * <p>
 * This method returns empty string if exception or file type
 * cannot be determined.
 *
 * @param  attachment  SQL Blob
 * @return the file type stored in Blob
 * @see    java.sql.Blob
 */
 private String findMimeType(Blob attachment) {

 String returnString = "";

 //Define binary markers for the file types
 byte[] officeMagic = hexStringToByteArray("D0CF11E0A1B11AE1");
 byte[] wordDocMagic = hexStringToByteArray("4D6963726F736F667420576F726420446F63756D656E74");
 byte[] excelMagic = hexStringToByteArray("4D6963726F736F667420457863656C20576F726B7368656574");
 byte[] excelMagic2 = hexStringToByteArray("4D6963726F736F667420457863656C");
 byte[] pdfMagic = hexStringToByteArray("255044462D");
 byte[] pptMagic =
 hexStringToByteArray("50006F0077006500720050006F0069006E007400200044006F00630075006D0065006E0074");
 byte[] pptMagic2 = hexStringToByteArray("4D6963726F736F667420506F776572506F696E74");

	try {
		//check if pdf file
		if (attachment.position(pdfMagic, 1) != -1) {

			returnString = ".pdf";
		} else if (attachment.position(officeMagic, 1) != -1) {
			//Microsoft office document

			if (attachment.position(wordDocMagic, 1) != -1) {
				returnString = ".doc";
			} else if (attachment.position(excelMagic, 1) != -1) {
				returnString = ".xls";
			} else if (attachment.position(excelMagic2, 1) != -1) {
				returnString = ".xls";
			} else if (attachment.position(pptMagic, 1) != -1) {
				returnString = ".ppt";
			} else if (attachment.position(pptMagic2, 1) != -1) {
				returnString = ".ppt";
		}
	}

	} catch (Exception e) {

     	//log warning here
	}

	return returnString;
}

	/**
	 * This method converts a HEX string to byte array
	 * @param s Hex string
	 * @return byte array
	 */
	private static byte[] hexStringToByteArray(String s) {
	    int len = s.length();
	    byte[] data = new byte[len / 2];
	    for (int i = 0; i < len; i += 2) {
	        data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
	                             + Character.digit(s.charAt(i+1), 16));
	    }
	    return data;
	}

Here is a quick primer on Java enums:

• Enumeration is fixed set of constants
• Provides type-safe representation of constant data
• enum is the Java class that represents enumeration
• enum cannot extend any other class
• Constants in enum are public,final, and static
• enum can declare additional methods and fields
• enum can declare any number of constructors
• values() returns array of enum values
• If you need int value, you can use ordinal() static method
• static valueOf() method can be used to convert a string into corresponding enum
• enum can be used in switch statement

Here is an example of enum with constructors:

public enum IceCream {

	PLAIN(2),
	SUGAR(3),
	WAFFLE(5);

	private IceCream(int scoops) {
		this.scoops = scoops;
	}

	public final int scoops;
}

public class TestEnum {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		IceCream cone1 = IceCream.PLAIN;
		IceCream cone2 = IceCream.SUGAR;
		IceCream cone3 = IceCream.WAFFLE;

		System.out.println("cone 1 needs " + cone1.scoops + " scoops");
		System.out.println("cone 2 needs " + cone2.scoops + " scoops");
		System.out.println("cone 3 needs " + cone3.scoops + " scoops");

	}

}

Output:

cone 1 needs 2 scoops
cone 2 needs 3 scoops
cone 3 needs 5 scoops