Code4java: September 2015

Hello Friends ,hope you all are fine.today i am going to demonstrate you ,how we can configure spring batch application.

Spring batch is useful to process large volume data.consider scenario where we want to read data from database and write those all data into xml file.in this we can use Spring Batch.Spring Batch Provides classes and api's to read/write resources, transaction management,job processing statistics etc.

Apart from Spring jars, i have used two main jars which will be used for batch processing :
(1)spring-batch-core-2.2.0.RELEASE.jar,
(2)spring-batch-infrastructure-2.2.0.RELEASE.jar

In this example i have used maven project structure ,i will read all files from particular directory ,make one zip of it and then i will dump all file details of that particular directory in database, apart from that i am also keeping track how many times batch will get executed.

Project Structure is look like given below :

database script ::

(1)

DROP TABLE IF EXISTS `studentdb`.`batchstrn`;
CREATE TABLE `studentdb`.`batchstrn` (
`BATCHRUNID` int(10) unsigned NOT NULL AUTO_INCREMENT,
`BATCHID` int(10) unsigned NOT NULL,
`REQDATE` datetime NOT NULL,
`PROCSTARTDATE` datetime NOT NULL,
`STATUSCODE` varchar(45) NOT NULL,
PRIMARY KEY (`BATCHRUNID`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=latin1;

(2)

DROP TABLE IF EXISTS `studentdb`.`zip_dtl`;
CREATE TABLE `studentdb`.`zip_dtl` (
`ZIP_ID` int(10) unsigned NOT NULL AUTO_INCREMENT,
`FILE_NAME` varchar(45) NOT NULL,
`FILE_PATH` varchar(45) NOT NULL,
PRIMARY KEY (`ZIP_ID`)
) ENGINE=InnoDB AUTO_INCREMENT=288 DEFAULT CHARSET=latin1;

Main Class :
package org.zip;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
//@Component
public class App {

public static void main(String[] args) {

App obj = new App();
obj.run();

}

private void run() {

String[] springConfig = { "spring/batch/jobs/job-zip-gen.xml" }; //xml that contains job configuration parameters

ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);

JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
Job job = (Job) context.getBean("zipGenJob");

try {

JobExecution execution = jobLauncher.run(job, new JobParameters());
System.out.println("Exit Status : " + execution.getStatus());
System.out.println("Exit Status : " + execution.getAllFailureExceptions());

} catch (Exception e) {
e.printStackTrace();

}

System.out.println("Done");

}

}

The Configuration file for job is as given below :
job-zip-gen.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:batch="http://www.springframework.org/schema/batch"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:task="http://www.springframework.org/schema/task"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/task
http://www.springframework.org/schema/task/spring-task-3.2.xsd
">

<import resource="../config/context.xml" />

<context:annotation-config/>
<context:component-scan base-package="org.zip"></context:component-scan>


<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/studentdb" />
<property name="username" value="root" />
<property name="password" value="admin!@#" />
</bean>



<job id="zipGenJob" xmlns="http://www.springframework.org/schema/batch">

<step id="zipGen">
<tasklet ref="ZipGenerationTasklet" />
</step>
</job>

<bean id="ZipGenerationTasklet" class="org.zip.tasklet.ZipGenerationTasklet" >






</bean>



</beans>

context.xml

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

<bean id="jobRepository"
class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean">
<property name="transactionManager" ref="transactionManager" />
</bean>

<bean id="transactionManager"
class="org.springframework.batch.support.transaction.ResourcelessTransactionManager" />

<bean id="jobLauncher"
class="org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name="jobRepository" ref="jobRepository" />
</bean>





<bean id="envProperties"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>classpath:META-INF/i18n/zip-batch.properties</value>
</list>
</property>
</bean>

</beans>

Model Class :

package org.zip.model;

import java.io.Serializable;

public class ZIPGEN implements Serializable {

/**
*
*/
private static final long serialVersionUID = 1L;
private int ZIP_ID;
private String FILE_NAME;
public int getZIP_ID() {
return ZIP_ID;
}
public void setZIP_ID(int zIP_ID) {
ZIP_ID = zIP_ID;
}
public String getFILE_NAME() {
return FILE_NAME;
}
public void setFILE_NAME(String fILE_NAME) {
FILE_NAME = fILE_NAME;
}
public String getFILE_PATH() {
return FILE_PATH;
}
public void setFILE_PATH(String fILE_PATH) {
FILE_PATH = fILE_PATH;
}
private String FILE_PATH;

}

Tasklet to get files as well as dump those file details is as given below :

package org.zip.tasklet;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.math.BigInteger;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import javax.sql.DataSource;

import org.springframework.batch.core.ExitStatus;
import org.springframework.batch.core.StepContribution;
import org.springframework.batch.core.StepExecution;
import org.springframework.batch.core.StepExecutionListener;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;
import org.springframework.stereotype.Component;

@Component
public class ZipGenerationTasklet implements Tasklet, InitializingBean,StepExecutionListener {

/*private Resource directory;*/
List<String> fileList =new ArrayList<String>();
private String OUTPUT_ZIP_FILE= "D:\\MyFile.zip";
private String SOURCE_FOLDER ="D:\\NisargPics";

private JdbcTemplate jdbcTemplate;
int batchid;
BigInteger batch_run_id;
private long batchId=2;

private SimpleJdbcCall simpleJdbcCall;
@Autowired
public void setDataSource(DataSource dataSource) {
this.jdbcTemplate = new JdbcTemplate(dataSource);
simpleJdbcCall = new SimpleJdbcCall(dataSource).withFunctionName("get_id");
}

@Override
public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {

System.out.println("Proc call to get auto incr. value .....!");

SqlParameterSource mapParam = new MapSqlParameterSource().addValue("name_","zip_dtl");

Map<String,Object> map = simpleJdbcCall.execute(mapParam);

System.out.println("Executing The Procedure .....!");
BigInteger id = (BigInteger)map.get("sequence_no_");

// batch_run_id=jdbcTemplate.queryForObject("SELECT sequence_no+1 FROM sequence_generate_tab", BigInteger.class);

String sql="INSERT INTO BATCHSTRN (BATCHRUNID,BATCHID,REQDATE,PROCSTARTDATE,STATUSCODE)"
+ "VALUES (?, ?, ?, ?, 'S')";

jdbcTemplate.update(sql,batch_run_id,batchId,getCurrentTimeStamp(),getCurrentTimeStamp());

System.out.println("Execution Start .....!");

generateFileList(new File(SOURCE_FOLDER));
zipIt(OUTPUT_ZIP_FILE,id);

System.out.println("Execution End .....!");

return RepeatStatus.FINISHED;

}
/*
public Resource getDirectory() {
return directory;
}

public void setDirectory(Resource directory) {
this.directory = directory;
}
*/
public void zipIt(String zipFile, BigInteger id){

//System.out.println("id:::::::::->"+id);

String sql = "INSERT INTO ZIP_DTL " +
"(ZIP_ID,FILE_NAME, FILE_PATH) VALUES (?, ?, ?)";
byte[] buffer = new byte[1024];

try{

FileOutputStream fos = new FileOutputStream(zipFile);
ZipOutputStream zos = new ZipOutputStream(fos);

System.out.println("Output to Zip : " + zipFile);

int i =2;
for(String file : this.fileList){

System.out.println("File Added : " + file);

//

jdbcTemplate.update(sql,new Object[]{id,file,file});

i=i+1;

ZipEntry ze= new ZipEntry(file);
zos.putNextEntry(ze);

FileInputStream in =
new FileInputStream(SOURCE_FOLDER + File.separator + file);

int len;
while ((len = in.read(buffer)) > 0) {
zos.write(buffer, 0, len);
}

in.close();
}

zos.closeEntry();
//remember close it
zos.close();

System.out.println("Done");
}catch(IOException ex){
ex.printStackTrace();
}
}

/**
* Traverse a directory and get all files,
* and add the file into fileList
* @param node file or directory
*/
public void generateFileList(File node){

//add file only
if(node.isFile()){
fileList.add(generateZipEntry(node.getAbsoluteFile().toString()));
}

if(node.isDirectory()){
String[] subNote = node.list();
for(String filename : subNote){
generateFileList(new File(node, filename));
}
}

}

/**
* Format the file path for zip
* @param file file path
* @return Formatted file path
*/
private String generateZipEntry(String file){
return file.substring(SOURCE_FOLDER.length()+1, file.length());
}

@Override
public void afterPropertiesSet() throws Exception {
// TODO Auto-generated method stub

}

@Override
public ExitStatus afterStep(StepExecution stepExecution) {
// TODO Auto-generated method stub

stepExecution.getJobExecution().getExecutionContext()
.put("BATCHRUNID", batch_run_id);

return null;
}

@Override
public void beforeStep(StepExecution arg0) {
// TODO Auto-generated method stub

}

public static String getCurrentTimeStamp() {
SimpleDateFormat sdfDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//dd/MM/yyyy
Date now = new Date();
String strDate = sdfDate.format(now);
return strDate;
}
}

for the sake of simplicity , I have shared the project ,you can download it from following link
Download Project

for any query ping me on npjava90@gmail.com
Happy Learning...!!

Thanks

Code4java

Friday 18 September 2015

Spring Batch Processing Example

Spring Boot SSL configuration -Tomcat Server

Translate

Total Pageviews