Examples of how to construct Restlet applications mentioned in Restlet Tutorials


For example groovy scripts, see http://svn.codehaus.org/groovy-contrib/groovyrestlet/trunk/src/test/groovy/org/lpny/groovyrestlet/examples/tutorials/

Example of Part02

Example about creating a Restlet Client instance.

You can use shortcut client constructor as shown in `#1`; also you can use the generic restlet constructor to create client instance.

you can use `restlet(ofClass:class name)` to create any instance of derived type of Restlet. In this case, you need to specify attribute `consArgs` which are an array of constructing parameters.

//#1 using shortcut
builder.client(protocol.HTTP)

//#2 generic restlet constructor
builder.restlet(ofClass:"org.restlet.Client", consArgs:[protocol.HTTP] as Object[])
Example of Part03

At current moment, server construction does not support `restlet` way

Nesting here indicates a parent-child relationship.

The child of a server component becoming the target property of the Server.

builder.server(protocol:protocol.HTTP,port:8182){
    restlet(handle:{req, resp->
        resp.setEntity("Hello World", mediaType.TEXT_PLAIN)
    })
}.start()
//or you can define restlet first
def restlet = builder.restlet(handle:{req, resp->
    resp.setEntity("Hello World", mediaType.TEXT_PLAIN)
})
builder.server(protocol:protocol.HTTP,port:8182, target:restlet).start()
Example of Part05
//using component shortcut constructor
def component = builder.component{
    current.servers.add(protocol.HTTP, 8182)

    restlet(uri:"/trace", handle: {req, resp->
        println "To process request: ${req}"
        def message = """Resource URI: ${req.resourceRef}
Root URI : ${req.rootRef}
Routed part : ${req.resourceRef.baseRef}
Remaining part: ${req.resourceRef.remainingPart}
"""
        resp.setEntity(message, mediaType.TEXT_PLAIN)
    })
}
Example of Part06
def ROOT_URI = "file:."
builder.component{
    current.servers.add(protocol.HTTP, 8182)
    current.clients.add(protocol.FILE)
    application(uri:"") {
        directory(root:ROOT_URI)
    }
}.start()
Example of Part09

Using current to reference to the current instance.

By default any nested component will be automatically attached to its parent component according to their parent-child relationship. Here Guard is automatically attached to its parent (Application here) as its root. Adding attribute autoAttach:false can disable this feature.

builder.component{
    current.servers.add(protocol.HTTP, 8182)
    application(uri:"") {
        guard(scheme:challengeScheme.HTTP_BASIC, realm:"Tutorial").secrets.put("scott","tiger".toCharArray())
        def dir = directory(autoAttach:false, root:"")
        current.root.next=dir
    }
}.start()
Example of Part10

In Restlet, an attaching operation (on Router.attach) returns an instance of Route. It might be needed to do some post processing on a route. Attribute postAttach which refers a closure is used to support this.

builder.component{
    current.servers.add(protocol.HTTP, 8182)
    application(uri:""){
        def router = router{
            def target = "http://www.google.com/search?q= {keywords}"
            redirector(uri:"/search",targetTemplate:target,
                 mode:redirectorMode.MODE_CLIENT_TEMPORARY,
                 postAttach:{route->
                         route.extractQuery("keywords","kwd",true)
                })
       }
   }
}.start()
Example of Part11

You can implement the handle method of a Restlet using a groovy closure.

builder.component{
    current.servers.add(protocol.HTTP, 8182)

    application(uri:""){
        router{
            def guard = guard(uri:"/docs", scheme:challengeScheme.HTTP_BASIC, realm:"Restlet Tutorials")
            guard.secrets.put("scott", "tiger".toCharArray())
            guard.next = directory(root:"", autoAttach:false)
            restlet(uri:"/users/ {user}", handle:{req,resp->
               resp.setEntity("Account of user \"${req.attributes.get('user')}\"",mediaType.TEXT_PLAIN)
            })

            restlet(uri:"/users/{user}/orders", handle:{req, resp->
                resp.setEntity("Orders or user \"${req.attributes.get('user')}\"",mediaType.TEXT_PLAIN)
            })
            restlet(uri:"/users/{user}/orders/{order}", handle:{req, resp->
               def attrs = req.attributes
               def message = "Order \"${attrs.get('order')}\" for User \"${attrs.get('user')}\""
               resp.setEntity(message, mediaType.TEXT_PLAIN)
            })
       }
    }
}.start()
Example of Part12

Same as handle closure of a Restlet, you can implement a simple Restlet Resource using groovy closures. Following attributes are supported: