Global References To ApplicationContext(s) Unintrusively

June 6, 2005 – 19:58 | java, spring

Spring provides an out-of-box SingletonBeanFactoryLocator (or WebApplicationContextUtils in the case of a Web application) for code to globally reference bean factories and application contexts. The class takes a resource string (by default "classpath*:beanRefFactory.xml") and builds a bean factory from all the definition files on the classpath matching the resource string. Most of the time this suffices - straightforward and easy to use. However this locator-also-creates approach can be inconvenient in some cases, where I don't find myself having control over when and how to create the bean factories. This is where my "passive" AppContextCollector comes in.

The implementation itself is quite simple and straightforward.

PLAIN TEXT
JAVA:
  1. package com.digizen.commons.spring;
  2.  
  3. import org.apache.log4j.Logger;
  4.  
  5. import java.lang.ref.WeakReference;
  6. import java.util.HashMap;
  7. import java.util.Iterator;
  8. import java.util.Map;
  9.  
  10. import org.springframework.beans.BeansException;
  11. import org.springframework.beans.factory.BeanInitializationException;
  12. import org.springframework.beans.factory.InitializingBean;
  13. import org.springframework.context.ApplicationContext;
  14. import org.springframework.context.ApplicationContextAware;
  15.  
  16. import com.digizen.commons.util.ReferenceIteratorWrapper;
  17.  
  18. public class AppContextCollector implements ApplicationContextAware, InitializingBean {
  19.  
  20.     private static final Logger LOG = Logger.getLogger(AppContextCollector.class);
  21.  
  22.     private static Map<string , WeakReference<ApplicationContext>> contextMap_ =
  23.         new HashMap</string><string , WeakReference<ApplicationContext>>();
  24.  
  25.     private String currentKey_;
  26.     private ApplicationContext currentContext_;
  27.  
  28.     public static ApplicationContext getContext(String key) {
  29.         return contextMap_.get(key).get();
  30.     }
  31.  
  32.     public static Iterator<applicationcontext> getContextIterator() {
  33.         return new ReferenceIteratorWrapper</applicationcontext><applicationcontext>(contextMap_.values().iterator());
  34.     }
  35.  
  36.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  37.         currentContext_ = applicationContext;
  38.     }
  39.  
  40.     public String getContextKey() {
  41.         return currentKey_;
  42.     }
  43.  
  44.     public void setContextKey(String contextKey) {
  45.         currentKey_ = contextKey;
  46.     }
  47.  
  48.     public void afterPropertiesSet() throws BeanInitializationException{
  49.         if (currentKey_ == null) {
  50.             throw new BeanInitializationException("Property 'contextKey' is required.");
  51.         }
  52.  
  53.         contextMap_.put(currentKey_, new WeakReference</applicationcontext><applicationcontext>(currentContext_));
  54.  
  55.         if (LOG.isDebugEnabled()) {
  56.             LOG.debug("ApplicationContext '" + currentKey_ + "' is collected.");
  57.         }
  58.  
  59.         currentKey_ = null;
  60.         currentContext_ = null;
  61.     }
  62. }

To collect an ApplicationContext and make it available globally through a key, declare a Spring bean in the definition file for that particular ApplicationContext:

PLAIN TEXT
XML:
  1. <bean id="contextCollector"
  2.       class="com.digizen.commons.spring.AppContextCollector"
  3.       singleton="true">
  4.   <property name="contextKey"><value>mainContext</value></property>
  5. </bean>

Anywhere in your code, you can then use:

PLAIN TEXT
JAVA:
  1. AppContextCollector.getContext("mainContext");[/code]
  2.  
  3. To get the reference to the context instance.
  4.  
  5. Appendix: The <code>ReferenceIteratorWrapper</code> class(referenced in the above class) to avoid hanging onto any context references as they are supposed to be kept in weak references:
  6. [code lang="java"]
  7. package com.digizen.commons.util;
  8.  
  9. import java.lang.ref.Reference;
  10. import java.util.Iterator;
  11.  
  12. public final class ReferenceIteratorWrapper<t> implements Iterator</t><t> {
  13.  
  14.     private Iterator<? extends Reference<T>> iterator_;
  15.  
  16.     public ReferenceIteratorWrapper(Iterator<? extends Reference<T>> iterator) {
  17.         iterator_ = iterator;
  18.     }
  19.  
  20.     public boolean hasNext() {
  21.         return iterator_.hasNext();
  22.     }
  23.  
  24.     public T next() {
  25.         return iterator_.next().get();
  26.     }
  27.  
  28.     public T nextNotNull() {
  29.         while (iterator_.hasNext()) {
  30.             T t = iterator_.next().get();
  31.             if (t != null) {
  32.                 return t;
  33.             }
  34.         }
  35.         return null;
  36.     }
  37.  
  38.     public void remove() {
  39.         iterator_.remove();
  40.     }
  41. }

Trackback from your site, or follow the comments in RSS.

  1. 4 Responses to “Global References To ApplicationContext(s) Unintrusively”

  2. Great idea! I'm using Java 1.4, how would the non-generics version of ReferenceIteratorWrapper be?

    Thanks,
    Daniel Serodio

    By Daniel Serodio on Jul 16, 2005

  3. None of this really depends on generics. I guess to backport to 1.4, you just need to literally remove all the bracket pairs and whatever's between them, replace T with Object, and add type casting where necessary.

    By Jing Xue on Jul 16, 2005

  4. Thanks, I've been using your AppContextCollector successfully since then. Did you consider submitting it to Spring ?

    By Daniel Serodio on May 4, 2006

  5. Glad it helps. The Spring codebase is still pre-1.5 for the obvious compatibility reason. Also for it to fit into Spring, this class probably needs to implement the SingleFactoryLocator interface somehow.

    By Jing Xue on May 4, 2006

Post a Comment

The Path to Zen is proudly powered by WordPress Entries (RSS) and Comments (RSS). Designed by Bob