View Javadoc
   /* ====================================================================
    * License: 
    * 
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions
    * are met:
    *
    * 1. Redistributions of source code must retain the above copyright
    *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by 
   *        Robert Half International (http://www.rhi.com/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Parc", "RHI", and "Robert Half International" must
   *    not be used to endorse or promote products derived from this
   *    software without prior written permission. For written
   *    permission, please contact pete.mckinstry@rhi.com.
   *
   * 5. Products derived from this software may not be called "PARC",
   *    nor may "PARC" appear in their name, without prior written
   *    permission of Robert Half International.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   */
  package com.rhi.architecture.cache.simple;
  
  import com.rhi.architecture.cache.CacheFactory;
  import com.rhi.architecture.cache.CacheLoader;
  import com.rhi.architecture.cache.CacheManager;
  import com.rhi.architecture.logging.LogUtil;
  import com.rhi.architecture.logging.Logger;
  import com.rhi.architecture.config.ConfigurationException;
  import com.rhi.architecture.resource.InitializationException;
  
  import java.util.Enumeration;
  import java.util.HashMap;
  import java.util.Properties;
  
  /***
   * CacheFactory class manages caching creation/retrieval of specific cache mgr.
   * This class uses simple HashMap to store cacheable objects.
   *
   * It is a resource class hence has it will be registered into the
   * the ResourceContext and in the init method it initilizes all the
   * CacheManagers and its respective caches.
   *
   * @author G Srinivas
   * @copyright 2002, Robert Half Int'l., Inc. All rights reserved.
   *
   * @since 1.0
   */
  public class SimpleCacheFactory implements CacheFactory {
     
     private HashMap managers; // Collection of CacheManagers.
  
     private static Logger log = null;
  
     /***
      * convenience method to retrieve logger.
      * @return
      */
     protected static Logger log() {
        return log;
     }
  
     /***
      * Constructor
      *
      * @since 1.0
      */
     public SimpleCacheFactory() {
        super();
     }
  
     /***
      * This init method will be called while Resources are being
      * registered and initilised.  It obtains all the cacheable objects
     * class names and calls load on it to load cache in the CacheManagers.
     *
     * @param p
     * @exception InitializationException
     */
    public void init(Properties p) throws InitializationException {
       try {
          log = LogUtil.getLogger();
       }
       catch (ConfigurationException e) {
          throw new InitializationException(
             "Logger cannot be initialized:",
             e);
       }
 
       managers = new HashMap(50);
       log().info("Entered SimpleCacheFactory init method");
 
       // Pick each from config table and load for each.
       Enumeration names = p.propertyNames();
       String cacheableClassName = null;
       SimpleCacheManager cacheManager = null;
       String propertyName = null;
       Object cacheableObject = null;
       Class cacheableClass = null;
 
       try {
          while (names.hasMoreElements()) {
             propertyName = (String) names.nextElement();
             if (propertyName.startsWith("CacheableClass.")) {
                log().debug("CacheableClass is present:" + propertyName);
                cacheableClassName = p.getProperty(propertyName);
                cacheManager = new SimpleCacheManager(cacheableClassName);
 
                //Add the CacheManager to the manager list.
                managers.put(cacheableClassName, cacheManager);
                cacheableClass = Class.forName(cacheableClassName);
                cacheableObject = cacheableClass.newInstance();
 
                /*
                 * Check if the cacheable instance is implementing
                 * CacheLoader, if yes, then call its loadCache() method
                 * to load all its data into cache ie by adding cache in
                 * cachemanager that is passed as argument.  Otherwise
                 * the cacheable object is understood to be lazy-loaded.
                 */
                if (cacheableObject instanceof CacheLoader) {
                   ((CacheLoader) cacheableObject).loadCache(cacheManager);
                }
             }
          } //enum
       }
       catch (ClassNotFoundException cnfe) {
          throw new InitializationException("ClassNotFoundException", cnfe);
       }
       catch (InstantiationException ie) {
          throw new InitializationException("InstantiationException", ie);
       }
       catch (IllegalAccessException iae) {
          throw new InitializationException("IllegalAccessException", iae);
       }
    }
 
    /***
     * Retrieves the CacheManager that is specific to the className object.
     *
     * @param className
     * @return CacheManager
     */
    public CacheManager getManager(Object className) {
       return (CacheManager) managers.get(className);
    }
 
    /***
     * As part of Resource object it cleans up the CacheManagers
     * which inturn will make cached data garbage collected.
     */
    public void close() {
       managers.clear();
    }
 
 }