1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 package org.apache.commons.beanutils; 19 20 import java.util.Map; 21 import java.util.WeakHashMap; 22 23 /** 24 * An instance of this class represents a value that is provided per (thread) 25 * context classloader. 26 * 27 * <p>Occasionally it is necessary to store data in "global" variables 28 * (including uses of the Singleton pattern). In applications which have only 29 * a single classloader such data can simply be stored as "static" members on 30 * some class. When multiple classloaders are involved, however, this approach 31 * can fail; in particular, this doesn't work when the code may be run within a 32 * servlet container or a j2ee container, and the class on which the static 33 * member is defined is loaded via a "shared" classloader that is visible to all 34 * components running within the container. This class provides a mechanism for 35 * associating data with a ClassLoader instance, which ensures that when the 36 * code runs in such a container each component gets its own copy of the 37 * "global" variable rather than unexpectedly sharing a single copy of the 38 * variable with other components that happen to be running in the same 39 * container at the same time (eg servlets or EJBs.)</p> 40 * 41 * <p>This class is strongly patterned after the java.lang.ThreadLocal 42 * class, which performs a similar task in allowing data to be associated 43 * with a particular thread.</p> 44 * 45 * <p>When code that uses this class is run as a "normal" application, ie 46 * not within a container, the effect is identical to just using a static 47 * member variable to store the data, because Thread.getContextClassLoader 48 * always returns the same classloader (the system classloader).</p> 49 * 50 * <p>Expected usage is as follows:<br> 51 * <pre> 52 * public class SomeClass { 53 * private static final ContextClassLoaderLocal<String> global 54 * = new ContextClassLoaderLocal<String>() { 55 * protected String initialValue() { 56 * return new String("Initial value"); 57 * }; 58 * 59 * public void testGlobal() { 60 * String s = global.get(); 61 * System.out.println("global value:" + s); 62 * buf.set("New Value"); 63 * } 64 * </pre> 65 * </p> 66 * 67 * <p><strong>Note:</strong> This class takes some care to ensure that when 68 * a component which uses this class is "undeployed" by a container the 69 * component-specific classloader and all its associated classes (and their 70 * static variables) are garbage-collected. Unfortunately there is one 71 * scenario in which this does <i>not</i> work correctly and there 72 * is unfortunately no known workaround other than ensuring that the 73 * component (or its container) calls the "unset" method on this class for 74 * each instance of this class when the component is undeployed. The problem 75 * occurs if: 76 * <ul> 77 * <li>the class containing a static instance of this class was loaded via 78 * a shared classloader, and</li> 79 * <li>the value stored in the instance is an object whose class was loaded 80 * via the component-specific classloader (or any of the objects it refers 81 * to were loaded via that classloader).</li> 82 * </ul> 83 * The result is that the map managed by this object still contains a strong 84 * reference to the stored object, which contains a strong reference to the 85 * classloader that loaded it, meaning that although the container has 86 * "undeployed" the component the component-specific classloader and all the 87 * related classes and static variables cannot be garbage-collected. This is 88 * not expected to be an issue with the commons-beanutils library as the only 89 * classes which use this class are BeanUtilsBean and ConvertUtilsBean and 90 * there is no obvious reason for a user of the beanutils library to subclass 91 * either of those classes.</p> 92 * 93 * <p><strong>Note:</strong> A WeakHashMap bug in several 1.3 JVMs results in 94 * a memory leak for those JVMs.</p> 95 * 96 * <p><strong>Note:</strong> Of course all of this would be unnecessary if 97 * containers required each component to load the full set of classes it 98 * needs, ie avoided providing classes loaded via a "shared" classloader.</p> 99 * 100 * @param <T> the type of data stored in an instance 101 * @version $Id$ 102 * @see java.lang.Thread#getContextClassLoader 103 */ 104 public class ContextClassLoaderLocal<T> { 105 private final Map<ClassLoader, T> valueByClassLoader = new WeakHashMap<ClassLoader, T>(); 106 private boolean globalValueInitialized = false; 107 private T globalValue; 108 109 /** 110 * Construct a context classloader instance 111 */ 112 public ContextClassLoaderLocal() { 113 super(); 114 } 115 116 /** 117 * Returns the initial value for this ContextClassLoaderLocal 118 * variable. This method will be called once per Context ClassLoader for 119 * each ContextClassLoaderLocal, the first time it is accessed 120 * with get or set. If the programmer desires ContextClassLoaderLocal variables 121 * to be initialized to some value other than null, ContextClassLoaderLocal must 122 * be subclassed, and this method overridden. Typically, an anonymous 123 * inner class will be used. Typical implementations of initialValue 124 * will call an appropriate constructor and return the newly constructed 125 * object. 126 * 127 * @return a new Object to be used as an initial value for this ContextClassLoaderLocal 128 */ 129 protected T initialValue() { 130 return null; 131 } 132 133 /** 134 * Gets the instance which provides the functionality for {@link BeanUtils}. 135 * This is a pseudo-singleton - an single instance is provided per (thread) context classloader. 136 * This mechanism provides isolation for web apps deployed in the same container. 137 * @return the object currently associated with the context-classloader of the current thread. 138 */ 139 public synchronized T get() { 140 // synchronizing the whole method is a bit slower 141 // but guarantees no subtle threading problems, and there's no 142 // need to synchronize valueByClassLoader 143 144 // make sure that the map is given a change to purge itself 145 valueByClassLoader.isEmpty(); 146 try { 147 148 final ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader(); 149 if (contextClassLoader != null) { 150 151 T value = valueByClassLoader.get(contextClassLoader); 152 if ((value == null) 153 && !valueByClassLoader.containsKey(contextClassLoader)) { 154 value = initialValue(); 155 valueByClassLoader.put(contextClassLoader, value); 156 } 157 return value; 158 159 } 160 161 } catch (final SecurityException e) { /* SWALLOW - should we log this? */ } 162 163 // if none or exception, return the globalValue 164 if (!globalValueInitialized) { 165 globalValue = initialValue(); 166 globalValueInitialized = true; 167 }//else already set 168 return globalValue; 169 } 170 171 /** 172 * Sets the value - a value is provided per (thread) context classloader. 173 * This mechanism provides isolation for web apps deployed in the same container. 174 * 175 * @param value the object to be associated with the entrant thread's context classloader 176 */ 177 public synchronized void set(final T value) { 178 // synchronizing the whole method is a bit slower 179 // but guarentees no subtle threading problems 180 181 // make sure that the map is given a change to purge itself 182 valueByClassLoader.isEmpty(); 183 try { 184 185 final ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader(); 186 if (contextClassLoader != null) { 187 valueByClassLoader.put(contextClassLoader, value); 188 return; 189 } 190 191 } catch (final SecurityException e) { /* SWALLOW - should we log this? */ } 192 193 // if in doubt, set the global value 194 globalValue = value; 195 globalValueInitialized = true; 196 } 197 198 /** 199 * Unsets the value associated with the current thread's context classloader 200 */ 201 public synchronized void unset() { 202 try { 203 204 final ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader(); 205 unset(contextClassLoader); 206 207 } catch (final SecurityException e) { /* SWALLOW - should we log this? */ } 208 } 209 210 /** 211 * Unsets the value associated with the given classloader 212 * @param classLoader The classloader to <i>unset</i> for 213 */ 214 public synchronized void unset(final ClassLoader classLoader) { 215 valueByClassLoader.remove(classLoader); 216 } 217 }