Random Thoughts

How to use Velocity to generate code in GWT

2012-01-28T21:44:00.000+01:00

The JSON/XML mapper Piriti is heavily based on deferred binding and code generation. As I started to implement code generators in Piriti I looked around how other projects deal with it and read thru the ofiicial documentation on the GWT site. The usual way to generate code is to extend com.google.gwt.core.ext.Generator and then call GeneratorContext.tryCreate(TreeLogger, String, String). The returned PrintWriter is then often wrapped into somekind of IndentedWriter like the one used by GWT itself. This class adds methods to indent and unindent code and supports printf() like behaviour. Finally the writer is used to generate all code. This in turn results in code which looks like that:

writer.write("%s %s = null;", parameterizedValueType, value);
writer.write("List<Element> %s = filterElements(element.selectNodes(\"%s\"));", elements, property.getPathOrName());
writer.write("if (!%s.isEmpty()) {", elements);
writer.indent();
writer.write("%s = new %s<%s>();", value, collectionImplementation, elementType);
if (property.isConverter()) {
  // even more writer.write() statements
}
writer.write("for (Element currentElement : %s) {", elements);
writer.indent();
writer.write("%s currentValue = null;", elementType);
writer.write("XmlReader<%1$s> currentReader = xmlRegistry.getReader(%1$s.class);", elementType);
writer.write("if (currentReader != null) {");
writer.indent();
writer.write("currentValue = currentReader.read(currentElement);");
writer.outdent();
writer.write("}");
writer.write("if (currentValue != null) {");
writer.indent();
writer.write("%s.add(currentValue);", value);
writer.outdent();
writer.write("}");
writer.outdent();
writer.write("}");
writer.outdent();
writer.write("}");

I can't help, but this code somehow reminds me of the old times, where we generated HTML code in servlets. This approach might work as long as the amount of generated code is small. In Piriti the code generation process is somewhat complex and distributed over several classes. Changing the generated code became very difficult and error-prone. Only the correct use of writer.indent() and writer.outdent() is not a trivial task. To some extent this problem can be solved by the use of an abstract base class, which contains common code. The generated class would extend from the abstract base class. But at the end of the day you have to generate some code in the concrete subclass.

Velocity to the rescue
Velocity is a Java-based template engine. It permits anyone to use a simple yet powerful template language to reference objects defined in Java code. Velocity supports for loops, if-then-else conditions and custom macros. Templates can include other templates. This way you can put common code in extra templates and reuse it in other templates. Velocity is mainly used in web projects for HTML generation. Another common use case is to generate email bodies. But there's no reason not to use Velocity for code generation in GWT.

Doing so the above code snippet becomes something like that:

$parameterizedValueType $value = null;
List<Element> $elements = filterElements(element.selectNodes("$property.pathOrName"));
if (!${elements}.isEmpty()) {
  $value = new $collectionImplementation<$elementType>();
  #if ($property.converter) #createConverter() #end
  for (Element currentElement : $elements) {
    $elementType currentValue = null;
    XmlReader<$elementType> currentReader = xmlRegistry.getReader(${elementType}.class);
    if (currentReader != null) {
      currentValue = currentReader.read(currentElement);
    }
    if (currentValue != null) {
      ${value}.add(currentValue);
    }
  }
}

If you compare the two code snippets you get the idea! The velocity based code is much more readable. As you can see the velocity template contains variable references like $elements. Before the template is rendered all necessary variables must be put into the so-called Velocity context which is more or less a big map. If the variable refers to a java object you can use its properties and even call methods.

To use Velocity for code generation you have to setup the Velocity engine, create the Velocity context and merge the template. In Piriti the engine is configured with the following properties:


velocimacro.library = name/pehl/piriti/rebind/propertyMacros.vm
runtime.log.logsystem.class = name.pehl.piriti.rebind.VelocityLogger
input.encoding = UTF-8
output.encoding = UTF-8
resource.manager.logwhenfound = true
resource.manager.defaultcache.size = 0
resource.loader = cp
cp.resource.loader.class = org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader
cp.resource.loader.cache = false

Finally the code generation process is reduced to the following lines:

