Fixes JIRA issues SGF-238, SGF-239 and SGF-240 involving jndi-binding cache settings.

2013-12-13 14:59:03 -08:00
parent fb61e19f1e
commit 8dee6f7ab2
7 changed files with 418 additions and 213 deletions
--- a/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java
+++ b/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java
@@ -17,6 +17,8 @@
 package org.springframework.data.gemfire;

 import java.io.File;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
@@ -43,7 +45,6 @@ import com.gemstone.gemfire.GemFireException;
 import com.gemstone.gemfire.cache.Cache;
 import com.gemstone.gemfire.cache.CacheClosedException;
 import com.gemstone.gemfire.cache.CacheFactory;
-import com.gemstone.gemfire.cache.CacheTransactionManager;
 import com.gemstone.gemfire.cache.DynamicRegionFactory;
 import com.gemstone.gemfire.cache.GemFireCache;
 import com.gemstone.gemfire.cache.TransactionListener;
@@ -75,98 +76,55 @@ import com.gemstone.gemfire.pdx.PdxSerializer;
 */
 public class CacheFactoryBean implements BeanNameAware, BeanFactoryAware, BeanClassLoaderAware, InitializingBean,
 		DisposableBean, FactoryBean<Cache>, PersistenceExceptionTranslator {
+
+	protected static final List<String> VALID_JNDI_DATASOURCE_TYPE_NAMES = Collections.unmodifiableList(
+		Arrays.asList("ManagedDataSource", "PooledDataSource", "SimpleDataSource", "XAPooledDataSource"));
+
+	protected boolean close = true;
+	protected boolean lazyInitialize = true;
+	protected boolean useBeanFactoryLocator = true;
+
 	protected final Log log = LogFactory.getLog(getClass());

-	protected Cache cache;
-
-	protected Resource cacheXml;
-
-	protected Properties properties;
-
-	protected ClassLoader beanClassLoader;
-
-	protected GemfireBeanFactoryLocator factoryLocator;
-
 	protected BeanFactory beanFactory;

-	protected String beanName;
-
-	protected boolean useBeanFactoryLocator = true;
-
-	protected boolean close = true;
-
-	// PDX options
-	protected Object pdxSerializer;
-
+	protected Boolean copyOnRead;
+	protected Boolean pdxIgnoreUnreadFields;
 	protected Boolean pdxPersistent;
-
 	protected Boolean pdxReadSerialized;

-	protected Boolean pdxIgnoreUnreadFields;
+	protected Cache cache;

-	protected String pdxDiskStoreName;
-
-	protected Boolean copyOnRead;
-
-	protected Integer lockTimeout;
-
-	protected Integer lockLease;
-
-	protected Integer messageSyncInterval;
-
-	protected Integer searchTimeout;
-
-	protected List<TransactionListener> transactionListeners;
-
-	protected TransactionWriter transactionWriter;
-
-	protected Float evictionHeapPercentage;
-
-	protected Float criticalHeapPercentage;
+	protected ClassLoader beanClassLoader;

 	protected DynamicRegionSupport dynamicRegionSupport;

+	protected Float criticalHeapPercentage;
+	protected Float evictionHeapPercentage;
+
+	protected GemfireBeanFactoryLocator factoryLocator;
+
+	protected Integer lockLease;
+	protected Integer lockTimeout;
+	protected Integer messageSyncInterval;
+	protected Integer searchTimeout;
+
 	protected List<JndiDataSource> jndiDataSources;

+	protected List<TransactionListener> transactionListeners;
+
 	// Defined this way for backward compatibility
 	protected Object gatewayConflictResolver;
+	protected Object pdxSerializer;

-	protected boolean lazyInitialize = true;
+	protected Properties properties;

-	/**
-	 * Inner class to avoid a hard dependency on the GemFire 6.6 API.
-	 * 
-	 * @author Costin Leau
-	 */
+	protected Resource cacheXml;

-	private class PdxOptions implements Runnable {
+	protected String beanName;
+	protected String pdxDiskStoreName;

-		private final CacheFactory factory;
-
-		PdxOptions(CacheFactory factory) {
-			this.factory = factory;
-		}
-
-		@Override
-		public void run() {
-			if (pdxSerializer != null) {
-				Assert.isAssignable(PdxSerializer.class, pdxSerializer.getClass(), "Invalid pdx serializer used");
-				factory.setPdxSerializer((PdxSerializer) pdxSerializer);
-			}
-			if (pdxDiskStoreName != null) {
-				factory.setPdxDiskStore(pdxDiskStoreName);
-			}
-			if (pdxIgnoreUnreadFields != null) {
-				factory.setPdxIgnoreUnreadFields(pdxIgnoreUnreadFields);
-			}
-			if (pdxPersistent != null) {
-				factory.setPdxPersistent(pdxPersistent);
-			}
-			if (pdxReadSerialized != null) {
-				factory.setPdxReadSerialized(pdxReadSerialized);
-			}
-		}
-	}
+	protected TransactionWriter transactionWriter;

 	public static class DynamicRegionSupport {
 		private String diskDir;
@@ -221,10 +179,11 @@ public class CacheFactoryBean implements BeanNameAware, BeanFactoryAware, BeanCl
 	}

 	public static class JndiDataSource {
-		private Map<String, String> attributes;

 		private List<ConfigProperty> props;

+		private Map<String, String> attributes;
+
 		public Map<String, String> getAttributes() {
 			return attributes;
 		}
@@ -242,47 +201,80 @@ public class CacheFactoryBean implements BeanNameAware, BeanFactoryAware, BeanCl
 		}
 	}

