This is an automated email from the ASF dual-hosted git repository. davsclaus pushed a commit to branch CAMEL-27289-transformer-lazy-load in repository https://gitbox.apache.org/repos/asf/camel.git
commit 9da4a6b505df9cb443a085675a29335d56ddc1fb Author: Claus Ibsen <[email protected]> AuthorDate: Fri Nov 20 10:29:23 2026 +0100 CAMEL-27289: camel-core - the transformer registry lazy loads the transformer of the to data type before it falls back to one of the from data type 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))); + } + } + }
