Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.wicket.request.handler.render; import java.util.List; import org.apache.wicket.Application; import org.apache.wicket.Session; import org.apache.wicket.core.request.handler.RenderPageRequestHandler; import org.apache.wicket.core.request.handler.RenderPageRequestHandler.RedirectPolicy; import org.apache.wicket.feedback.FeedbackCollector; import org.apache.wicket.feedback.FeedbackMessage; import org.apache.wicket.protocol.http.BufferedWebResponse; import org.apache.wicket.protocol.http.WebApplication; import org.apache.wicket.request.IRequestHandler; import org.apache.wicket.request.Request; import org.apache.wicket.request.Url; import org.apache.wicket.request.component.IRequestablePage; import org.apache.wicket.request.cycle.RequestCycle; import org.apache.wicket.request.http.WebRequest; import org.apache.wicket.request.http.WebResponse; import org.apache.wicket.util.lang.Objects; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * {@link PageRenderer} for web applications. * * @author Matej Knopp */ public class WebPageRenderer extends PageRenderer { private static final Logger logger = LoggerFactory.getLogger(WebPageRenderer.class); /** * Construct. * * @param renderPageRequestHandler */ public WebPageRenderer(RenderPageRequestHandler renderPageRequestHandler) { super(renderPageRequestHandler); } protected boolean isAjax(RequestCycle requestCycle) { boolean isAjax = false; Request request = requestCycle.getRequest(); if (request instanceof WebRequest) { WebRequest webRequest = (WebRequest) request; isAjax = webRequest.isAjax(); } return isAjax; } /** * Store the buffered response at application level. If current session is * temporary, a permanent one is created. * * @param url * @param response */ protected void storeBufferedResponse(Url url, BufferedWebResponse response) { if (isSessionTemporary()) { Session.get().bind(); } WebApplication.get().storeBufferedResponse(getSessionId(), url, response); } /** * Renders page to a {@link BufferedWebResponse}. All URLs in page will be rendered relative to * <code>targetUrl</code> * * @param targetUrl * @param requestCycle * @return BufferedWebResponse containing page body */ protected BufferedWebResponse renderPage(Url targetUrl, RequestCycle requestCycle) { // get the page before checking for a scheduled request handler because // the page may call setResponsePage in its constructor IRequestablePage requestablePage = getPage(); IRequestHandler scheduled = requestCycle.getRequestHandlerScheduledAfterCurrent(); if (scheduled != null) { // no need to render return null; } // keep the original response final WebResponse originalResponse = (WebResponse) requestCycle.getResponse(); // buffered web response for page BufferedWebResponse response = new BufferedWebResponse(originalResponse); // keep the original base URL Url originalBaseUrl = requestCycle.getUrlRenderer().setBaseUrl(targetUrl); try { requestCycle.setResponse(response); requestablePage.renderPage(); if (requestCycle.getRequestHandlerScheduledAfterCurrent() != null) { // This is a special case. // During page render another request handler got scheduled and will want to // overwrite the response, so we need to let it. // Just preserve the meta data headers. Clear the initial actions because they are // already copied into the new response's actions originalResponse.reset(); response.writeMetaData(originalResponse); return null; } else { return response; } } finally { // restore original response and base URL requestCycle.setResponse(originalResponse); requestCycle.getUrlRenderer().setBaseUrl(originalBaseUrl); } } /** * * @param url * @param requestCycle */ protected void redirectTo(Url url, RequestCycle requestCycle) { bindSessionIfNeeded(); WebResponse response = (WebResponse) requestCycle.getResponse(); String relativeUrl = requestCycle.getUrlRenderer().renderUrl(url); response.sendRedirect(relativeUrl); } /** * Bind the session if there are feedback messages pending. * https://issues.apache.org/jira/browse/WICKET-5165 */ private void bindSessionIfNeeded() { // check for session feedback messages only FeedbackCollector collector = new FeedbackCollector(); List<FeedbackMessage> feedbackMessages = collector.collect(); if (feedbackMessages.size() > 0) { Session.get().bind(); } } /* * TODO: simplify the code below. See WICKET-3347 */ @Override public void respond(RequestCycle requestCycle) { Url currentUrl = requestCycle.getUrlRenderer().getBaseUrl(); Url targetUrl = requestCycle.mapUrlFor(getRenderPageRequestHandler()); // // the code below is little hairy but we have to handle 3 redirect policies, // 3 rendering strategies and two kind of requests (ajax and normal) // if (shouldRenderPageAndWriteResponse(requestCycle, currentUrl, targetUrl)) { BufferedWebResponse response = renderPage(currentUrl, requestCycle); if (response != null) { response.writeTo((WebResponse) requestCycle.getResponse()); } } else if (shouldRedirectToTargetUrl(requestCycle, currentUrl, targetUrl)) { redirectTo(targetUrl, requestCycle); // note: if we had session here we would render the page to buffer and then // redirect to URL generated *after* page has been rendered (the statelessness // may change during render). this would save one redirect because now we have // to render to URL generated *before* page is rendered, render the page, get // URL after render and if the URL is different (meaning page is not stateless), // save the buffer and redirect again (which is pretty much what the next step // does) } else { if (isRedirectToBuffer() == false && logger.isDebugEnabled()) { String details = String.format("redirect strategy: '%s', isAjax: '%s', redirect policy: '%s', " + "current url: '%s', target url: '%s', is new: '%s', is stateless: '%s', is temporary: '%s'", Application.get().getRequestCycleSettings().getRenderStrategy(), isAjax(requestCycle), getRedirectPolicy(), currentUrl, targetUrl, isNewPageInstance(), isPageStateless(), isSessionTemporary()); logger.debug("Falling back to Redirect_To_Buffer render strategy because none of the conditions " + "matched. Details: " + details); } // force creation of possible stateful page to get the final target url getPage(); Url beforeRenderUrl = requestCycle.mapUrlFor(getRenderPageRequestHandler()); // redirect to buffer BufferedWebResponse response = renderPage(beforeRenderUrl, requestCycle); if (response == null) { return; } // the url might have changed after page has been rendered (e.g. the // stateless flag might have changed because stateful components // were added) final Url afterRenderUrl = requestCycle.mapUrlFor(getRenderPageRequestHandler()); if (beforeRenderUrl.getSegments().equals(afterRenderUrl.getSegments()) == false) { // the amount of segments is different - generated relative URLs // will not work, we need to rerender the page. This can happen // with IRequestHandlers that produce different URLs with // different amount of segments for stateless and stateful pages response = renderPage(afterRenderUrl, requestCycle); } if (currentUrl.equals(afterRenderUrl)) { // no need to redirect when both urls are exactly the same response.writeTo((WebResponse) requestCycle.getResponse()); } // if page is still stateless after render else if (isPageStateless() && !enableRedirectForStatelessPage()) { // we don't want the redirect to happen for stateless page // example: // when a normal mounted stateful page is hit at /mount/point // wicket renders the page to buffer and redirects to /mount/point?12 // but for stateless page the redirect is not necessary // also for request listeners on stateful page we want to redirect // after the listener is invoked, but on stateless page the user // must ask for redirect explicitly response.writeTo((WebResponse) requestCycle.getResponse()); } else { storeBufferedResponse(afterRenderUrl, response); redirectTo(afterRenderUrl, requestCycle); } } } protected boolean isPageStateless() { return getPage().isPageStateless(); } protected boolean isNewPageInstance() { return getPageProvider().isNewPageInstance(); } protected boolean shouldPreserveClientUrl(RequestCycle requestCycle) { return ((WebRequest) requestCycle.getRequest()).shouldPreserveClientUrl(); } /** * Should the client be redirected to target url. */ protected boolean shouldRedirectToTargetUrl(RequestCycle cycle, Url currentUrl, Url targetUrl) { return alwaysRedirect(getRedirectPolicy()) // || isRedirectToRender() // || (isAjax(cycle) && targetUrl.equals(currentUrl)) // || (!targetUrl.equals(currentUrl) && (isNewPageInstance() || (isSessionTemporary() && isPageStateless()))); // if target URL is different and session is temporary and page is stateless // this is special case when page is stateless but there is no session so we can't // render it to buffer // alternatively if URLs are different and we have a page class and not an instance we // can redirect to the url which will instantiate the instance of us } /** * Should the page be rendered immediately. */ protected boolean shouldRenderPageAndWriteResponse(RequestCycle cycle, Url currentUrl, Url targetUrl) { // WICKET-5484 never render and write for Ajax requests if (isAjax(cycle)) { return false; } return (compatibleProtocols(currentUrl.getProtocol(), targetUrl.getProtocol())) && (neverRedirect(getRedirectPolicy()) || ((isOnePassRender() && notForcedRedirect(getRedirectPolicy())) || (targetUrl.equals(currentUrl) && (!isNewPageInstance() && !isPageStateless()))) || (targetUrl.equals(currentUrl) && isRedirectToRender()) || (shouldPreserveClientUrl(cycle) && notForcedRedirect(getRedirectPolicy()))); } private static boolean neverRedirect(RedirectPolicy redirectPolicy) { return redirectPolicy == RedirectPolicy.NEVER_REDIRECT; } private static boolean alwaysRedirect(RedirectPolicy redirectPolicy) { return redirectPolicy == RedirectPolicy.ALWAYS_REDIRECT; } private static boolean notForcedRedirect(RedirectPolicy redirectPolicy) { return !alwaysRedirect(redirectPolicy); } /** * Compares the protocols of two {@link Url}s * * @param p1 * the first protocol * @param p2 * the second protocol * @return {@code false} if the protocols are both non-null and not equal, * {@code true} - otherwise */ protected boolean compatibleProtocols(String p1, String p2) { if (p1 != null && p2 != null) { return Objects.equal(p1, p2); } return true; } }