All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.springframework.jndi.JndiObjectFactoryBean Maven / Gradle / Ivy

There is a newer version: 5.3.39
Show newest version
/*
 * Copyright 2002-2007 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 javax.naming.NamingException;

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}.
 *
 * 

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. * *

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. * *

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. * *

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, BeanClassLoaderAware { private Class[] proxyInterfaces; private boolean lookupOnStartup = true; private boolean cache = true; private Object defaultObject; private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader(); private Object jndiObject; /** * 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. * @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. *

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". *

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. * @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". *

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. * @see #setProxyInterface * @see #setLookupOnStartup */ public void setCache(boolean cache) { this.cache = cache; } /** * 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. * @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. */ public void afterPropertiesSet() throws IllegalArgumentException, NamingException { super.afterPropertiesSet(); if (!this.lookupOnStartup || !this.cache) { // We need to create a proxy for this... if (this.proxyInterfaces == null) { Class expectedType = getExpectedType(); if (expectedType != null) { if (expectedType.isInterface()) { this.proxyInterfaces = new Class[] {expectedType}; } else { this.proxyInterfaces = ClassUtils.getAllInterfacesForClass(expectedType); } } } if (this.proxyInterfaces == null) { throw new IllegalArgumentException( "Cannot deactivate 'lookupOnStartup' or 'cache' without specifying a 'proxyInterface'"); } } if (this.proxyInterfaces != null) { 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 { 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; } } /** * 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. *

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 jof) throws 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(); proxyFactory.setInterfaces(jof.proxyInterfaces); proxyFactory.setTargetSource(targetSource); return proxyFactory.getProxy(jof.beanClassLoader); } } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy