Bean Builder II: Modeling Java Beans

BeanBuilder main use case

On a previous entry the requirements for BeanBuilder were sketched. The basic idea is to use a configuration file as a poor-man way to model a hierarchy of JavaBeans, and then generate Java source code from that.

So, what format should I use for this configuration file? Mmmm... there're lots of options. Let me review some of them.


A simple approach could be to use plain Java files annotated with Xdoclet tags. The problem is that XDoclet seems to be dead (version 1.2.2 was released in 2004!), and I won't resurrect it just to build some plain POJOS, right?

... or Eclipse EMF...

Another option would be, of course, to use the Eclipse Modeling Framework. Eclipse's EMF seems appealing, but too heavy for just building some JavaBeans, right?. A quick look at Eclipse EMF reveals:

While EMF uses XMI (XML Metadata Interchange) as its canonical form of a model definition[1] , you have several ways of getting your model into that form:

  • Create the XMI document directly, using an XML or text editor
  • Export the XMI document from a modeling tool such as Rational Rose
  • Annotate Java interfaces with model properties
  • Use XML Schema to describe the form of a serialization of the model Eclipse EMF Overview

Wait, wait. I have to model my JavaBeans using Rational Rose? No way, dude!

... or Java annotations...

Someone suggested using Java annotations for describing what my JavaBeans should look like. I could use @JavaBean and @Property and @BoundProperty or whatever.

That's an interesting approach, but if I annotate Java source code with annotations I would depend on the annotations, right? And that violates one of my requirements: have as little dependencies as possible. Can we make any better?

... or a Domain Specific Language...

Another approach would be creating a Domain Specific Language for building JavaBeans.

I could do that quickly with, say, Scheme or Lisp.

But, you know, I think there's a better approach:

... or XML Schemas (and or Relax NG)

Another approach is using XML Schema files. These seem to be quite popular. Some benefits I can think of:

  • Good XML Schema editors out there. NetBeans' is terrific!.
  • Lots of existing public repositories of XML Schemas that I can use to model my JavaBeans. From "Bookmarks" to "VectorImages", lots of stuff out there just ready to use.
  • No dependencies at all. I mean, just download the XML Schema (or create a new one) and I'm all set.
  • JAXB code generation. Of course. I can use XML Schemas or Relax NG to define how my JavaBeans are going to look like.

So, unless you have a better alternative, I think I'll choose XML Schemas for defining the structure of the generated JavaBeans.

Happy bean-building!


blog comments powered by Disqus