Originally posted by Ram Chilukuri:
I still am confused as to which business interface (BusinessInterfaceLocal or BusinessInterfaceRemote) the bean should implement. Does it really matter which interface the bean should implement since there is no difference between the business method signatures?
First of all, +1 on the XDoclet suggestion. I can't begin to convey how much happier my programming time is not having to propogate new methods from the bean to the interfaces et al. Two thumbs way up!
XDoclet will generate both your local and remote interfaces, your local and remote home interfaces, and more. It takes some work to get started, so definitely subscribe to the mailing list.
Now, since your remote interface is going to throw RemoteException but the local one won't, you can't use the same interface for both. What I did, however, was use the Service Delegate pattern (might be the wrong name, sorry) in front of my session beans. I started by taking the generated local interface as the business interface. Then there are two delegates that implement that interface: one remote and one local. The only difference between them is that the remote delegate catches RemoteExceptions and throws a ServiceException (unchecked application exception) with the RE as the cause.
Each delegate has a session bean stub that it creates the first time the service is requested. The delegates are regular
Java Beans with accessors for the JNDI factory class, URL, and root. Those are used to connect to the bean. With that, each method simply delegates to the bean (thus the name).
Just last night when I was confronted with creating a third delegate for a new session bean I took the time to refactor the code. Now there is an abstract class hierarchy for the delegates:
ServiceDelegate
LocalServiceDelegate
RemoteServiceDelegate
Those declare the configuration property accessors and the framework for connecting to the bean (catching excceptions mostly). To create a pair of delegates for a new session bean, I create the interface from the generated local interface and create two classes: Local<bean>Delegate and Remote<bean>Delegate. Each extends the appropriate base class and implements the bean's business interface. All they need is one method to connect to the bean and then the actual business methods that are cut-n-paste as they all look the same.
The nice thing is that I can swap out the remote or local delegate with no chnanges to the client. Since I'm using DTOs to pass all data, there are no local/remote artifacts in the delegates themselves. I'm quite sure I could create a template for XDoclet to generate the delegates, too. Maybe that's next week.
