BVAL-298 The current caching of the ValidationProviders don't work, because the providers themselves keep a hard reference to the class loaders. Wrapping the list of providers into a SoftReference instead (see also ValidationTest)

Author: hferentschik

src/main/java/javax/validation/Validation.java

@@ -16,12 +16,12 @@
 */
 package javax.validation;
 
+import java.lang.ref.SoftReference;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
 import java.util.ServiceConfigurationError;
 import java.util.ServiceLoader;
 import java.util.WeakHashMap;
@@ -295,8 +295,8 @@ private static class DefaultValidationProviderResolver implements ValidationProv
 		//cache per classloader for an appropriate discovery
 		//keep them in a weak hashmap to avoid memory leaks and allow proper hot redeployment
 		//TODO use a WeakConcurrentHashMap
-		private static final Map<ClassLoader, List<ValidationProvider<?>>> providersPerClassloader =
-				new WeakHashMap<ClassLoader, List<ValidationProvider<?>>>();
+		private static final WeakHashMap<ClassLoader, SoftReference<List<ValidationProvider<?>>>> providersPerClassloader =
+				new WeakHashMap<ClassLoader, SoftReference<List<ValidationProvider<?>>>>();
 
 		public List<ValidationProvider<?>> getValidationProviders() {
 			List<ValidationProvider<?>> validationProviderList = new ArrayList<ValidationProvider<?>>();
@@ -340,11 +340,12 @@ public List<ValidationProvider<?>> getValidationProviders() {
 		}
 
 		private synchronized List<ValidationProvider<?>> getCachedValidationProviders(ClassLoader classLoader) {
-			return providersPerClassloader.get( classLoader );
+			SoftReference<List<ValidationProvider<?>>> ref = providersPerClassloader.get( classLoader );
+			return ref != null ? ref.get() : null;
 		}
 
 		private synchronized void cacheValidationProviders(ClassLoader classLoader, List<ValidationProvider<?>> providers) {
-			providersPerClassloader.put( classLoader, providers );
+			providersPerClassloader.put( classLoader, new SoftReference<List<ValidationProvider<?>>>( providers ) );
 		}
 	}
 

src/test/java/javax/validation/DummyValidationProvider.java

@@ -0,0 +1,106 @@
+/*
+* JBoss, Home of Professional Open Source
+* Copyright 2012, Red Hat, Inc. and/or its affiliates, and individual contributors
+* by the @authors tag. See the copyright.txt in the distribution for a
+* full listing of individual contributors.
+*
+* 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 javax.validation;
+
+import java.io.InputStream;
+import java.lang.ref.SoftReference;
+import java.util.ArrayList;
+import java.util.List;
+import javax.validation.spi.BootstrapState;
+import javax.validation.spi.ConfigurationState;
+import javax.validation.spi.ValidationProvider;
+
+/**
+ * @author Hardy Ferentschik
+ */
+public class DummyValidationProvider implements ValidationProvider {
+	public static List<SoftReference<DummyValidationProvider>> createdValidationProviders =  new ArrayList<SoftReference<DummyValidationProvider>>();
+
+	public DummyValidationProvider() {
+		createdValidationProviders.add( new SoftReference<DummyValidationProvider>( this ) );
+	}
+
+	public Configuration createSpecializedConfiguration(BootstrapState state) {
+		return null;
+	}
+
+	public Configuration<?> createGenericConfiguration(BootstrapState state) {
+		return new DummyConfiguration();
+	}
+
+	public ValidatorFactory buildValidatorFactory(ConfigurationState configurationState) {
+		return null;
+	}
+
+
+	public static class DummyConfiguration implements Configuration {
+
+		public Configuration ignoreXmlConfiguration() {
+			return null;
+		}
+
+		public Configuration messageInterpolator(MessageInterpolator interpolator) {
+			return null;
+		}
+
+		public Configuration traversableResolver(TraversableResolver resolver) {
+			return null;
+		}
+
+		public Configuration constraintValidatorFactory(ConstraintValidatorFactory constraintValidatorFactory) {
+			return null;
+		}
+
+		public Configuration parameterNameProvider(ParameterNameProvider parameterNameProvider) {
+			return null;
+		}
+
+		public Configuration addMapping(InputStream stream) {
+			return null;
+		}
+
+		public Configuration addProperty(String name, String value) {
+			return null;
+		}
+
+		public MessageInterpolator getDefaultMessageInterpolator() {
+			return null;
+		}
+
+		public TraversableResolver getDefaultTraversableResolver() {
+			return null;
+		}
+
+		public ConstraintValidatorFactory getDefaultConstraintValidatorFactory() {
+			return null;
+		}
+
+		public ParameterNameProvider getDefaultParameterNameProvider() {
+			return null;
+		}
+
+		public ConfigurationSource getConfigurationSource() {
+			return null;
+		}
+
+		public ValidatorFactory buildValidatorFactory() {
+			return null;
+		}
+	}
+}
+
+

