Annotations are the best thing that has happened to Java for a long time. I've been wanting to write up my thoughts on annotations for a long time, but The case against Annotations (via serverside) prompted me to stop being lazy.
I can be hardheaded at times, but the experience of using a technology trumps everything. No matter how good or bad a technology looks, it all come back to whether or not it makes my life as a developer better. Does it make me more productive? Does it make my life easier in some way? Will I get something even better out of it? That's the test. The developer experience using annotations is great.
Right after JavaOne, I wrote the DVD Store application to demonstrate what a complete EJB3 application would look like. I had dabbled with EJB3 and annotations before. I was starting to get the sneaking suspicion that I had misjudged them, but when I sat down to write a complete application, I was completely floored by the development model. I haven't promoted this much, but I actually wrote the DVD Store application over the course of one weekend.
I wrote the entity POJOs sitting at the airport waiting for my flight back from JavaOne. I had the database schema already since this was really a port of a php application used my Dell. So, the persistence consisted of writing classes with getters and setters and annotating a tiny bit to make sure everything mapped to the right tables. If I didn't have to map to existing tables, it would have taken about 20 minutes to finish the persistence tier. The mapping details took the bulk of the time.
After getting back home, I got to work on the web application, using a very simple session bean facade. I don't like facades in general, but for a small app with only a tiny amount of business logic it made sense. EJB3 session beans require almost no annotations. The default transaction management is exactly what you need to work with the entity manager. With the miracle of annotation-drive dependency injection, the code is remarkably light. EJB3 with annotations is spring without all the build-it-yourself micromanagement. The use case is so much simpler that it isn't even funny.
Using JSF on the web tier was a mixed blessing. On one hand JSF is a very easy framework to use and learn, but it doesn't use annotations anywhere. Managing everything in XML again was a bit akward, but configuring managed beans in JSF is no harder than in Spring so it wasn't a huge burden. JSF with annotations to configure the managed beans, and maybe a better view technology like facelets, would have been an even bigger win, but it will take time for web frameworks to simplify the way EJB3 has.
It may sound like I'm promoting EJB3 here. My overall point is not that it EJB3 is great but that it is great because annotations work so well. It's all about the developer experience, and the developer experience is very liberating. Annotations let the developer work quickly and efficiently. Annotations let you write simple POJO objects while giving hints to the environment about how the object should be treated. If configuration-by-exception is the guiding policy, you end up only needing to annotate very lightly.
I've gone a bit longer than I thought, so I'll leave by once again encouraging you to try it for yourself. EJB3 is the best example of how annotations work right, but it's only the first of many. I'll talk about where I think annotations are going in another post. But, having seen some of the annotation-based frameworks in development, I can safely say that we've only touched the surface of what annotations can do. Annotations open up a lot of very interesting doors, and it's for that reason I think they are by far the best thing that has happened to Java in a long time.
Previous Topic
