Fabio Cepeda

Archive for the ‘Spring’ Category

Aware of the application context in the service layer.

Last night, I spent a few hours understanding how to load a file from a class in the service layer of my webapp that did not have access to the application context. I started using DefaultResourceLoader class to load the file with:

DefaultResourceLoader loader = new DefaultResourceLoader();
File file = loader.getResource(“file:”+filePath).getFile();

It worked on my windows environment, but when tested on Ubuntu it trhew an FileNotFoundException, the reason for this was that the ClassLoader used by the DefaultResorceLoader default constructor is the ClassLoader of the current Thread so the initial path was somewhere in /etc/init.d/, I tried using different prefixes without good results.

After investigating about Resources in the Spring Documentation I found that most of the resources are easily resolved when you have access to the aplication context, so I look how the form controllers had this access and found this useful class: ApplicationObjectSupport

Therefore, I had my class extend ApplicationObjectSupport and I was able to load the file using:

ApplicationContext ctx = getApplicationContext();
File file = ctx.getResource(xslPath).getFile();

The xslPath being something like WEB-INF/xsl/test.xsl

Some questions after this:

1. Is expensive to call the getApplicationContext()?
2. What class loader can be used for DefaultResourceLoader so that the file can be loaded?



These last two weeks I’ve been re-working on dynamically binding a list of objects using SpringMVC. My goal is not to loose the elements in the collections when an error happens in the submission of the form. Right now I am adding and deleting collection elements using jQuery, and DWR excellent javascript libraries by the way.

Some history of the problem:

The first attempt used what Matt Raible used initially in Appfuse 1.8 long time ago, where a select list was used to group the elements of the collection and at submission the collection was formed in the onSubmit method of the form controller. The second attempt used a new kind of editor in spring called CustomCollectionEditor and also followed some later findings of Matt Raible. In this solution, spring was able to form a collection of objects of any type by overriding the convertElement() method in the initBinder() method. This solution clear up the code in the onSubmit() method and move it where it belongs. The addition and deletion of objects in the collections is managed by javascript, but this causes to lose the elements of a collection in the presence of an error during form submission.

For right now, I have opted to avoid the binding errors through optical cues in the form so that the user can select what is suppossed to. One thing that I discover is that if you want to have the elements binded when added to the collection with javascript you will have to exposed this functionality through DWR and make sure the element gets persisted. In my case this complicate things since the collection element is a fairly complex and large POJO. Maybe there is another way, using onBind or those methods to make sure the collection is binded. I’ll check into that and post my findings later.


I develop a java web application that uses a lot of type objects. For example, Object Visit has a property state that could be Programmed, Done, Cancelled, etc… The current solution for this is to have a table in the DB representing the state of the visit and a FK from the table visit to the table with the states. Within the layers of the code the state is manage as an Entity with its own CRUD implemetation.

When you have a lot of object value types this could add up a lot tables in your DB and code in your application. In some cases I guess is ok to have CRUD functionality, but in others I wish the process could be shorter. For example: types that are not reusable and unique to a particular POJO. So, I was thinking of a way to be able to reduce some of the states or types using enum types throughout my application.

Today, I researched about how to map a JAVA 5 Enum type to a MySQL enum in order to be used with a web application that uses Spring.

Here, some of my findings:

I found these good article on how to deal with the Hibernate part, it seems straight forward:


For the Spring part, I guess it is just a matter of writing the PropertyEditor

Doubts still remaining:

Will that solution above, map the Enumeration to a enum type in MySQL? Does Hibernate supports this? Is it better to map the elements of an enumeration to another table in the DB or having it inside your main table as a MySQL enum is better?

Will mapping the JAVA enumeration to the MySQL enumeration saves time when adding a new type?

Here are some disadvanges:

From what I read, it seems you have to recompile your code when you have a JAVA enumeration and you want to add and extra element to it. In the current solution, you only have to add that value in the DB and Hibernate can deal with it without a recompile.

Some Advantages:

Enumeration could make your code cleaner making it easier to code tests for states and types comparissions. Surely it will be less verbose and easier to read.