Esta página todavía no ha sido revisada su traducción al castellano. Puedes ayudarnos con la tarea simplemente presionando el botón Edit Page. Para más información puedes leer esta guía para el traductor. Aquí puedes ver cuánto nos falta para terminar la traducción.

Una petición HTTP (al menos para aquellos que usan las operaciones POST y PUT) tienen un cuerpo. Este cuerpo puede ser formateado con cualquier formato especificado en el encabezado Content-Type. Un body parser transforma el cuerpo de la petición en un valor Java.

Nota: Usted no puede escribir una implementación de BodyParser directamente usando Java. Debido a que un BodyParser de Play debe manejar el contenido del cuerpo incrementalmente usando un Iteratee[Array[Byte], A] debe ser implementado en Scala.

Sin embargo Play proporciona un BodyParser por defecto que debería encajar en la mayoría de los casos de uso (procesando Json, Xml, Text, subiendo archivos). Usted puede reusar estos BodyParser para crear uno propio directamente en Java; por ejemplo usted puede proveer un parser para RDF basado en el parser para Texto.

En la API de Java, todos los Body Parsers deben generar un valor play.mvc.Http.RequestBody. Este valor procesado por el Body Parser puede ser recuperado por medio de request().body():

pulic static Result index() {
  RequestBody body = request().body();
  ok("Got body: " + body);
}

Usted puede especificar el BodyParser a usar para una acción en particular usando la anotación @BodyParser.Of:

@BodyParser.Of(BodyParser.Json.class)
pulic static Result index() {
  RequestBody body = request().body();
  ok("Got json: " + body.asJson());
}

Como ya lo dijimos todos los Body Parsers en el API de Java deben retornar un valor play.mvc.Http.RequestBody. A partir de este objeto usted puede recuperar el contenido de la petición en el valor Java mas apropiado.

Nota: Los métodos de RequestBody como asText() o asJson() retornaran null si el parser usado para procesar el cuerpo no soporta el tipo de contenido. Por ejemplo en un action method anotado con @BodyParser.Of(BodyParser.Json.class), llamar asXml() sobre el cuerpo generado retornará null.

Algunos parsers pueden proveer un tipo mas específico que Http.RequestBody (e.j. una subclase de Http.RequestBody). usted puede automáticamente hacer cast sobre el cuerpo de petición para obtener otro tipo usando el método utilitario as(...):

@BodyParser.Of(BodyLengthParser.class)
pulic static Result index() {
  BodyLength body = request().body().as(BodyLength.class);
  ok("Request body length: " + body.getLength());
}

Si usted no especifica su propio Body Parser, Play usará el Body Parser por defecto adivinando el tipo de contenido mas apropiado a partir del encabezado Content-Type:

• text/plain: String, accesible usando asText()
• application/json: JsonNode, accesible usando asJson()
• text/xml: org.w3c.Document, accesible usando asXml()
• application/form-url-encoded: Map<String, String[]>, accesible usando asFormUrlEncoded()
• multipart/form-data: Http.MultipartFormData, accesible usando asMultipartFormData()
• Cualquier otro content type: Http.RawBuffer, accesible usando asRaw()

Ejemplo:

pulic static Result save() {
  RequestBody body = request().body();
  String textBody = body.asText();
  
  if(textBody != null) {
    ok("Got: " + text);
  } else {
    badRequest("Expecting text/plain request body");
  }
}

Body Parsers basados en texto (tales como text, json, xml o formUrlEncoded) usan un tamaño máximo de contenido ya que deben cargar todo el contenido en memoria.

Hay un tamaño de contenido por defecto (100 KB).

Tip: el tamaño de contenido por defecto puede ser definido en application.conf:

parsers.text.maxLength=128K

Usted también puede especificar el tamaño máximo de contenido usando la anotación @BodyParser.Of:

// Accept only 10KB of data.
@BodyParser.Of(value = BodyParser.Text.class, maxLength = 10 * 1024)
pulic static Result index() {
  if(request().body().isMaxSizeExceeded()) {
    return badRequest("Too much data!");
  } else {
    ok("Got body: " + request().body().asText()); 
  }
}

Next: Composición de Acciones