Package org.apache.wicket.markup

Class MarkupCache

  • All Implemented Interfaces:
    IMarkupCache
    public class MarkupCache
extends java.lang.Object
implements IMarkupCache
    This is Wicket's default IMarkupCache implementation. It will load the markup and cache it for fast retrieval.

    If the application is in development mode and a markup file changes, it'll automatically be removed from the cache and reloaded when needed.

    MarkupCache is registered with MarkupFactory which in turn is registered with MarkupSettings and thus can be replaced with a sub-classed version.

    Author:
    Jonathan Locke, Juergen Donnerstag
    See Also:
    MarkupSettings, MarkupFactory

    • Constructor Detail

      • MarkupCache

        protected MarkupCache()
        Constructor.

    • Method Detail

      • get

        public static IMarkupCache get()
        A convenient helper to get the markup cache registered with the application.
        Returns:
        The markup cache registered with the Application

      • clear

        public void clear()
        Description copied from interface: IMarkupCache
        Clear markup cache and force reload of all markup data
        Specified by:
        clear in interface IMarkupCache

      • shutdown

        public void shutdown()
        Description copied from interface: IMarkupCache
        Will be called by the application while shutting down. It allows the markup cache to cleanup if necessary.
        Specified by:
        shutdown in interface IMarkupCache

      • removeMarkup

        public final IMarkupFragment removeMarkup​(java.lang.String cacheKey)
        Note that this method will be called from a "cleanup" thread which might not have a thread local application.
        Specified by:
        removeMarkup in interface IMarkupCache
        Returns:
        The markup removed from the cache. Null, if nothing was found.
        See Also:
        MarkupResourceStream.getCacheKey()

      • size

        public final int size()
        Specified by:
        size in interface IMarkupCache
        Returns:
        the number of elements currently in the cache.

      • getMarkupCache

        public final MarkupCache.ICache<java.lang.String,​Markup> getMarkupCache()
        Get a unmodifiable map which contains the cached data. The map key is of type String and the value is of type Markup.

        May be used to debug or iterate the cache content.

        Returns:
        cache implementation

      • getMarkup

        public final Markup getMarkup​(MarkupContainer container,
                              java.lang.Class<?> clazz,
                              boolean enforceReload)
        Description copied from interface: IMarkupCache
        Gets any (immutable) markup resource for the container or any of its parent classes (markup inheritance)
        Specified by:
        getMarkup in interface IMarkupCache
        Parameters:
        container - The original requesting markup container
        clazz - The class to get the associated markup for. If null, the container's class is used, but it can be a parent class of the container as well (markup inheritance)
        enforceReload - The cache will be ignored and all, including inherited markup files, will be reloaded. Whatever is in the cache, it will be ignored
        Returns:
        Markup resource

      • onMarkupNotFound

        protected Markup onMarkupNotFound​(java.lang.String cacheKey,
                                  MarkupContainer container,
                                  Markup markup)
        Will be called if the markup was not in the cache yet and could not be found either.

        Subclasses may change the default implementation. E.g. they might choose not to update the cache to enforce reloading of any markup not found. This might be useful in very dynamic environments. Additionally a non-caching IResourceStreamLocator should be used.

        Parameters:
        cacheKey -
        container -
        markup - Markup.NO_MARKUP
        Returns:
        Same as parameter "markup"
        See Also:
        ResourceSettings.setResourceStreamLocator(org.apache.wicket.core.util.resource.locator.IResourceStreamLocator)

      • putIntoCache

        protected Markup putIntoCache​(java.lang.String locationString,
                              MarkupContainer container,
                              Markup markup)
        Put the markup into the cache if cacheKey is not null and the cache does not yet contain the cacheKey. Return the markup stored in the cache if cacheKey is present already. More sophisticated implementations may call a container method to e.g. cache it per container instance.
        Parameters:
        locationString - If null then ignore the cache
        container - The container this markup is for.
        markup -
        Returns:
        markup The markup provided, except if the cacheKey already existed in the cache, then the markup from the cache is provided.

      • getMarkupFromCache

        protected Markup getMarkupFromCache​(java.lang.String cacheKey,
                                    MarkupContainer container)
        Wicket's default implementation just uses the cacheKey to retrieve the markup from the cache. More sophisticated implementations may call a container method to e.g. ignore the cached markup under certain situations.
        Parameters:
        cacheKey - If null, than the cache will be ignored
        container -
        Returns:
        null, if not found or to enforce reloading the markup

      • getMarkupCacheKeyProvider

        public IMarkupCacheKeyProvider getMarkupCacheKeyProvider​(MarkupContainer container)
        Get the markup cache key provider to be used
        Parameters:
        container - The MarkupContainer requesting the markup resource stream
        Returns:
        IMarkupResourceStreamProvider

      • newCacheImplementation

        protected <K,​V> MarkupCache.ICache<K,​V> newCacheImplementation()
        Allows you to change the map implementation which will hold the cache data. By default it is a ConcurrentHashMap() in order to allow multiple thread to access the data in a secure way.
        Type Parameters:
        K -
        V -
        Returns:
        new instance of cache implementation