src/test/java/javax/validation/ValidationTest.java

@@ -17,13 +17,18 @@
 package javax.validation;
 
 
+import java.io.IOException;
+import java.lang.ref.SoftReference;
 import java.net.URL;
 import java.net.URLClassLoader;
+import java.util.Enumeration;
+import javax.validation.spi.ValidationProvider;
 
 import org.testng.annotations.Test;
 
-import static org.testng.AssertJUnit.assertEquals;
-import static org.testng.AssertJUnit.fail;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertTrue;
+import static org.testng.Assert.fail;
 
 /**
  * @author Hardy Ferentschik
@@ -41,9 +46,11 @@ public void testCurrentClassLoaderIsUsedInCaseContextClassLoaderCannotLoadServic
 			fail();
 		}
 		catch ( ValidationException e ) {
+			// the custom context URL class loader cannot load the service file, so the exception
+			// must be triggered by using the current class loader
 			assertEquals(
-					"Unable to load Bean Validation provider non.existent.ValidationProvider",
-					e.getMessage()
+					e.getMessage(),
+					"Unable to load Bean Validation provider non.existent.ValidationProvider"
 			);
 		}
 		finally {
@@ -61,15 +68,80 @@ public void testCurrentClassLoaderIsUsedInCaseContextClassLoaderIsNull() {
 			fail();
 		}
 		catch ( ValidationException e ) {
+			// context class loader is not. exception must be caused by using the current class loader
 			assertEquals(
-					"Unable to load Bean Validation provider non.existent.ValidationProvider",
-					e.getMessage()
+					e.getMessage(),
+					"Unable to load Bean Validation provider non.existent.ValidationProvider"
 			);
 		}
 		finally {
 			Thread.currentThread().setContextClassLoader( contextClassLoader );
 		}
 	}
+
+	// BVAL-298
+	@Test
+	public void testCachedProvidersCanBeGarbageCollected() {
+		int LOOP_COUNT = 100;
+
+		ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
+		try {
+			for ( int i = 1; i <= LOOP_COUNT; i++ ) {
+				Thread.currentThread().setContextClassLoader( new CustomValidationXmlClassLoader( "-2" ) );
+				Validation.buildDefaultValidatorFactory();
+			}
+
+			int createdProviders = countInMemoryProviders();
+			assertTrue( createdProviders > 1, "There should be cached providers" );
+
+			try {
+				byte[][] buf = new byte[1024][];
+				for ( int i = 0; i < buf.length; i++ ) {
+					buf[i] = new byte[10 * 1024 * 1024];
+				}
+				fail( "The byte array allocation should have triggered a OutOfMemoryError" );
+			}
+			catch ( OutOfMemoryError ex ) {
+				// expected
+			}
+
+			// the VM guarantees that all soft references are cleared before a OutOfMemoryError occurs
+			assertEquals( countInMemoryProviders(), 0 );
+		}
+		finally {
+			Thread.currentThread().setContextClassLoader( contextClassLoader );
+		}
+	}
+
+	private int countInMemoryProviders() {
+		int count = 0;
+		// we cannot access Validation.DefaultValidationProviderResolver#providersPerClassloader, so we have to
+		// indirectly count the providers via DummyValidationProvider#createdValidationProviders
+		for ( SoftReference<DummyValidationProvider> ref : DummyValidationProvider.createdValidationProviders ) {
+			if ( ref.get() != null ) {
+				count++;
+			}
+		}
+		return count;
+	}
+
+	public static class CustomValidationXmlClassLoader extends ClassLoader {
+		private static final String SERVICES_FILE = "META-INF/services/" + ValidationProvider.class.getName();
+		private final String validationXmlSuffix;
+
+
+		public CustomValidationXmlClassLoader(String suffix) {
+			super( CustomValidationXmlClassLoader.class.getClassLoader() );
+			this.validationXmlSuffix = suffix;
+		}
+
+		public Enumeration<URL> getResources(String name) throws IOException {
+			if ( SERVICES_FILE.equals( name ) && validationXmlSuffix != null ) {
+				name = name + validationXmlSuffix;
+			}
+			return super.getResources( name );
+		}
+	}
 }
 
 

src/test/resources/META-INF/services/javax.validation.spi.ValidationProvider-2

@@ -0,0 +1 @@
+javax.validation.DummyValidationProvider