Receive custom exceptions from Restlet Framework in GWT client

Question

I want to use Exception handling with the Restlet Framework and GWT clients. The Restlet Framework supports the concept of annotated exceptions as described in this post;

http://restlet.com/company/blog/2015/12/21/exception-handling-with-restlet-framework/

In my project i created a LocationNameException

@Status(value = 409)
public class LocationNameException extends Exception
{
    ...

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    public LocationNameException(String pMessage, Throwable pCause)
    {
        super(pMessage, pCause);
    }
}

And use this in my ServerResource;

   @Override
    @Transactional(rollbackOn = LocationNameException.class)
    public LocationDto postLocation(LocationDto pLocationDto) throws LocationNameException
    {
        ...

        Location lLocation = new Location(pLocationDto);

        try
        {
            LocationDao lLocationDao = getLocationDao();
            lLocationDao.persist(lLocation);
        }
        catch (PersistenceException pPersistenceException)
        {
            throw new LocationNameException("Location requires unique Name", pPersistenceException);
        }

        ...

        return lLocationDto;
    }

With the interface

public interface LocationListServerResourceInt
{
    ...

    @Post
    LocationDto postLocation(LocationDto pLocationDto) throws LocationNameException;

    ...
}  

This works, in the case of an exception the call returns code 409;

And at the GWT client side onFailure() is called;

private class PostLocationCallback implements AsyncCallback<LocationDto>
{
    ...

    @Override
    public void onFailure(Throwable pCaught)
    {
        mCallback.onFailure(pCaught, mLocationDto);
    }
}

But parameter pCaught only contains a ResourceException with the status code 409. My LocationNameException isn't included in the underlying cause stack. I need this LocationNameException for appropriate error message handling.

The reason is the generated ServerResourceProxy LocationListServerResourceProxyImpl by the Restlet GWT ClientProxyGenerator;

public void postLocation(LocationDto param1, final LocationDto> callback)
{       
    ...

    public void handle(Request request, Response response)
    {
       if (getClientResource().getStatus().isError())
       {       
          callback.onFailure(new ResourceException(getClientResource().getStatus()));
       }
       else
       {

    ...

}

I think i have to rewrite the Post method in the ClientProxyGenerator;

The LocationNameException is present in the Response data so the Basic approach using the getResponseEntity() method of the ClientResource class should be possible.

Is this the way to go? Or can i catch the LocationNameException exception somewhere else as suggested by Catching annotated exceptions?

It is really hard to try a different approach because of the generated code. Is there an easy way to circumvent the code generator with custom classes?

Answer 1

As already mentioned the LocationNameException is present in the Response data. Therefore we can get it, just like a normal entity;

...

       public void handle(Request request, Response response)
        {
            if (getClientResource().getStatus().isError())
            {
                LocationNameException lLocationNameException = null;
                boolean serializationError = false;

                try
                {
                    if (response.isEntityAvailable())
                    {
                        if (MediaType.APPLICATION_JAVA_OBJECT_GWT.equals(response.getEntity().getMediaType()))
                        {
                            lLocationNameException = new ObjectRepresentation<LocationNameException>(
                                    response.getEntity().getText(),
                                    (SerializationStreamFactory) MyLocationListServerResourceProxyImpl.this, false)
                                    .getObject();
                        }
                        else
                        {
                            throw new IOException("Can't parse the enclosed LocationNameException.");
                        }
                    }
                }
                catch (Throwable e)
                {
                    serializationError = true;
                    callback.onFailure(new ResourceException(e));
                }

                if (!serializationError)
                {
                    callback.onFailure(lLocationNameException);
                }
            }
            else
            {

...

The ClientProxyGenerator needs to know the exception type (in this case LocationNameException). Therefore we specify the exception in the ClientProxy interface;

    @Post
    void postLocation(LocationDto pLocationDto, AsyncCallback<LocationDto> pResult) throws LocationNameException;

And use getExceptionTypes() or getGenericExceptionTypes() in the ClientProxyGenerator;

    Class<?>[] exceptionTypes = method.getExceptionTypes();
    java.lang.reflect.Type[] genericExceptionTypes = method.getGenericExceptionTypes();

Of course not all REST methods use a custom exception. When getExceptionTypes() returns an empty list we just return the good old status code;

callback.onFailure(new ResourceException(getClientResource().getStatus()));

Answer 2

With help of Jerome Louvel and Thierry Boileau i created a new ClientProxyGenerator() that supports custom exceptions towards a GWT client;

Just specify the exception from the interface in the ServerResourceProxy (ClientProxy)

and voilà

It is possible to use this custom ClientProxyGenerator() in your project right away.

Download custom ClientProxyGenerator

And place it in a package on the server (for example package com.ludus.server.util)

In GWT module XML change the ClientProxyGenerator to the new version on the server;

And you're ready to go with your custom exceptions, but it would be nice if this extension would be integrated in the Restlet framework.