PrintWriter printWriter = generatorContext.tryCreate(treeLogger, somePackage, implName);
if (printWriter != null)
{
  VelocityContext context = new VelocityContext();
  // Put all neccesarry objects into the velocity context
  context.put("foo", ...);

  InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream(“name/pehl/piriti/rebind/velocity.properties”);
  Properties properties = new Properties();
  properties.load(inputStream);
  VelocityEngine velocityEngine = new VelocityEngine(properties);
  velocityEngine.mergeTemplate("someTemplate.vm", "UTF-8", context, printWriter);
  generatorContext.commit(treeLogger, printWriter);
}

If you want to delve deeper into the code generation process in Piriti, check out the trunk and take a look into the code.

Announcement: Piriti 0.7.0b1

2011-05-09T23:12:00.003+02:00

I'm pleased to announce the first beta of the upcoming Piriti 0.7.0 release. Piriti 0.7.0 is a major release with breaking API changes, lots of new features and bugfixes.

Breaking API Changes:

Piriti requires GWT 2.2 and GIN 1.5
Dropped GXT support
Removed @Json, @JsonMappings, @Xml and @XmlMappings annotations

New Features:

Devided Piriti into different modules:

name.pehl.piriti.commons.Commons
name.pehl.piriti.converter.Converter
name.pehl.piriti.json.JSON
name.pehl.piriti.property.Property
name.pehl.piriti.xml.XML

Simplified mapping setup: All properties in a POJO hirarchy are now mapped by default
Added new annotations to overide default behaviour:

@Order
@Path
@Format
@Native
@Transient
@CreateWith
@MapUpTo

Added @Mappings and @Mapping annotation for external mappings (JSON and XML)
Added support for polymorhic assoziations
Converters can now be used for any type
Added XML serialisation (not yet implemented, but scheduled for the 0.7.0 release)
Added support for IDs and IDREFs in JSON (not yet implemented, but scheduled for the 0.7.0 release)

Bugfixes:

Fixed problems when mapping collection implementations
GWT.create() is now used instead of new operator

I also restructured the wiki and added a FAQ and a comparison to other JSON / XML mappers. Feel free to visit http://code.google.com/p/piriti and test the new release.

Taoki and TiRe mentioned in GWT-GAE-Book

2010-12-03T08:48:00.000+01:00

Taoki and TiRe are mentioned in the free online book on GWT and AppEngine
development by Marius Andreiana.

The book covers also a lot of GWTP and its core examples are great illustrations for many features of the framework! It also makes use of Gin, Guice, Twig-Persist, Mockito and many other useful tools.

Go check it out: http://code.google.com/p/gwt-gae-book/

Many thanks to Marius for such a valuable resource, and congratulations on publishing it!

Announcement: Piriti 0.6

2010-10-27T15:52:00.000+02:00

I'm pleased to announce Piriti 0.6. This is a major update which adds support for JSONPath expressions. Please take a look at the release notes for further info.

TiRe - Time recording made easy

2010-10-03T22:53:00.005+02:00

Currently I'm developing a personal time recording tool based on GWT and deployed at Google App Engine. Besides being useful I wanted to use the latest web techniques / frameworks in a real application. TiRe uses the following stack:

Work is still in progress. But you can take a first look at TiRe following the link below. One last note: TiRe uses some of the new HTML5 / CSS3 features and therefore requires a modern browser.

http://tire-d8.appspot.com/

Paging in resources

2010-09-13T11:21:00.002+02:00

A common requirement for resources which return large collections of records is paging. Paging can be implemented in many different ways. See the following pages as an entry point to the discussion:

In the following sections I will introduce three different solutions. All of them are implemented in Taoki - a small extension for Restlet.

Template Parameter

This implementation uses parts of the url to carry the paging information:

GET /books
GET /books/0/50
GET /books/0/50/author/asc

The advantage of this implementation is that the resource can be cached by proxies. The drawback is that a lot of template parameters are "wasted". For example /books/report/{quarter} won't be available as route, since it is occupied by /books/{offset}/{pageSize}

Query Parameter

This implementation uses query parameter.

GET /books
GET /books?offset=0&limit=50
GET /books?offset=0&limit=50&sortField=author&sortDir=asc

Most proxies won't cache resources which include parameters, but there are no template parameters wasted.

Custom Header

This implementation uses the custom header Item-Range.

GET /books
GET /books
Item-Range: items=0-49
GET /books
Item-Range: items=0-49;author:desc

It combines the advantages of the other two implementations. A minor drawback of this solution is that the paging information is no longer visible in the URL.

Announcement: Piriti 0.4

2010-07-07T16:28:00.000+02:00

