So instead of designing the WSDL along with the matching schema definition for the connector classes, I decided to start of by designing the interfaces and the connector classes, then just create the implementation with the corresponding annotations on the server side, that will be deployed automatically. The WSDL is generated from the annotations and the connector classes, there is no need to write them manually.

Take the following example. The web service has a simple method to query a list of items, that can throw a simple exception when the database is unreachable.

import java.util.List;

import dummy.ws.type.Item;

public interface ItemService {
    public List<Item> getItemList() throws ItemException;
}

with the implementation example like:

import java.util.List;

import dummy.ws.type.Item;

import javax.jws.WebMethod;
import javax.jws.WebService;

@WebService(serviceName = "ItemService", targetNamespace = "http://dummy/ws", portName = "ItemPortType")
public class ItemServiceImpl implements ItemService {
    @WebMethod
    public List<Item> getItemList() throws ItemException {
        // TODO implementation comes here
    }
}

can be invoked with the following simple code

...
    Service service = Service.create(new URL(URLBASE
                     + "/ItemService?wsdl"), new QName(
                     "http://dummy/ws", "ItemService"));
    ItemService itemService = service.getPort(new QName(
                             "http://dummy/ws", "itemPortType"),
                             ItemService.class);
    List<Item> itemList = itemService.getItemList();
...

There are several problems with this, even though it would be great to have it working right away. It could actually work, if there were no Collections involved on the return value. So creating a simple wrapper class for the return value like:

package dummy.ws.types;

import java.util.List;

public class ItemList {

        private List<Item> content;
        public ItemList() {
        }

        public ItemList(List<Item> content) {
               this.content = content;
       }

        public List<Item> getContent() {
                return content;
        }

        public void setContent(List<Item> content) {
                this.content = content;
        }
}

along with the modification of the interface and of course the implementation to use the newly created class should break the ice.

There is another shortcoming to this method yet. The thrown exception must contain a constructor with (String, Object) parameters, and an Object getFaultInfo method. Took me quite a time to figure it out, as there is a huge gap in the documentation when you try this. Once you’ve done that you are ready to deploy.

In the project we are using WebSphere Application Server Community Edition, which is an Apache Geronimo based quite stable and fast server. The WAS CE uses Axis2 for web service implementation. The rich client we implemented used the latest Axis2 libs.

The whole thing worked well until the middle of the project, when all of a sudden, without any major change that we could trace, the client suddenly started throwing JAXB exceptions (classname nor any of its super class is known to this context). This could only be cured by creating the jaxb.index in the ws.types package with all the connector classnames listed in it, along with an ObjectFactory that has a XXX createXXX () method for each ws.type class. Intrestingly however this class, while mandatory is never touched by the code, the class is not even loaded!

On the whole this approach provided a really quick and a bit dirty way of using the web services in a single project. However I would not dare to use it on a bigger scale. I still consider starting from the WSDL and the schema, then generating the interfaces and the connector classes from them the best approach.

I know this is Hungary, but I very much fear this is also the case for most countries and most companies.

Take one of my last tasks as an example, I cannot be allocated for another project, but I was “borrowed” for a couple of days to set up a project environment for a very urgent and important job. The project was then handed over to two less then qualified developers. It was fun to set the project up, as the technologies I’ve chosen integrated nicely and resulted in an easy to maintain, compact environment. However I was forced to skip adding unit testing, as there was no way the project would fit writing a single test case.

Anyway I was going to write about the project itself and not mourn about the problems I can’t help.

The project is planned on simple grounds, there is a need for a GUI client, as a quite sophisticated editor is required. There is a need for small simple clients, so the the users would be able to use it with a relatively small configuration. The software delivery should be simple, so it would not burden the helpdesk. There is a need for security, as the application has some financial perspective to it. The project must be simple, so the not to advanced developers would be able to finish it. Ah yes, and I have two days to bang it together.

Well… Let’s start… The main constraint is the developers, they know some Hibernate, they know some Java, but know nothing about WSDL. Then the technology, to be easily deliverable it’s best to use Webstart, this will zero the deploy costs choosing Swing as the windowing environment enables the developers to use visual editors to bang some forms together, while reduces the deployment size greatly, if we consider the SWT alternative. The application will communicate with the server through web service through SSL to ensure security.

I have thus set up a project which contains both the client and the server code and the common codebase as well (the interfaces and POJOs used in web services), there is an ANT script to generate the WSDL, the code for Axis based web service classes, and the Hibernate POJO, and DAO-s. The generated code is stored in it’s respective folders, separated from the handwritten code. The ANT script is then compiles the files and it is also able to create the WAR and deploy on either Tomcat or WebSphere Application Server. The project is set up in an Anthill to ensure that at least the developers are notified if their committed code breaks the application.

Even though I’ve created this environment as simple as humanly possible, when I handled it over to the developers-to-be they were less than understandig.

I can only hope they don’t mess it up too bad.