Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   *
   * Copyright (c) 1997-2012 Oracle and/or its affiliates. All rights reserved.
   *
   * The contents of this file are subject to the terms of either the GNU
   * General Public License Version 2 only ("GPL") or the Common Development
   * and Distribution License("CDDL") (collectively, the "License").  You
   * may not use this file except in compliance with the License.  You can
  * obtain a copy of the License at
  * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
  * or packager/legal/LICENSE.txt.  See the License for the specific
  * language governing permissions and limitations under the License.
  *
  * When distributing the software, include this License Header Notice in each
  * file and include the License file at packager/legal/LICENSE.txt.
  *
  * GPL Classpath Exception:
  * Oracle designates this particular file as subject to the "Classpath"
  * exception as provided by Oracle in the GPL Version 2 section of the License
  * file that accompanied this code.
  *
  * Modifications:
  * If applicable, add the following below the License Header, with the fields
  * enclosed by brackets [] replaced by your own identifying information:
  * "Portions Copyright [year] [name of copyright owner]"
  *
  * Contributor(s):
  * If you wish your version of this file to be governed by only the CDDL or
  * only the GPL Version 2, indicate your decision by adding "[Contributor]
  * elects to include this software in this distribution under the [CDDL or GPL
  * Version 2] license."  If you don't indicate a single choice of license, a
  * recipient has the option to distribute your version of this file under
  * either the CDDL, the GPL Version 2 or to extend the choice of license to
  * its licensees as provided above.  However, if you add GPL Version 2 code
  * and therefore, elected the GPL Version 2 license, then the option applies
  * only if the new code is made subject to such option by the copyright
  * holder.
  */
 
 package com.sun.appserv.web.cache;
 
 
 import java.util.*;
 
 public class CacheManager {
 
     public static final String CACHE_MANAGER_ATTR_NAME = 
         "com.sun.appserv.web.CacheManager";
 
     public static final int DEFAULT_CACHE_MAX_ENTRIES = 4096;
 
     public static final int DEFAULT_CACHE_TIMEOUT = 30;
 
     public static final String DEFAULT_CACHE_CLASSNAME = 
         "com.sun.appserv.util.cache.LruCache";
 
     private static final Logger _logger = .;

    
The resource bundle containing the localized message strings.
 
     private static final ResourceBundle _rb = .getResourceBundle();
 
     @LogMessageInfo(
             message = "Exception in creating cache",
             level = "WARNING")
     private static final String CACHE_MANAGER_EXCEPTION_CREATING_CACHE = "AS-WEB-00200";
 
     @LogMessageInfo(
             message = "Exception initializing cache-helper {0}; please check your helper class implementation",
             level = "INFO")
     private static final String CACHE_MANAGER_EXCEPTION_INITIALIZING_CACHE_HELPER = "AS-WEB-00201";
 
     // default max maximum number of entries in the cache
     
     boolean enabled = false;
 
     // application servlet context
 
     // XXX: potentially zero or more caches?
     Cache defaultCache;
 
     // cache mappings indexed by the filter name
        new HashMap<StringCacheMapping>();
    // default-helper, its properties
    // cache helpers indexed by their name and filter name
        new HashMap<StringHashMap<StringString>>();
        new HashMap<StringCacheHelper>();
        new HashMap<StringCacheHelper>();
    // CacheManagerListener classes
        new ArrayList<CacheManagerListener>();

    
default constructor
    public CacheManager() { }

    
set the maximum number of entries of this cache

Parameters:
maxEntries number of entries the cache should carry
    public void setMaxEntries(int maxEntries) {
        this. = maxEntries;
    }

    
set the defaultTimeout of this cache

Parameters:
defaultTimeout in seconds
    public void setDefaultTimeout(int defaultTimeout) {
        this. = defaultTimeout;
    }

    
set the whether this is enabled

Parameters:
enabled is this enabled?
    public void setEnabled(boolean enabled) {
        this. = enabled;
    }

    

Returns:
whether this is enabled
    public boolean isEnabled() {
        return ;
    }

    
add generic property

Parameters:
name named property
value value
    public void addProperty(String nameString value) {
        if (name.equalsIgnoreCase("cacheClassName")) {
            = value
        } else {
            if ( == null) {
                 = new Properties();
            }
            .setProperty(namevalue);
        }
    }

    
add a CacheHelper definition

Parameters:
name CacheHelper name
helperDef CacheHelper definition
    public void addCacheHelperDef(String nameHashMap<StringStringhelperDef) {
        .put(namehelperDef);
    }

    
set the default-helper's properties

Parameters:
map a HashMap of properties
    public void setDefaultHelperProps(Map<StringStringmap) {
        this. = map;
    }

    
set the ServletContext of this application

Parameters:
context ServletContext
    public void setServletContext(ServletContext context) {
        this. = context;
    }
    
    
load the helper class

Parameters:
className of the helper
Returns:
CacheHelper instance
    private CacheHelper loadCacheHelper(String className)
        throws Exception {
        // use the context class loader to load class so that any
        // user-defined classes in WEB-INF can also be loaded.
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        Class helperClass = cl.loadClass(className);
        CacheHelper helper = (CacheHelperhelperClass.newInstance();
        return helper;
    }

    
Start this Context component.

Throws:
org.apache.catalina.LifecycleException if a startup error occurs
    public void start() throws LifecycleException {
        if (!)
            return;
        // create the default cache
        try {
             = createCache();
        } catch (Exception e) {
        }
        // initialize the "default" helper
         = new DefaultCacheHelper();
        .setCacheManager(this);
        // initialize the custom cache-helpers
        Iterator<StringhelperNames = .keySet().iterator();
        while(helperNames.hasNext()) {
            String name = helperNames.next();
            HashMap<StringStringmap = .get(name);
            try {
                String className = map.get("class-name");
                CacheHelper helper = loadCacheHelper(className);
                helper.init(map);
                .put(namehelper);
            } catch (Exception e) {
                Object[] params = { name };
                msg = MessageFormat.format(msgparams);
                throw new LifecycleException(msge);
            }
        }
        // cache-mappings are ordered by the associated filter name
        Iterator<StringfilterNames = .keySet().iterator();
        while(filterNames.hasNext()) {
            String name = filterNames.next();
            CacheMapping mapping = .get(name);
            String helperNameRef = mapping.getHelperNameRef();
            CacheHelper helper;
            if (helperNameRef == null || helperNameRef.equals("default")) {
                helper = ;
            } else {
                helper = .get(helperNameRef);
            }
            .put(namehelper);
        }
    }

    
get the underlying cache name

Returns:
the cacheClassName
    public String getCacheClassName() {
        return ;
    }

    
create the designated cache object

Returns:
the Cache implementation
Throws:
java.lang.Exception
    public Cache createCache() throws Exception {
    }

    
create the designated cache object

Returns:
the Cache implementation
Throws:
java.lang.Exception
    public Cache createCache(int cacacityString className
                    throws Exception {
        // use the context class loader to load class so that any
        // user-defined classes in WEB-INF can also be loaded.
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        Class cacheClass = cl.loadClass(className);
        Cache cacheImpl = (Cache)cacheClass.newInstance();
        cacheImpl.init();
        return cacheImpl;
    }

    
get the application wide default cache expiry timeout

Returns:
timeout in seconds
    public int getDefaultTimeout() {
        return ;
    }

    
get the default application-wide cache

Returns:
cache object
    public Cache getDefaultCache() {
        return ;
    }

    
add cache mapping

Parameters:
name unique name of the mapping
mapping CacheMapping
    public void addCacheMapping(String nameCacheMapping mapping) {
        .put(namemapping);
    }

    
get cacheMapping given its name

Parameters:
name name identifying the mapping
Returns:
CacheMapping
    public CacheMapping getCacheMapping(String name) {
        return .get(name);
    }

    
get the helper by name

Parameters:
name name of the cache-helper
Returns:
CacheHelper implementation
    public CacheHelper getCacheHelper(String name) {
        return .get(name);
    }

    
get the helper by filter name

Parameters:
filterName filter name
Returns:
CacheHelper implementation
    public CacheHelper getCacheHelperByFilterName(String filterName) {
        return .get(filterName);
    }

    
add CacheManagerListener object

Parameters:
listener CacheManagerListener object
    public void addCacheManagerListener(CacheManagerListener listener) {
        synchronized () {
            .add(listener);
        }
    }

    
remove CacheManagerListener object

Parameters:
listener CacheManagerListener object
    public void removeCacheManagerListener(CacheManagerListener listener) {
        synchronized () {
            .remove(listener);
        }
    }

    
enable the cache manager (and all the listeners)
    public void enable() {
        for (int i = 0; i < .size(); i++) {
            CacheManagerListener listener = .get(i);
            listener.cacheManagerEnabled();
        }
    }

    
enable the cache manager (and all the listeners)
    public void disable() {
        for (int i = 0; i < .size(); i++) {
            CacheManagerListener listener = .get(i);
            listener.cacheManagerDisabled();
        }
    }

    
Stop this Context component. destroy all the caches created and flush/clear the cached content

Throws:
org.apache.catalina.LifecycleException if a shutdown error occurs
    public void stop() throws LifecycleException {
        disable();
        try {
            if ( != null) {
                .destroy();
            }
        } catch (Exception e) {
            // XXX: ignore
        }
        // destroy the cache-helpers
        Enumeration<CacheHelperhelpers = Collections.enumeration(.values());
        while(helpers.hasMoreElements()) {
            CacheHelper cacheHelper = helpers.nextElement();
            try {
                cacheHelper.destroy();
            } catch (Exception e) {
                // XXX: ignore
            }
        } 
        .clear();
        .clear();
        .clear();
    }
New to GrepCode? Check out our FAQ X