public interface ServletRequest 
{
    /**
     * Obtiene el contenido del cuerpo de la petición como un Object. 
     * 
     * <p>Los bytes recibidos por el servidor serán parseados y
     * convertidos a un Object por un {@link RequestContentConverter}
     * del contenedor o de la aplicación configurado en el descriptor 
     * de despliegue o las anotaciones del servlet. 
     * Ejemplos del tipo de Object que pueden ser retornados incluyen 
     * {@link java.nio.ByteBuffer}, {@link String}, {@link java.io.File} y 
     * {@link org.w3c.dom.Document}. Si la petición especifica una
     * codificación de caracteres o un Locale, entonces esto se usará en el
     * parseo del contenido, sinó se deben especificar codificaciones por
     * defecto en el descriptor de despliegue o en las anotaciones del servlet.
     * </p>
     * 
     * <p>Si el descriptor de despliegue o las anotaciones del servlet indican que la
     * URL de la petición es asíncrona, entonces el contenedor parseará en contenido
     * antes de que la petición sea servida a la cadena de filtros o/y al servlet y
     * esta llamada nunca se bloqueará. De otro modo, el contenido es parseado
     * durante esta llamada y puede bloquearse esperando a recibir el contenido completo.</p>
     * 
     * @return   un objeto que contiene el cuerpo parseado de la petición
     *
     * @exception IllegalStateException  si los métodos {@link #getReader} o 
     *     {@link #getInputStream} ya han sido llamados por esta para esta
     *	   petición
     *                                   
     * @exception ObjectSTreamException  si hubo algún problema parseando el contenido.                                
     *
     * @exception IOException           si ha ocurrido un excepción de entrada o salida.
     */
    Object getContent() throws IllegalStateException, ObjectStreamException;

    /**
     * Suspende el procesador de la petición y de la {@link ServletResponse} asociada.
     * 
     * <p>Despues de que este método sea llamado, el ciclo de vida de la petición será extendida
     * más allá del retorno al contenedor desde el método 
     * {@link Servlet#service(ServletRequest, ServletResponse)}  y las llamadas
     * {@link Filter#doFilter(ServletRequest, ServletResponse, FilterChain)}. Si una  
     * petición es suspendida, entonces el contenedor no confirmará la respuesta asociada 
     * cuando la llamada a la cadena de filtros y/o al service del servlet vuelve al 
     * contenedor. En su lugar, el contenedor esperará hasta que se llame a  
     * {@link ServletRequest#resume()} o expire el timeout, y entonces la petición se
     * volverá a despachar via la cadena de filtros al servlet.
     * </p>
     * 
     * <p>El objeto {@link ServletResponse} es deshabilitado por esta llamada,  
     * de modo que todas las llamada para modificar o generar una respuesta son
     * ignoradas, hasta que una petición sea devuelta. Con la excepción de que 
     * los objetos devueltos por {@link ServletResponse#getNonStopOutputStream()} y  
     * {@link ServletResponse#getNonStopWriter} permanecen activos durante todo 
     * el ciclo de vida de la petición.</p>
     * 
     * <p>Si ya hay una petición suspendida, cualquiera llamada subsiguiente a
     * suspender establecerá el timeout al mínimo del timeout previo y del nuevo
     * timeout pasado</p>
     *
     * <p>Suspender sólo debe ser llamado por un thread que esté dentro de la pila de
     * llamadas al servicio de {@link Filter#doFilter(ServletRequest, ServletResponse, FilterChain)}
     * y/o {@link Servlet#service(ServletRequest, ServletResponse)}</p>    
     * 
     * @see {@link #resume()}
     * 
     * @param timeoutMs El tiempo en milisegundos a esperar antes de devolver esta petición.
     * 
     * @exception IllegalStateException Si el thread ejecutor no está dentro de la pila de llamadas
     * de {@link Filter#doFilter(ServletRequest, ServletResponse, FilterChain)}
     * y/o {@link Servlet#service(ServletRequest, ServletResponse)}
     */
    void suspend(long timeoutMs);

    /**
     * Reanudar una request suspendida.
     * 
     * <p>Este método puede ser llamado por cualquier thread al que se le haya pasado una referencia a
     * a la petición para pedir que la request sea reenviada</p>
     * 
     * <p>Si resume se llama antes de que una petición suspendida sea devuelta al contenedor 
     * (ie el thread que llamó a {@link #suspend(long)} está todavía dentro de la cadena de filtros
     * y/o en el método service del servlet), entonces la reanudación no se lleva a cabo hasta que
     * la llamada a la filter chain y/o al método service vuelvan al contenedor. En este caso, hasta  
     * que vuelva la llamada a service, tanto {@link #isSuspended()} como {@link isResumed()}
     * devuelvan true.</p>
     * 
     * <p>Si se llama a resume en una petición no suspendida, se aplicará la reanudación a  
     * cualquier llamada subsiguiente a suspend. En este caso, {@link #isResumed()} será true 
     * y {@link #isSuspended()} false. </p>
     * 
     * <p>Si resume es llamado en una petición después de que el ciclo de vida de una petición
     * se complete, los resultados quedan indefinidos</p>
     * 
     * <p>Multiples llamadas a resume son ignoradas</p>
     * 
     * @see {@link #response()}
     * 
     */
    void resume();

