You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@bval.apache.org by ta...@apache.org on 2026/07/24 23:32:22 UTC
(bval) 04/09: reduce allocations
This is an automated email from the ASF dual-hosted git repository.
asf-gitbox-commits pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/bval.git
commit ec653094b133d2008a03ff6730e2b1636a2eeaab
Author: tandraschko <ta...@apache.org>
AuthorDate: Fri Jul 24 18:24:26 2026 +0200
reduce allocations
---
.../org/apache/bval/jsr/job/ValidationJob.java | 23 ++++++++---
.../java/org/apache/bval/jsr/util/NodeImpl.java | 48 ++++++++++++++++------
2 files changed, 53 insertions(+), 18 deletions(-)
diff --git a/bval-jsr/src/main/java/org/apache/bval/jsr/job/ValidationJob.java b/bval-jsr/src/main/java/org/apache/bval/jsr/job/ValidationJob.java
index 670297f..12747bb 100644
--- a/bval-jsr/src/main/java/org/apache/bval/jsr/job/ValidationJob.java
+++ b/bval-jsr/src/main/java/org/apache/bval/jsr/job/ValidationJob.java
@@ -559,12 +559,25 @@ public abstract class ValidationJob<T> {
protected static final TypeVariable<?> ITERABLE_ELEMENT = Iterable.class.getTypeParameters()[0];
private static Stream<ConstraintD<?>> constraintsFor(ElementD<?, ?> descriptor, GroupStrategy groups) {
+ // Resolve the target groups once per call rather than once per constraint: GroupStrategy.getGroups()
+ // may allocate (a singleton for a plain Group, a fully streamed-and-collected set for a Composite),
+ // and it is invariant across the constraints being filtered.
+ final Set<Group> targetGroups = groups.getGroups();
return descriptor.getConstraintDescriptors().stream().<ConstraintD<?>> map(ConstraintD.class::cast)
- .filter(c -> {
- final Set<Class<?>> constraintGroups = c.getGroups();
- return groups.getGroups().stream().map(Group::getGroup).anyMatch(g -> constraintGroups.contains(g)
- || constraintGroups.contains(Default.class) && c.getDeclaringClass().equals(g));
- });
+ .filter(c -> matchesGroups(c, targetGroups));
+ }
+
+ private static boolean matchesGroups(ConstraintD<?> constraint, Set<Group> targetGroups) {
+ final Set<Class<?>> constraintGroups = constraint.getGroups();
+ final boolean impliesDefault = constraintGroups.contains(Default.class);
+ for (final Group target : targetGroups) {
+ final Class<?> g = target.getGroup();
+ if (constraintGroups.contains(g)
+ || impliesDefault && constraint.getDeclaringClass().equals(g)) {
+ return true;
+ }
+ }
+ return false;
}
protected final ApacheFactoryContext validatorContext;
diff --git a/bval-jsr/src/main/java/org/apache/bval/jsr/util/NodeImpl.java b/bval-jsr/src/main/java/org/apache/bval/jsr/util/NodeImpl.java
index f0b182b..7437d79 100644
--- a/bval-jsr/src/main/java/org/apache/bval/jsr/util/NodeImpl.java
+++ b/bval-jsr/src/main/java/org/apache/bval/jsr/util/NodeImpl.java
@@ -78,6 +78,34 @@ public abstract class NodeImpl implements Path.Node, Serializable {
return 0;
}).thenComparing((Function<Object, String>) Objects::toString));
+ // Per-kind node comparators are stateless and constant; hoisted to static finals so they are not
+ // re-allocated on every compareSpecificNodeInfo/compareIterability call (both are hot during path
+ // comparison, e.g. violation de-duplication).
+ private static final Comparator<Node> KEY_NODE_COMPARATOR = comparing(Node::getKey, KEY_COMPARATOR);
+
+ private static final Comparator<Node> BEAN_NODE_COMPARATOR =
+ comparing(to(BeanNode.class), comparing(BeanNode::getContainerClass, CLASS_COMPARATOR)
+ .thenComparing(BeanNode::getTypeArgumentIndex, nullsFirst(naturalOrder())));
+
+ private static final Comparator<Node> PROPERTY_NODE_COMPARATOR =
+ comparing(to(PropertyNode.class), comparing(PropertyNode::getContainerClass, CLASS_COMPARATOR)
+ .thenComparing(PropertyNode::getTypeArgumentIndex, nullsFirst(naturalOrder())));
+
+ private static final Comparator<Node> CONTAINER_ELEMENT_NODE_COMPARATOR =
+ comparing(to(ContainerElementNode.class), comparing(ContainerElementNode::getContainerClass, CLASS_COMPARATOR)
+ .thenComparing(ContainerElementNode::getTypeArgumentIndex, nullsFirst(naturalOrder())));
+
+ private static final Comparator<Node> CONSTRUCTOR_NODE_COMPARATOR =
+ comparing(to(ConstructorNode.class).andThen(ConstructorNode::getParameterTypes),
+ Comparators.comparingIterables(CLASS_COMPARATOR));
+
+ private static final Comparator<Node> METHOD_NODE_COMPARATOR =
+ comparing(to(MethodNode.class).andThen(MethodNode::getParameterTypes),
+ Comparators.comparingIterables(CLASS_COMPARATOR));
+
+ private static final Comparator<Node> PARAMETER_NODE_COMPARATOR =
+ comparing(to(ParameterNode.class).andThen(ParameterNode::getParameterIndex));
+
private static final char INDEX_OPEN = '[';
private static final char INDEX_CLOSE = ']';
@@ -144,7 +172,7 @@ public abstract class NodeImpl implements Path.Node, Serializable {
if (quid.isInIterable()) {
if (quo.isInIterable()) {
if (quid.getKey() != null) {
- return Comparator.comparing(Node::getKey, KEY_COMPARATOR).compare(quid, quo);
+ return KEY_NODE_COMPARATOR.compare(quid, quo);
}
if (quo.getKey() != null) {
return -1;
@@ -173,28 +201,22 @@ public abstract class NodeImpl implements Path.Node, Serializable {
final Comparator<Node> cmp;
switch (kind) {
case BEAN:
- cmp = comparing(to(BeanNode.class), comparing(BeanNode::getContainerClass, CLASS_COMPARATOR)
- .thenComparing(BeanNode::getTypeArgumentIndex, nullsFirst(naturalOrder())));
+ cmp = BEAN_NODE_COMPARATOR;
break;
case PROPERTY:
- cmp = comparing(to(PropertyNode.class), comparing(PropertyNode::getContainerClass, CLASS_COMPARATOR)
- .thenComparing(PropertyNode::getTypeArgumentIndex, nullsFirst(naturalOrder())));
+ cmp = PROPERTY_NODE_COMPARATOR;
break;
case CONTAINER_ELEMENT:
- cmp = comparing(to(ContainerElementNode.class),
- comparing(ContainerElementNode::getContainerClass, CLASS_COMPARATOR)
- .thenComparing(ContainerElementNode::getTypeArgumentIndex, nullsFirst(naturalOrder())));
+ cmp = CONTAINER_ELEMENT_NODE_COMPARATOR;
break;
case CONSTRUCTOR:
- cmp = comparing(to(ConstructorNode.class).andThen(ConstructorNode::getParameterTypes),
- Comparators.comparingIterables(CLASS_COMPARATOR));
+ cmp = CONSTRUCTOR_NODE_COMPARATOR;
break;
case METHOD:
- cmp = comparing(to(MethodNode.class).andThen(MethodNode::getParameterTypes),
- Comparators.comparingIterables(CLASS_COMPARATOR));
+ cmp = METHOD_NODE_COMPARATOR;
break;
case PARAMETER:
- cmp = comparing(to(ParameterNode.class).andThen(ParameterNode::getParameterIndex));
+ cmp = PARAMETER_NODE_COMPARATOR;
break;
default:
return 0;