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.core.request.mapper; import java.util.Objects; import java.util.function.Supplier; import org.apache.wicket.core.request.handler.ListenerRequestHandler; 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.mapper.info.ComponentInfo; import org.apache.wicket.request.mapper.info.PageComponentInfo; import org.apache.wicket.request.mapper.info.PageInfo; import org.apache.wicket.request.mapper.parameter.IPageParametersEncoder; import org.apache.wicket.request.mapper.parameter.PageParameters; import org.apache.wicket.request.mapper.parameter.PageParametersEncoder; import org.apache.wicket.util.lang.Args; import org.apache.wicket.util.reference.ClassReference; import org.apache.wicket.util.string.Strings; /** * Encoder for mounted URL. The mount path can contain parameter placeholders, i.e. * <code>/mount/${foo}/path</code>. In that case the appropriate segment from the URL will be * accessible as named parameter "foo" in the {@link PageParameters}. Similarly when the URL is * constructed, the second segment will contain the value of the "foo" named page parameter. * Optional parameters are denoted by using a # instead of $: <code>/mount/#{foo}/path/${bar}</code> * has an optional {@code foo} parameter, a fixed {@code /path/} part and a required {@code bar} * parameter. When in doubt, parameters are matched from left to right, where required parameters * are matched before optional parameters, and optional parameters eager (from left to right). * <p> * Decodes and encodes the following URLs: * * <pre> * Page Class - Render (BookmarkablePageRequestHandler for mounted pages) * /mount/point * (these will redirect to hybrid alternative if page is not stateless) * * IPage Instance - Render Hybrid (RenderPageRequestHandler for mounted pages) * /mount/point?2 * * IPage Instance - Bookmarkable Listener (BookmarkableListenerRequestHandler for mounted pages) * /mount/point?2-click-foo-bar-baz * /mount/point?2-5.click.1-foo-bar-baz (1 is behavior index, 5 is render count) * (these will redirect to hybrid if page is not stateless) * </pre> * * @author Matej Knopp */ public class MountedMapper extends AbstractBookmarkableMapper { /** bookmarkable page class. */ private final Supplier<Class<? extends IRequestablePage>> pageClassProvider; /** * Construct. * * @param mountPath * @param pageClass */ public MountedMapper(String mountPath, Class<? extends IRequestablePage> pageClass) { this(mountPath, pageClass, new PageParametersEncoder()); } /** * Construct. * * @param mountPath * @param pageClassProvider */ public MountedMapper(String mountPath, Supplier<Class<? extends IRequestablePage>> pageClassProvider) { this(mountPath, pageClassProvider, new PageParametersEncoder()); } /** * Construct. * * @param mountPath * @param pageClass * @param pageParametersEncoder */ public MountedMapper(String mountPath, Class<? extends IRequestablePage> pageClass, IPageParametersEncoder pageParametersEncoder) { this(mountPath, new ClassReference(pageClass), pageParametersEncoder); } /** * Construct. * * @param mountPath * @param pageClassProvider * @param pageParametersEncoder */ public MountedMapper(String mountPath, Supplier<Class<? extends IRequestablePage>> pageClassProvider, IPageParametersEncoder pageParametersEncoder) { super(mountPath, pageParametersEncoder); Args.notNull(pageClassProvider, "pageClassProvider"); this.pageClassProvider = pageClassProvider; } @Override protected UrlInfo parseRequest(Request request) { Url url = request.getUrl(); // when redirect to buffer/render is active and redirectFromHomePage returns true // check mounted class against the home page class. if it matches let wicket redirect // to the mounted URL if (redirectFromHomePage() && checkHomePage(url)) { return new UrlInfo(null, getContext().getHomePageClass(), newPageParameters()); } // check if the URL starts with the proper segments else if (urlStartsWithMountedSegments(url)) { // try to extract page and component information from URL PageComponentInfo info = getPageComponentInfo(url); Class<? extends IRequestablePage> pageClass = getPageClass(); PageParameters pageParameters = extractPageParameters(request, url); return new UrlInfo(info, pageClass, pageParameters); } else { return null; } } @Override public Url mapHandler(IRequestHandler requestHandler) { Url url = super.mapHandler(requestHandler); if (url == null && requestHandler instanceof ListenerRequestHandler && getRecreateMountedPagesAfterExpiry()) { ListenerRequestHandler handler = (ListenerRequestHandler) requestHandler; IRequestablePage page = handler.getPage(); if (checkPageInstance(page)) { Integer renderCount = null; if (handler.includeRenderCount()) { renderCount = page.getRenderCount(); } String componentPath = handler.getComponentPath(); PageInfo pageInfo = getPageInfo(handler); ComponentInfo componentInfo = new ComponentInfo(renderCount, componentPath, handler.getBehaviorIndex()); PageComponentInfo pageComponentInfo = new PageComponentInfo(pageInfo, componentInfo); PageParameters parameters = newPageParameters(); parameters.mergeWith(page.getPageParameters()); UrlInfo urlInfo = new UrlInfo(pageComponentInfo, page.getClass(), parameters.mergeWith(handler.getPageParameters())); url = buildUrl(urlInfo); } } return url; } /** * @see AbstractBookmarkableMapper#buildUrl(AbstractBookmarkableMapper.UrlInfo) */ @Override protected Url buildUrl(UrlInfo info) { Url url = new Url(); for (String s : mountSegments) { url.getSegments().add(s); } encodePageComponentInfo(url, info.getPageComponentInfo()); PageParameters copy = newPageParameters(); copy.mergeWith(info.getPageParameters()); if (setPlaceholders(copy, url) == false) { // mandatory parameter is not provided => cannot build Url return null; } return encodePageParameters(url, copy, pageParametersEncoder); } /** * Check if the URL is for home page and the home page class match mounted class. If so, * redirect to mounted URL. * * @param url * @return request handler or <code>null</code> */ private boolean checkHomePage(Url url) { if (url.getSegments().isEmpty() && url.getQueryParameters().isEmpty()) { // this is home page if (getPageClass().equals(getContext().getHomePageClass())) { return true; } } return false; } /** * If this method returns <code>true</code> and application home page class is same as the class * mounted with this encoder, request to home page will result in a redirect to the mounted * path. * * @return whether this encode should respond to home page request when home page class is same * as mounted class. */ protected boolean redirectFromHomePage() { return true; } /** * @see AbstractBookmarkableMapper#pageMustHaveBeenCreatedBookmarkable() */ @Override protected boolean pageMustHaveBeenCreatedBookmarkable() { return false; } /** * @see AbstractBookmarkableMapper#checkPageClass(java.lang.Class) */ @Override protected boolean checkPageClass(Class<? extends IRequestablePage> pageClass) { return Objects.equals(pageClass, this.getPageClass()); } private Class<? extends IRequestablePage> getPageClass() { return pageClassProvider.get(); } @Override public String toString() { return "MountedMapper [mountSegments=" + Strings.join("/", mountSegments) + "]"; } }