@Grab("io.ratpack:ratpack-groovy:0.9.2")
import static ratpack.groovy.Groovy.*
ratpack {
handlers {
}
}
ratpack{
handlers {
get {
render 'Hello World!'
}
}
}
get {
def name = request.queryParams.name
render "Hi $name!"
}
get('name/:name') {
def name = pathTokens.name
render "Hi $name, this time from PathTokens!"
}
post('name/:name?') {
def name = pathTokens.name
render "Hi $name, this time from PathTokens and a POST endpoint!"
}
get('something') {
render htmlBuilder {
head {
title 'My website title'
}
body {
h1 'Hi stranger!'
p {
a href: 'http://github.com', "Let's visit GitHub!"
}
}
}
}
Handler
get {
render groovyTemplate([name: 'John Doe'], 'testTemplate.html')
}
Template
String que viene del modelo
${model.name}
import ratpack.form.Form
post('myform') {
def form = parse Form
form.get('param')
form.file('fileName')
}
Podríamos usar un módulo de Guice
para Jackson
En su lugar, usaremos JsonOutput
y toJson
import static groovy.json.JsonOutput.toJson
get {
response.contentType 'application/json'
render toJson(['message': 'Long live to Json!'])
}
get('simpler') {
response.send 'application/json', toJson(['even': 'simpler'])
}
handler('myendpoint') {
byMethod {
get {
response.send 'application/json', toJson(['method': 'GET'])
}
post {
response.send 'application/json', toJson(['method': 'POST'])
}
}
}
get {
byContent {
json {
render 'JSON'
}
plainText {
render 'TEXT'
}
html {
render 'HTML'
}
}
}
prefix('api') {
get('end') {
render 'end'
}
get('point') {
render 'point'
}
}
ratpack {
handlers {
assets("public")
}
}
Ya tenemos algo funcionando
Podemos integrar nuestra aplicación con gradle
a través del plugin ratpack-groovy
Herramienta de creación de proyectos a partir de plantillas
lazybones create [ratpack template] [ratpack version] [app name]
src
|
+- ratpack
| |
| +- ratpack.groovy
| +- ratpack.properties
| +- public // Static assets in here
|
+- main
| |
| +- groovy
| |
| +- // App classes in here!
|
+- test
|
+- groovy
|
+- // Spock tests in here!
apply plugin: "ratpack-groovy"
buildscript {
repositories {
jcenter()
}
dependencies {
classpath "io.ratpack:ratpack-gradle:0.9.2"
}
}
repositories {
jcenter()
maven { url "http://repo.springsource.org/repo" } // for springloaded
}
dependencies {
testCompile "org.spockframework:spock-core:0.7-groovy-2.0"
// SpringLoaded enables runtime hot reloading.
springloaded "org.springsource.springloaded:springloaded-core:1.1.1"
}
HandlerFactory
, el puerto...LaunchConfig
ratpack {
handlers {
}
}
ratpack-guice
class ScriptExecutionModule extends AbstractModule {
@Override
protected void configure() {
bind(ScriptExecutor).to(GroovyScriptExecutor)
}
}
class GroovyScriptExecutor implements ScriptExecutor {
ScriptResult execute(String scriptText) {
...
}
}
ratpack {
modules {
register new ScriptExecutionModule()
}
post("execute") { ScriptExecutor scriptExecutor ->
def form = parse form()
def script = form.script
render scriptExecutor.execute(script)
}
}
Hay poca documentación en "prosa".
Javadoc es tu amigo.
Handler
import ratpack.handling.Handler
import ratpack.handling.Context
class TestHandler implements Handler {
void handle(Context context) {
context.render "Hello World!"
}
}
get 'chain', new FirstHandler()
class FirstHandler implements Handler {
void handle(Context context) {
println 'Soy el primer handler'
context.insert new SecondHandler()
}
}
class SecondHandler implements Handler {
void handle(Context context) {
println 'Soy el segundo handler'
context.render 'Response!'
}
}
// == Output GET /chain ==
// Soy el primer handler
// Soy el segundo handler
// [200] Response!
El último handler es siempre uno interno que envía un 404
context.clientError 404
request
y response
context
y se lo pasan al siguienteregistry
class MyHandler implements Handler {
void handle(Context context) {
// get some data
Map myData = ['message': "hoy es ${new Date()}"]
// delegates on JSON
context.insert(registry(myData), new ToJson())
}
}
class ToJson implements Handler {
void handle(Context context) {
def myData = context.get(LinkedHashMap.class)
context.response.contentType 'application/json'
context.render toJson(myData)
}
}
spock
gradle
prepara el proyecto para testingUnitTest.invoke()
GroovyUnitTest.invoke()
ApplicationUnderTest
TestHttpClient
class MyHandler implements Handler {
void handle(Context context) {
context.with {
def outputHeader = request.headers.get("input-value") + ":bar"
response.headers.set("output-value", outputHeader)
render "received: " + request.path
}
}
}
import static ratpack.groovy.test.GroovyUnitTest.invoke
def invocation = invoke(new MyHandler()) {
header "input-value", "foo"
uri "some/path"
}
assert invocation.rendered(String) == "received: some/path"
assert invocation.headers.get("output-value") == "foo:bar"
gradle
# Genera la estructura de la aplicación
# en build/install/$applicationName
gradle installApp
# Comprime la aplicación en un fichero .zip
gradle distZip
# Comprime la aplicación en un fichero .tar
gradle distTar
ratpack.groovy
& ratpack.properties
/templates
/public
Scripts de shell
y batch
que settean el classpath y ejecutan la aplicación
"${applicationName}.jar"
Consume pocos recursos
No toma decisiones por ti