public void print(final Logger log) { final Collection<CacheLocation> locs = configuredLocations.values(); for (CacheLocation loc : locs) { final String id = loc.getId(); final List<Cache> caches = loc.getCaches(); log.warn("CacheLocation: " + id); for (Cache c : caches) { log.warn("\tCache: " + c.getId() + " : " + c.toString()); } } }
/** * Compile stats from all registered caches. * * <p>This is basically a hacky version of instrumentation which is being thrown in because we * don't have a full instrumentation strategy yet. This is here with the full expectation that it * will be replaced by something a bit more elaborate, like JMX. */ public static Map getStats() { Map allStats = new HashMap(); Cache cache = null; Iterator cachesIT = caches.values().iterator(); while (cachesIT.hasNext()) { cache = (Cache) cachesIT.next(); allStats.put(cache.getId(), cache.getStats()); } return allStats; }
/** * Ask the CacheManager to construct a cache. * * <p>Normally the CacheManager will use whatever CacheFactory has been chosen for the system via * the cache.defaultFactory property. However, it is possible to override the use of the default * factory by supplying a "factory" property to this method. The value should be the full * classname for the factory you want to use for constructing the cache. * * <p>example: factory -> org.apache.roller.weblogger.util.cache.LRUCacheFactoryImpl * * <p>This allows Roller admins the ability to choose a caching strategy to use for the whole * system, but override it in certain places where they see fit. It also allows users to write * their own caching modifications and have them used only by specific caches. */ public static Cache constructCache(CacheHandler handler, Map properties) { log.debug("Constructing new cache with props " + properties); Cache cache = null; if (properties != null && properties.containsKey("factory")) { // someone wants a custom cache instance String classname = (String) properties.get("factory"); try { // use reflection to instantiate the factory class Class factoryClass = Class.forName(classname); log.info("PageCacheFactory:" + factoryClass); CacheFactory factory = (CacheFactory) factoryClass.newInstance(); // now ask for a new cache cache = factory.constructCache(properties); } catch (ClassCastException cce) { log.error( "It appears that your factory [" + classname + "] does not implement the CacheFactory interface", cce); } catch (Exception e) { log.error( "Unable to instantiate cache factory [" + classname + "] falling back on default", e); } } if (cache == null) { // ask our default cache factory for a new cache instance cache = cacheFactory.constructCache(properties); } if (cache != null) { caches.put(cache.getId(), cache); // register the handler for this new cache if (handler != null) { cacheHandlers.add(handler); } } return cache; }