I'm pleased to announce Piriti 0.4. This is a major update which adds support for namespaces in XML document and XPath expressions. Please take a look at the release notes for further info.

New XML parser for GWT

2010-07-07T13:37:00.000+02:00

I'm pleased to announce the first release of Totoe. Totoe is a XML parser for GWT which comes with XPath and namespace support. It originated from Piriti a JSON and XML mapper for GWT.

Totoe uses Sarissa for the XML parsing. Sarissa is a great cross browser XML parser for javascript. Essentially Totoe is a GWT port of Sarissa with the goal to offer a similar API as the GWT XML module. Right now the focus is on parsing XML - there are no methods to create, insert or append documents, elements or nodes. Those features might come in later releases. The big advantage over the GWT XML module is IMHO a cleaner API and the support of XPath and namespaces.

Announcement: Piriti 0.3.5

2010-06-18T17:19:00.003+02:00

I'm pleased to announce Piriti 0.3.5. This is a minor update which fixes some bugs and changes the way JSON data is parsed. Please take a look at the release notes for further info.

I'm still looking for a clever way to include namespace support into Piriti. So if there's anybody out there with a namespace aware XPath implementation that works in IE, contact me!

Announcement: Piriti 0.3.1

2010-03-26T14:07:00.000+01:00

I'm pleased to announce Piriti 0.3.1. Piriti is a JSON and XML mapper for GWT. It is based on annotations and deferred binding. Here are some of the features:

Built-in support for many types (primitives, String, Date, Enums, ..)
Possibility to specify date and number formats
Support for mapping arrays and collections
Flexible XML mapping using XPath expressions
GXT extension for mapping to GXT models
Restlet extension built on top of the Restlet GWT edition

If you want to learn more about Piriti here are some links where you can start:

Project page: http://code.google.com/p/piriti/
Getting started: http://code.google.com/p/piriti/wiki/GettingStarted
Sample application: http://piriti-sample.appspot.com/

Sample application for Piriti

2010-03-26T12:11:00.001+01:00

I created a sample application for Piriti which demonstrates its basic features:

http://piriti-sample.appspot.com/

The sample provides a 'books' resources which returns three books. The resource is available in two representations:

XML
JSON. To see the representation use some kind of rest client (e.g. RESTClient for Firefox), call 'http://piriti-sample.appspot.com/rest/v1/books' and set the 'Accept' header to 'application/json'

The sample has links to request each representation and convert the results to POJOs and GXT models. For each request the relevant source code plus the processing time (without network traffic) is displayed.

The full source code of the sample application is available in the subversion repository or as seperate download.

Restlet extension of Piriti

2010-03-25T09:49:00.005+01:00

Restlet is a RESTful Web framework for Java. There's also a GWT edition available. The Piriti Restlet extensions is built on top of that edition. Therefore the 2.x version of Restlet is used. There are two representations available which use the Piriti readers to convert JSON and XML data to your model (POJOs and/or GXT models).

Read and convert JSON
To read the JSON data you need an instance of JsonReader<T>:

public class Book
{
    interface BookReader extends JsonReader<Book> {}
    public static final BookReader JSON = GWT.create(BookReader.class);

    // Fields annotated with @JsonField
    ...
}

Then you can read the JSON data like this:

ClientResource clientResource = 
    new ClientResource("/resource/with/json/representation");