-	private void init() throws Exception {
+	/**
+	 * Inner class to avoid a hard dependency on the GemFire 6.6 API.
+	 *
+	 * @author Costin Leau
+	 */
+	private class PdxOptions implements Runnable {

+		private final CacheFactory factory;
+
+		PdxOptions(CacheFactory factory) {
+			this.factory = factory;
+		}
+
+		@Override
+		public void run() {
+			if (pdxSerializer != null) {
+				Assert.isAssignable(PdxSerializer.class, pdxSerializer.getClass(), "Invalid pdx serializer used");
+				factory.setPdxSerializer((PdxSerializer) pdxSerializer);
+			}
+			if (pdxDiskStoreName != null) {
+				factory.setPdxDiskStore(pdxDiskStoreName);
+			}
+			if (pdxIgnoreUnreadFields != null) {
+				factory.setPdxIgnoreUnreadFields(pdxIgnoreUnreadFields);
+			}
+			if (pdxPersistent != null) {
+				factory.setPdxPersistent(pdxPersistent);
+			}
+			if (pdxReadSerialized != null) {
+				factory.setPdxReadSerialized(pdxReadSerialized);
+			}
+		}
+	}
+
+	private void init() throws Exception {
 		if (useBeanFactoryLocator && factoryLocator == null) {
 			factoryLocator = new GemfireBeanFactoryLocator();
 			factoryLocator.setBeanFactory(beanFactory);
 			factoryLocator.setBeanName(beanName);
 			factoryLocator.afterPropertiesSet();
 		}
-		// use the bean class loader to load Declarable classes
-		Thread th = Thread.currentThread();
-		ClassLoader oldTCCL = th.getContextClassLoader();
+
+		final ClassLoader originalThreadContextClassLoader = Thread.currentThread().getContextClassLoader();

 		try {
-			th.setContextClassLoader(beanClassLoader);
-			// first look for open caches
-			String msg = null;
+			String messagePrefix;
+
+			// use bean ClassLoader to load GemFire Declarable classes
+			Thread.currentThread().setContextClassLoader(beanClassLoader);
+
 			try {
 				cache = (Cache) fetchCache();
-				msg = "Retrieved existing";
-			} catch (CacheClosedException ex) {
-
+				messagePrefix = "Retrieved existing";
+			}
+			catch (CacheClosedException ex) {
 				initializeDynamicRegionFactory();

 				Object factory = createFactory(this.properties);

 				// GemFire 6.6 specific options
-				if (pdxSerializer != null || pdxPersistent != null || pdxReadSerialized != null
-						|| pdxIgnoreUnreadFields != null || pdxDiskStoreName != null) {
+				if (isPdxSettingsSpecified()) {
 					Assert.isTrue(ClassUtils.isPresent("com.gemstone.gemfire.pdx.PdxSerializer", beanClassLoader),
-							"Cannot set PDX options since GemFire 6.6 not detected");
+						"Cannot set PDX options since GemFire 6.6 not detected.");
 					applyPdxOptions(factory);
 				}

 				// fall back to cache creation
 				cache = (Cache) createCache(factory);
-				msg = "Created";
+				messagePrefix = "Created new";
 			}
+
 			if (this.copyOnRead != null) {
 				cache.setCopyOnRead(this.copyOnRead);
 			}
-
 			if (lockLease != null) {
 				cache.setLockLease(lockLease);
 			}
@@ -295,7 +287,6 @@ public class CacheFactoryBean implements BeanNameAware, BeanFactoryAware, BeanCl
 			if (messageSyncInterval != null) {
 				cache.setMessageSyncInterval(messageSyncInterval);
 			}
-
 			if (gatewayConflictResolver != null) {
 				cache.setGatewayConflictResolver((GatewayConflictResolver) gatewayConflictResolver);
 			}
@@ -303,10 +294,12 @@ public class CacheFactoryBean implements BeanNameAware, BeanFactoryAware, BeanCl
 			DistributedSystem system = cache.getDistributedSystem();

 			DistributedMember member = system.getDistributedMember();
-			log.info("Connected to Distributed System [" + system.getName() + "=" + member.getId() + "@"
-					+ member.getHost() + "]");

-			log.info(msg + " GemFire v." + CacheFactory.getVersion() + " Cache [" + cache.getName() + "]");
+			log.info(String.format("Connected to Distributed System [%1$s] as Member [%2$s] on Host [%3$s].",
+				system.getName(), member.getId(), member.getHost()));
+
+			log.info(String.format("%1$s GemFire v.%2$s Cache [%3$s].", messagePrefix, CacheFactory.getVersion(),
+				cache.getName()));

 			// load/init cache.xml
 			if (cacheXml != null) {
@@ -321,16 +314,26 @@ public class CacheFactoryBean implements BeanNameAware, BeanFactoryAware, BeanCl
 			registerTransactionListeners();
 			registerTransactionWriter();
 			registerJndiDataSources();
-		} finally {
-			th.setContextClassLoader(oldTCCL);
+		}
+		finally {
+			Thread.currentThread().setContextClassLoader(originalThreadContextClassLoader);
 		}
 	}

-	private void registerJndiDataSources() {
-		if (jndiDataSources != null) {
-			for (JndiDataSource jndiDataSource : jndiDataSources) {
-				JNDIInvoker.mapDatasource(jndiDataSource.getAttributes(), jndiDataSource.getProps());
-			}
+	private boolean isPdxSettingsSpecified() {
+		return (pdxSerializer != null || pdxPersistent != null || pdxReadSerialized != null
+			|| pdxIgnoreUnreadFields != null || pdxDiskStoreName != null);
+	}
+
+	/**
+	 * Sets the PDX properties for the given object. Note this is implementation
+	 * specific as it depends on the type of the factory passed in.
+	 *
+	 * @param factory
+	 */
+	protected void applyPdxOptions(Object factory) {
+		if (factory instanceof CacheFactory) {
+			new PdxOptions((CacheFactory) factory).run();
 		}
 	}

@@ -344,22 +347,15 @@ public class CacheFactoryBean implements BeanNameAware, BeanFactoryAware, BeanCl
 		}
 	}

-	private void setHeapPercentages() {
-		if (criticalHeapPercentage != null) {
-			Assert.isTrue(criticalHeapPercentage > 0.0 && criticalHeapPercentage <= 100.0,
-					"invalid value specified for criticalHeapPercentage :" + criticalHeapPercentage
-							+ ". Must be > 0.0 and <= 100.0");
-			cache.getResourceManager().setCriticalHeapPercentage(criticalHeapPercentage);
-
+	/**
+	 * Register all declared transaction listeners
+	 */
+	protected void registerTransactionListeners() {
+		if (!CollectionUtils.isEmpty(transactionListeners)) {
+			for (TransactionListener transactionListener : transactionListeners) {
+				cache.getCacheTransactionManager().addListener(transactionListener);
+			}
 		}
-
-		if (evictionHeapPercentage != null) {
-			Assert.isTrue(evictionHeapPercentage > 0.0 && evictionHeapPercentage <= 100.0,
-					"invalid value specified for evictionHeapPercentage :" + evictionHeapPercentage
-							+ ". Must be > 0.0 and <= 100.0");
-			cache.getResourceManager().setEvictionHeapPercentage(evictionHeapPercentage);
-		}
-
 	}

 	/**
@@ -371,56 +367,64 @@ public class CacheFactoryBean implements BeanNameAware, BeanFactoryAware, BeanCl
 		}
 	}

-	/**
-	 * Register all declared transaction listeners
-	 */
-	protected void registerTransactionListeners() {
-		if (!CollectionUtils.isEmpty(transactionListeners)) {
-			CacheTransactionManager txManager = cache.getCacheTransactionManager();
-			for (TransactionListener transactionListener : transactionListeners) {
-				txManager.addListener(transactionListener);
+	private void registerJndiDataSources() {
+		if (jndiDataSources != null) {
+			for (JndiDataSource jndiDataSource : jndiDataSources) {
+				validate(jndiDataSource);
+				JNDIInvoker.mapDatasource(jndiDataSource.getAttributes(), jndiDataSource.getProps());
 			}
 		}
 	}

-	/**
-	 * Sets the PDX properties for the given object. Note this is implementation
-	 * specific as it depends on the type of the factory passed in.
-	 * 
-	 * @param factory
-	 */
-	protected void applyPdxOptions(Object factory) {
-		if (factory instanceof CacheFactory) {
-			new PdxOptions((CacheFactory) factory).run();
+	private void validate(final JndiDataSource jndiDataSource) {
+		Map<String, String> attributes = jndiDataSource.getAttributes();
+		String typeAttributeValue = attributes.get("type");
+		Assert.isTrue(VALID_JNDI_DATASOURCE_TYPE_NAMES.contains(typeAttributeValue),
+			String.format("The 'jndi-binding', 'type' [%1$s] is invalid; the 'type' must be one of %2$s.",
+				typeAttributeValue, VALID_JNDI_DATASOURCE_TYPE_NAMES));
+	}
+
+	private void setHeapPercentages() {
+		if (criticalHeapPercentage != null) {
+			Assert.isTrue(criticalHeapPercentage > 0.0 && criticalHeapPercentage <= 100.0,
+				String.format("Invalid value specified for 'criticalHeapPercentage' (%1$s). Must be > 0.0 and <= 100.0.",
+					criticalHeapPercentage));
+			cache.getResourceManager().setCriticalHeapPercentage(criticalHeapPercentage);
 		}
+
+		if (evictionHeapPercentage != null) {
+			Assert.isTrue(evictionHeapPercentage > 0.0 && evictionHeapPercentage <= 100.0,
+				String.format("Invalid value specified for 'evictionHeapPercentage' (%1$s). Must be > 0.0 and <= 100.0.",
+					evictionHeapPercentage));
+			cache.getResourceManager().setEvictionHeapPercentage(evictionHeapPercentage);
+		}
+	}
+
+	protected GemFireCache createCache(Object factory) {
+		return (cache != null ? cache : ((CacheFactory) factory).create());
+	}
+
+	protected GemFireCache fetchCache() {
+		return (cache != null ? cache : CacheFactory.getAnyInstance());
 	}

 	protected Object createFactory(Properties props) {
 		return new CacheFactory(props);
 	}

-	protected GemFireCache fetchCache() {
-		return (cache == null) ? CacheFactory.getAnyInstance() : cache;
-	}
-
-	protected GemFireCache createCache(Object factory) {
-		return (cache == null) ? ((CacheFactory) factory).create() : cache;
-	}
-
 	@Override
 	public void destroy() throws Exception {
-		if (!close) {
-			return;
-		}
-		if (cache != null && !cache.isClosed()) {
-			cache.close();
-		}
+		if (close) {
+			if (cache != null && !cache.isClosed()) {
+				cache.close();
+			}

-		cache = null;
+			cache = null;

-		if (factoryLocator != null) {
-			factoryLocator.destroy();
-			factoryLocator = null;
+			if (factoryLocator != null) {
+				factoryLocator.destroy();
+				factoryLocator = null;
+			}
 		}
 	}

@@ -665,13 +669,19 @@ public class CacheFactoryBean implements BeanNameAware, BeanFactoryAware, BeanCl
 	}

 	/**
-	 * 
-	 * @param jndiDataSources
+	 * @param jndiDataSources the list of configured JndiDataSources to use with this Cache.
 	 */
 	public void setJndiDataSources(List<JndiDataSource> jndiDataSources) {
 		this.jndiDataSources = jndiDataSources;
 	}

+	/**
+	 * @return the list of configured JndiDataSources.
+	 */
+	public List<JndiDataSource> getJndiDataSources() {
+		return jndiDataSources;
+	}
+
 	/**
 	 * @param lazyInitialize set to false to force cache initialization if no other bean references it
 	 */
@@ -813,13 +823,6 @@ public class CacheFactoryBean implements BeanNameAware, BeanFactoryAware, BeanCl
 		return dynamicRegionSupport;
 	}

-	/**
-	 * @return the jndiDataSources
-	 */
-	public List<JndiDataSource> getJndiDataSources() {
-		return jndiDataSources;
-	}
-
 	/**
 	 * @return the gatewayConflictResolver
 	 */
--- a/src/main/java/org/springframework/data/gemfire/config/CacheParser.java
+++ b/src/main/java/org/springframework/data/gemfire/config/CacheParser.java
@@ -170,33 +170,50 @@ class CacheParser extends AbstractSimpleBeanDefinitionParser {

 	private void parseJndiBindings(Element element, BeanDefinitionBuilder builder) {
 		List<Element> jndiBindings = DomUtils.getChildElementsByTagName(element, "jndi-binding");
+
 		if (!CollectionUtils.isEmpty(jndiBindings)) {
-			ManagedList<Object> jndiDataSources = new ManagedList<Object>();
-			ManagedMap<String, String> jndiAttributes = new ManagedMap<String, String>();
+			ManagedList<Object> jndiDataSources = new ManagedList<Object>(jndiBindings.size());
+
 			for (Element jndiBinding : jndiBindings) {
-				BeanDefinitionBuilder jndiDataSource = BeanDefinitionBuilder
-						.genericBeanDefinition(CacheFactoryBean.JndiDataSource.class);
-				NamedNodeMap nnm = jndiBinding.getAttributes();
-				for (int i = 0; i < nnm.getLength(); i++) {
-					Attr attr = (Attr) nnm.item(i);
-					jndiAttributes.put(attr.getLocalName(), attr.getValue());
+				BeanDefinitionBuilder jndiDataSource = BeanDefinitionBuilder.genericBeanDefinition(
+					CacheFactoryBean.JndiDataSource.class);
+
+				// NOTE 'jndi-name' and 'type' are required by the XSD so we should have at least 2 attributes.
+				NamedNodeMap attributes = jndiBinding.getAttributes();
+				ManagedMap<String, String> jndiAttributes = new ManagedMap<String, String>(attributes.getLength());
+
+				for (int index = 0, length = attributes.getLength(); index < length; index++) {
+					Attr attribute = (Attr) attributes.item(index);
+					jndiAttributes.put(attribute.getLocalName(), attribute.getValue());
 				}
+
 				jndiDataSource.addPropertyValue("attributes", jndiAttributes);

-				List<Element> jndiProps = DomUtils.getChildElementsByTagName(element, "jndi-prop");
+				List<Element> jndiProps = DomUtils.getChildElementsByTagName(jndiBinding, "jndi-prop");
+
 				if (!CollectionUtils.isEmpty(jndiProps)) {
-					ManagedList<ConfigProperty> props = new ManagedList<ConfigProperty>();
+					ManagedList<Object> props = new ManagedList<Object>(jndiProps.size());
+
 					for (Element jndiProp : jndiProps) {
 						String key = jndiProp.getAttribute("key");
-						String value = jndiProp.getNodeValue();
-						String type = StringUtils.hasText(jndiProp.getAttribute("type")) ? jndiProp
-								.getAttribute("type") : String.class.getName();
-						props.add(new ConfigProperty(key, value, type));
+						String type = jndiProp.getAttribute("type");
+						String value = jndiProp.getTextContent();
+
+						type = (StringUtils.hasText(type) ? type : String.class.getName());
+
+						props.add(BeanDefinitionBuilder.genericBeanDefinition(ConfigProperty.class)
+							.addConstructorArgValue(key)
+							.addConstructorArgValue(value)
+							.addConstructorArgValue(type)
+							.getBeanDefinition());
 					}
+
 					jndiDataSource.addPropertyValue("props", props);
 				}
+
 				jndiDataSources.add(jndiDataSource.getBeanDefinition());
 			}
+
 			builder.addPropertyValue("jndiDataSources", jndiDataSources);
 		}
 	}
--- a/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.4.xsd
+++ b/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.4.xsd
@@ -2244,8 +2244,7 @@ The name of the pool used by the index. Used usually in client scenarios.
 	<!-- -->
 	<xsd:complexType name="jndiBindingType">
 		<xsd:sequence>
-			<xsd:element name="jndi-prop" type="configPropertyType"
-						 minOccurs="0" maxOccurs="unbounded">
+			<xsd:element name="jndi-prop" type="configPropertyType" minOccurs="0" maxOccurs="unbounded">
 				<xsd:annotation>
 					<xsd:documentation><![CDATA[
 Specifies a vendor-specific property
@@ -2256,24 +2255,16 @@ Specifies a vendor-specific property
 		<xsd:attribute name="jndi-name" type="xsd:string" use="required">
 			<xsd:annotation>
 				<xsd:documentation><![CDATA[
-The JNDI name for this datasource. Will be prefixed with "java:/"
+The JNDI name for this DataSource. Will be prefixed with "java:/"
            ]]></xsd:documentation>
 			</xsd:annotation>
 		</xsd:attribute>
-		<xsd:attribute name="type" use="required">
+		<xsd:attribute name="type" type="xsd:string" use="required">
 			<xsd:annotation>
 				<xsd:documentation><![CDATA[
-Specifies the datasource implementation: ManagedDataSource,SimpleDataSource,PooledDataSource,XaPooledDataSource
+Specifies the DataSource implementation: ManagedDataSource, PooledDataSource, SimpleDataSource, or XAPooledDataSource.
            ]]></xsd:documentation>
 			</xsd:annotation>
-			<xsd:simpleType>
-				<xsd:restriction base="xsd:string">
-					<xsd:enumeration value="ManagedDataSource" />
-					<xsd:enumeration value="SimpleDataSource" />
-					<xsd:enumeration value="PooledDataSource" />
-					<xsd:enumeration value="XaPooledDataSource" />
-				</xsd:restriction>
-			</xsd:simpleType>
 		</xsd:attribute>
 		<xsd:attribute name="blocking-timeout-seconds" type="xsd:string"
 					   use="optional" />
@@ -2305,14 +2296,14 @@ Specifies the datasource implementation: ManagedDataSource,SimpleDataSource,Pool
 		<xsd:attribute name="key" type="xsd:string" use="required">
 			<xsd:annotation>
 				<xsd:documentation><![CDATA[
-Specifies The property key
+Specifies the property key.
            ]]></xsd:documentation>
 			</xsd:annotation>
 		</xsd:attribute>
 		<xsd:attribute name="type" type="xsd:string" use="optional">
 			<xsd:annotation>
 				<xsd:documentation><![CDATA[
-Specifies a data type if other than java.lang.String
+Specifies the data type if other than java.lang.String.
            ]]></xsd:documentation>
 			</xsd:annotation>
 		</xsd:attribute>
--- a/src/test/java/org/springframework/data/gemfire/config/JndiBindingsPropertyPlaceholderTest.java
+++ b/src/test/java/org/springframework/data/gemfire/config/JndiBindingsPropertyPlaceholderTest.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright 2010-2013 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.data.gemfire.config;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContext;
+import org.springframework.data.gemfire.CacheFactoryBean;
+import org.springframework.data.gemfire.test.GemfireTestApplicationContextInitializer;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.gemstone.gemfire.internal.datasource.ConfigProperty;
+
+/**
+ * The JndiBindingsPropertyPlaceholderTest class is a test suite of test cases testing the configuration of a GemFire
+ * Cache JNDI DataSource using property placeholders.
+ * <p/>
+ * @author John Blum
+ * @see org.junit.Test
+ * @see org.springframework.context.ApplicationContext
+ * @see org.springframework.data.gemfire.test.GemfireTestApplicationContextInitializer
+ * @see org.springframework.test.context.ContextConfiguration
+ * @see org.springframework.test.context.junit4.SpringJUnit4ClassRunner
+ * @since 1.4.0
+ * @since 7.0.1 (GemFire)
+ */
+@ContextConfiguration(locations = "jndi-binding-with-property-placeholders-ns.xml",
+	initializers = GemfireTestApplicationContextInitializer.class)
+@RunWith(SpringJUnit4ClassRunner.class)
+public class JndiBindingsPropertyPlaceholderTest {
+
+	@Autowired
+	@SuppressWarnings("unused")
+	private ApplicationContext context;
+
+	protected void assertPropertyValueExists(final String expectedPropertyName, final String expectedPropertyValue,
+			final List<ConfigProperty> properties) {
+		for (ConfigProperty property : properties) {
+			if (expectedPropertyName.equals(property.getName())) {
+				assertEquals(expectedPropertyValue, property.getValue());
+				assertEquals(String.class.getName(), property.getType());
+				return;
+			}
+		}
+
+		fail(String.format("ConfigProperty with name [%1$s] was not found!", expectedPropertyName));
+	}
+
+	@Test
+	public void testCacheJndiDataSourceConfiguration() {
+		CacheFactoryBean factory = context.getBean("&gemfireCache", CacheFactoryBean.class);
+
+		List<CacheFactoryBean.JndiDataSource> jndiDataSources = factory.getJndiDataSources();
+
+		assertNotNull(jndiDataSources);
+		assertEquals(1, jndiDataSources.size());
+
+		CacheFactoryBean.JndiDataSource dataSource = jndiDataSources.get(0);
+
+		assertNotNull(dataSource);
+
+		Map<String, String> attributes = dataSource.getAttributes();
+
+		assertNotNull(attributes);
+		assertFalse(attributes.isEmpty());
+		assertEquals("testDataSource", attributes.get("jndi-name"));
+		assertEquals("XAPoolDataSource", attributes.get("type"));
+		assertEquals("60", attributes.get("blocking-timeout-seconds"));
+		assertEquals("org.apache.derby.jdbc.EmbeddedConnectionPoolDataSource", attributes.get("conn-pooled-datasource-class"));
+		assertEquals("jdbc:derby:testDataStore;create=true", attributes.get("connection-url"));
+		assertEquals("180", attributes.get("idle-timeout-seconds"));
+		assertEquals("10", attributes.get("init-pool-size"));
+		assertEquals("org.apache.derby.jdbc.EmbeddedDriver", attributes.get("jdbc-driver-class"));
+		assertEquals("30", attributes.get("login-timeout-seconds"));
+		assertEquals("org.apache.derby.jdbc.NonExistingManagedConnectionFactoryClass", attributes.get("managed-connection-factory-class"));
+		assertEquals("50", attributes.get("max-pool-size"));
+		assertEquals("test123", attributes.get("password"));
+		assertEquals("XATransaction", attributes.get("transaction-type"));
+		assertEquals("masterdba", attributes.get("user-name"));
+		assertEquals("org.apache.derby.jdbc.EmbeddedXADataSource", attributes.get("xa-datasource-class"));
+
+		List<ConfigProperty> props = dataSource.getProps();
+
+		assertNotNull(props);
+		assertFalse(props.isEmpty());
+		assertPropertyValueExists("schemaName", "testSchema", props);
+		assertPropertyValueExists("databaseName", "testDataStore", props);
+		assertPropertyValueExists("description", "test", props);
+		assertPropertyValueExists("email", "masterdba@xcompany.com", props);
+		assertPropertyValueExists("phone", "501-555-1234", props);
+	}
+
+}
--- a/src/test/java/org/springframework/data/gemfire/config/JndiBindingsTest.java
+++ b/src/test/java/org/springframework/data/gemfire/config/JndiBindingsTest.java
@@ -13,10 +13,11 @@
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
+
 package org.springframework.data.gemfire.config;

 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;

 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -29,22 +30,29 @@ import com.gemstone.gemfire.cache.Cache;
 import com.gemstone.gemfire.internal.datasource.GemFireBasicDataSource;

 /**
- * @author David Turanski
- * 
 * This test requires a real cache
+ * <p/>
+ * @author David Turanski
+ * @author John Blum
 */
+@ContextConfiguration("jndi-binding-ns.xml")
@RunWith(SpringJUnit4ClassRunner.class)
-@ContextConfiguration("/org/springframework/data/gemfire/config/jndi-binding-ns.xml")
+@SuppressWarnings("unused")
 public class JndiBindingsTest {

-	 @Autowired ApplicationContext ctx;
+	@Autowired
+	private Cache cache;

 	@Test
 	public void testJndiBindings() throws Exception {
-		Cache cache = ctx.getBean("gemfireCache", Cache.class);
-		assertNotNull(cache.getJNDIContext().lookup("java:/SimpleDataSource"));
-		GemFireBasicDataSource ds = (GemFireBasicDataSource) cache.getJNDIContext().lookup("java:/SimpleDataSource");
-		assertEquals("org.apache.derby.jdbc.EmbeddedDriver", ds.getJDBCDriver());
-		assertEquals(60, ds.getLoginTimeout());
+		Object dataSourceObject = cache.getJNDIContext().lookup("java:/SimpleDataSource");
+
+		assertTrue(dataSourceObject instanceof GemFireBasicDataSource);
+
+		GemFireBasicDataSource dataSource = (GemFireBasicDataSource) dataSourceObject;
+
+		assertEquals("org.apache.derby.jdbc.EmbeddedDriver", dataSource.getJDBCDriver());
+		assertEquals(60, dataSource.getLoginTimeout());
 	}
+
 }
--- a/src/test/resources/org/springframework/data/gemfire/config/jndi-binding-ns.xml
+++ b/src/test/resources/org/springframework/data/gemfire/config/jndi-binding-ns.xml
@@ -1,23 +1,29 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
-	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:gfe="http://www.springframework.org/schema/gemfire"
-	xmlns:p="http://www.springframework.org/schema/p" default-lazy-init="true"
-	xmlns:util="http://www.springframework.org/schema/util"
-	xsi:schemaLocation="http://www.springframework.org/schema/gemfire http://www.springframework.org/schema/gemfire/spring-gemfire.xsd
+	   xmlns:gfe="http://www.springframework.org/schema/gemfire"
+	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	   xsi:schemaLocation="
 		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
-		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
+	   	http://www.springframework.org/schema/gemfire http://www.springframework.org/schema/gemfire/spring-gemfire.xsd
+">

 	<gfe:cache>
-		<gfe:jndi-binding type="SimpleDataSource" jndi-name="SimpleDataSource"
-			jdbc-driver-class="org.apache.derby.jdbc.EmbeddedDriver"
-			init-pool-size="2" max-pool-size="7" idle-timeout-seconds="40"
-			blocking-timeout-seconds="40" login-timeout-seconds="60"
-			conn-pooled-datasource-class="org.apache.derby.jdbc.EmbeddedConnectionPoolDataSource"
-			xa-datasource-class="org.apache.derby.jdbc.EmbeddedXADataSource"
-			user-name="mitul" password="83f0069202c571faf1ae6c42b4ad46030e4e31c17409e19a"
-			connection-url="jdbc:derby:newDB;create=true">
+		<gfe:jndi-binding jndi-name="SimpleDataSource"
+						  type="SimpleDataSource"
+						  blocking-timeout-seconds="40"
+						  conn-pooled-datasource-class="org.apache.derby.jdbc.EmbeddedConnectionPoolDataSource"
+						  connection-url="jdbc:derby:newDB;create=true"
+						  idle-timeout-seconds="40"
+						  init-pool-size="2"
+						  jdbc-driver-class="org.apache.derby.jdbc.EmbeddedDriver"
+						  login-timeout-seconds="60"
+						  max-pool-size="7"
+						  password="83f0069202c571faf1ae6c42b4ad46030e4e31c17409e19a"
+						  user-name="mitul"
+						  xa-datasource-class="org.apache.derby.jdbc.EmbeddedXADataSource">
 			<gfe:jndi-prop key="description">hi</gfe:jndi-prop>
 			<gfe:jndi-prop key="databaseName">newDB</gfe:jndi-prop>
 		</gfe:jndi-binding>
 	</gfe:cache>
-</beans>
+
+</beans>
--- a/src/test/resources/org/springframework/data/gemfire/config/jndi-binding-with-property-placeholders-ns.xml
+++ b/src/test/resources/org/springframework/data/gemfire/config/jndi-binding-with-property-placeholders-ns.xml
@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+	   xmlns:context="http://www.springframework.org/schema/context"
+	   xmlns:gfe="http://www.springframework.org/schema/gemfire"
+	   xmlns:util="http://www.springframework.org/schema/util"
+	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	   xsi:schemaLocation="
+		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
+		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
+	   	http://www.springframework.org/schema/gemfire http://www.springframework.org/schema/gemfire/spring-gemfire.xsd
+		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
+">
+
+	<util:properties id="jndi-binding-settings">
+		<prop key="jndi.binding.name">testDataSource</prop>
+		<prop key="jndi.binding.type">XAPoolDataSource</prop>
+		<prop key="jndi.binding.blocking.timeout.seconds">60</prop>
+		<prop key="jndi.binding.conn.pooled.datasource.class">org.apache.derby.jdbc.EmbeddedConnectionPoolDataSource</prop>
+		<prop key="jndi.binding.connection.url">jdbc:derby:testDataStore;create=true</prop>
+		<prop key="jndi.binding.idle.timeout.seconds">180</prop>
+		<prop key="jndi.binding.init.pool.size">10</prop>
+		<prop key="jndi.binding.jdbc.driver.class">org.apache.derby.jdbc.EmbeddedDriver</prop>
+		<prop key="jndi.binding.login.timeout.seconds">30</prop>
+		<prop key="jndi.binding.managed.connection.factory.class">org.apache.derby.jdbc.NonExistingManagedConnectionFactoryClass</prop>
+		<prop key="jndi.binding.max.pool.size">50</prop>
+		<prop key="jndi.binding.password">test123</prop>
+		<prop key="jndi.binding.transaction.type">XATransaction</prop>
+		<prop key="jndi.binding.user.name">masterdba</prop>
+		<prop key="jndi.binding.xa.datasource.class">org.apache.derby.jdbc.EmbeddedXADataSource</prop>
+		<prop key="jndi.prop.schema.name">testSchema</prop>
+		<prop key="jndi.prop.database.name">testDataStore</prop>
+		<prop key="jndi.prop.description">test</prop>
+		<prop key="jndi.prop.email">masterdba@xcompany.com</prop>
+		<prop key="jndi.prop.phone">501-555-1234</prop>
+	</util:properties>
+
+	<context:property-placeholder properties-ref="jndi-binding-settings"/>
+
+	<gfe:cache lazy-init="true">
+		<gfe:jndi-binding jndi-name="${jndi.binding.name}"
+						  type="${jndi.binding.type}"
+						  blocking-timeout-seconds="${jndi.binding.blocking.timeout.seconds}"
+						  conn-pooled-datasource-class="${jndi.binding.conn.pooled.datasource.class}"
+						  connection-url="${jndi.binding.connection.url}"
+						  idle-timeout-seconds="${jndi.binding.idle.timeout.seconds}"
+						  init-pool-size="${jndi.binding.init.pool.size}"
+						  jdbc-driver-class="${jndi.binding.jdbc.driver.class}"
+						  login-timeout-seconds="${jndi.binding.login.timeout.seconds}"
+						  managed-connection-factory-class="${jndi.binding.managed.connection.factory.class}"
+						  max-pool-size="${jndi.binding.max.pool.size}"
+						  password="${jndi.binding.password}"
+						  transaction-type="${jndi.binding.transaction.type}"
+						  user-name="${jndi.binding.user.name}"
+						  xa-datasource-class="${jndi.binding.xa.datasource.class}">
+			<gfe:jndi-prop key="schemaName">${jndi.prop.schema.name}</gfe:jndi-prop>
+			<gfe:jndi-prop key="databaseName">${jndi.prop.database.name}</gfe:jndi-prop>
+			<gfe:jndi-prop key="description">${jndi.prop.description}</gfe:jndi-prop>
+			<gfe:jndi-prop key="email">${jndi.prop.email}</gfe:jndi-prop>
+			<gfe:jndi-prop key="phone">${jndi.prop.phone}</gfe:jndi-prop>
+		</gfe:jndi-binding>
+	</gfe:cache>
+
+</beans>