HV-1480 Avoid initializing lists and maps in the common case where we

only have the default group

Also optimize a bit the advanced case with groups.

Author: gsmet

engine/src/main/java/org/hibernate/validator/internal/engine/groups/DefaultValidationOrder.java

@@ -7,47 +7,58 @@
 package org.hibernate.validator.internal.engine.groups;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+
 import javax.validation.GroupDefinitionException;
 
+import org.hibernate.validator.internal.util.CollectionHelper;
 import org.hibernate.validator.internal.util.logging.Log;
 import org.hibernate.validator.internal.util.logging.LoggerFactory;
 
-import static org.hibernate.validator.internal.util.CollectionHelper.newArrayList;
-import static org.hibernate.validator.internal.util.CollectionHelper.newHashMap;
-
 /**
  * An instance of {@code ValidationOrder} defines the group order during one validation call.
  *
  * @author Hardy Ferentschik
+ * @author Guillaume Smet
  */
 public final class DefaultValidationOrder implements ValidationOrder {
 	private static final Log log = LoggerFactory.make();
 
 	/**
 	 * The list of single groups to be used this validation.
 	 */
-	private List<Group> groupList = newArrayList();
+	private List<Group> groupList;
 
 	/**
 	 * The different sequences for this validation. The map contains the sequences mapped to their sequence
 	 * name.
 	 */
-	private Map<Class<?>, Sequence> sequenceMap = newHashMap();
+	private Map<Class<?>, Sequence> sequenceMap;
 
 	@Override
 	public Iterator<Group> getGroupIterator() {
+		if ( groupList == null ) {
+			return Collections.<Group>emptyIterator();
+		}
 		return groupList.iterator();
 	}
 
 	@Override
 	public Iterator<Sequence> getSequenceIterator() {
+		if ( sequenceMap == null ) {
+			return Collections.<Sequence>emptyIterator();
+		}
 		return sequenceMap.values().iterator();
 	}
 
 	public void insertGroup(Group group) {
+		if ( groupList == null ) {
+			groupList = new ArrayList<>( 5 );
+		}
+
 		if ( !groupList.contains( group ) ) {
 			groupList.add( group );
 		}
@@ -58,9 +69,11 @@ public void insertSequence(Sequence sequence) {
 			return;
 		}
 
-		if ( !sequenceMap.containsKey( sequence.getDefiningClass() ) ) {
-			sequenceMap.put( sequence.getDefiningClass(), sequence );
+		if ( sequenceMap == null ) {
+			sequenceMap = CollectionHelper.newHashMap( 5 );
 		}
+
+		sequenceMap.putIfAbsent( sequence.getDefiningClass(), sequence );
 	}
 
 	@Override
@@ -83,6 +96,10 @@ public String toString() {
 	@Override
 	public void assertDefaultGroupSequenceIsExpandable(List<Class<?>> defaultGroupSequence)
 			throws GroupDefinitionException {
+		if ( sequenceMap == null ) {
+			return;
+		}
+
 		for ( Map.Entry<Class<?>, Sequence> entry : sequenceMap.entrySet() ) {
 			List<Group> sequenceGroups = entry.getValue().getComposingGroups();
 			int defaultGroupIndex = sequenceGroups.indexOf( Group.DEFAULT_GROUP );

engine/src/main/java/org/hibernate/validator/internal/engine/groups/ValidationOrder.java

@@ -16,6 +16,7 @@
  * Interface defining the methods needed to execute groups and sequences in the right order.
  *
  * @author Hardy Ferentschik
+ * @author Guillaume Smet
  */
 public interface ValidationOrder {
 
@@ -35,17 +36,22 @@ public interface ValidationOrder {
 	void assertDefaultGroupSequenceIsExpandable(List<Class<?>> defaultGroupSequence)
 			throws GroupDefinitionException;
 
+	/**
+	 * A {@link org.hibernate.validator.internal.engine.groups.ValidationOrder} which contains a single group, {@code Default}.
+	 */
+	ValidationOrder DEFAULT_GROUP = new DefaultGroupValidationOrder();
+
 	/**
 	 * A {@link org.hibernate.validator.internal.engine.groups.ValidationOrder} which contains a single sequence which
 	 * in turn contains a single group, {@code Default}.
 	 */
-	ValidationOrder DEFAULT_SEQUENCE = new DefaultValidationOrder();
+	ValidationOrder DEFAULT_SEQUENCE = new DefaultSequenceValidationOrder();
 
-	class DefaultValidationOrder implements ValidationOrder {
+	class DefaultSequenceValidationOrder implements ValidationOrder {
 
 		private final List<Sequence> defaultSequences;
 
-		private DefaultValidationOrder() {
+		private DefaultSequenceValidationOrder() {
 			defaultSequences = Collections.singletonList( Sequence.DEFAULT );
 		}
 
@@ -63,4 +69,27 @@ public Iterator<Sequence> getSequenceIterator() {
 		public void assertDefaultGroupSequenceIsExpandable(List<Class<?>> defaultGroupSequence) throws GroupDefinitionException {
 		}
 	}
+
+	class DefaultGroupValidationOrder implements ValidationOrder {
+
+		private final List<Group> defaultGroups;
+
+		private DefaultGroupValidationOrder() {
+			defaultGroups = Collections.singletonList( Group.DEFAULT_GROUP );
+		}
+
+		@Override
+		public Iterator<Group> getGroupIterator() {
+			return defaultGroups.iterator();
+		}
+
+		@Override
+		public Iterator<Sequence> getSequenceIterator() {
+			return Collections.<Sequence>emptyIterator();
+		}
+
+		@Override
+		public void assertDefaultGroupSequenceIsExpandable(List<Class<?>> defaultGroupSequence) throws GroupDefinitionException {
+		}
+	}
 }

engine/src/main/java/org/hibernate/validator/internal/engine/groups/ValidationOrderGenerator.java

@@ -31,13 +31,6 @@ public class ValidationOrderGenerator {
 
 	private final ConcurrentMap<Class<?>, Sequence> resolvedSequences = new ConcurrentHashMap<Class<?>, Sequence>();
 
-	private final DefaultValidationOrder validationOrderForDefaultGroup;
-
-	public ValidationOrderGenerator() {
-		validationOrderForDefaultGroup = new DefaultValidationOrder();
-		validationOrderForDefaultGroup.insertGroup( Group.DEFAULT_GROUP );
-	}
-
 	/**
 	 * Creates a {@link ValidationOrder} for the given validation group.
 	 *
@@ -49,6 +42,10 @@ public ValidationOrderGenerator() {
 	 * @return a {@link ValidationOrder} for the given validation group
 	 */
 	public ValidationOrder getValidationOrder(Class<?> group, boolean expand) {
+		if ( Default.class.equals( group ) ) {
+			return ValidationOrder.DEFAULT_GROUP;
+		}
+
 		if ( expand ) {
 			return getValidationOrder( Arrays.<Class<?>>asList( group ) );
 		}
@@ -74,7 +71,7 @@ public ValidationOrder getValidationOrder(Collection<Class<?>> groups) {
 		// HV-621 - if we deal with the Default group we return the default ValidationOrder. No need to
 		// process Default as other groups which saves several reflection calls (HF)
 		if ( groups.size() == 1 && groups.contains( Default.class ) ) {
-			return validationOrderForDefaultGroup;
+			return ValidationOrder.DEFAULT_GROUP;
 		}
 
 		for ( Class<?> clazz : groups ) {