    /**
     * @return true después de que {@link #suspend(long)} haya sido llamado y antes de que 
     * la petición haya sido reanudada o expirada.
     */
    boolean isSuspended();

    /**
     * @return true despues de que {@link #resume()} haya sido llamado y antes de cualquier llamada
     * subsiguiente a suspend
     */
    boolean isResumed();

    /**
     * @return true después de que una petición haya sido devuelta como el resultado de un resume o 
     * timeout
     */
    boolean isRetry();

    /**
     * @return true después de que una petición haya sido devuelta como resultado de timeout
     */
    boolean isTimeout();
}

public interface ServletResponse
{
    // Se han omitido los métodos de response ya existentes

    /**
     * Establece el cuerpo del contenido de la respuesta (response)
     * 
     * <p>Establece el cuerpo de la response para ser enviada como un Object.  
     * El Object será convertido una instancia de bytes {@link ResponseContentConverter} 
     * suministrada por el contenedor o la aplicación y configurado en el descriptor
     * de despliegue o las annotations del servlet.</p>
     * 
     * <p>El conversor establecerá la longitud del contenido, el content type y el 
     * content encoding de la response.</p>
     * 
     * <p>Una llamada a {@link #flushBuffer()} bloqueará hasta que todo el contenido sea
     * convertido a bytes y sea enviado. Si no se llama a {@link #flushBuffer()}, el 
     * contenedor tiene que generar y escribir el contenido asíncronamente después de 
     * de que la llamada a la cadena de filtros y al método service vuelva al contenedor.
     * 
     * @exception IllegalStateException si cualquiera de los métodos {@link #getWriter()}, 
     *     {@link #getNonStopWriter(),  {@link #getOutputStream()} o
     *     {@link #getNonStopOutputStream()} han sido llamados en esta response
     *
     */
    void setContent(Object content);

    /**
     * Devuelve un {@link PrintWriter} adecuado para escribir texto en la response.
     * A diferencia del writer retornado por {@link #getWriter()}, este writer no
     * está afectado por una llamada a {@link ServletRequest#suspend(long)} y
     * puede ser usado por cualquier thread durante el ciclo de vida de la
     * request. </p>
     * 
     * <p>No está garantizado que el writer sea thread safe, y si varios threads 
     * usan el stream, deben usar alguna forma de exclusión mutua.</p>
     *
     * <p>Calling flush() on the Writer commits the response.</p>
     *
     * @return a {@link ServletOutputStream} para escribir datos binarios   
     *
     * @exception IllegalStateException si cualquiera de los métodos {@link #getWriter()}, 
     *     {@link #getNonStopWriter() o {@link #setContent(Object)} han sido llamados
     *     en esta response
     *     
     * @exception UnsupportedEncodingException
     *                  si el char encoding devuelto por <code>getCharacterEncoding</code>
     *                  no se puede usar
     *
     *
     */
    PrintWriter getNonStopWriter();

    /**
     *
     * Devuelve un {@link ServletOutputStream} para escribir datos binarios en la  
     * response. El contenedor no codifica los datos binarios. A diferencia del
     * stream devuelto por {@link #getOutputStream()}, el stream devuelto por este 
     * método no está afectado por una llamada a {@link ServletRequest#suspend(long)}
     * y puede ser usado por cualquier thread durante el ciclo de vida de la 
     * request. </p>
     * 
     * <p>No está garantizado que el stream sea thread safe, y si varios threads están
     * el stream, deben usar alguna forma de exclusión mutua.</p>
     *
     * <p>Calling flush() on the ServletOutputStream commits the response.</p>
     *
     *
     * @return a {@link ServletOutputStream} for writing binary data   
     *
     * @exception IllegalStateException if any of the {@link #getWriter()}, 
     *     {@link #getNonStopWriter() or {@link #setContent(Object)} methods
     *     have been called on this response
     *
     * @exception IOException   if an input or output exception occurred
     *
     */
    ServletOutputStream getNonStopOutputStream();
}

