Package org.apache.wicket.protocol.http

Class WebApplication

  • All Implemented Interfaces:
    IEventSink, IMetadataContext<Object,​Application>, ISessionStore.UnboundListener
    Direct Known Subclasses:
    AuthenticatedWebApplication, MockApplication
    public abstract class WebApplication
extends Application
    A web application is a subclass of Application which associates with an instance of WicketServlet to serve pages over the HTTP protocol. This class is intended to be subclassed by framework clients to define a web application.

    Application settings are given defaults by the WebApplication() constructor and internalInit method, such as error page classes appropriate for HTML. WebApplication subclasses can override these values and/or modify other application settings by overriding the init() method and then by calling getXXXSettings() to retrieve an interface to a mutable Settings object. Do not do this in the constructor itself because the defaults will then override your settings.

    If you want to use a filter specific configuration, e.g. using init parameters from the FilterConfig object, you should override the init() method. For example: 

      public void init() {
  String webXMLParameter = getInitParameter("myWebXMLParameter");
  URL schedulersConfig = getServletContext().getResource("/WEB-INF/schedulers.xml");
  ...
    Author:
    Jonathan Locke, Chris Turner, Johan Compagner, Eelco Hillenius, Juergen Donnerstag
    See Also:
    WicketFilter, ApplicationSettings, DebugSettings, ExceptionSettings, MarkupSettings, PageSettings, RequestCycleSettings, ResourceSettings, SecuritySettings, Filter, FilterConfig, ServletContext

    • Constructor Detail

      • WebApplication

        public WebApplication()
        Constructor. Use init() for any configuration of your application instead of overriding the constructor.

    • Method Detail

      • getInitParameter

        public String getInitParameter​(String key)
        Gets an init parameter of the filter, or null if the parameter does not exist.
        Parameters:
        key - the key to search for
        Returns:
        the value of the filter init parameter

      • setServletContext

        public void setServletContext​(javax.servlet.ServletContext servletContext)
        Sets servlet context this application runs after. This is uaully done from a filter or a servlet responsible for managing this application object, such as WicketFilter
        Parameters:
        servletContext -

      • getServletContext

        public javax.servlet.ServletContext getServletContext()
        Gets the servlet context for this application. Use this to get references to absolute paths, global web.xml parameters (<context-param>), etc.
        Returns:
        The servlet context for this application

      • getSessionAttributePrefix

        public String getSessionAttributePrefix​(WebRequest request,
                                        String filterName)
        Gets the prefix for storing variables in the actual session (typically HttpSession for this application instance.
        Parameters:
        request - the request
        filterName - If null, than it defaults to the WicketFilter filter name. However according to the ServletSpec the Filter is not guaranteed to be initialized e.g. when WicketSessionFilter gets initialized. Thus, though you (and WicketSessionFilter) can provide a filter name, you must make sure it is the same as WicketFilter will provide once initialized.
        Returns:
        the prefix for storing variables in the actual session

      • mount

        public void mount​(IRequestMapper mapper)
        Mounts an encoder at the given path.
        Parameters:
        mapper - the encoder that will be used for this mount

      • mountPage

        public <T extends Page> MountedMapper mountPage​(String path,
                                                Class<T> pageClass)
        Mounts a page class to the given path.

        NOTE: mount path must not start with reserved URL segments! See IMapperContext to know which segments are reserved for internal use.

        Type Parameters:
        T - type of page
        Parameters:
        path - the path to mount the page class on
        pageClass - the page class to be mounted

      • mountResource

        public ResourceMapper mountResource​(String path,
                                    ResourceReference reference)
        Mounts a shared resource to the given path.

        NOTE: mount path must not start with reserved URL segments! See IMapperContext to know which segments are reserved for internal use.

        Parameters:
        path - the path to mount the resource reference on
        reference - resource reference to be mounted

      • mountPackage

        public <P extends Page> PackageMapper mountPackage​(String path,
                                                   Class<P> pageClass)
        Mounts mounts all bookmarkable pages in a the pageClass's package to the given path.

        NOTE: mount path must not start with reserved URL segments! See IMapperContext to know which segments are reserved for internal use.

        Type Parameters:
        P - type of page
        Parameters:
        path - the path to mount the page class on
        pageClass - the page class to be mounted

      • unmount

        public void unmount​(String path)
        Unregisters all IRequestMappers which would match on a this path.

        Useful in OSGi environments where a bundle may want to update the mount point.

        Parameters:
        path - the path to unmount

      • addResourceReplacement

        public final void addResourceReplacement​(JavaScriptResourceReference base,
                                         ResourceReference replacement)
        Registers a replacement resource for the given javascript resource. This replacement can be another JavaScriptResourceReference for a packaged resource, but it can also be an UrlResourceReference to replace the resource by a resource hosted on a CDN. Registering a replacement will cause the resource to replaced by the given resource throughout the application: if base is added, replacement will be added instead.
        Parameters:
        base - The resource to replace
        replacement - The replacement

      • addResourceReplacement

        public final void addResourceReplacement​(CssResourceReference base,
                                         ResourceReference replacement)
        Registers a replacement resource for the given CSS resource. This replacement can be another CssResourceReference for a packaged resource, but it can also be an UrlResourceReference to replace the resource by a resource hosted on a CDN. Registering a replacement will cause the resource to replaced by the given resource throughout the application: if base is added, replacement will be added instead.
        Parameters:
        base - The resource to replace
        replacement - The replacement

      • newWebRequest

        public WebRequest newWebRequest​(javax.servlet.http.HttpServletRequest servletRequest,
                                String filterPath)
        Create a new WebRequest. Subclasses of WebRequest could e.g. decode and obfuscate URL which has been encoded by an appropriate WebResponse.
        Parameters:
        servletRequest - the current HTTP Servlet request
        filterPath - the filter mapping read from web.xml
        Returns:
        a WebRequest object

      • newWebResponse

        protected WebResponse newWebResponse​(WebRequest webRequest,
                                     javax.servlet.http.HttpServletResponse httpServletResponse)
        Creates a WebResponse. Subclasses of WebRequest could e.g. encode wicket's default URL and hide the details from the user. A appropriate WebRequest must be implemented and configured to decode the encoded URL.
        Parameters:
        webRequest - the WebRequest that will handle the current HTTP Servlet request
        httpServletResponse - the current HTTP Servlet response
        Returns:
        a WebResponse object

      • newSession

        public Session newSession​(Request request,
                          Response response)
        Description copied from class: Application
        Creates a new session. Override this method if you want to provide a custom session.
        Specified by:
        newSession in class Application
        Parameters:
        request - The request that will create this session.
        response - The response to initialize, for example with cookies. This is important to use cases involving unit testing because those use cases might want to be able to sign a user in automatically when the session is created.
        Returns:
        The session

      • setWicketFilter

        public final void setWicketFilter​(WicketFilter wicketFilter)
        THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT CALL IT.
        Parameters:
        wicketFilter - The wicket filter instance for this application

      • init

        protected void init()
        Initialize; if you need the wicket servlet/filter for initialization, e.g. because you want to read an initParameter from web.xml or you want to read a resource from the servlet's context path, you can override this method and provide custom initialization. This method is called right after this application class is constructed, and the wicket servlet/filter is set. Use this method for any application setup instead of the constructor.
        Overrides:
        init in class Application

      • internalInit

        protected void internalInit()
        THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT CALL IT. Internal initialization. First determine the deployment mode. First check the system property -Dwicket.configuration. If it does not exist check the servlet init parameter ( <init-param><param-name>configuration</param-name>). If not found check the servlet context init parameter <context-param><param-name6gt;configuration</param-name>). If the parameter is "development" (which is default), settings appropriate for development are set. If it's "deployment" , deployment settings are used. If development is specified and a "sourceFolder" init parameter is also set, then resources in that folder will be polled for changes.
        Overrides:
        internalInit in class Application

      • getConfigurationType

        public RuntimeConfigurationType getConfigurationType()
        Gets the configuration mode to use for configuring the app, either RuntimeConfigurationType.DEVELOPMENT or RuntimeConfigurationType.DEPLOYMENT.

        The configuration type. Must currently be either DEVELOPMENT or DEPLOYMENT. Currently, if the configuration type is DEVELOPMENT, resources are polled for changes, component usage is checked, wicket tags are not stripped from output and a detailed exception page is used. If the type is DEPLOYMENT, component usage is not checked, wicket tags are stripped from output and a non-detailed exception page is used to display errors.

        Note that you should not run Wicket in DEVELOPMENT mode on production servers - the various debugging checks and resource polling is inefficient and may leak resources, particularly on webapp redeploy.

        To change the deployment mode, add the following to your web.xml, inside your mapping (or mapping if you're using 1.3.x): 

         <init-param>
             <param-name>configuration</param-name>
             <param-value>deployment</param-value>
 </init-param>

        You can alternatively set this as a <context-param> on the whole context.

        Another option is to set the "wicket.configuration" system property to either "deployment" or "development". The value is not case-sensitive.

        The system property is checked first, allowing you to add a web.xml param for deployment, and a command-line override when you want to run in development mode during development.

        You may also override Application.getConfigurationType() to provide your own custom switch, in which case none of the above logic is used.

        IMPORTANT NOTE

        THIS METHOD IS CALLED OFTEN FROM MANY DIFFERENT POINTS IN CODE, INCLUDING DURING THE RENDER PROCESS, THEREFORE THE IMPLEMENTATION SHOULD BE FAST - PREFERRABLY USING A FAST-TO-RETRIEVE CACHED VALUE
        Specified by:
        getConfigurationType in class Application
        Returns:
        configuration

      • renderXmlDecl

        public void renderXmlDecl​(WebPage page,
                          boolean insert)
        The rules if and when to insert an xml decl in the response are a bit tricky. Hence, we allow the user to replace the default implementation per page and per application.

        Default implementation: the page mime type must be "application/xhtml+xml" and request HTTP_ACCEPT header must include "application/xhtml+xml" to automatically include the xml decl. Please see Writing JavaScript for XHTML for details.

        Please note that xml decls in Wicket's markup are only used for reading the markup. The markup's xml decl will always be removed and never be used to configure the response.

        Parameters:
        page - The page currently being rendered
        insert - If false, than the rules are applied. If true, it'll always be written. In order to never insert it, than subclass renderXmlDecl() with an empty implementation.

      • newAjaxRequestTarget

        public final AjaxRequestTarget newAjaxRequestTarget​(Page page)
        Creates a new ajax request target used to control ajax responses
        Parameters:
        page - page on which ajax response is made
        Returns:
        non-null ajax request target instance

      • outputDevelopmentModeWarning

        protected void outputDevelopmentModeWarning()
        This method prints a warning to stderr that we are starting in development mode.

        If you really need to test Wicket in development mode on a staging server somewhere and are annoying the sysadmin for it with stderr messages, you can override this to make it do something else.

      • hasBufferedResponse

        public boolean hasBufferedResponse​(String sessionId,
                                   Url url)
        Parameters:
        sessionId -
        url -
        Returns:
        true if has buffered response

      • hasFilterFactoryManager

        public final boolean hasFilterFactoryManager()
        Returns:
        True if at least one filter factory has been added.