Package org.springframework.beans

Class CachedIntrospectionResults

java.lang.Object
org.springframework.beans.CachedIntrospectionResults
public final class CachedIntrospectionResults extends Object
Internal class that caches JavaBeans PropertyDescriptor information for a Java class. Not intended for direct use by application code.

Necessary for Spring's own caching of bean descriptors within the application ClassLoader, rather than relying on the JDK's system-wide BeanInfo cache (in order to avoid leaks on individual application shutdown in a shared JVM).

Information is cached statically, so we don't need to create new objects of this class for every JavaBean we manipulate. Hence, this class implements the factory design pattern, using a private constructor and a static forClass(Class) factory method to obtain instances.

Note that for caching to work effectively, some preconditions need to be met: Prefer an arrangement where the Spring jars live in the same ClassLoader as the application classes, which allows for clean caching along with the application's lifecycle in any case. For a web application, consider declaring a local IntrospectorCleanupListener in web.xml in case of a multi-ClassLoader layout, which will allow for effective caching as well.

In case of a non-clean ClassLoader arrangement without a cleanup listener having been set up, this class will fall back to a weak-reference-based caching model that recreates much-requested entries every time the garbage collector removed them. In such a scenario, consider the IGNORE_BEANINFO_PROPERTY_NAME system property.

Since:
05 May 2001
Author:
Rod Johnson, Juergen Hoeller
See Also:

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static final String
    IGNORE_BEANINFO_PROPERTY_NAME
    System property that instructs Spring to use the Introspector.IGNORE_ALL_BEANINFO mode when calling the JavaBeans Introspector: "spring.beaninfo.ignore", with a value of "true" skipping the search for BeanInfo classes (typically for scenarios where no such classes are being defined for beans in the application in the first place).

  • Method Summary

    Modifier and Type
    Method
    Description
    static void
    acceptClassLoader(ClassLoader classLoader)
    Accept the given ClassLoader as cache-safe, even if its classes would not qualify as cache-safe in this CachedIntrospectionResults class.
    static void
    clearClassLoader(ClassLoader classLoader)
    Clear the introspection cache for the given ClassLoader, removing the introspection results for all classes underneath that ClassLoader, and removing the ClassLoader (and its children) from the acceptance list.

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • Field Details

    • IGNORE_BEANINFO_PROPERTY_NAME

      public static final String IGNORE_BEANINFO_PROPERTY_NAME
      System property that instructs Spring to use the Introspector.IGNORE_ALL_BEANINFO mode when calling the JavaBeans Introspector: "spring.beaninfo.ignore", with a value of "true" skipping the search for BeanInfo classes (typically for scenarios where no such classes are being defined for beans in the application in the first place).

      The default is "false", considering all BeanInfo metadata classes, like for standard Introspector.getBeanInfo(Class) calls. Consider switching this flag to "true" if you experience repeated ClassLoader access for non-existing BeanInfo classes, in case such access is expensive on startup or on lazy loading.

      Note that such an effect may also indicate a scenario where caching doesn't work effectively: Prefer an arrangement where the Spring jars live in the same ClassLoader as the application classes, which allows for clean caching along with the application's lifecycle in any case. For a web application, consider declaring a local IntrospectorCleanupListener in web.xml in case of a multi-ClassLoader layout, which will allow for effective caching as well.

      See Also:

  • Method Details

    • acceptClassLoader

      public static void acceptClassLoader(@Nullable ClassLoader classLoader)
      Accept the given ClassLoader as cache-safe, even if its classes would not qualify as cache-safe in this CachedIntrospectionResults class.

      This configuration method is only relevant in scenarios where the Spring classes reside in a 'common' ClassLoader (e.g. the system ClassLoader) whose lifecycle is not coupled to the application. In such a scenario, CachedIntrospectionResults would by default not cache any of the application's classes, since they would create a leak in the common ClassLoader.

      Any acceptClassLoader call at application startup should be paired with a clearClassLoader(java.lang.ClassLoader) call at application shutdown.

      Parameters:
      classLoader - the ClassLoader to accept

    • clearClassLoader

      public static void clearClassLoader(@Nullable ClassLoader classLoader)
      Clear the introspection cache for the given ClassLoader, removing the introspection results for all classes underneath that ClassLoader, and removing the ClassLoader (and its children) from the acceptance list.
      Parameters:
      classLoader - the ClassLoader to clear the cache for