I've created a few of my own annotations that my application uses reflectively at runtime. However, when I have a mapped pojo that gets proxied, I lose the ability to discover my annotations because getClass() returns the proxied class type, not the underlying class type.

I've been using Hibernate.getClass(proxiedClass) to work around the issue, but this is starting to introduce Hibernate classes into layers of my application that do not have to be aware of persistence concerns. From my point of view, if hibernate proxies a class, that should not unduly impact the application using that proxied class.

Unfortunately annotations don't have any real inheritence mechanism. Does anyone have any thoughts about this?

One thing that I can think of would be that somehow proxied classes have their annotations copied over during the proxy process.

Any thoughts or pointers are appreciated.

-Erik

P.S. I realize that strictly speaking, this is more a CGLIB and general Hibernate problem and not specific to EJB3/Hibernte Annotations.

Class annotations can be inherited, but method annotations cannot. This is how Java annotations work.

In our case, there is code that caches annotation information for performance reasons, so there's a handy bottleneck there for me to query for the actual class. I haven't come up with a more elegant solution than that.

As you say, this is more of a CGLIB issue. Seems to me like it might be possible to propagate annotations into the generated class & methods and make the proxying more transparent, but I haven't thought it through all the way.

anders

propagate annotations to subclasses in a generic way is a bad idea IMO.
Usually the annotation reader mechanism goes to the whole hierarchy to find the needed annotations if it makes sense

I can understand the point about not using standard inheritence mechanisms to propogate annotations to a subclass.

However, in this case, Hibernate is injecting the subclass using CGLIB. It would be nice if the annotations were copied onto the subclass so client code could continue to use the class transparently.

// is annotation present on ClassXYZ - yes.

// retrieve an instance (InstanceXYZ) of this class from Hibernate

// is annotation present on InstanceXYZ.getClass() - no.

To your point, checking for the presence of an annotation should probably climb the inheritence tree looking for it rather than just blindly assuming the object's class remains unchanged.

So...

A. It would be nice if Hibernate/CGLIB made the proxies behave the same way as the original class with respect to annotiations.

B. Good OO design principles dictact that when looking for annotations, you should climb the class hierarchy anyhow.