Replacing dao layer

Question

I am developing a series of webservices (based on spring and spring mvc).

For the first time in my dev career I do plan on replacing the dao layer in the future(I have always seen it mentioned but never had to do it).

Currently I'm using spring annotations, so I could simply change the qualifier name of the injected dao in each place it is used; is there a better (global) mechanism I could use ?

Currently my code looks like this (declaring the dao) :

@Repository("regionDao")
public class RegionDao implements IRegionDao

and Injecting it :

@Resource(name = "regionDao")
IRegionDao regionDao;

But going into each service class and changing the qualifier name seems rather long winded, is their a better way. Basically in the future I want to flip a switch and each reference to a regionDao will then point to newRegionDao and so on for other dao's.

A solution using annotations is preferred- for no other reason than I subjectively prefer them. But I realize this may be a case for xml based config ?

Answer 1

You can add a layer of indirection by using property placeholders for class names:

< bean id="regionDao" class="${com.wibble.newRegionDao}" >

And then configuring DAOs class names in the property files.

I agree with other posters that this is possibly overkill to do this for a task you'll do as rarely as changing your persistence back end.

[This technique is possibly more useful in integration testing scenarios by the way - where you for instance want to run tests against one data store or messaging provider and run in production against another.]

http://static.springsource.org/spring/docs/1.1.5/api/org/springframework/beans/factory/config/PropertyPlaceholderConfigurer.html

Answer 2

Personally I fail to see what could be easier than changing the name of the Resource that I am injecting into my Service classes and integration tests. Even in a large system where you have hundreds of DAO's this will only take you what, 2 hours at most? And besides, you can just make an intern or fresher do it :)

For a truly one step process, I suggest configuring Spring through XML documents however. I know this isn't what you want to hear because I personally love Annotation based configuration as well, but considering that you anticipate a high likelihood of shifting data layers in the future then this could be a better idea for a number of reasons.

Also consider a system that you may need to deploy into very different configuration environments, possibly for different customers. Where I work we are a software vendor and our two major clients for one of our products both have different needs to host our software. One client has an enterprise license to Oracle, while the other has an enterprise license to SQL Server, neither of which want to spend additional money on database licenses and support for a single system, and rightfully so.

Creating a seperate Spring DAO configuration XML for each client at that point becomes a necessity for an automated build script that include the appropriate DAO configuration XML for the client build in question. So basically as clean as annotations may look and as easy as it makes deciphering the purpose and configuration of a class, annotations are essentially useless to me in this scenario.