Risposte:
requestDispatcher - metodo forward ()
Quando utilizziamo il
forward
metodo, la richiesta viene trasferita a un'altra risorsa all'interno dello stesso server per un'ulteriore elaborazione.Nel caso di
forward
, il contenitore web gestisce internamente tutte le elaborazioni e il client o il browser non sono coinvolti.Quando
forward
viene chiamatorequestDispatcher
sull'oggetto, passiamo gli oggetti richiesta e risposta, quindi il nostro vecchio oggetto richiesta è presente sulla nuova risorsa che elaborerà la nostra richiesta.Visivamente, non siamo in grado di vedere l'indirizzo inoltrato, è trasparente.
L'uso del
forward()
metodo è più veloce disendRedirect
.Quando reindirizziamo usando forward e vogliamo usare gli stessi dati in una nuova risorsa, possiamo usarli
request.setAttribute()
dato che abbiamo un oggetto richiesta disponibile.sendRedirect
In caso di
sendRedirect
, la richiesta viene trasferita a un'altra risorsa, a un dominio diverso o a un server diverso per un'ulteriore elaborazione.Quando si utilizza
sendRedirect
, il contenitore trasferisce la richiesta al client o al browser, quindi l'URL fornito all'interno delsendRedirect
metodo è visibile come nuova richiesta al client.In caso di
sendRedirect
chiamata, i vecchi oggetti richiesta e risposta vengono persi perché vengono trattati come nuova richiesta dal browser.Nella barra degli indirizzi, possiamo vedere il nuovo indirizzo reindirizzato. Non è trasparente.
sendRedirect
è più lento perché è richiesto un round trip aggiuntivo, perché viene creata una richiesta completamente nuova e il vecchio oggetto richiesta viene perso. Sono necessarie due richieste del browser.Ma in
sendRedirect
, se vogliamo utilizzare gli stessi dati per una nuova risorsa, dobbiamo memorizzare i dati in sessione o passare insieme all'URL.Qual è buono?
Dipende dallo scenario per il quale il metodo è più utile.
Se si desidera che il controllo venga trasferito a un nuovo server o contesto e venga trattato come un'attività completamente nuova, allora si opta per
sendRedirect
. In genere, è necessario utilizzare un forward se l'operazione può essere ripetuta in sicurezza al ricaricamento del browser della pagina Web e non influirà sul risultato.
Nel mondo dello sviluppo web, il termine "reindirizzamento" è l'atto di inviare al client una risposta HTTP vuota con solo Location
un'intestazione contenente il nuovo URL a cui il client deve inviare una nuova richiesta GET. Quindi in poche parole:
some.jsp
.Location: other.jsp
intestazioneother.jsp
(questo si riflette nella barra degli indirizzi del browser!)other.jsp
.Puoi seguirlo con il set di strumenti per sviluppatori integrato / addon del browser web. Premi F12 in Chrome / IE9 / Firebug e controlla la sezione "Rete" per vederlo.
Esattamente quanto sopra si ottiene da sendRedirect("other.jsp")
. Il RequestDispatcher#forward()
non invia un reindirizzamento. Invece, utilizza il contenuto della pagina di destinazione come risposta HTTP.
some.jsp
.other.jsp
.Tuttavia, poiché la richiesta HTTP originale doveva avvenire some.jsp
, l'URL nella barra degli indirizzi del browser rimane invariato. Inoltre, tutti gli attributi di richiesta impostati nel controller dietro some.jsp
saranno disponibili in other.jsp
. Ciò non accade durante un reindirizzamento perché in pratica stai forzando il client a creare una nuova richiesta HTTP other.jsp
, eliminando la richiesta originale some.jsp
includendo tutti i suoi attributi.
Il RequestDispatcher
è estremamente utile nel paradigma MVC e / o quando si desidera nascondere JSP di accesso diretto. È possibile inserire i JSP nella /WEB-INF
cartella e utilizzare a Servlet
che controlla, preprocessa e postprocessa le richieste. I JSP nella /WEB-INF
cartella non sono direttamente accessibili tramite URL, ma Servlet
possono accedervi utilizzando RequestDispatcher#forward()
.
È possibile ad esempio avere un file JSP in /WEB-INF/login.jsp
ed una LoginServlet
che viene mappato su un url-pattern
di /login
. Quando si invoca http://example.com/context/login
, verrà richiamato il servlet doGet()
. Puoi eseguire qualsiasi operazione di pre- elaborazione e infine inoltrare la richiesta come:
request.getRequestDispatcher("/WEB-INF/login.jsp").forward(request, response);
Quando invii un modulo, normalmente desideri utilizzare POST
:
<form action="login" method="post">
In questo modo doPost()
verranno invocati i servlet e potrai eseguire qualsiasi operazione di post- elaborazione (ad esempio convalida, logica aziendale, login dell'utente, ecc.).
Se sono presenti errori, normalmente si desidera inoltrare la richiesta alla stessa pagina e visualizzare gli errori lì accanto ai campi di input e così via. Puoi usare RequestDispatcher
per questo.
Se a ha POST
successo, normalmente si desidera reindirizzare la richiesta, in modo che la richiesta non venga reinviata quando l'utente aggiorna la richiesta (es. Premendo F5 o navigando indietro nella cronologia).
User user = userDAO.find(username, password);
if (user != null) {
request.getSession().setAttribute("user", user); // Login user.
response.sendRedirect("home"); // Redirects to http://example.com/context/home after succesful login.
} else {
request.setAttribute("error", "Unknown login, please try again."); // Set error.
request.getRequestDispatcher("/WEB-INF/login.jsp").forward(request, response); // Forward to same page so that you can display error.
}
Un reindirizzamento indica quindi al client di attivare una nuova GET
richiesta sull'URL specificato. L'aggiornamento della richiesta aggiorna quindi solo la richiesta reindirizzata e non la richiesta iniziale. Ciò eviterà "doppi invii", confusione e cattive esperienze utente. Questo è anche chiamato il POST-Redirect-GET
modello .
L' RequestDispatcher
interfaccia consente di eseguire un forward / include lato server mentre sendRedirect()
esegue un reindirizzamento lato client. In un reindirizzamento lato client, il server invierà un codice di stato HTTP di 302
(reindirizzamento temporaneo) che fa sì che il browser web emetta una nuova GET
richiesta HTTP per il contenuto nella posizione reindirizzata. Al contrario, quando si utilizza l' RequestDispatcher
interfaccia, l'inclusione / inoltro della nuova risorsa viene gestito interamente dal lato server.
forward
non è reindirizzamento.
La principale differenza importante tra il metodo forward () e sendRedirect () è che in caso di forward (), il reindirizzamento avviene all'estremità del server e non è visibile al client, ma in caso di sendRedirect (), il reindirizzamento avviene all'estremità del client ed è visibile al cliente.
Ciascuno di questi metodi può essere "migliore", cioè più adatto, a seconda di ciò che si desidera fare.
Un reindirizzamento lato server è più veloce nella misura in cui ottieni i dati da una pagina diversa senza fare un viaggio di andata e ritorno al browser. Ma l'URL visualizzato nel browser è ancora l'indirizzo originale, quindi stai creando una piccola incoerenza lì.
Un reindirizzamento lato client è più versatile in quanto può inviarti a un server completamente diverso o cambiare il protocollo (ad esempio da HTTP a HTTPS) o entrambi. E il browser è a conoscenza del nuovo URL. Ma ci vuole un ulteriore avanti e indietro tra server e client.
SendRedirect()
cercherà il contenuto tra i server. è lento perché deve intimare il browser inviando l'URL del contenuto. quindi il browser creerà una nuova richiesta per il contenuto all'interno dello stesso server o in un altro.
RquestDispatcher
è per la ricerca del contenuto all'interno del server, penso. è il processo lato server ed è più veloce rispetto al SendRedirect()
metodo. ma il fatto è che non indicherà il browser in cui server sta cercando la data o il contenuto richiesti, né chiederà al browser di cambiare l'URL nella scheda URL. quindi causa poco disagio all'utente.
Tecnicamente, il reindirizzamento dovrebbe essere utilizzato se è necessario trasferire il controllo a un dominio diverso o per ottenere la separazione delle attività.
Ad esempio, nell'applicazione di pagamento eseguiamo prima il PaymentProcess e poi reindirizziamo a displayPaymentInfo. Se il client aggiorna il browser, verrà eseguito nuovamente solo displayPaymentInfo e PaymentProcess non verrà ripetuto. Ma se utilizziamo forward in questo scenario, sia PaymentProcess che displayPaymentInfo verranno rieseguiti in sequenza, il che potrebbe generare dati incoerenti.
Per altri scenari, forward è efficiente da usare poiché è più veloce di sendRedirect
Request Dispatcher è un'interfaccia che viene utilizzata per inviare la richiesta o la risposta dalla risorsa web a un'altra risorsa web. Contiene principalmente due metodi.
request.forward(req,res)
: Questo metodo viene utilizzato per inoltrare la richiesta da una risorsa Web a un'altra risorsa. cioè da un servlet a un altro servlet o da un'applicazione web a un'altra applicazione web.
response.include(req,res)
: Questo metodo viene utilizzato per includere la risposta di un servlet a un altro servlet
NOTA: utilizzando Request Dispatcher possiamo inoltrare o includere la richiesta o le risposte nello stesso server.
request.sendRedirect()
: Usando questo possiamo inoltrare o includere la richiesta o le risposte attraverso i diversi server. In questo il client riceve un'intimazione durante il reindirizzamento della pagina, ma nel processo sopra il client non riceverà alcuna intimazione
Semplicemente differenza tra Forward(ServletRequest request, ServletResponse response)
ed sendRedirect(String url)
è
inoltrare():
forward()
metodo viene eseguito sul lato server.forward ()
metodo è fornito dal contenitore servlet.forward()
metodo è più veloce del sendRedirect()
metodo.RequestDispatcher
nell'interfaccia.sendRedirect ():
response.sendRedirect("..")
alla pagina index.jsp del sito. Ma questo perde i file css e del testo dalla pagina jsp, portando a un caricamento parziale della pagina. Ma quando creo index.jsp nella pagina di benvenuto del sito web, tutto funziona correttamente e la pagina viene caricata completa. cosa c'è di sbagliato nel reindirizzamento?