This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
The following commit(s) were added to refs/heads/main by this push:
new 028b52ffcdcd CAMEL-27289: camel-core - the transformer registry lazy
loads the transformer of the to data type before the from fallback (#30486)
028b52ffcdcd is described below
commit 028b52ffcdcd136a6a0462d04c9c75bd7c651df1
Author: Claus Ibsen <[email protected]>
AuthorDate: Fri Nov 20 11:02:16 2026 +0100
CAMEL-27289: camel-core - the transformer registry lazy loads the
transformer of the to data type before the from fallback (#30486)
When no transformer matched a key, DefaultTransformerRegistry took a
transformer of the from data type before it lazy loaded the one of the to
data type, and kept that as an alias. Only binary, text and
application-x-unchanged are loaded up front, so an input data type such as
application-json, after a step that left one of these types, got the
transformer of the previous type: an action Kamelet with the in type
application-json after one with the out type application-x-unchanged left
the body as it was, with no Content-Type.
The registry now lazy loads the transformer of the to data type first, and
falls back to a transformer of the from data type only when there is none,
such as for a data format transformer of a scheme that unmarshals into a
Java type.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Signed-off-by: Claus Ibsen <[email protected]>
---
.../impl/engine/DefaultTransformerRegistry.java | 48 ++++++++++++++--------
.../engine/DefaultTransformerRegistryTest.java | 42 +++++++++++++++++++
2 files changed, 73 insertions(+), 17 deletions(-)
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultTransformerRegistry.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultTransformerRegistry.java
index 6db39ccbbfec..73b443cbf48d 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultTransformerRegistry.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultTransformerRegistry.java
@@ -92,26 +92,15 @@ public class DefaultTransformerRegistry extends
AbstractDynamicRegistry<Transfor
}
}
- if (answer == null && !DataType.isAnyType(key.getFrom())) {
- alias = new TransformerKey(key.getFrom());
- answer = get(alias);
-
- if (answer == null) {
- alias = new TransformerKey(key.getFrom().getScheme());
- answer = get(alias);
- }
- }
-
if (answer != null) {
- if (LOG.isDebugEnabled()) {
- LOG.debug("Found transformer {} for key {} using alias {}",
ObjectHelper.name(answer.getClass()), key, alias);
- }
-
- aliasMap.put(key, alias);
- return answer;
+ return addAlias(key, alias, answer);
}
- if (!DataType.isJavaType(key.getTo())) {
+ // lazy load the transformer of the to data type before falling back
to a transformer of the from data type:
+ // only a few transformers are loaded up front, so a loaded
transformer of the from data type (such as the one
+ // of the data type of the previous step) would otherwise be taken,
and kept, for a to data type that is not
+ // loaded yet
+ if (!DataType.isAnyType(key.getTo()) &&
!DataType.isJavaType(key.getTo())) {
answer = lazyLoadTransformer(new TransformerKey(key.getTo()));
if (answer != null) {
@@ -124,9 +113,34 @@ public class DefaultTransformerRegistry extends
AbstractDynamicRegistry<Transfor
if (LOG.isDebugEnabled()) {
LOG.debug("Found transformer {} for key {}",
ObjectHelper.name(answer.getClass()), key);
}
+ return answer;
+ }
+ }
+
+ // a transformer of the from data type, such as the transformer of a
data format scheme that unmarshals into a
+ // Java type
+ if (!DataType.isAnyType(key.getFrom())) {
+ alias = new TransformerKey(key.getFrom());
+ answer = get(alias);
+
+ if (answer == null) {
+ alias = new TransformerKey(key.getFrom().getScheme());
+ answer = get(alias);
}
}
+ if (answer != null) {
+ return addAlias(key, alias, answer);
+ }
+
+ return null;
+ }
+
+ private Transformer addAlias(TransformerKey key, TransformerKey alias,
Transformer answer) {
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Found transformer {} for key {} using alias {}",
ObjectHelper.name(answer.getClass()), key, alias);
+ }
+ aliasMap.put(key, alias);
return answer;
}
diff --git
a/core/camel-core/src/test/java/org/apache/camel/impl/engine/DefaultTransformerRegistryTest.java
b/core/camel-core/src/test/java/org/apache/camel/impl/engine/DefaultTransformerRegistryTest.java
index 1f21e61e5c96..bf3f2cf19eea 100644
---
a/core/camel-core/src/test/java/org/apache/camel/impl/engine/DefaultTransformerRegistryTest.java
+++
b/core/camel-core/src/test/java/org/apache/camel/impl/engine/DefaultTransformerRegistryTest.java
@@ -20,6 +20,8 @@ package org.apache.camel.impl.engine;
import org.apache.camel.impl.DefaultCamelContext;
import org.apache.camel.processor.transformer.ByteArrayDataTypeTransformer;
import org.apache.camel.processor.transformer.StringDataTypeTransformer;
+import org.apache.camel.processor.transformer.UnchangedDataTypeTransformer;
+import org.apache.camel.spi.DataType;
import org.apache.camel.spi.Transformer;
import org.apache.camel.spi.TransformerKey;
import org.junit.jupiter.api.Assertions;
@@ -45,4 +47,44 @@ class DefaultTransformerRegistryTest {
Assertions.assertEquals(UppercaseDataTypeTransformer.class,
transformer.getClass());
}
+ @Test
+ public void shouldLazyLoadToTransformerBeforeFromTransformer() {
+ // load binary and application-x-unchanged first, as a Camel context
does up front: the transformer of the
+ // from data type must not be taken for a to data type that is not
loaded yet (CAMEL-27289)
+ loadTransformers("application-octet-stream",
"application-x-unchanged");
+ TransformerKey key = new TransformerKey(new
DataType("application-octet-stream"), new DataType("lowercase"));
+ Transformer transformer = dataTypeRegistry.resolveTransformer(key);
+ Assertions.assertNotNull(transformer);
+ Assertions.assertEquals(LowercaseDataTypeTransformer.class,
transformer.getClass());
+ // and the same again, from the cache
+ transformer = dataTypeRegistry.resolveTransformer(key);
+ Assertions.assertEquals(LowercaseDataTypeTransformer.class,
transformer.getClass());
+
+ transformer = dataTypeRegistry.resolveTransformer(
+ new TransformerKey(new DataType("application-x-unchanged"),
new DataType("uppercase")));
+ Assertions.assertNotNull(transformer);
+ Assertions.assertEquals(UppercaseDataTypeTransformer.class,
transformer.getClass());
+ }
+
+ @Test
+ public void shouldFallBackToFromTransformer() {
+ // no transformer of the to data type, neither loaded nor to lazy
load: the one of the from data type is used
+ loadTransformers("text-plain", "application-x-unchanged");
+ Transformer transformer = dataTypeRegistry.resolveTransformer(
+ new TransformerKey(new DataType("text-plain"), new
DataType("java:" + Integer.class.getName())));
+ Assertions.assertNotNull(transformer);
+ Assertions.assertEquals(StringDataTypeTransformer.class,
transformer.getClass());
+
+ transformer = dataTypeRegistry.resolveTransformer(
+ new TransformerKey(new DataType("application-x-unchanged"),
new DataType("no-such-type")));
+ Assertions.assertNotNull(transformer);
+ Assertions.assertEquals(UnchangedDataTypeTransformer.class,
transformer.getClass());
+ }
+
+ private void loadTransformers(String... names) {
+ for (String name : names) {
+ Assertions.assertNotNull(dataTypeRegistry.resolveTransformer(new
TransformerKey(name)));
+ }
+ }
+
}