Cattura contenuto dinamico dinamico sul lato server

Question

C'è un modo con cui posso acquisire contenuto dinamico generato sul lato server e ottenere quel file o oggetto stringa dello stesso sul servlet.

Possiamo generare contenuto dinamico con JSP, ma non abbiamo accesso al contenuto dinamico generato sul lato server. Non appena eseguiamo il contenitore di inoltro, genera il contenuto dinamico e lo invia alla risposta.

Ho bisogno di accedere al contenuto dinamico generato sul lato server.

Qualsiasi aiuto sarà apprezzato.

Answer 1

Se la richiesta è idempotente (come ad esempio le richieste GET), utilizzare semplicemente java.net.URL per ottenere un InputStream dell'output JSP. Per esempio.

InputStream input = new URL("http://localhost/context/page.jsp").openStream(); 

Se la richiesta non è idempotente (come POST richieste sono), quindi è necessario creare un Filter che wraps la ServletResponse con un'implementazione personalizzata del PrintWriter con i cinque write() metodi stato uno scostamento in cui si copia in uscita in un buffer/builder memorizzato nella sessione o una cartella temporanea sul file system del disco locale in modo che possa essere successivamente richiamato nelle richieste successive. Per esempio.

package mypackage; 

import java.io.IOException; 
import java.io.OutputStreamWriter; 
import java.io.PrintWriter; 
import java.io.Writer; 

import javax.servlet.Filter; 
import javax.servlet.FilterChain; 
import javax.servlet.FilterConfig; 
import javax.servlet.ServletException; 
import javax.servlet.ServletRequest; 
import javax.servlet.ServletResponse; 
import javax.servlet.http.HttpServletRequest; 
import javax.servlet.http.HttpServletResponse; 
import javax.servlet.http.HttpServletResponseWrapper; 

public class CopyResponseFilter implements Filter { 

    public void init(FilterConfig config) throws ServletException { 
     // NOOP. 
    } 

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
     throws IOException, ServletException 
    { 
     // Set character encoding for better world domination. 
     response.setCharacterEncoding("UTF-8"); 

     // Create copy writer. 
     HttpServletResponse httpResponse = (HttpServletResponse) response; 
     CopyWriter copyWriter = new CopyWriter(new OutputStreamWriter(
      httpResponse.getOutputStream(), httpResponse.getCharacterEncoding())); 

     // Filter request with response which is wrapped with new writer. 
     chain.doFilter(request, wrapResponse(httpResponse, copyWriter)); 

     // Store the copy writer afterwards in session so that it's available in next request. 
     HttpServletRequest httpRequest = (HttpServletRequest) request; 
     httpRequest.getSession().setAttribute("copyWriter", copyWriter); 
    } 

    public void destroy() { 
     // NOOP. 
    } 

    private static HttpServletResponse wrapResponse 
     (final HttpServletResponse response, final PrintWriter writer) 
    { 
     return new HttpServletResponseWrapper(response) { 
      public PrintWriter getWriter() throws IOException { 
       return writer; 
      } 
     }; 
    } 

} 

class CopyWriter extends PrintWriter { 

    StringBuilder copy = new StringBuilder(); 

    public CopyWriter(Writer out) { 
     super(out); 
    } 

    public void write(int c) { 
     copy.append((char) c); // It is actually a char, not an int. 
     super.write(c); 
     super.flush(); 
    } 

    public void write(char[] chars) { 
     copy.append(chars); 
     super.write(chars); 
     super.flush(); 
    } 

    public void write(char[] chars, int offset, int length) { 
     copy.append(chars, offset, length); 
     super.write(chars, offset, length); 
     super.flush(); 
    } 

    public void write(String string) { 
     copy.append(string); 
     super.write(string); 
     super.flush(); 
    } 

    public void write(String string, int offset, int length) { 
     copy.append(string, offset, length); 
     super.write(string, offset, length); 
     super.flush(); 
    } 

    public String getCopy() { 
     return copy.toString(); 
    } 

} 

È possibile accedere l'output finale in ogni servlet della successiva richiesta (si noti che è l'accesso che non può in qualsiasi servlet della corrente richiesta , perché è già troppo tardi per fare qualcosa con esso) semplicemente accedendo al CopyWriter nella sessione:

CopyWriter copyWriter = (CopyWriter) request.getSession().getAttribute("copyWriter"); 
String outputOfPreviousRequest = copyWriter.getCopy(); 

nota che si dovrebbe mappare questo filtro su un url-pattern che copre le pagine JSP di interesse e quindi non su /* o giù di lì, altrimenti si correrebbe il file statici (css, js, immagini, ecc.) che sono inclusi nello stesso JSP.

Si noti inoltre che più richieste all'interno della stessa sessione si annulleranno a vicenda, spetta a te distinguere tra quelle richieste utilizzando un opportuno url-pattern o un altro modo di memorizzarlo in sessione, ad es. nel sapore di un Map<URL, CopyWriter> o così.

Spero che questo aiuti.

Answer 2

È necessario avere accesso ai servlet appropriati sul lato server o scrivere il servlet.

Here è un piccolo tutorial sull'utilizzo di servlet.

Answer 3

Cosa importante da notare è che JSP sono compilate per i servlet tramite JSP compilatore (che potrebbe generare il codice Java a metà strada trogolo), quindi tutto si può fare in una JSP si può fare con servlet.

Una nota a margine sul tema: si deve essere consapevoli di MVC, generalmente parlando servlet agiscono in qualità di titolari, JSP come Vista, e tutte le strutture di dati (Java beans e simili) agire come il modello.

Per il tuo problema dovresti generare il contenuto/dati nel servlet - questo è il tuo contenuto dinamico rappresentato da oggetti, fai qualsiasi elaborazione devi fare, imposta questi dati in modo che i JSP possano accedervi (in request attribute per esempio), accedere e formattarlo per il client in JSP.

Per familiarizzare è necessario controllare Story of a Servlet: An Instant Tutorial, The Java™ EE 5 Tutorial on Web tier.

Answer 4

Per quanto riguarda il tuo obiettivo, vuoi memorizzare il contenuto generato. Mentre non riesco a pensare a nessuna ragione per farlo, è possibile.

è possibile utilizzare un Filter e creare un wrapper del vostro HttpServletResponse, sovrascrivere alcuni write metodi e catturare tutti i contenuti che sarà emesso al browser.

Modifica: la risposta di BalusC è l'estensione esatta di cui hai bisogno, quindi non entrerò nei dettagli.