Announcement Announcement Module
Collapse
No announcement yet.
Spring Batch Page Title Module
Move Remove Collapse
X
Conversation Detail Module
Collapse
  • Filter
  • Time
  • Show
Clear All
new posts

  • Spring Batch

    I am new to Spring Batch. Can anybody help me with step by step instructions to create a spring batch? Do we have to add external jar files ? I did import org.springframework.batch.core.Job;
    import org.springframework.batch.core.configuration.JobRe gistry; But it shows error. I want a bacth creation for a simple program with Database connection.Can anybody please help me with step by step instruction.

  • #2
    I'm assuming you found the reference documentation and have read through it? If not, it can be found here:

    http://static.springframework.org/sp...tml/index.html

    There was also a recent blog post that did a good job of creating and walking through a 'hello world':

    http://jroller.com/0xcafebabe/entry/..._hello_world_1

    Comment


    • #3
      Spring Batch

      I tried that program (Hello Batch) . From the Application Context it shows error.
      "org.springframework.batch.execution.launch.Simple JobLauncher" cannot resolve class or package . Do I have to add external jar files? I did the imports.Can you please help me
      Thanks a lot for your help. I was stucked with this from yesterday.Thank you very much. May God Bless you

      Comment


      • #4
        You will definitely have to have the spring batch jars on your classpath.

        Comment


        • #5
          Thank you

          Now My Hello world not showing any error. I added the jar files.
          My next question is Can I run this program from Linux instead of Maven. If 'yes ', How?.Please help me
          Thanks
          May God Bless

          Comment


          • #6
            It's really the same way as you would run any java application from Linux, you'll need to write a shell script to kick off a jvm process using the CommandLineJobRunner as you main method, etc.

            Comment


            • #7
              My Java project is under “/users/abc/SpringBatch” and Java is in “System/Library/Java”
              How will I set the classpath and set CommandLineJobRunner in Linux? How will I do kick off a jvm process using the CommandLineJobRunner as my main method? Please help
              Thanks
              May God Bless

              Comment


              • #8
                I think what you asked has nothing to do with Spring Batch.

                Please find a Java book and do some exercises, and try to understand what is a Java application, what is classpath etc.

                Comment


                • #9
                  I did all the class path settings
                  But I am not able to execute the CommandLineJobRunner

                  Comment


                  • #10
                    How will I add 'pom.xml' in my project library? I tried. since its not a jar file, I am not able to add it. Can anybody please help?

                    Comment


                    • #11
                      All your questions have nothing to do with Spring Batch.

                      Instead of yelling around here, would you mind getting a Java book or do some Googling, and learn some basics in Java?

                      for POM.xml, go to maven.apache.org to learn it.

                      Comment


                      • #12
                        spring batch

                        Hi,

                        Hi,

                        I'm beginner with spring quartz and i have a problem for my project.

                        I'would whan my job is failed or sleep, the scheduler relance it and the job can retake
                        where it has stopped.

                        This is a differents steps how i was did :
                        In the first i have m y class scheduler:

                        Code:
                        
                        @DisallowConcurrentExecution
                        public class JobLauncherDetails extends QuartzJobBean /*implements JobExecutionListener*/ {
                        
                        	private static final String JOB_DATA_MAP_MAX_RETRY = "maxRetry";
                        	//private static final String JOB_DATA_MAP_NB_RETRIES = "nbRetries";
                        	private final static String JOB_LOCATOR_CONTEXT_KEY = "jobLocator";
                        	private final static String JOB_LAUNCHER_CONTEXT_KEY = "jobLauncher";
                        	private static final String JOB_DATA_MAP_START_DATE = "startDate";
                        	private static final String JOB_PARAM_LISTENER_DELAY_KEY = "listenerDelay";
                        	private static final long JOB_PARAM_DEFAULT_LISTENER_DELAY = 1000;
                        
                        	private static Logger log = LoggerFactory.getLogger(JobLauncherDetails.class);
                        
                        	/**
                        	 * Special key in job data map for the name of a job to run.
                        	 */
                        	private static final String JOB_NAME = "jobName";
                        
                        	private JobLocator jobLocator;
                        	private JobLauncher jobLauncher;
                        	private String jobName;
                            private JobListener MyjobListener;
                        	/**
                        	 * Method called by Quartz trigger. The given {@link JobExecutionContext}
                        	 * gives info on the Job to run.
                        	 */
                        	protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
                        		try {
                        			jobLocator = (JobLocator) context.getScheduler().getContext().get(JOB_LOCATOR_CONTEXT_KEY);
                        			jobLauncher = (JobLauncher) context.getScheduler().getContext().get(JOB_LAUNCHER_CONTEXT_KEY);
                        			MyjobListener=(JobListener)context.getScheduler().getContext().get(MyjobListener);
                        			
                        		
                        		} catch (SchedulerException se) {
                        			log.error("Unable to get jobLocator and jobLauncher from scheduler context.", se);
                        		}
                        
                        		if (jobLocator == null || jobLauncher == null) {
                        			log.error("Unable to run a job without valids jobLocator and jobLauncher.");
                        		} else {
                        			JobDetail jobDetail = context.getJobDetail();
                        			Map<String, Object> jobDataMap = context.getMergedJobDataMap();
                        			
                        			if (jobDataMap == null || jobDataMap.size() == 0) {
                        				log.error("Unable to run a job without a valid jobDataMap (no job name provided...).");
                        			} else {
                        				
                        				jobName = (String) jobDataMap.get(JOB_NAME);
                        
                        				if (jobName == null || jobName.isEmpty()) {
                        					log.error("Unable to run a job: no job name provided...");
                        				} else {
                        					
                        					if(context.getRefireCount()==0) {
                        						// Add a date to the jobDataMap so that the job is unique.
                        						// It is useful to distinguish 2 instances of the same trigger.
                        						// Otherwise, a JobExecutionAlreadyRunningException will be launched
                        						// (no need to modify this parameter for a refired job)
                        						jobDataMap.put(JOB_DATA_MAP_START_DATE, new Date());
                        					}
                        
                        					JobParameters jobParameters = getJobParametersFromJobMap(jobDataMap);
                        					Scheduler sched= context.getScheduler();
                        					try {
                        						sched.getListenerManager().addJobListener(new NcaJobListener());
                        						
                        					} catch (SchedulerException e) {
                        						// TODO Auto-generated catch block
                        						e.printStackTrace();
                        					}	
                        					
                        					if (log.isInfoEnabled())
                        						log.info("\n**********************************************************************\n" 
                        								+ "* Quartz trigger - start job: {}. Key: {}\n"
                        								+ "* Firing unique ID: {}\n" 
                        								+ "* Refire count: {}\n" 
                        								+ "* Job parameters: {}\n"
                        								+ "* isConcurrentExectionDisallowed: {}\n"
                        								+ "**********************************************************************\n",
                        								new Object[] { jobName, jobDetail==null?"":jobDetail.getKey(), context.getFireInstanceId(), 
                        												context.getRefireCount(), jobParameters==null?"":jobParameters.toString(), 
                        												context.getJobDetail().isConcurrentExectionDisallowed() });
                        					
                        					JobExecution jobExec = null;
                        					BatchStatus jobStatus = BatchStatus.UNKNOWN;
                        
                        					try {
                        						jobExec = jobLauncher.run(jobLocator.getJob(jobName), jobParameters);
                        						log.info("Job Id: {}", jobExec.getId());
                        
                        					}
                        
                        					} catch (Exception ex) {
                        						if(!(ex instanceof JobExecutionException)) {
                        							log.error("Error while running Job [{}]. Rescheduling if possible.\nError: {}\n******************************", jobName, ex.toString());
                        							// TODO: retirer ce log...
                        							log.error("Error full stack:", ex);
                        							
                        						} else {
                        							throw (JobExecutionException) ex;
                        						}
                        					}
                        
                        					if (log.isInfoEnabled())
                        						log.info("\n**********************************************************************\n" 
                        								+ "* Quartz trigger - end job: {}\n"
                        								+ "* Firing unique ID: {}\n" 
                        								+ "* Refire count: {}\n" 
                        								+ "* Job parameters: {}\n"
                        								+ "* Start date: {}\n"
                        								+ "* End date: {}\n"
                        								+ "* Status: {}\n"
                        								+ "**********************************************************************\n",
                        								new Object[] { jobName, context.getFireInstanceId(), context.getRefireCount(), 
                        												jobParameters==null?"":jobParameters.toString(),
                        												jobExec==null?"":jobExec.getStartTime(),
                        												jobExec==null?"":jobExec.getEndTime(),
                        												jobStatus });
                        				}
                        			}
                        		}
                        	}
                        
                        	/**
                        	 * Copy parameters that are of the correct type over to
                        	 * {@link JobParameters}, ignoring jobName.
                        	 * 
                        	 * @return a {@link JobParameters} instance
                        	 */
                        	private JobParameters getJobParametersFromJobMap(Map<String, Object> jobDataMap) {
                        
                        		JobParametersBuilder builder = new JobParametersBuilder();
                        
                        		for (Entry<String, Object> entry : jobDataMap.entrySet()) {
                        			String key = entry.getKey();
                        			Object value = entry.getValue();
                        			if (value instanceof String && !key.equals(JOB_NAME)) {
                        				builder.addString(key, (String) value);
                        			} else if (value instanceof Float || value instanceof Double) {
                        				builder.addDouble(key, ((Number) value).doubleValue());
                        			} else if (value instanceof Integer || value instanceof Long) {
                        				builder.addLong(key, ((Number) value).longValue());
                        			} else if (value instanceof Date) {
                        				builder.addDate(key, (Date) value);
                        			} else {
                        				log.debug("JobDataMap contains values which are not job parameters (ignoring).");
                        			}
                        		}
                        
                        		return builder.toJobParameters();
                        	}
                        
                        	/*@Override
                        	public void afterJob(JobExecution jobExecution) {
                        		// TODO Auto-generated method stub
                        		log.info("*************************** Job ended with status: {} ********************", jobExecution.getExitStatus());
                        
                        		if (ExitStatus.FAILED.equals(jobExecution.getExitStatus())) {
                        			log.error("******************************\nJob [{}] failed. Reschedule if possible.\n******************************", jobName);
                        
                        			// rescheduleJob(jobExecution);
                        		}
                        	}
                        
                        	@Override
                        	public void beforeJob(JobExecution jobExecution) {
                        		log.info("************** Before running job {} **************", jobName);
                        	}*/
                        
                        }

                        Comment


                        • #13
                          In the second i have a class jobfaileur:

                          Code:
                          public class JobFailureListener implements JobExecutionListener {
                          	private static Logger log = LoggerFactory.getLogger(JobFailureListener.class);
                          	private static final String JOB_DATA_MAP_MAX_RETRY = "maxRetry";
                          	private static final String JOB_NAME = "jobName";
                          	private String jobName;
                          	public void beforeJob(JobExecution jobExecution) {
                          	// nothing to do
                          		log.info("*************************** Job ended with status: {} ********************", jobExecution.getExitStatus());
                          	}
                          
                          	public void afterJob(JobExecution jobExecution, JobExecutionContext context) throws JobExecutionException {
                          	
                          		if( jobExecution.getStatus() == BatchStatus.COMPLETED ){
                          			System.out.println("!!!!!!!!!!!!!!!!!  sa	 marche !!!!!!!!!!!!!!!!");
                          	    }
                          		
                          		else
                          		
                          			if (!jobExecution.getAllFailureExceptions().isEmpty()) {
                          	ExitStatus exitStatus = ExitStatus.FAILED;
                          	log.error("******************************\nJob [{}] failed. Reschedule if possible.\n******************************");
                          	
                          	//rescheduler if possible
                          	rescheduleJob(jobExecution, context);
                          	
                          	for (Throwable e : jobExecution.getAllFailureExceptions()) {
                          
                          	exitStatus = exitStatus.addExitDescription(e);
                          
                          	}
                          
                          	jobExecution.setExitStatus(exitStatus);
                          
                          	}
                          
                          	}
                          
                          	private void rescheduleJob(JobExecution jobExec, JobExecutionContext context) throws JobExecutionException {
                          		rescheduleJob(jobExec, context, null);
                          	}
                          
                          	private void rescheduleJob(JobExecution jobExec, JobExecutionContext context, Throwable excep) throws JobExecutionException {
                          		// TODO: Gérer la politique de réessai, ex :
                          		// http://stackoverflow.com/questions/4408858/quartz-retry-when-failure
                          	
                          		if(jobExec == null)
                          			throw new IllegalArgumentException("jobExec cannot be null.");
                          		
                          		if(context == null)
                          			throw new IllegalArgumentException("context cannot be null.");
                          		
                          		String fireInstanceId =   context.getFireInstanceId();
                          		int refireCount = context.getRefireCount();
                          		
                          		if (log.isInfoEnabled())
                          			log.info("\n**********************************************************************\n" 
                          					+ "* Quartz trigger - rescheduling job: {}\n"
                          					+ "* Firing unique ID: {}\n" 
                          					+ "* Refire count: {}\n" 
                          					+ "**********************************************************************\n",
                          					new Object[] { jobName, fireInstanceId, refireCount});
                          		
                          		JobDataMap dataMap = context.getJobDetail().getJobDataMap();
                          		int maxRetry = dataMap.getIntValue(JOB_DATA_MAP_MAX_RETRY);
                          		
                          		JobExecutionException jobExecutionException = null;
                          		
                                  if(maxRetry>0 && refireCount<maxRetry) {        	
                                  	jobExecutionException = new JobExecutionException("Error: the job [" + jobName + "] didn't end properly, refire it immediately.", excep);
                                  	jobExecutionException.setRefireImmediately(true);
                                  	//boolean refireImmediatelyResult = jobExecutionException.refireImmediately();
                                  	
                                  	log.info("************** Job Id: {} - rescheduled. ", jobExec.getId());
                                  	
                                  	throw jobExecutionException;
                                  } else {
                                  	//jobExecutionException = new JobExecutionException("Error: the job [" + jobName + "] didn't end properly. No more retry possible, sending alarm.", excep);
                                  	
                                  	log.error("\n**********************************************************************\n" 
                          					+ "* Quartz trigger - No more retry possible for job: {}\n"
                          					+ "* Firing unique ID: {}\n" 
                          					+ "* UNSCHEDULING TRIGGER + SENDING EXPLOIT ALARM...\n"
                          					+ "**********************************************************************\n",
                          					jobName, fireInstanceId);
                                  	
                                  	AlarmDef alarmDef = AlarmExploit.searchBatchFailedAlarmDefByBatchName(jobName);
                                  	AlarmExploit.generateAlarmWithoutTemplate(alarmDef, "Batch failed", "The following batch failed (no more retry possible): " + jobName, Locale.ENGLISH.toString(), null);
                                  }
                          	}
                          
                          	@Override
                          	public void afterJob(JobExecution jobExecution) {
                          		// TODO Auto-generated method stub
                          			}
                          	
                          }
                          I also add an sleep for my job and when i run i have a message who said that my job is finished or it's nnot there but juste sleep.
                          Please can i have a response, exemple or others suggestions , i need some one to help me please

                          Thanks a lot

                          Comment

                          Working...
                          X