Open Source Repository

Home /spring/spring-context-3.0.5 | Repository Home


org/springframework/jndi/JndiObjectFactoryBean.java
/*
 * Copyright 2002-2010 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.jndi;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import javax.naming.Context;
import javax.naming.NamingException;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

import org.springframework.aop.framework.ProxyFactory;
import org.springframework.beans.factory.BeanClassLoaderAware;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.util.ClassUtils;

/**
 {@link org.springframework.beans.factory.FactoryBean} that looks up a
 * JNDI object. Exposes the object found in JNDI for bean references,
 * e.g. for data access object's "dataSource" property in case of a
 {@link javax.sql.DataSource}.
 *
 <p>The typical usage will be to register this as singleton factory
 * (e.g. for a certain JNDI-bound DataSource) in an application context,
 * and give bean references to application services that need it.
 *
 <p>The default behavior is to look up the JNDI object on startup and cache it.
 * This can be customized through the "lookupOnStartup" and "cache" properties,
 * using a {@link JndiObjectTargetSource} underneath. Note that you need to specify
 * a "proxyInterface" in such a scenario, since the actual JNDI object type is not
 * known in advance.
 *
 <p>Of course, bean classes in a Spring environment may lookup e.g. a DataSource
 * from JNDI themselves. This class simply enables central configuration of the
 * JNDI name, and easy switching to non-JNDI alternatives. The latter is
 * particularly convenient for test setups, reuse in standalone clients, etc.
 *
 <p>Note that switching to e.g. DriverManagerDataSource is just a matter of
 * configuration: Simply replace the definition of this FactoryBean with a
 {@link org.springframework.jdbc.datasource.DriverManagerDataSource} definition!
 *
 @author Juergen Hoeller
 @since 22.05.2003
 @see #setProxyInterface
 @see #setLookupOnStartup
 @see #setCache
 @see JndiObjectTargetSource
 */
public class JndiObjectFactoryBean extends JndiObjectLocator implements FactoryBean<Object>, BeanClassLoaderAware {

  private Class[] proxyInterfaces;

  private boolean lookupOnStartup = true;

  private boolean cache = true;

  private boolean exposeAccessContext = false;

  private Object defaultObject;

  private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();

  private Object jndiObject;


  /**
   * Specify the proxy interface to use for the JNDI object.
   <p>Typically used in conjunction with "lookupOnStartup"=false and/or "cache"=false.
   * Needs to be specified because the actual JNDI object type is not known
   * in advance in case of a lazy lookup.
   @see #setProxyInterfaces
   @see #setLookupOnStartup
   @see #setCache
   */
  public void setProxyInterface(Class proxyInterface) {
    this.proxyInterfaces = new Class[] {proxyInterface};
  }

  /**
   * Specify multiple proxy interfaces to use for the JNDI object.
   <p>Typically used in conjunction with "lookupOnStartup"=false and/or "cache"=false.
   * Note that proxy interfaces will be autodetected from a specified "expectedType",
   * if necessary.
   @see #setExpectedType
   @see #setLookupOnStartup
   @see #setCache
   */
  public void setProxyInterfaces(Class[] proxyInterfaces) {
    this.proxyInterfaces = proxyInterfaces;
  }

  /**
   * Set whether to look up the JNDI object on startup. Default is "true".
   <p>Can be turned off to allow for late availability of the JNDI object.
   * In this case, the JNDI object will be fetched on first access.
   <p>For a lazy lookup, a proxy interface needs to be specified.
   @see #setProxyInterface
   @see #setCache
   */
  public void setLookupOnStartup(boolean lookupOnStartup) {
    this.lookupOnStartup = lookupOnStartup;
  }

  /**
   * Set whether to cache the JNDI object once it has been located.
   * Default is "true".
   <p>Can be turned off to allow for hot redeployment of JNDI objects.
   * In this case, the JNDI object will be fetched for each invocation.
   <p>For hot redeployment, a proxy interface needs to be specified.
   @see #setProxyInterface
   @see #setLookupOnStartup
   */
  public void setCache(boolean cache) {
    this.cache = cache;
  }

  /**
   * Set whether to expose the JNDI environment context for all access to the target
   * object, i.e. for all method invocations on the exposed object reference.
   <p>Default is "false", i.e. to only expose the JNDI context for object lookup.
   * Switch this flag to "true" in order to expose the JNDI environment (including
   * the authorization context) for each method invocation, as needed by WebLogic
   * for JNDI-obtained factories (e.g. JDBC DataSource, JMS ConnectionFactory)
   * with authorization requirements.
   */
  public void setExposeAccessContext(boolean exposeAccessContext) {
    this.exposeAccessContext = exposeAccessContext;
  }

  /**
   * Specify a default object to fall back to if the JNDI lookup fails.
   * Default is none.
   <p>This can be an arbitrary bean reference or literal value.
   * It is typically used for literal values in scenarios where the JNDI environment
   * might define specific config settings but those are not required to be present.
   <p>Note: This is only supported for lookup on startup.
   @see #setLookupOnStartup
   */
  public void setDefaultObject(Object defaultObject) {
    this.defaultObject = defaultObject;
  }

  public void setBeanClassLoader(ClassLoader classLoader) {
    this.beanClassLoader = classLoader;
  }


