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)));
+        }
+    }
+
 }

Reply via email to