Class MarkupCache

  • All Implemented Interfaces:

    public class MarkupCache
    extends 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.

    Jonathan Locke, Juergen Donnerstag
    See Also:
    MarkupSettings, MarkupFactory
    • Constructor Detail

    • Method Detail

      • 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
      • size

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

        public final MarkupCache.ICache<String,​MarkupgetMarkupCache()
        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.

        cache implementation
      • getMarkup

        public final Markup getMarkup​(MarkupContainer container,
                                      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
        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
        Markup resource
      • putIntoCache

        protected Markup putIntoCache​(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.
        locationString - If null then ignore the cache
        container - The container this markup is for.
        markup -
        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​(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.
        cacheKey - If null, than the cache will be ignored
        container -
        null, if not found or to enforce reloading the markup
      • 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 -
        new instance of cache implementation