This time it was about web services. We had already decided to write them in Java, and we had a rough idea of the interfaces we were going to expose, but the rest was "carte blanche". This was particularly exciting because, even though I had worked with web services on other projects, this was the first time I was actually going to design web services from the start, so there I was, rolling up my sleeves and reading the Axis2 reference pages.
The other exciting part was that someone else was going to develop an application that would consume my web services, and due to certain timing requirements in their development lifecycle they would have to do their work in parallel with mine. This introduced an interesting challenge: the interfaces would have to be pretty much rock-solid long before any actual web services code was written.
No problem, I thought. We already knew more or less what interfaces we were going to expose, so I can literally code them in Java, build the WSDL from the compiled interfaces and ship the WSDL to the developers on the "consumer project". This way, we can then work out the web services implementation and the consumer implementation independently.
First things first: the contract is not just about the information that a specific method takes as arguments and the information it will spit out as a response. There is a bit more to it. For example, we knew that in our implementation of the web services every method should have a set of "standard" arguments in its request, like the id of the application that originated the request, or the id of the specific language requested by the consumer (e.g. EN, DE, FR, etc). We also knew every method response must include some sort of status code and status message. Finally, we wanted to also include support for digitally signing both the request and the response.
Easy, I thought, we would obviously stick all of these in the relevant super-classes in our implementation, so I created the related super-interfaces in the package that I would use to create the WSDL.
Just for clarity, it worked out to be something like this:
// Base interface for all requests and responses
public interface WebServiceMessage {
public String getSignature();
public void setSignature(String signature);
}
// Base interface for all requests
public interface WebServiceRequest extends WebServiceMessage {
public String getLanguageId();
public void setLanguageId(String languageId);
}
// Base interface for all responses
public interface WebServiceResponse extends WebServiceMessage {
public int getStatusCode();
public String getStatusMsg();
}
// The request for the method doSomething() in the web service
public interface SomeRequest extends WebServiceRequest {
public int getSomeArg();
public void setSomeArg(int someArg);
}
// The response for the method doSomething() in the web service
public interface SomeResponse extends WebServiceResponse {
public int getSomeResult();
public void setSomeResult(int someResult);
}
// This is the actual web service
public interface MyWebService {
public SomeResponse doSomething(SomeRequest request);
}
Just to prove the concept, I carried on and mocked up a basic implementation for a couple more methods, then packaged and published the mock service and proceeded to give it a simple test through SoapUI. I gave SoapUI the address of my service endpoint and it quickly digested the web service's WSDL, presenting all the right methods, which was good... until I asked SoapUI to generate a sample request for one of the methods.
The request was incomplete. There were some elements completely missing. So I checked the WSDL and... shock, horror... the schema for SomeRequest only showed some members but not others!
<complexType name="SomeRequest">
<complexContent>
<extension base="impl:SomeRequest">
<sequence>
<element name="someArg" nillable="true" type="xsd:int"/>
</sequence>
</extension>
</complexContent>
</complexType>
Where were the inherited members, like the language id? Lost. Gone. No trace.
Did I use the wrong arguments in java2WSDL? Nope. It turned out that java2WSDL did not support interface inheritance. Digging around online forums and googling up "java2WSDL support inheritance" unfortunately confirmed that. Apparently this is a limitation of the reflection engine they use in Axis2, to be rectified in a future release.
This exercise has now resulted in a couple of learning points for me.
- even when you think you have identified your assumptions, think again: there are a lot of implicit assumptions (these are the assumptions that are not actually spelled out) in a piece of architecture, and "support for inheritance" is one of those
- after you have identified your assumptions, check them out: it turned out that java2WSDL supported class inheritance, but not interface inheritance
- hold on writing your mocks until you've been through the above: I could have saved a whole day of refactoring if I had waited mocking up the web service until I had checked the WSDL generation
Mea culpa.
M.