/**
 * Un conversor para el contenido de la petición.
 * 
 * <p>Las implementaciones de esta interficie son responsables de
 * convertir los bytes recibidos de una request a un Object que
 * estará disponible via el método.</p>
 * 
 * <p>El contenedor creará tantas instancias de un conversors como
 * sean necesarias y una instancia será asociada con una request
 * por una llamada a {@link #init(ServletRequest)}. El contenedor
 * llamará a {@link #convert(byte[])} a medida que reciba contenido
 * hasta que se devuelva un objeto o se lance una excepción.</p>
 * 
 * <p>Para implementar esta interfaz no se requieren los conversores
 * provistos por el contenedor.</p>
 * 
 */
public interface RequestContentConverter
{

    /**
     * Inicializa este converter para la request.
     * @param request La request que contiene el contenido. Se pueden
     * inspeccionar las cabeceras de esta petición, pero no se puede
     * consumir contenido de la petición (ejemplo {@link ServletRequest#getInputStream()}). 
     * @throws IllegalStateException Si este converter no puede convertir la petición.
     */
    void init(ServletRequest request);

    /**
     * Convierte unos bytes del contenido.
     * 
     * <p>Este método se llama cuando un contenedor recibe algunos bytes de
     * del contenido. El contenido puede que no esté completo y será necesario
     * más llamadas a convert para tratar todo el contenido.
     * No se hará una llamada subsiguiente hasta después de que la llamada
     * actual haya retornado.</p>
     * 
     * @param chunk Contenido parcial o completo como una array de bytes.
     * @return El objeto convertido o null si se requiere más contenido.
     * @throws IOException Si no se puede analizar el contenido.
     */
    Object convert(byte[] chunk) throws IOException;

}

/* ------------------------------------------------------------ */
/**
 * Un converter para el contenido de Response.
 * 
 * <p>Las implementaciones de esta interficie son responsables de convertir
 * los Objects pasados en el método {@link ServletResponse#setContent(Object)}  
 * a bytes para ser enviados como contenido de la respuesta.</p>
 * 
 * <p>El contenedor creará tantas instancias como necesite y una instancia
 * se asociará con una response por una llamada a {@link #init(ServletResponse)}.
 * El contenedor llamará a {@link #convert(byte[], int, int)} hasta que se
 * devuelva un -1.</p>
 * 
 * <p>Los conversores del contenedor no son requeridos para implementar esta intarficie.
 *
 */
public interface ResponseContentConverter
{
    /**
     * Asocia este converter con una response.
     * <p>Se pueden establecer cabeceras de la response para indicar el tamaño
     * del contenido, el tipo y la codificación.</p>	
     * 
     * @param response La respuesta.
     * @param content El contenido a convertir.
     * @throws IllegalStateException Si el contenido no se puede  the content cannot be converted
     * by this converter.
     */
    void init(HttpServletResponse response, Object content);

    /** 
     * Convierte el contenido a bytes. Los bytes convertidos se escriben en
     * el buffer pasado comenzando en el offset dado y sin exceder la 
     * longitud dada. Devuelve el número real de bytes escritos.
     * Los bytes escritos puede representar todo el contenido o una parte
     * de él. Pueden ser necesarias más llamadas a converte para convertir
     * el contenido completo.
     * 
     * <p>El contenedor no llamará a converte hasta que una llamada previa
     * a convert termine. El contenedor puede retrasar la llamada a convert
     * hasta que esté listo para enviar más contenido al cliente.</p>
     * 
     * @param buffer El array de bytes dónde se debe escribir el contenido.
     * @param offset El offset dentro del array dónde se debe escribir el
     *               contenido.
     * @param length El número máximo de bytes que pueden ser escritos.
     * @return El número de bytes escritos o -1 para indicar que se ha 
     * escrito todo el contenido.
     * @throws IOException Si el contenido no se puede convertir.
     */
    int convert(byte[] buffer,int offset, int length) throws IOException;
}

<request-converter>
  <url-pattern>/comet/*</url-pattern>

  <mime-type>text/json</mime-type>
  <content-class>java.util.Map</content-class>
  <asynchronous/>
  <provided/>
  <converter-class>com.acme.ajax.JsonContentParser</converter-class>
</request-converter>

<response-converter>
  <url-pattern>/comet/*</url-pattern>

  <content-class>org.w3c.dom.Document</content-class>
  <content-type>text/xml; charset=utf-8</content-type>
  <provided/>
</request-converter>

<%@ page contentType=‘text/html; charset=UTF-8′ import=‘java.util.Map,java.io.File’ %>
<%
Map content=(Map)request.getContent();
if (content==null)
{
%>
    <h2>UPLOAD content</h2>
    <form method=‘POST’ enctype=‘multipart/form-data’ accept-charset=‘utf-8′ action=“.”