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();
		}
}

Look up the JNDI object and store it.

 protected Class createCompositeInterface(Class[] interfaces) 
{
		return ClassUtils.createCompositeInterface(interfaces, this.beanClassLoader);
}

Create a composite interface Class for the given interfaces, implementing the given interfaces in one single Class.

The default implementation builds a JDK proxy class for the given interfaces.

 public Object getObject() 
{
		return this.jndiObject;
}

Return the singleton JNDI object.

 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;
}

 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);
			}
		}
}

Lookup variant that that returns the specified "defaultObject" (if any) in case of lookup failure.

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

 public  void setCache(boolean cache) 
{
		this.cache = cache;
}

Set whether to cache the JNDI object once it has been located. Default is "true".

Can be turned off to allow for hot redeployment of JNDI objects. In this case, the JNDI object will be fetched for each invocation.

For hot redeployment, a proxy interface needs to be specified.

 public  void setDefaultObject(Object defaultObject) 
{
		this.defaultObject = defaultObject;
}

Specify a default object to fall back to if the JNDI lookup fails. Default is none.

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.

Note: This is only supported for lookup on startup.

 public  void setExposeAccessContext(boolean exposeAccessContext) 
{
		this.exposeAccessContext = exposeAccessContext;
}

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.

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 setLookupOnStartup(boolean lookupOnStartup) 
{
		this.lookupOnStartup = lookupOnStartup;
}

Set whether to look up the JNDI object on startup. Default is "true".

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.

For a lazy lookup, a proxy interface needs to be specified.

 public  void setProxyInterface(Class proxyInterface) 
{
	                                             	 
		this.proxyInterfaces = new Class[] {proxyInterface};
}

Specify the proxy interface to use for the JNDI object.

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.

 public  void setProxyInterfaces(Class[] proxyInterfaces) 
{
		this.proxyInterfaces = proxyInterfaces;
}

Specify multiple proxy interfaces to use for the JNDI object.

Typically used in conjunction with "lookupOnStartup"=false and/or "cache"=false. Note that proxy interfaces will be autodetected from a specified "expectedType", if necessary.