Jethro Borsje

personal website

  • Increase font size
  • Default font size
  • Decrease font size

2014-01-18 - Hiking @ Hitland

In January we went hiking in Hitland a couple of times, one of those times was Saturday the 18th of January. The weather here in The Netherlands is very warm for this time of year, so instead of ice skating we plan to go hiking regularly. During our visits to Hitland we saw various types of birds. The most notable one was the Great Egret also known as the White Heron. Although the Grey Heron is very common in The Netherlands the White Heron is seen here less often (although it is not rare). We didn't spot the White Heron before in Hitland, but this year we've seen a few of them on several different occasions. It is nice to see that the diversity of birds is increasing in Hitland. Other birds we saw this year include the Gadwell, the Common Pochard and the Red-crested Pochard.

Bellow are some pictures of the 18th:

 

2014-01-12 - Hiking @ Meijendel

On Sunday the 12th of January we went hiking with the three of us for one of the first times. We decided to go to the Meijendel which is a coastal area near The Hague. The area is comprised of dunes and woods and is a nice place to go for a hike. In the weekends it can be a bid crowded, especially if the weather is nice like it was on the 12th. When we arrived it was less crowded than we expected and we ended up hiking about 7km without to much crowds.

Bellow are some pictures of this hike:

Last Updated on Tuesday, 25 February 2014 15:24
 

2014-02-01 - Ice skating @ Rotterdam

Last Saturday I went ice skating again. It has been a busy week at work so I decided to take it easy and go skating a little shorter than usual. I skated for about an hour and did 51 laps (20,4 km). It will probably stay busy at work for the next couple of weeks, so I'm not sure if I will make it to my goal of 100 laps anytime soon this season.

 

2014-01-25 - Ice skating @ Rotterdam

Today I went ice skating at schaatsbaan Rotterdam again. Last week I wasn't feeling so good so I skipped ice skating for a week. This time around I felt pretty good so I felt comfortable about achieving my goal set last time which was skating at least 75 laps (30 kilometers). I reached the 75 laps quite quickly so I decided to continue until the scheduled track maintenance started. I ended up skating 83 laps (33,2 kilometers). Hopefully next time I will reach 85 laps. My ultimate goal is to reach the 100 laps again somewhere this season.

 

Spring @Async and exception handling

Introduction

When using Spring to asynchronously execute pieces of your code you typically use the @Async annotation on your Spring @Components methods. When using the @Async annotation Spring will use AOP (Aspect Oriented Programming) to wrap your call in a Runnable. This Runnable will then be scheduled for execution on a TaskExecutor. More information about asynchronous execution and its transactional context can be found here.

Exception handling

Spring comes with a number of pre-packaged TaskExecutors which are documented in the Spring documentation here. In practice you will likely use the ThreadPoolTaskExecutor or the SimpleAsyncTaskExecutor. When doing so you might at times wonder why a task has not been executed. This happens when an exception occurs inside the method you are trying to execute asynchronous. The aforementioned task executors do not handle the exceptions so the execution fails silently. This problem can be solved by implementing your own AsyncTaskExecutor which handles the exceptions by logging them (or in any other way you wish). Bellow you'll find an example implementation of such a AsyncTaskExecutor.

package nl.jborsje.blog.examples;

import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import org.springframework.core.task.AsyncTaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

public class ExceptionHandlingAsyncTaskExecutor implements AsyncTaskExecutor {
    private AsyncTaskExecutor executor;

    public ExceptionHandlingAsyncTaskExecutor(AsyncTaskExecutor executor) {
        this.executor = executor;
    }

    public void execute(Runnable task) {
        executor.execute(createWrappedRunnable(task));
    }

    public void execute(Runnable task, long startTimeout) {
        executor.execute(createWrappedRunnable(task), startTimeout);
    }

    public Future submit(Runnable task) {
        return executor.submit(createWrappedRunnable(task));
    }

    public  Future submit(final Callable task) {
        return executor.submit(createCallable(task));
    }

    private  Callable createCallable(final Callable task) {
        return new Callable() {
            public T call() throws Exception {
                try {
                    return task.call();
                } catch (Exception ex) {
                    handle(ex);
                    throw ex;
                }
            }
        };
    }

    private Runnable createWrappedRunnable(final Runnable task) {
        return new Runnable() {
            public void run() {
                try {
                    task.run();
                } catch (Exception ex) {
                    handle(ex);
                }
            }
        };
    }

    private void handle(Exception ex) {
        System.err.println("Error during @Async execution: " + ex);
    }
}

This task executor decorates another task executor and wraps all Runnables and Callables in versions which handle the exception. In order to be able to use this task executor it has to be configured in the Spring application context as a managed bean and it has to be passed the real executor (the one that does the actual work) in its constructor. An example of such a configuration can be found bellow.



    



JUnit testing

In the application context used for JUnit testing Spring beans the asynchronous execution of methods can be cumbersome. You typically want to validate the inner workings of your methods not Springs asynchronicity. To achieve this you can use the SyncTaskExecutor provided by Spring. This task executor runs the tasks it is given immediately on the thread that adds the task instead of using a thread pool and running the tasks asynchronous. This task executor is configured in the test scope application context as follows.




Last Updated on Sunday, 26 January 2014 09:12
 


Page 2 of 4

JoomlaGATor!

Latest Comments


Recently played

My apps

Who's Online

We have 31 guests online