clientResource.setOnResponse(new Uniform()
{
    @Override
    public void handle(Request request, Response response)
    {
        PiritiJsonRepresentation<Book> representation = 
            new PiritiJsonRepresentation<Book>(Book.JSON, response.getEntity());
        try
        {
            // Depending whether there's one book or an array of books
            // in your JSON data
            List<Book> books = representation.getModels();
            Book book = representation.getModel();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
});
clientResource.get(MediaType.APPLICATION_JSON);

The entity returned by the resource has to be a valid JSON object. In case you want to read a list of books, the JSON object has to contain one key (name does not matter) with the array of books:

{books: [{isbn: "0815", title: "Foo"}, {isbn: "1234", title: "Bar"}]}

Read and convert XML
To read the XML data you need an instance of XmlReader<T>

public class Book
{
    interface BookReader extends XmlReader<Book> {}
    public static final BookReader XML = GWT.create(BookReader.class);

    // Fields annotated with @XmlField
    ...
}

Then you can read the XML data like this:

ClientResource clientResource = 
    new ClientResource("/resource/with/xml/representation");
clientResource.setOnResponse(new Uniform()
{
    @Override
    public void handle(Request request, Response response)
    {
        PiritiXmlRepresentation<Book> representation = 
            new PiritiXmlRepresentation<Book>(Book.XML, response.getEntity());
        try
        {
            // Depending whether there's one book element or a list of book
            // elements in your XML data
            List<Book> books = representation.getModels();
            Book book = representation.getModel();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
});
clientResource.get(MediaType.TEXT_XML);

The entity returned by the resource has to be a valid XML document. In case you want to read a list of books, the document must contain a list of book elements as direct children of the root element:

<books>
    <book>
        <isbn>0815</isbn>
        <title>Foo</title>
    </book>
    <book>
        <isbn>1234</isbn>
        <title>Bar</title>
    </book>
</books>

Further information
If you want to learn more about Piriti and its extensions, please feel free to take a look at it under http://code.google.com/p/piriti/

JSON Mapping in Piriti

2010-03-22T12:11:00.004+01:00

Following a proposal by Jerome Louvel, I added JSON mapping to Piriti. Piriti is a JSON / XML mapper for GWT based on annotations and deferred binding.

To map JSON data you have to annotate your model classes with @JsonField annotations. In case you have the following JSON structure:

{
    isbn: "978-0345417954", 
    pages: 432,
    title: "The Hotel New Hampshire",
    author: {
        firstname: "John",
        surname: "Irving", 
    },
    reviews: [
        "A hectic gaudy saga with the verve of a Marx Brothers movie.", 
        "Rejoice! John Irving has written another book according to your world.", 
        "Spellbinding, intensely human, a high-wire act of dazzling virtuosity."
    ]
}

You can use the following code to map the JSON data to your model:

public class Book
{
    interface BookReader extends JsonReader<Book> {}
    public static final BookReader JSON = GWT.create(BookReader.class);

    @JsonField String isbn;
    @JsonField int pages;
    @JsonField String title;
    @JsonField Author author;
    @JsonField List<String> reviews;
}

...

public class Author
{
    interface AuthorReader extends JsonReader<Author> {}
    public static final AuthorReader JSON = GWT.create(AuthorReader.class);

    @JsonField String firstname;
    @JsonField String surname;
}

...

String jsonString = ...; // The JSON structure (see above) 
Book book = Book.JSON.read(jsonString);

To learn more about piriti take a look at code.google.com/p/piriti/.

Restlet and Google Guice

2010-02-15T17:39:00.001+01:00

In an earlier post I described how to configure resources with Google Guice. I decided to move the relevant code to a small library called "Taoki" (Maori for "rest").

Besides the features described in the initial post, I added the possibility to configure security for resources. The details will be described in a separated post.

For those interested, take a look at http://code.google.com/p/taoki/.

XML Mapper for GWT

2010-01-14T17:41:00.004+01:00

I'm a big fan of RESTful architectures. When using REST resources with XML representations in combination with GWT you have to parse the XML and map it to the model used in the GWT client. The code therefore is tedious and error-prone. So I decided to start a little framework called "piriti" (Maori for bridge). It is hosted on goolge code under code.google.com/p/piriti/. The basic idea behind piriti is to use annotations on your model and generate the parsing / mapping code with the help of deferred binding.

Let's assume you have a REST resource for a book which produces the following XML representation

<book>
    <isbn>978-0345417954</isbn>
    <pages>432</pages>
    <title>The Hotel New Hampshire</title>
    <author>
        <firstname>John</firstname>
        <surname>Irving</surname>
    </author>
    <reviews>
        <review>A hectic gaudy saga with the verve of a Marx Brothers movie.</review>
        <review>Rejoice! John Irving has written another book according to your world. You must read this book.</review>
        <review>Spellbinding, intensely human, a high-wire act of dazzling virtuosity.</review>
    </reviews>
</book>

On the GWT client you have the following model classes

public class Book
{
    String isbn;
    int pages;
    String title;
    Author author;
    List<String> reviews;
}

public class Author
{
    String firstname;
    String surname;
}

To map the XML to your model, all you have to do is annotate the relevant fields in your model and define an interface of type XmlReader<T>

public class Book
{
    interface BookReader extends XmlReader<Book> {}
    public static final BookReader XML = GWT.create(BookReader.class);

    @XmlField String isbn;
    @XmlField int pages;
    @XmlField String title;
    @XmlField Author author;
    @XmlField("reviews/review") List<String> reviews;
}

public class Author
{
    interface AuthorReader extends XmlReader<Author> {}
    public static final AuthorReader XML = GWT.create(AuthorReader.class);

    @XmlField String firstname;
    @XmlField String surname;
}

Now you can map the XML to your model by calling

Document document = ...; // XML representation of the book resource
Book book = Book.XML.read(document);

To learn more about piriti take a look at code.google.com/p/piriti/.

Google AppEngine, Restlet & Security

2009-11-24T17:06:00.006+01:00

I was wondering how to secure the resources in my current application. The application is deployed on the Google AppEngine and uses Guice 2.0 and Restlet 2.0. Inspired by the post from David M. Chandler I decided to use the AppEngine cookie named "ACSID" as a token in each and every url to secure my resources. This way the url to the "projects" resource becomes http://tire-d8.appspot.com/rest/v1/<ACSID>/projects.

Technically I'm using an aspect together with a custom annotation to secure the resources. Here's the Guice module for the security stuff:

public class SecurityModule extends AbstractModule
{
    @Override
    protected void configure()
    {
        SecurityInterceptor interceptor = new SecurityInterceptor();
        bindInterceptor(Matchers.subclassesOf(ServerResource.class), Matchers.annotatedWith(Secured.class), interceptor);
    }
}

With the above setup all methodes in subclasses of ServerResource which are annotated with the custom @Secured annotation are handled by the SecurityInterceptor. This class contains the logic to check whether there's a authenticated user and whether the session cookie is correct (that's essentially the code from David M. Chandlers post)

public class SecurityInterceptor implements MethodInterceptor
{
    private static final String APPENGINE_COOKIE = "ACSID";


    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable
    {
        UserService userService = UserServiceFactory.getUserService();
        User user = userService.getCurrentUser();
        if (user == null)
        {
            throw new SecurityException("No user");
        }

        ServerResource resource = (ServerResource) invocation.getThis();
        String token = (String) resource.getRequest().getAttributes().get("token");
        if (token == null || token.length() == 0)
        {
            throw new SecurityException("No security token");
        }

        // Skip check on localhost so we can test in AppEngine local dev env
        String sessionId = findSessionId(resource);
        String serverName = resource.getReference().getHostDomain();
        if (!("localhost".equals(serverName)) && !(token.equals(sessionId)))
        {
            throw new SecurityException("Security token invalid");
        }

        return invocation.proceed();
    }


    private String findSessionId(ServerResource resource)
    {
        String result = null;
        Series<Cookie> cookies = resource.getCookies();
        for (Cookie cookie : cookies)
        {
            if (APPENGINE_COOKIE.equals(cookie.getName()))
            {
                result = cookie.getValue();
                break;
            }
        }
        return result;
    }
}

To make this work the resource mappings have to include a {token} parameter. So inside your Router you should have something like that

attach("/{token}/projects", ProjectsResource.class);

Finally the methods you want to protect have to be annotated with the @Secured annotation:

public class ProjectsResource extends ServerResource
{
    private final ProjectService service;
    private final TemplateConverter converter;


    @Inject
    public ProjectsResource(ProjectService service, TemplateConverter converter)
    {
        this.service = service;
        this.converter = converter;
    }


    @Secured
    @Override
    protected Representation get()
    {
        Context context = new Context();
        context.set("projects", service.list());
        String xml = converter.convert("templates/projects.vm", context);
        return new StringRepresentation(xml, MediaType.TEXT_XML);
    }
}

One last note: First I tried to use the @Get annotation from Restlet 2.0 instead of a custom annotation and configured the SecurityInterceptor as follows:

bindInterceptor(Matchers.subclassesOf(ServerResource.class), Matchers.annotatedWith(Get.class), interceptor);

Unfortunately that didn't work because the @Get annotation is not available in the generated AOP proxy. So Restlet has no way to figure out what method to call for a GET request. Instead you have to override the get method.

Google AppEngine, Restlet & Guice

2009-11-22T13:26:00.030+01:00

Currently I'm developing an application for time recording called TiRe. TiRe is deloyed on the Google AppEngine for Java (GAE/J) and uses inter alia the following stack:

Basically there are two different ways to go when using the Restlet framework:

Run as a standalone application
Run in a servlet container

For the first approach there's a blog entry from Tim Peierls on how to configure your resources using Guice.
As TiRe is deployed on the GAE/J, I'm using the second approach. Therefore I created a custom servlet in combination with custom Finder and Router classes. All classes are bind together with Guice. This post describes my setup and shows the relevant code. Let's start by looking at the web.xml:

<web-app xmlns="http://java.sun.com/xml/ns/javaee" version="2.5">

    <filter>
        <filter-name>guiceFilter</filter-name>
        <filter-class>com.google.inject.servlet.GuiceFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>guiceFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <listener>
        <listener-class>name.pehl.tire.server.servlet.ServletConfig</listener-class>
    </listener>

</web-app>

Nothing special here. The main configuration happens in the ServletConfig class:

public class ServletConfig extends GuiceServletContextListener
{
    @Override
    protected Injector getInjector()
    {
        // Further modules are omitted...
        return Guice.createInjector(new ServletModule(), new RestModule());
    }
}

I use two different modules: One for the servlet configuration and one for the setup of the resources. The servlet module registers the custom REST servlet:

public class ServletModule extends com.google.inject.servlet.ServletModule
{
    @Override
    protected void configureServlets()
    {
        serve("/rest/v1/*").with(RestletServlet.class);
    }
}

All REST requests are handled by the RestletServlet. The url mapping contains a version number. Using this approach you can later on add another servlet with a different interface / version and maintain backward compatibility. Now let's look at the RestletServlet:

@Singleton
public class RestletServlet extends HttpServlet
{
    @Inject
    private Injector injector;
    private Context context;
    private ServletAdapter adapter;


    @Override
    public void init() throws ServletException
    {
        context = new Context();
        Application application = new Application();
        application.setContext(context);
        application.setInboundRoot(new GuiceRouter(injector, context)
        {
            @Override
            protected void attachRoutes()
            {
                attach("/projects", ProjectsResource.class);
            }
        });
        adapter = new ServletAdapter(getServletContext());
        adapter.setTarget(application);
    }


    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException
    {
        adapter.service(request, response);
    }
}

The servlet is normal HttpServlet. The integration with the Restlet framework is not reached by inheritance but by using the ServletAdapter class. The ServletAdapter is configured to use a new Context, Application and our own GuiceRouter.

Another important aspect is that a reference to the Injector is provided by Guice (see "Injecting the injector" in the Guice documentation). We will need the injector later in the GuiceFinder class.

The GuiceRouter is responsible for setting up the mappings between the urls and the resources. Therefore it has the abstract method attachRoutes(). The GuiceRouter extends the Router from the Restlet framework and uses a GuiceFinder to create the resource instances:

public abstract class GuiceRouter extends Router
{
    private final Injector injector;


    public GuiceRouter(Injector injector, Context context)
    {
        super(context);
        this.injector = injector;
        attachRoutes();
    }


    @Override
    public Finder createFinder(Class targetClass)
    {
        return new GuiceFinder(injector, getContext(), targetClass);
    }


    protected abstract void attachRoutes();


    protected Injector getInjector()
    {
        return injector;
    }
}

The GuiceFinder is the class where the resources are created. Therefore the method create() is overwritten. By calling Injector.getInstance(targetClass) the resource is created and all its dependencies are injected by Guice:

public class GuiceFinder extends Finder
{
    private final Injector injector;


    public GuiceFinder(Injector injector, Context context, Class targetClass)
    {
        super(context, targetClass);
        this.injector = injector;
    }


    @Override
    public ServerResource create(Class targetClass, Request request, Response response)
    {
        return injector.getInstance(targetClass);
    }
}

The following code shows one of the resource used in TiRe. The resource is bound to the url "/projects". So when the url http://server/rest/v1/projects is called a new instance of the ProjectsResource is created by Guice and all dependencies are injected.

public class ProjectsResource extends ServerResource
{
    private final ProjectService service;
    private final TemplateConverter converter;


    @Inject
    public ProjectsResource(ProjectService service, TemplateConverter converter)
    {
        this.service = service;
        this.converter = converter;
    }


    @Get("xml")
    public Representation represent()
    {
        Context context = new Context();
        context.set("projects", service.list());
        String xml = converter.convert("templates/projects.vm", context);
        return new StringRepresentation(xml, MediaType.TEXT_XML);
    }
}

As you can see, there's not much code necessary to integrate the Restlet framework with the GAE/J using the servlet approach. Feel free to comment and let me know if this is somewhat useful.