protected AbstractCacheAdministrator() 
{
                       
        this(null);
}

Create the AbstractCacheAdministrator. This will initialize all values and load the properties from oscache.properties.

 protected AbstractCacheAdministrator(Properties p) 
{
        loadProps(p);
        initCacheParameters();
        if (log.isDebugEnabled()) {
            log.debug("Constructed AbstractCacheAdministrator()");
        }
}

Create the AbstractCacheAdministrator.

Parameters:

p - the configuration properties for this cache.

 protected Cache configureStandardListeners(Cache cache) 
{
        if (config.getProperty(PERSISTENCE_CLASS_KEY) != null) {
            cache = setPersistenceListener(cache);
        }
        if (config.getProperty(CACHE_ENTRY_EVENT_LISTENERS_KEY) != null) {
            // Grab all the specified listeners and add them to the cache's
            // listener list. Note that listeners that implement more than
            // one of the event interfaces will be added multiple times.
            CacheEventListener[] listeners = getCacheEventListeners();
            for (int i = 0; i <  listeners.length; i++) {
                // Pass through the configuration to those listeners that require it
                if (listeners[i] instanceof LifecycleAware) {
                    try {
                        ((LifecycleAware) listeners[i]).initialize(cache, config);
                    } catch (InitializationException e) {
                        log.error("Could not initialize listener '" + listeners[i].getClass().getName() + "'. Listener ignored.", e);
                        continue;
                    }
                }
                if (listeners[i] instanceof CacheEntryEventListener) {
                    cache.addCacheEventListener(listeners[i]);
                } else if (listeners[i] instanceof CacheMapAccessEventListener) {
                    cache.addCacheEventListener(listeners[i]);
                }
            }
        }
        return cache;
}

Applies all of the recognised listener classes to the supplied cache object. Recognised classes are CacheEntryEventListener and CacheMapAccessEventListener .

 protected  void finalizeListeners(Cache cache) 
{
        // It's possible for cache to be null if getCache() was never called (CACHE-63)
        if (cache == null) {
            return;
        }
        Object[] listeners = cache.listenerList.getListenerList();
        for (int i = listeners.length - 2; i  >= 0; i -= 2) {
            if (listeners[i + 1] instanceof LifecycleAware) {
                try {
                    ((LifecycleAware) listeners[i + 1]).finialize();
                } catch (FinalizationException e) {
                    log.error("Listener could not be finalized", e);
                }
            }
        }
}

Finalizes all the listeners that are associated with the given cache object. Any FinalizationExceptions that are thrown by the listeners will be caught and logged.

 protected CacheEventListener[] getCacheEventListeners() 
{
        List classes = StringUtil.split(config.getProperty(CACHE_ENTRY_EVENT_LISTENERS_KEY), ',");
        CacheEventListener[] listeners = new CacheEventListener[classes.size()];
        for (int i = 0; i <  classes.size(); i++) {
            String className = (String) classes.get(i);
            try {
                Class clazz = Class.forName(className);
                if (!CacheEventListener.class.isAssignableFrom(clazz)) {
                    log.error("Specified listener class '" + className + "' does not implement CacheEventListener. Ignoring this listener.");
                } else {
                    listeners[i] = (CacheEventListener) clazz.newInstance();
                }
            } catch (ClassNotFoundException e) {
                log.error("CacheEventListener class '" + className + "' not found. Ignoring this listener.", e);
            } catch (InstantiationException e) {
                log.error("CacheEventListener class '" + className + "' could not be instantiated because it is not a concrete class. Ignoring this listener.", e);
            } catch (IllegalAccessException e) {
                log.error("CacheEventListener class '" + className + "' could not be instantiated because it is not public. Ignoring this listener.", e);
            }
        }
        return listeners;
}

Retrieves an array containing instances all of the CacheEventListener classes that are specified in the OSCache configuration file.

 public String getProperty(String key) 
{
        return config.getProperty(key);
}

Retrieves the value of one of the configuration properties.

 public boolean isBlocking() 
{
        return blocking;
}

Indicates whether the cache will block waiting for new content to be built, or serve stale content instead of waiting. Regardless of this setting, the cache will always block if new content is being created, ie, there's no stale content in the cache that can be served.

 public boolean isMemoryCaching() 
{
        return memoryCaching;
}

Whether entries are cached in memory or not. Default is true. Set by the cache.memory property.

 public boolean isOverflowPersistence() 
{
        return this.overflowPersistence;
}

Check if we use overflowPersistence

 public boolean isUnlimitedDiskCache() 
{
        return unlimitedDiskCache;
}

Indicates whether the unlimited disk cache is enabled or not.

 public  void setAlgorithmClass(String newAlgorithmClass) 
{
        algorithmClass = newAlgorithmClass;
}

Sets the algorithm to use for the cache.

 protected  void setCacheCapacity(int newCacheCapacity) 
{
        cacheCapacity = newCacheCapacity;
}

Sets the cache capacity (number of items). Administrator implementations should override this method to ensure that their Cache objects are updated correctly (by calling AbstractConcurrentReadCache#setMaxEntries(int) }}.

 public  void setOverflowPersistence(boolean overflowPersistence) 
{
        this.overflowPersistence = overflowPersistence;
}

Sets the overflowPersistence flag

 protected Cache setPersistenceListener(Cache cache) 
{
        String persistenceClassname = config.getProperty(PERSISTENCE_CLASS_KEY);
        try {
            Class clazz = Class.forName(persistenceClassname);
            PersistenceListener persistenceListener = (PersistenceListener) clazz.newInstance();
            cache.setPersistenceListener(persistenceListener.configure(config));
        } catch (ClassNotFoundException e) {
            log.error("PersistenceListener class '" + persistenceClassname + "' not found. Check your configuration.", e);
        } catch (Exception e) {
            log.error("Error instantiating class '" + persistenceClassname + "'", e);
        }
        return cache;
}

If there is a PersistenceListener in the configuration it will be instantiated and applied to the given cache object. If the PersistenceListener cannot be found or instantiated, an error will be logged but the cache will not have a persistence listener applied to it and no exception will be thrown.

A cache can only have one PersistenceListener.