We will now start from a NetBeans project that already contains a simple batch application. So just open the "Lab4" project in NetBeans. As you explore the project files, you will notice the servlet that is used to control the batch, the reader, the processor and the writer, the JSL that defines the job, etc. In short, this application does almost what we developed in the first exercise. The only real difference is that it is now possible to add Payroll input records in the UI and restart the last executed job. Run the job and check the result in the GlassFish console.

Let’s define a listener at the job level. For that, you should create a class called "PayrollJobListener" that implements the javax.batch.api.listener.JobListener interface. Make sure to decorate the class with the @Named annotation. NetBeans will help you to resolve the missing import and implement the abstract methods : beforeJob() and afterJob().

To use, in the listener, information related to the job instance, we need to inject the job context object.

Rewrite the 2 methods as follow :

The last thing we need to do is to update the JSL to include this listener ans since it is a Job level listener, we should make sure to define it at the job level!

If we run the batch once again, we can observer in the console that the job level listener has been invoked at the beginning (beforeJob() method) and at the end (afterJob() method).

Setting listeners at the level of the job might be, in some cases, too coarse grained. Luckily, JSR 352 allows us to define listeners at the step level.

In the project source directory, create a new java class called "PayrollStepListener". This class needs to implement the javax.batch.api.listener.StepListener interface. Use NetBeans to resolve the import and implements the abstract methods.

You should now have 2 methods : beforeStep() and afterStep()

In the previous listener, we used the Job context but this time, we have also the step context at our disposal. You can inject the step context in your listener.

We will use this context to gather some information. Update the beforeStep() and afterStep() methods as follow (make the necessary changes for the 2nd method).

Now that we have defined the implementation of the listener, we need to update the batch JSL to reference it. Update the step defined in the JSL as follow:

If you run the batch, you will see that our 2 listeners are correctly invoked. You can also notice the listener invokation chain order : job before, step before, step after, job after.

We saw that we can define listeners at the level of a Job and at the level of a Step but this might still be too coarse grained. JSR 352 also allows to define listeners within a step itself.

Before adding this listener, let’s simulate a use case in the application by adding a record. Make sure to respect the format expected by the application : int,salary. For example, fill in "6,10000" and click "add". You can now launch the job. After you have hit "refresh", the displayed results should includes the record you have just added.

Let’s now pretend we did a mistake and add a record using an incorrect format (e.g. "61000"). If you now run the batch again, GlassFish will throw some exceptions as clearly the application can only handle record correctly formated.

Our step is made of a reader, a processor and a writer. JSR 352 allows to also define listener at this level, i.e. within a step. In this example, we will define a listener at the reader level. Typically, such a listener would be used to intervene and handle any misread data by the reader.

In the source directory, create a new java class called "PayrollInputRecordReadListener" and decorate it with the @Named annotation. As we want a reader at the reader level, we need to implements the javax.batch.api.chunk.listener.ItemReadListener interface, so update your class definition accordingly. Use NetBeans to implement the abstract methods of the interface.

We can inject, in our listener, contexts: the job and the step context.

You can remove the body of the beforeRead() and the afterRead() methods as we won’t use them. Change the onReadError() method as follows:

Your PayrollInputRecordReadListener.java listener should now looks like this.

Now that we have defined the listener implementation, we need to configure our job JSL file as follow:

If you test the batch with a incorrect record, you will notice that the Listener is invoked but you can also see that exceptions are still thrown.

To avoid that, we can define a set of exceptions that can be skipped if they are thrown during the execution of the step. To do that, define at the step level in the JSL which exception(s) can be skipped.

The updated JSL should now looks like this (previous listeners have been removed for shortness, you can keep them):

If you try again to run the batch job with an incorrect record, you should get the following output in the GlassFish console.

In this Lab, we learnt how to define and use listener to intervene within the life-cycle of a batch job.