  /**
   * Look up the JNDI object and store it.
   */
  @Override
  public void afterPropertiesSet() throws IllegalArgumentException, NamingException {
    super.afterPropertiesSet();

    if (this.proxyInterfaces != null || !this.lookupOnStartup || !this.cache || this.exposeAccessContext) {
      // We need to create a proxy for this...
      if (this.defaultObject != null) {
        throw new IllegalArgumentException(
            "'defaultObject' is not supported in combination with 'proxyInterface'");
      }
      // We need a proxy and a JndiObjectTargetSource.
      this.jndiObject = JndiObjectProxyFactory.createJndiObjectProxy(this);
    }
    else {
      if (this.defaultObject != null && getExpectedType() != null &&
          !getExpectedType().isInstance(this.defaultObject)) {
        throw new IllegalArgumentException("Default object [" this.defaultObject +
            "] of type [" this.defaultObject.getClass().getName() +
            "] is not of expected type [" + getExpectedType().getName() "]");
      }
      // Locate specified JNDI object.
      this.jndiObject = lookupWithFallback();
    }
  }

  /**
   * Lookup variant that that returns the specified "defaultObject"
   * (if any) in case of lookup failure.
   @return the located object, or the "defaultObject" as fallback
   @throws NamingException in case of lookup failure without fallback
   @see #setDefaultObject
   */
  protected Object lookupWithFallback() throws NamingException {
    ClassLoader originalClassLoader = ClassUtils.overrideThreadContextClassLoader(this.beanClassLoader);
    try {
      return lookup();
    }
    catch (TypeMismatchNamingException ex) {
      // Always let TypeMismatchNamingException through -
      // we don't want to fall back to the defaultObject in this case.
      throw ex;
    }
    catch (NamingException ex) {
      if (this.defaultObject != null) {
        if (logger.isDebugEnabled()) {
          logger.debug("JNDI lookup failed - returning specified default object instead", ex);
        }
        else if (logger.isInfoEnabled()) {
          logger.info("JNDI lookup failed - returning specified default object instead: " + ex);
        }
        return this.defaultObject;
      }
      throw ex;
    }
    finally {
      if (originalClassLoader != null) {
        Thread.currentThread().setContextClassLoader(originalClassLoader);
      }
    }
  }


  /**
   * Return the singleton JNDI object.
   */
  public Object getObject() {
    return this.jndiObject;
  }

  public Class<?> getObjectType() {
    if (this.proxyInterfaces != null) {
      if (this.proxyInterfaces.length == 1) {
        return this.proxyInterfaces[0];
      }
      else if (this.proxyInterfaces.length > 1) {
        return createCompositeInterface(this.proxyInterfaces);
      }
    }
    if (this.jndiObject != null) {
      return this.jndiObject.getClass();
    }
    else {
      return getExpectedType();
    }
  }

  public boolean isSingleton() {
    return true;
  }


  /**
   * Create a composite interface Class for the given interfaces,
   * implementing the given interfaces in one single Class.
   <p>The default implementation builds a JDK proxy class for the
   * given interfaces.
   @param interfaces the interfaces to merge
   @return the merged interface as Class
   @see java.lang.reflect.Proxy#getProxyClass
   */
  protected Class createCompositeInterface(Class[] interfaces) {
    return ClassUtils.createCompositeInterface(interfaces, this.beanClassLoader);
  }


  /**
   * Inner class to just introduce an AOP dependency when actually creating a proxy.
   */
  private static class JndiObjectProxyFactory {

    private static Object createJndiObjectProxy(JndiObjectFactoryBean jofthrows NamingException {
      // Create a JndiObjectTargetSource that mirrors the JndiObjectFactoryBean's configuration.
      JndiObjectTargetSource targetSource = new JndiObjectTargetSource();
      targetSource.setJndiTemplate(jof.getJndiTemplate());
      targetSource.setJndiName(jof.getJndiName());
      targetSource.setExpectedType(jof.getExpectedType());
      targetSource.setResourceRef(jof.isResourceRef());
      targetSource.setLookupOnStartup(jof.lookupOnStartup);
      targetSource.setCache(jof.cache);
      targetSource.afterPropertiesSet();

      // Create a proxy with JndiObjectFactoryBean's proxy interface and the JndiObjectTargetSource.
      ProxyFactory proxyFactory = new ProxyFactory();
      if (jof.proxyInterfaces != null) {
        proxyFactory.setInterfaces(jof.proxyInterfaces);
      }
      else {
        Class targetClass = targetSource.getTargetClass();
        if (targetClass == null) {
          throw new IllegalStateException(
              "Cannot deactivate 'lookupOnStartup' without specifying a 'proxyInterface' or 'expectedType'");
        }
        Class[] ifcs = ClassUtils.getAllInterfacesForClass(targetClass, jof.beanClassLoader);
        for (Class ifc : ifcs) {
          if (Modifier.isPublic(ifc.getModifiers())) {
            proxyFactory.addInterface(ifc);
          }
        }
      }
      if (jof.exposeAccessContext) {
        proxyFactory.addAdvice(new JndiContextExposingInterceptor(jof.getJndiTemplate()));
      }
      proxyFactory.setTargetSource(targetSource);
      return proxyFactory.getProxy(jof.beanClassLoader);
    }
  }


  /**
   * Interceptor that exposes the JNDI context for all method invocations,
   * according to JndiObjectFactoryBean's "exposeAccessContext" flag.
   */
  private static class JndiContextExposingInterceptor implements MethodInterceptor {

    private final JndiTemplate jndiTemplate;

    public JndiContextExposingInterceptor(JndiTemplate jndiTemplate) {
      this.jndiTemplate = jndiTemplate;
    }

    public Object invoke(MethodInvocation invocationthrows Throwable {
      Context ctx = (isEligible(invocation.getMethod()) this.jndiTemplate.getContext() null);
      try {
        return invocation.proceed();
      }
      finally {
        this.jndiTemplate.releaseContext(ctx);
      }
    }

    protected boolean isEligible(Method method) {
      return !Object.class.equals(method.getDeclaringClass());
    }
  }

}