[camel] 12/18: CAMEL-16102: Source code generate @InvokeOnHeader for reflection free

Sat, 06 Feb 2021 04:05:08 -0800 

This is an automated email from the ASF dual-hosted git repository.

davsclaus pushed a commit to branch on-header
in repository https://gitbox.apache.org/repos/asf/camel.git

commit 31754eea955fa1acf058a5a5bb89c9c709569eb0
Author: Claus Ibsen <claus.ib...@gmail.com>
AuthorDate: Fri Feb 5 12:21:52 2021 +0100

    CAMEL-16102: Source code generate @InvokeOnHeader for reflection free
---
 .../camel/catalog/docs/spring-redis-component.adoc |   3 +-
 .../component/redis/RedisComponentConfigurer.java  |  11 +
 .../redis/RedisProducerInvokeOnHeaderFactory.java  | 236 ++++++++
 .../org.apache.camel.component.redis.RedisProducer |   2 +
 .../apache/camel/component/redis/spring-redis.json |   1 +
 .../src/main/docs/spring-redis-component.adoc      |   3 +-
 .../redis/AbstractRedisProcessorCreator.java       |  56 --
 .../component/redis/AllRedisProcessorsCreator.java |  46 --
 .../org/apache/camel/component/redis/Command.java  |   2 +-
 .../redis/ConnectionRedisProcessorsCreator.java    |  33 --
 .../camel/component/redis/ExchangeConverter.java   |   2 +-
 .../component/redis/GeoRedisProcessorsCreator.java |  47 --
 .../redis/HashesRedisProcessorsCreator.java        |  54 --
 .../redis/KeysRedisProcessorsCreator.java          |  53 --
 .../redis/ListsRedisProcessorsCreator.java         |  69 ---
 .../redis/PubSubRedisProcessorsCreator.java        |  34 --
 .../camel/component/redis/RedisComponent.java      |  18 +-
 .../camel/component/redis/RedisEndpoint.java       |  15 +-
 .../camel/component/redis/RedisProducer.java       | 598 ++++++++++++++++++++-
 .../redis/SetsRedisProcessorsCreator.java          |  59 --
 .../redis/SortedSetsRedisProcessorsCreator.java    |  73 ---
 .../redis/StringsRedisProcessorsCreator.java       |  66 ---
 .../redis/TransactionRedisProcessorsCreator.java   |  35 --
 .../dsl/SpringRedisComponentBuilderFactory.java    |  17 +
 .../camel/support/HeaderSelectorProducer.java      |  23 +-
 .../modules/ROOT/pages/spring-redis-component.adoc |   3 +-
 .../packaging/GenerateInvokeOnHeaderMojo.java      |  19 +-
 27 files changed, 902 insertions(+), 676 deletions(-)

diff --git 
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/spring-redis-component.adoc
 
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/spring-redis-component.adoc
index c24bb95..ce57b66 100644
--- 
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/spring-redis-component.adoc
+++ 
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/spring-redis-component.adoc
@@ -44,13 +44,14 @@ You can append query options to the URI in the following 
format,
 
 
 // component options: START
-The Spring Redis component supports 3 options, which are listed below.
+The Spring Redis component supports 4 options, which are listed below.
 
 
 
 [width="100%",cols="2,5,^1,2",options="header"]
 |===
 | Name | Description | Default | Type
+| *redisTemplate* (common) | *Autowired* Reference to a pre-configured 
RedisTemplate instance to use. |  | RedisTemplate
 | *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the 
Camel routing Error Handler, which mean any exceptions occurred while the 
consumer is trying to pickup incoming messages, or the likes, will now be 
processed as a message and handled by the routing Error Handler. By default the 
consumer will use the org.apache.camel.spi.ExceptionHandler to deal with 
exceptions, that will be logged at WARN or ERROR level and ignored. | false | 
boolean
 | *lazyStartProducer* (producer) | Whether the producer should be started lazy 
(on the first message). By starting lazy you can use this to allow CamelContext 
and routes to startup in situations where a producer may otherwise fail during 
starting and cause the route to fail being started. By deferring this startup 
to be lazy then the startup failure can be handled during routing messages via 
Camel's routing error handlers. Beware that when the first message is processed 
then creating and [...]
 | *autowiredEnabled* (advanced) | Whether autowiring is enabled. This is used 
for automatic autowiring options (the option must be marked as autowired) by 
looking up in the registry to find if there is a single instance of matching 
type, which then gets configured on the component. This can be used for 
automatic configuring JDBC data sources, JMS connection factories, AWS Clients, 
etc. | true | boolean
diff --git 
a/components/camel-spring-redis/src/generated/java/org/apache/camel/component/redis/RedisComponentConfigurer.java
 
b/components/camel-spring-redis/src/generated/java/org/apache/camel/component/redis/RedisComponentConfigurer.java
index 20241fa..8e98244 100644
--- 
a/components/camel-spring-redis/src/generated/java/org/apache/camel/component/redis/RedisComponentConfigurer.java
+++ 
b/components/camel-spring-redis/src/generated/java/org/apache/camel/component/redis/RedisComponentConfigurer.java
@@ -27,11 +27,18 @@ public class RedisComponentConfigurer extends 
PropertyConfigurerSupport implemen
         case "bridgeErrorHandler": 
target.setBridgeErrorHandler(property(camelContext, boolean.class, value)); 
return true;
         case "lazystartproducer":
         case "lazyStartProducer": 
target.setLazyStartProducer(property(camelContext, boolean.class, value)); 
return true;
+        case "redistemplate":
+        case "redisTemplate": target.setRedisTemplate(property(camelContext, 
org.springframework.data.redis.core.RedisTemplate.class, value)); return true;
         default: return false;
         }
     }
 
     @Override
+    public String[] getAutowiredNames() {
+        return new String[]{"redisTemplate"};
+    }
+
+    @Override
     public Class<?> getOptionType(String name, boolean ignoreCase) {
         switch (ignoreCase ? name.toLowerCase() : name) {
         case "autowiredenabled":
@@ -40,6 +47,8 @@ public class RedisComponentConfigurer extends 
PropertyConfigurerSupport implemen
         case "bridgeErrorHandler": return boolean.class;
         case "lazystartproducer":
         case "lazyStartProducer": return boolean.class;
+        case "redistemplate":
+        case "redisTemplate": return 
org.springframework.data.redis.core.RedisTemplate.class;
         default: return null;
         }
     }
@@ -54,6 +63,8 @@ public class RedisComponentConfigurer extends 
PropertyConfigurerSupport implemen
         case "bridgeErrorHandler": return target.isBridgeErrorHandler();
         case "lazystartproducer":
         case "lazyStartProducer": return target.isLazyStartProducer();
+        case "redistemplate":
+        case "redisTemplate": return target.getRedisTemplate();
         default: return null;
         }
     }
diff --git 
a/components/camel-spring-redis/src/generated/java/org/apache/camel/component/redis/RedisProducerInvokeOnHeaderFactory.java
 
b/components/camel-spring-redis/src/generated/java/org/apache/camel/component/redis/RedisProducerInvokeOnHeaderFactory.java
new file mode 100644
index 0000000..5f030c2
--- /dev/null
+++ 
b/components/camel-spring-redis/src/generated/java/org/apache/camel/component/redis/RedisProducerInvokeOnHeaderFactory.java
@@ -0,0 +1,236 @@
+/* Generated by camel build tools - do NOT edit this file! */
+package org.apache.camel.component.redis;
+
+import org.apache.camel.AsyncCallback;
+import org.apache.camel.Exchange;
+import org.apache.camel.spi.InvokeOnHeaderStrategy;
+import org.apache.camel.component.redis.RedisProducer;
+
+/**
+ * Generated by camel build tools - do NOT edit this file!
+ */
+@SuppressWarnings("unchecked")
+public class RedisProducerInvokeOnHeaderFactory implements 
InvokeOnHeaderStrategy {
+
+    @Override
+    public Object invoke(Object obj, String key, Exchange exchange, 
AsyncCallback callback) throws Exception {
+        org.apache.camel.component.redis.RedisProducer target = 
(org.apache.camel.component.redis.RedisProducer) obj;
+        switch (key) {
+        case "append":
+        case "APPEND": return target.invokeAppend(exchange);
+        case "blpop":
+        case "BLPOP": return target.invokeBlpop(exchange);
+        case "brpop":
+        case "BRPOP": return target.invokeBrpop(exchange);
+        case "brpoplpush":
+        case "BRPOPLPUSH": return target.invokeBrpoplpush(exchange);
+        case "decr":
+        case "DECR": return target.invokeDecr(exchange);
+        case "decrby":
+        case "DECRBY": return target.invokeDecrby(exchange);
+        case "del":
+        case "DEL": target.invokeDel(exchange); return null;
+        case "discard":
+        case "DISCARD": target.invokeDiscard(exchange); return null;
+        case "echo":
+        case "ECHO": return target.invokeEcho(exchange);
+        case "exec":
+        case "EXEC": target.invokeExec(exchange); return null;
+        case "exists":
+        case "EXISTS": return target.invokeExists(exchange);
+        case "expire":
+        case "EXPIRE": return target.invokeExpire(exchange);
+        case "expireat":
+        case "EXPIREAT": return target.invokeExpireat(exchange);
+        case "geoadd":
+        case "GEOADD": return target.invokeGeoadd(exchange);
+        case "geodist":
+        case "GEODIST": return target.invokeGeodist(exchange);
+        case "geohash":
+        case "GEOHASH": return target.invokeGeohash(exchange);
+        case "geopos":
+        case "GEOPOS": return target.invokeGeopos(exchange);
+        case "georadius":
+        case "GEORADIUS": return target.invokeGeoradius(exchange);
+        case "georadiusbymember":
+        case "GEORADIUSBYMEMBER": return 
target.invokeGeoradiusbymember(exchange);
+        case "get":
+        case "GET": return target.invokeGet(exchange);
+        case "getbit":
+        case "GETBIT": return target.invokeGetbit(exchange);
+        case "getrange":
+        case "GETRANGE": return target.invokeGetrange(exchange);
+        case "getset":
+        case "GETSET": return target.invokeGetset(exchange);
+        case "hdel":
+        case "HDEL": target.invokeHdel(exchange); return null;
+        case "hexists":
+        case "HEXISTS": return target.invokeHexists(exchange);
+        case "hget":
+        case "HGET": return target.invokeHget(exchange);
+        case "hgetall":
+        case "HGETALL": return target.invokeHgetAll(exchange);
+        case "hincrby":
+        case "HINCRBY": return target.invokeHincrBy(exchange);
+        case "hkeys":
+        case "HKEYS": return target.invokeHkeys(exchange);
+        case "hlen":
+        case "HLEN": return target.invokeHlen(exchange);
+        case "hmget":
+        case "HMGET": return target.invokeHmget(exchange);
+        case "hmset":
+        case "HMSET": target.invokeHmset(exchange); return null;
+        case "hset":
+        case "HSET": target.invokeHset(exchange); return null;
+        case "hsetnx":
+        case "HSETNX": return target.invokeHsetnx(exchange);
+        case "hvals":
+        case "HVALS": return target.invokeHvals(exchange);
+        case "incr":
+        case "INCR": return target.invokeIncr(exchange);
+        case "incrby":
+        case "INCRBY": return target.invokeIncrby(exchange);
+        case "keys":
+        case "KEYS": return target.invokeKeys(exchange);
+        case "lindex":
+        case "LINDEX": return target.invokeLindex(exchange);
+        case "linsert":
+        case "LINSERT": return target.invokeLinsert(exchange);
+        case "llen":
+        case "LLEN": return target.invokeLlen(exchange);
+        case "lpop":
+        case "LPOP": return target.invokeLpop(exchange);
+        case "lpush":
+        case "LPUSH": return target.invokeLpush(exchange);
+        case "lpushx":
+        case "LPUSHX": return target.invokeLpushx(exchange);
+        case "lrange":
+        case "LRANGE": return target.invokeLrange(exchange);
+        case "lrem":
+        case "LREM": return target.invokeLrem(exchange);
+        case "lset":
+        case "LSET": target.invokeLset(exchange); return null;
+        case "ltrim":
+        case "LTRIM": target.invokeLtrim(exchange); return null;
+        case "mget":
+        case "MGET": return target.invokeMget(exchange);
+        case "move":
+        case "MOVE": return target.invokeMove(exchange);
+        case "mset":
+        case "MSET": target.invokeMset(exchange); return null;
+        case "msetnx":
+        case "MSETNX": target.invokeMsetnx(exchange); return null;
+        case "multi":
+        case "MULTI": target.invokeMulti(exchange); return null;
+        case "persist":
+        case "PERSIST": return target.invokePersist(exchange);
+        case "pexpire":
+        case "PEXPIRE": return target.invokePexpire(exchange);
+        case "pexpireat":
+        case "PEXPIREAT": return target.invokePexpireat(exchange);
+        case "ping":
+        case "PING": return target.invokePing(exchange);
+        case "publish":
+        case "PUBLISH": target.invokePublish(exchange); return null;
+        case "quit":
+        case "QUIT": target.invokeQuit(exchange); return null;
+        case "randomkey":
+        case "RANDOMKEY": return target.invokeRandomkey(exchange);
+        case "rename":
+        case "RENAME": target.invokeRename(exchange); return null;
+        case "renamenx":
+        case "RENAMENX": return target.invokeRenamenx(exchange);
+        case "rpop":
+        case "RPOP": return target.invokeRpop(exchange);
+        case "rpoplpush":
+        case "RPOPLPUSH": return target.invokeRpoplpush(exchange);
+        case "rpush":
+        case "RPUSH": return target.invokeRpush(exchange);
+        case "rpushx":
+        case "RPUSHX": return target.invokeRpushx(exchange);
+        case "sadd":
+        case "SADD": return target.invokeSadd(exchange);
+        case "scard":
+        case "SCARD": return target.invokeScard(exchange);
+        case "sdiff":
+        case "SDIFF": return target.invokeSdiff(exchange);
+        case "sdiffstore":
+        case "SDIFFSTORE": target.invokeSdiffstore(exchange); return null;
+        case "set":
+        case "SET": target.invokeSet(exchange); return null;
+        case "setbit":
+        case "SETBIT": target.invokeSetbit(exchange); return null;
+        case "setex":
+        case "SETEX": target.invokeSetex(exchange); return null;
+        case "setnx":
+        case "SETNX": return target.invokeSetnx(exchange);
+        case "setrange":
+        case "SETRANGE": target.invokeSetrange(exchange); return null;
+        case "sinter":
+        case "SINTER": return target.invokeSinter(exchange);
+        case "sinterstore":
+        case "SINTERSTORE": target.invokeSinterstore(exchange); return null;
+        case "sismember":
+        case "SISMEMBER": return target.invokeSismember(exchange);
+        case "smembers":
+        case "SMEMBERS": return target.invokeSmembers(exchange);
+        case "smove":
+        case "SMOVE": return target.invokeSmove(exchange);
+        case "sort":
+        case "SORT": return target.invokeSort(exchange);
+        case "spop":
+        case "SPOP": return target.invokeSpop(exchange);
+        case "srandmember":
+        case "SRANDMEMBER": return target.invokeSrandmember(exchange);
+        case "srem":
+        case "SREM": return target.invokeSrem(exchange);
+        case "strlen":
+        case "STRLEN": return target.invokeStrlen(exchange);
+        case "sunion":
+        case "SUNION": return target.invokeSunion(exchange);
+        case "sunionstore":
+        case "SUNIONSTORE": target.invokeSunionstore(exchange); return null;
+        case "ttl":
+        case "TTL": return target.invokeTtl(exchange);
+        case "type":
+        case "TYPE": return target.invokeType(exchange);
+        case "unwatch":
+        case "UNWATCH": target.invokeUnwatch(exchange); return null;
+        case "watch":
+        case "WATCH": target.invokeWatch(exchange); return null;
+        case "zadd":
+        case "ZADD": return target.invokeZadd(exchange);
+        case "zcard":
+        case "ZCARD": return target.invokeZcard(exchange);
+        case "zcount":
+        case "ZCOUNT": return target.invokeZcount(exchange);
+        case "zincrby":
+        case "ZINCRBY": return target.invokeZincrby(exchange);
+        case "zinterstore":
+        case "ZINTERSTORE": target.invokeZinterstore(exchange); return null;
+        case "zrange":
+        case "ZRANGE": return target.invokeZrange(exchange);
+        case "zrangebyscore":
+        case "ZRANGEBYSCORE": return target.invokeZrangebyscore(exchange);
+        case "zrank":
+        case "ZRANK": return target.invokeZrank(exchange);
+        case "zrem":
+        case "ZREM": return target.invokeZrem(exchange);
+        case "zremrangebyrank":
+        case "ZREMRANGEBYRANK": target.invokeZremrangebyrank(exchange); return 
null;
+        case "zremrangebyscore":
+        case "ZREMRANGEBYSCORE": target.invokeZremrangebyscore(exchange); 
return null;
+        case "zrevrange":
+        case "ZREVRANGE": return target.invokeZrevrange(exchange);
+        case "zrevrangebyscore":
+        case "ZREVRANGEBYSCORE": return 
target.invokeZrevrangebyscore(exchange);
+        case "zrevrank":
+        case "ZREVRANK": return target.invokeZrevrank(exchange);
+        case "zunionstore":
+        case "ZUNIONSTORE": target.invokeZunionstore(exchange); return null;
+        default: return null;
+        }
+    }
+
+}
+
diff --git 
a/components/camel-spring-redis/src/generated/resources/META-INF/services/org/apache/camel/invoke-on-header/org.apache.camel.component.redis.RedisProducer
 
b/components/camel-spring-redis/src/generated/resources/META-INF/services/org/apache/camel/invoke-on-header/org.apache.camel.component.redis.RedisProducer
new file mode 100644
index 0000000..416915e
--- /dev/null
+++ 
b/components/camel-spring-redis/src/generated/resources/META-INF/services/org/apache/camel/invoke-on-header/org.apache.camel.component.redis.RedisProducer
@@ -0,0 +1,2 @@
+# Generated by camel build tools - do NOT edit this file!
+class=org.apache.camel.component.redis.RedisProducerInvokeOnHeaderFactory
diff --git 
a/components/camel-spring-redis/src/generated/resources/org/apache/camel/component/redis/spring-redis.json
 
b/components/camel-spring-redis/src/generated/resources/org/apache/camel/component/redis/spring-redis.json
index baa7b66..f219a0b 100644
--- 
a/components/camel-spring-redis/src/generated/resources/org/apache/camel/component/redis/spring-redis.json
+++ 
b/components/camel-spring-redis/src/generated/resources/org/apache/camel/component/redis/spring-redis.json
@@ -22,6 +22,7 @@
     "lenientProperties": false
   },
   "componentProperties": {
+    "redisTemplate": { "kind": "property", "displayName": "Redis Template", 
"group": "common", "label": "", "required": false, "type": "object", 
"javaType": "org.springframework.data.redis.core.RedisTemplate", "deprecated": 
false, "autowired": true, "secret": false, "description": "Reference to a 
pre-configured RedisTemplate instance to use." },
     "bridgeErrorHandler": { "kind": "property", "displayName": "Bridge Error 
Handler", "group": "consumer", "label": "consumer", "required": false, "type": 
"boolean", "javaType": "boolean", "deprecated": false, "autowired": false, 
"secret": false, "defaultValue": false, "description": "Allows for bridging the 
consumer to the Camel routing Error Handler, which mean any exceptions occurred 
while the consumer is trying to pickup incoming messages, or the likes, will 
now be processed as a me [...]
     "lazyStartProducer": { "kind": "property", "displayName": "Lazy Start 
Producer", "group": "producer", "label": "producer", "required": false, "type": 
"boolean", "javaType": "boolean", "deprecated": false, "autowired": false, 
"secret": false, "defaultValue": false, "description": "Whether the producer 
should be started lazy (on the first message). By starting lazy you can use 
this to allow CamelContext and routes to startup in situations where a producer 
may otherwise fail during star [...]
     "autowiredEnabled": { "kind": "property", "displayName": "Autowired 
Enabled", "group": "advanced", "label": "advanced", "required": false, "type": 
"boolean", "javaType": "boolean", "deprecated": false, "autowired": false, 
"secret": false, "defaultValue": true, "description": "Whether autowiring is 
enabled. This is used for automatic autowiring options (the option must be 
marked as autowired) by looking up in the registry to find if there is a single 
instance of matching type, which t [...]
diff --git 
a/components/camel-spring-redis/src/main/docs/spring-redis-component.adoc 
b/components/camel-spring-redis/src/main/docs/spring-redis-component.adoc
index c24bb95..ce57b66 100644
--- a/components/camel-spring-redis/src/main/docs/spring-redis-component.adoc
+++ b/components/camel-spring-redis/src/main/docs/spring-redis-component.adoc
@@ -44,13 +44,14 @@ You can append query options to the URI in the following 
format,
 
 
 // component options: START
-The Spring Redis component supports 3 options, which are listed below.
+The Spring Redis component supports 4 options, which are listed below.
 
 
 
 [width="100%",cols="2,5,^1,2",options="header"]
 |===
 | Name | Description | Default | Type
+| *redisTemplate* (common) | *Autowired* Reference to a pre-configured 
RedisTemplate instance to use. |  | RedisTemplate
 | *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the 
Camel routing Error Handler, which mean any exceptions occurred while the 
consumer is trying to pickup incoming messages, or the likes, will now be 
processed as a message and handled by the routing Error Handler. By default the 
consumer will use the org.apache.camel.spi.ExceptionHandler to deal with 
exceptions, that will be logged at WARN or ERROR level and ignored. | false | 
boolean
 | *lazyStartProducer* (producer) | Whether the producer should be started lazy 
(on the first message). By starting lazy you can use this to allow CamelContext 
and routes to startup in situations where a producer may otherwise fail during 
starting and cause the route to fail being started. By deferring this startup 
to be lazy then the startup failure can be handled during routing messages via 
Camel's routing error handlers. Beware that when the first message is processed 
then creating and [...]
 | *autowiredEnabled* (advanced) | Whether autowiring is enabled. This is used 
for automatic autowiring options (the option must be marked as autowired) by 
looking up in the registry to find if there is a single instance of matching 
type, which then gets configured on the component. This can be used for 
automatic configuring JDBC data sources, JMS connection factories, AWS Clients, 
etc. | true | boolean
diff --git 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/AbstractRedisProcessorCreator.java
 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/AbstractRedisProcessorCreator.java
deleted file mode 100644
index 418607e..0000000
--- 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/AbstractRedisProcessorCreator.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.component.redis;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.function.Function;
-
-import org.apache.camel.Exchange;
-import org.apache.camel.Message;
-import org.apache.camel.Processor;
-
-public abstract class AbstractRedisProcessorCreator implements 
RedisProcessorsCreator {
-    protected Map<Command, Processor> result = new HashMap<>();
-
-    @Override
-    public Map<Command, Processor> getRedisProcessors() {
-        return result;
-    }
-
-    protected void bind(Command command, Processor processor) {
-        result.put(command, processor);
-    }
-
-    private void setResult(Exchange exchange, Object result) {
-        Message message;
-        if (exchange.getPattern().isOutCapable()) {
-            message = exchange.getOut();
-            message.copyFrom(exchange.getIn());
-        } else {
-            message = exchange.getIn();
-        }
-        message.setBody(result);
-    }
-
-    protected Processor wrap(Function<Exchange, Object> supplier) {
-        return exchange -> {
-            Object result = supplier.apply(exchange);
-            setResult(exchange, result);
-        };
-    }
-}
diff --git 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/AllRedisProcessorsCreator.java
 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/AllRedisProcessorsCreator.java
deleted file mode 100644
index b6aa83b..0000000
--- 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/AllRedisProcessorsCreator.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.component.redis;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import org.apache.camel.Processor;
-
-public class AllRedisProcessorsCreator implements RedisProcessorsCreator {
-
-    private final Map<Command, Processor> processors = new HashMap<>();
-
-    public AllRedisProcessorsCreator(RedisClient redisClient, 
ExchangeConverter exchangeConverter) {
-        this.processors.putAll(new 
ConnectionRedisProcessorsCreator().getProcessors(redisClient, 
exchangeConverter));
-        this.processors.putAll(new 
HashesRedisProcessorsCreator().getProcessors(redisClient, exchangeConverter));
-        this.processors.putAll(new 
KeysRedisProcessorsCreator().getProcessors(redisClient, exchangeConverter));
-        this.processors.putAll(new 
ListsRedisProcessorsCreator().getProcessors(redisClient, exchangeConverter));
-        this.processors.putAll(new 
PubSubRedisProcessorsCreator().getProcessors(redisClient, exchangeConverter));
-        this.processors.putAll(new 
SetsRedisProcessorsCreator().getProcessors(redisClient, exchangeConverter));
-        this.processors.putAll(new 
SortedSetsRedisProcessorsCreator().getProcessors(redisClient, 
exchangeConverter));
-        this.processors.putAll(new 
StringsRedisProcessorsCreator().getProcessors(redisClient, exchangeConverter));
-        this.processors.putAll(new 
TransactionRedisProcessorsCreator().getProcessors(redisClient, 
exchangeConverter));
-        this.processors.putAll(new 
GeoRedisProcessorsCreator().getProcessors(redisClient, exchangeConverter));
-    }
-
-    @Override
-    public Map<Command, Processor> getRedisProcessors() {
-        return processors;
-    }
-
-}
diff --git 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/Command.java
 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/Command.java
index 0b1628a..55e064b 100644
--- 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/Command.java
+++ 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/Command.java
@@ -145,5 +145,5 @@ public enum Command {
     GEOHASH,
     GEOPOS,
     GEORADIUS,
-    GEORADIUSBYMEMBER
+    GEORADIUSBYMEMBER;
 }
diff --git 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/ConnectionRedisProcessorsCreator.java
 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/ConnectionRedisProcessorsCreator.java
deleted file mode 100644
index 8426cc2..0000000
--- 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/ConnectionRedisProcessorsCreator.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.component.redis;
-
-import java.util.Map;
-
-import org.apache.camel.Processor;
-
-public class ConnectionRedisProcessorsCreator extends 
AbstractRedisProcessorCreator {
-
-    Map<Command, Processor> getProcessors(RedisClient redisClient, 
ExchangeConverter exchangeConverter) {
-        bind(Command.ECHO, wrap(exchange -> 
redisClient.echo(exchangeConverter.getStringValue(exchange))));
-        bind(Command.PING, wrap(exchange -> redisClient.ping()));
-        bind(Command.QUIT, exchange -> redisClient.quit());
-
-        return result;
-    }
-
-}
diff --git 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/ExchangeConverter.java
 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/ExchangeConverter.java
index b090faa..19cf314 100644
--- 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/ExchangeConverter.java
+++ 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/ExchangeConverter.java
@@ -21,7 +21,7 @@ import java.util.Map;
 
 import org.apache.camel.Exchange;
 
-class ExchangeConverter {
+public class ExchangeConverter {
     String getKey(Exchange exchange) {
         return getInHeaderValue(exchange, RedisConstants.KEY, String.class);
     }
diff --git 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/GeoRedisProcessorsCreator.java
 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/GeoRedisProcessorsCreator.java
deleted file mode 100755
index 88da806..0000000
--- 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/GeoRedisProcessorsCreator.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.component.redis;
-
-import java.util.Map;
-
-import org.apache.camel.Processor;
-
-public final class GeoRedisProcessorsCreator extends 
AbstractRedisProcessorCreator {
-
-    Map<Command, Processor> getProcessors(RedisClient redisClient, 
ExchangeConverter exchangeConverter) {
-        bind(Command.GEOADD,
-                wrap(exchange -> 
redisClient.geoadd(exchangeConverter.getKey(exchange),
-                        exchangeConverter.getLongitude(exchange),
-                        exchangeConverter.getLatitude(exchange), 
exchangeConverter.getValue(exchange))));
-        bind(Command.GEODIST,
-                wrap(exchange -> 
redisClient.geodist(exchangeConverter.getKey(exchange),
-                        
exchangeConverter.getValuesAsCollection(exchange).toArray()[0],
-                        
exchangeConverter.getValuesAsCollection(exchange).toArray()[1])));
-        bind(Command.GEOHASH, wrap(
-                exchange -> 
redisClient.geohash(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange))));
-        bind(Command.GEOPOS,
-                wrap(exchange -> 
redisClient.geopos(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange))));
-        bind(Command.GEORADIUS,
-                wrap(exchange -> 
redisClient.georadius(exchangeConverter.getKey(exchange),
-                        exchangeConverter.getLongitude(exchange), 
exchangeConverter.getLatitude(exchange),
-                        exchangeConverter.getRadius(exchange), 
exchangeConverter.getCount(exchange))));
-        bind(Command.GEORADIUSBYMEMBER,
-                wrap(exchange -> 
redisClient.georadius(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange),
-                        exchangeConverter.getRadius(exchange), 
exchangeConverter.getCount(exchange))));
-        return result;
-    }
-}
diff --git 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/HashesRedisProcessorsCreator.java
 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/HashesRedisProcessorsCreator.java
deleted file mode 100644
index e98b243..0000000
--- 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/HashesRedisProcessorsCreator.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.component.redis;
-
-import java.util.Map;
-
-import org.apache.camel.Processor;
-
-public final class HashesRedisProcessorsCreator extends 
AbstractRedisProcessorCreator {
-
-    Map<Command, Processor> getProcessors(RedisClient redisClient, 
ExchangeConverter exchangeConverter) {
-        bind(Command.HDEL, exchange -> 
redisClient.hdel(exchangeConverter.getKey(exchange),
-                exchangeConverter.getField(exchange)));
-        bind(Command.HEXISTS, wrap(exchange -> 
redisClient.hexists(exchangeConverter.getKey(exchange),
-                exchangeConverter.getField(exchange))));
-        bind(Command.HGET, wrap(exchange -> 
redisClient.hget(exchangeConverter.getKey(exchange),
-                exchangeConverter.getField(exchange))));
-        bind(Command.HGETALL, wrap(exchange -> 
redisClient.hgetAll(exchangeConverter.getKey(exchange))));
-        bind(Command.HINCRBY, wrap(exchange -> 
redisClient.hincrBy(exchangeConverter.getKey(exchange),
-                exchangeConverter.getField(exchange),
-                exchangeConverter.getValueAsLong(exchange))));
-        bind(Command.HKEYS, wrap(exchange -> 
redisClient.hkeys(exchangeConverter.getKey(exchange))));
-        bind(Command.HLEN, wrap(exchange -> 
redisClient.hlen(exchangeConverter.getKey(exchange))));
-        bind(Command.HMGET, wrap(exchange -> 
redisClient.hmget(exchangeConverter.getKey(exchange),
-                exchangeConverter.getFields(exchange))));
-        bind(Command.HMSET, exchange -> 
redisClient.hmset(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValuesAsMap(exchange)));
-        bind(Command.HSET, exchange -> 
redisClient.hset(exchangeConverter.getKey(exchange),
-                exchangeConverter.getField(exchange),
-                exchangeConverter.getValue(exchange)));
-        bind(Command.HSETNX, wrap(exchange -> 
redisClient.hsetnx(exchangeConverter.getKey(exchange),
-                exchangeConverter.getField(exchange),
-                exchangeConverter.getValue(exchange))));
-        bind(Command.HVALS, wrap(exchange -> 
redisClient.hvals(exchangeConverter.getKey(exchange))));
-        //missing: hincrbyfloat, hstrlen, hscan
-
-        return result;
-    }
-
-}
diff --git 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/KeysRedisProcessorsCreator.java
 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/KeysRedisProcessorsCreator.java
deleted file mode 100644
index 2714daa..0000000
--- 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/KeysRedisProcessorsCreator.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.component.redis;
-
-import java.util.Map;
-
-import org.apache.camel.Processor;
-
-public final class KeysRedisProcessorsCreator extends 
AbstractRedisProcessorCreator {
-
-    Map<Command, Processor> getProcessors(RedisClient redisClient, 
ExchangeConverter exchangeConverter) {
-        bind(Command.DEL, exchange -> 
redisClient.del(exchangeConverter.getKeys(exchange)));
-        bind(Command.EXISTS, wrap(exchange -> 
redisClient.exists(exchangeConverter.getKey(exchange))));
-        bind(Command.EXPIRE, wrap(exchange -> 
redisClient.expire(exchangeConverter.getKey(exchange),
-                exchangeConverter.getTimeout(exchange))));
-        bind(Command.EXPIREAT, wrap(exchange -> 
redisClient.expireat(exchangeConverter.getKey(exchange),
-                exchangeConverter.getTimestamp(exchange))));
-        bind(Command.KEYS, wrap(exchange -> 
redisClient.keys(exchangeConverter.getPattern(exchange))));
-        bind(Command.MOVE, wrap(exchange -> 
redisClient.move(exchangeConverter.getKey(exchange),
-                exchangeConverter.getDb(exchange))));
-        bind(Command.PERSIST, wrap(exchange -> 
redisClient.persist(exchangeConverter.getKey(exchange))));
-        bind(Command.PEXPIRE, wrap(exchange -> 
redisClient.pexpire(exchangeConverter.getKey(exchange),
-                exchangeConverter.getTimeout(exchange))));
-        bind(Command.PEXPIREAT, wrap(exchange -> 
redisClient.pexpireat(exchangeConverter.getKey(exchange),
-                exchangeConverter.getTimestamp(exchange))));
-        bind(Command.RANDOMKEY, wrap(exchange -> redisClient.randomkey()));
-        bind(Command.RENAME, exchange -> 
redisClient.rename(exchangeConverter.getKey(exchange),
-                exchangeConverter.getStringValue(exchange)));
-        bind(Command.RENAMENX, wrap(exchange -> 
redisClient.renamenx(exchangeConverter.getKey(exchange),
-                exchangeConverter.getStringValue(exchange))));
-        bind(Command.SORT, wrap(exchange -> 
redisClient.sort(exchangeConverter.getKey(exchange))));
-        bind(Command.TTL, wrap(exchange -> 
redisClient.ttl(exchangeConverter.getKey(exchange))));
-        bind(Command.TYPE, wrap(exchange -> 
redisClient.type(exchangeConverter.getKey(exchange))));
-        //missing: dump, migrate, object, pttl, restore, wait, scan
-
-        return result;
-    }
-
-}
diff --git 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/ListsRedisProcessorsCreator.java
 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/ListsRedisProcessorsCreator.java
deleted file mode 100644
index be8d625..0000000
--- 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/ListsRedisProcessorsCreator.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.component.redis;
-
-import java.util.Map;
-
-import org.apache.camel.Processor;
-
-public final class ListsRedisProcessorsCreator extends 
AbstractRedisProcessorCreator {
-
-    Map<Command, Processor> getProcessors(RedisClient redisClient, 
ExchangeConverter exchangeConverter) {
-        bind(Command.BLPOP, wrap(exchange -> 
redisClient.blpop(exchangeConverter.getKey(exchange),
-                exchangeConverter.getTimeout(exchange))));
-        bind(Command.BRPOP, wrap(exchange -> 
redisClient.brpop(exchangeConverter.getKey(exchange),
-                exchangeConverter.getTimeout(exchange))));
-        bind(Command.BRPOPLPUSH, wrap(exchange -> 
redisClient.brpoplpush(exchangeConverter.getKey(exchange),
-                exchangeConverter.getDestination(exchange),
-                exchangeConverter.getTimeout(exchange))));
-        bind(Command.LINDEX, wrap(exchange -> 
redisClient.lindex(exchangeConverter.getKey(exchange),
-                exchangeConverter.getIndex(exchange))));
-        bind(Command.LINSERT, wrap(exchange -> 
redisClient.linsert(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange),
-                exchangeConverter.getPivot(exchange),
-                exchangeConverter.getPosition(exchange))));
-        bind(Command.LLEN, wrap(exchange -> 
redisClient.llen(exchangeConverter.getKey(exchange))));
-        bind(Command.LPOP, wrap(exchange -> 
redisClient.lpop(exchangeConverter.getKey(exchange))));
-        bind(Command.LPUSH, wrap(exchange -> 
redisClient.lpush(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange))));
-        //nieuwe actie
-        bind(Command.LPUSHX, wrap(exchange -> 
redisClient.lpushx(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange))));
-        bind(Command.LRANGE, wrap(exchange -> 
redisClient.lrange(exchangeConverter.getKey(exchange),
-                exchangeConverter.getStart(exchange),
-                exchangeConverter.getEnd(exchange))));
-        bind(Command.LREM, wrap(exchange -> 
redisClient.lrem(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange),
-                exchangeConverter.getCount(exchange))));
-        bind(Command.LSET, exchange -> 
redisClient.lset(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange),
-                exchangeConverter.getIndex(exchange)));
-        bind(Command.LTRIM, exchange -> 
redisClient.ltrim(exchangeConverter.getKey(exchange),
-                exchangeConverter.getStart(exchange),
-                exchangeConverter.getEnd(exchange)));
-        bind(Command.RPOP, wrap(exchange -> 
redisClient.rpop(exchangeConverter.getKey(exchange))));
-        bind(Command.RPOPLPUSH, wrap(exchange -> 
redisClient.rpoplpush(exchangeConverter.getKey(exchange),
-                exchangeConverter.getDestination(exchange))));
-        bind(Command.RPUSH, wrap(exchange -> 
redisClient.rpush(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange))));
-        bind(Command.RPUSHX, wrap(exchange -> 
redisClient.rpushx(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange))));
-
-        return result;
-    }
-
-}
diff --git 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/PubSubRedisProcessorsCreator.java
 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/PubSubRedisProcessorsCreator.java
deleted file mode 100644
index 33908ba..0000000
--- 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/PubSubRedisProcessorsCreator.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.component.redis;
-
-import java.util.Map;
-
-import org.apache.camel.Processor;
-
-public final class PubSubRedisProcessorsCreator extends 
AbstractRedisProcessorCreator {
-
-    Map<Command, Processor> getProcessors(RedisClient redisClient, 
ExchangeConverter exchangeConverter) {
-        bind(Command.PUBLISH, exchange -> 
redisClient.publish(exchangeConverter.getChannel(exchange),
-                exchangeConverter.getMessage(exchange)));
-        //missing psubscribe, pubsub, punsubscribe, subscribe, unsubscribe
-        //psubscribe, subscribe are used in consumer
-
-        return result;
-    }
-
-}
diff --git 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/RedisComponent.java
 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/RedisComponent.java
index 5379e34..edb8ce7 100644
--- 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/RedisComponent.java
+++ 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/RedisComponent.java
@@ -19,8 +19,10 @@ package org.apache.camel.component.redis;
 import java.util.Map;
 
 import org.apache.camel.Endpoint;
+import org.apache.camel.spi.Metadata;
 import org.apache.camel.spi.annotations.Component;
 import org.apache.camel.support.DefaultComponent;
+import org.springframework.data.redis.core.RedisTemplate;
 
 /**
  * Represents the component that manages {@link RedisEndpoint}.
@@ -28,7 +30,8 @@ import org.apache.camel.support.DefaultComponent;
 @Component("spring-redis")
 public class RedisComponent extends DefaultComponent {
 
-    private final ExchangeConverter exchangeConverter = new 
ExchangeConverter();
+    @Metadata(autowired = true)
+    private RedisTemplate redisTemplate;
 
     public RedisComponent() {
     }
@@ -36,7 +39,9 @@ public class RedisComponent extends DefaultComponent {
     @Override
     protected Endpoint createEndpoint(String uri, String remaining, 
Map<String, Object> parameters) throws Exception {
         RedisConfiguration configuration = new RedisConfiguration();
+        configuration.setRedisTemplate(redisTemplate);
         setHostAndPort(configuration, remaining);
+
         RedisEndpoint endpoint = new RedisEndpoint(uri, this, configuration);
         setProperties(endpoint, parameters);
         return endpoint;
@@ -52,7 +57,14 @@ public class RedisComponent extends DefaultComponent {
         }
     }
 
-    public ExchangeConverter getExchangeConverter() {
-        return exchangeConverter;
+    public RedisTemplate getRedisTemplate() {
+        return redisTemplate;
+    }
+
+    /**
+     * Reference to a pre-configured RedisTemplate instance to use.
+     */
+    public void setRedisTemplate(RedisTemplate redisTemplate) {
+        this.redisTemplate = redisTemplate;
     }
 }
diff --git 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/RedisEndpoint.java
 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/RedisEndpoint.java
index 0672560..99820e8 100644
--- 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/RedisEndpoint.java
+++ 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/RedisEndpoint.java
@@ -33,7 +33,6 @@ public class RedisEndpoint extends DefaultEndpoint {
 
     @UriParam
     private RedisConfiguration configuration;
-    private RedisProcessorsCreator redisProcessorsCreator;
 
     public RedisEndpoint(String uri, RedisComponent component, 
RedisConfiguration configuration) {
         super(uri, component);
@@ -46,11 +45,9 @@ public class RedisEndpoint extends DefaultEndpoint {
         if (defaultCommand == null) {
             defaultCommand = Command.SET;
         }
+
         return new RedisProducer(
-                this,
-                RedisConstants.COMMAND,
-                defaultCommand.name(),
-                redisProcessorsCreator);
+                this, RedisConstants.COMMAND, defaultCommand.name(), new 
RedisClient(configuration.getRedisTemplate()));
     }
 
     @Override
@@ -61,14 +58,6 @@ public class RedisEndpoint extends DefaultEndpoint {
     }
 
     @Override
-    protected void doInit() throws Exception {
-        super.doInit();
-        redisProcessorsCreator = new AllRedisProcessorsCreator(
-                new RedisClient(configuration.getRedisTemplate()),
-                ((RedisComponent) getComponent()).getExchangeConverter());
-    }
-
-    @Override
     protected void doShutdown() throws Exception {
         super.doShutdown();
         configuration.stop();
diff --git 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/RedisProducer.java
 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/RedisProducer.java
index 3631e4d..285b171 100644
--- 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/RedisProducer.java
+++ 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/RedisProducer.java
@@ -16,23 +16,603 @@
  */
 package org.apache.camel.component.redis;
 
+import java.util.Collection;
+import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
 
 import org.apache.camel.Endpoint;
-import org.apache.camel.Processor;
+import org.apache.camel.Exchange;
+import org.apache.camel.spi.InvokeOnHeader;
 import org.apache.camel.support.HeaderSelectorProducer;
+import org.springframework.data.geo.Distance;
+import org.springframework.data.geo.GeoResults;
+import org.springframework.data.geo.Point;
+import org.springframework.data.redis.connection.RedisGeoCommands;
 
-final class RedisProducer extends HeaderSelectorProducer {
+public class RedisProducer extends HeaderSelectorProducer {
 
-    RedisProducer(Endpoint endpoint,
-                  String header,
-                  String defaultHeaderValue,
-                  RedisProcessorsCreator redisProcessorsCreator) {
+    private final ExchangeConverter exchangeConverter = new 
ExchangeConverter();
+    private final RedisClient client;
+
+    public RedisProducer(Endpoint endpoint,
+                         String header,
+                         String defaultHeaderValue,
+                         RedisClient redisClient) {
         super(endpoint, header, defaultHeaderValue);
+        this.client = redisClient;
+    }
+
+    @InvokeOnHeader("ECHO")
+    public String invokeEcho(Exchange exchange) {
+        return client.echo(exchangeConverter.getStringValue(exchange));
+    }
+
+    @InvokeOnHeader("PING")
+    public String invokePing(Exchange exchange) {
+        return client.ping();
+    }
+
+    @InvokeOnHeader("QUIT")
+    public void invokeQuit(Exchange exchange) {
+        client.quit();
+    }
+
+    @InvokeOnHeader("HDEL")
+    public void invokeHdel(Exchange exchange) {
+        client.hdel(exchangeConverter.getKey(exchange), 
exchangeConverter.getField(exchange));
+    }
+
+    @InvokeOnHeader("HEXISTS")
+    public Boolean invokeHexists(Exchange exchange) {
+        return client.hexists(exchangeConverter.getKey(exchange), 
exchangeConverter.getField(exchange));
+    }
+
+    @InvokeOnHeader("HGET")
+    public Object invokeHget(Exchange exchange) {
+        return client.hget(exchangeConverter.getKey(exchange), 
exchangeConverter.getField(exchange));
+    }
+
+    @InvokeOnHeader("HGETALL")
+    public Map<String, Object> invokeHgetAll(Exchange exchange) {
+        return client.hgetAll(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("HINCRBY")
+    public Long invokeHincrBy(Exchange exchange) {
+        return client.hincrBy(exchangeConverter.getKey(exchange), 
exchangeConverter.getField(exchange),
+                exchangeConverter.getValueAsLong(exchange));
+    }
+
+    @InvokeOnHeader("HKEYS")
+    public Set<String> invokeHkeys(Exchange exchange) {
+        return client.hkeys(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("HLEN")
+    public Long invokeHlen(Exchange exchange) {
+        return client.hlen(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("HMGET")
+    public Collection<Object> invokeHmget(Exchange exchange) {
+        return client.hmget(exchangeConverter.getKey(exchange), 
exchangeConverter.getFields(exchange));
+    }
+
+    @InvokeOnHeader("HMSET")
+    public void invokeHmset(Exchange exchange) {
+        client.hmset(exchangeConverter.getKey(exchange), 
exchangeConverter.getValuesAsMap(exchange));
+    }
+
+    @InvokeOnHeader("HSET")
+    public void invokeHset(Exchange exchange) {
+        client.hset(exchangeConverter.getKey(exchange), 
exchangeConverter.getField(exchange),
+                exchangeConverter.getValue(exchange));
+    }
+
+    @InvokeOnHeader("HSETNX")
+    public Boolean invokeHsetnx(Exchange exchange) {
+        return client.hsetnx(exchangeConverter.getKey(exchange), 
exchangeConverter.getField(exchange),
+                exchangeConverter.getValue(exchange));
+    }
+
+    @InvokeOnHeader("HVALS")
+    public Collection<Object> invokeHvals(Exchange exchange) {
+        return client.hvals(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("DEL")
+    public void invokeDel(Exchange exchange) {
+        client.del(exchangeConverter.getKeys(exchange));
+    }
+
+    @InvokeOnHeader("EXISTS")
+    public Boolean invokeExists(Exchange exchange) {
+        return client.exists(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("EXPIRE")
+    public Boolean invokeExpire(Exchange exchange) {
+        return client.expire(exchangeConverter.getKey(exchange), 
exchangeConverter.getTimeout(exchange));
+    }
+
+    @InvokeOnHeader("EXPIREAT")
+    public Boolean invokeExpireat(Exchange exchange) {
+        return client.expireat(exchangeConverter.getKey(exchange), 
exchangeConverter.getTimestamp(exchange));
+    }
+
+    @InvokeOnHeader("KEYS")
+    public Collection<String> invokeKeys(Exchange exchange) {
+        return client.keys(exchangeConverter.getPattern(exchange));
+    }
+
+    @InvokeOnHeader("MOVE")
+    public Boolean invokeMove(Exchange exchange) {
+        return client.move(exchangeConverter.getKey(exchange), 
exchangeConverter.getDb(exchange));
+    }
+
+    @InvokeOnHeader("PERSIST")
+    public Boolean invokePersist(Exchange exchange) {
+        return client.persist(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("PEXPIRE")
+    public Boolean invokePexpire(Exchange exchange) {
+        return client.pexpire(exchangeConverter.getKey(exchange), 
exchangeConverter.getTimeout(exchange));
+    }
+
+    @InvokeOnHeader("PEXPIREAT")
+    public Boolean invokePexpireat(Exchange exchange) {
+        return client.pexpireat(exchangeConverter.getKey(exchange), 
exchangeConverter.getTimestamp(exchange));
+    }
+
+    @InvokeOnHeader("RANDOMKEY")
+    public String invokeRandomkey(Exchange exchange) {
+        return client.randomkey();
+    }
+
+    @InvokeOnHeader("RENAME")
+    public void invokeRename(Exchange exchange) {
+        client.rename(exchangeConverter.getKey(exchange), 
exchangeConverter.getStringValue(exchange));
+    }
+
+    @InvokeOnHeader("RENAMENX")
+    public Boolean invokeRenamenx(Exchange exchange) {
+        return client.renamenx(exchangeConverter.getKey(exchange), 
exchangeConverter.getStringValue(exchange));
+    }
+
+    @InvokeOnHeader("SORT")
+    public List<Object> invokeSort(Exchange exchange) {
+        return client.sort(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("TTL")
+    public Long invokeTtl(Exchange exchange) {
+        return client.ttl(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("TYPE")
+    public String invokeType(Exchange exchange) {
+        return client.type(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("BLPOP")
+    public Object invokeBlpop(Exchange exchange) {
+        return client.blpop(exchangeConverter.getKey(exchange), 
exchangeConverter.getTimeout(exchange));
+    }
+
+    @InvokeOnHeader("BRPOP")
+    public Object invokeBrpop(Exchange exchange) {
+        return client.brpop(exchangeConverter.getKey(exchange), 
exchangeConverter.getTimeout(exchange));
+    }
+
+    @InvokeOnHeader("BRPOPLPUSH")
+    public Object invokeBrpoplpush(Exchange exchange) {
+        return client.brpoplpush(exchangeConverter.getKey(exchange), 
exchangeConverter.getDestination(exchange),
+                exchangeConverter.getTimeout(exchange));
+    }
+
+    @InvokeOnHeader("LINDEX")
+    public Object invokeLindex(Exchange exchange) {
+        return client.lindex(exchangeConverter.getKey(exchange), 
exchangeConverter.getIndex(exchange));
+    }
+
+    @InvokeOnHeader("LINSERT")
+    public Object invokeLinsert(Exchange exchange) {
+        return client.linsert(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange),
+                exchangeConverter.getPivot(exchange),
+                exchangeConverter.getPosition(exchange));
+    }
+
+    @InvokeOnHeader("LLEN")
+    public Long invokeLlen(Exchange exchange) {
+        return client.llen(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("LPOP")
+    public Object invokeLpop(Exchange exchange) {
+        return client.lpop(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("LPUSH")
+    public Long invokeLpush(Exchange exchange) {
+        return client.lpush(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange));
+    }
+
+    @InvokeOnHeader("LPUSHX")
+    public Long invokeLpushx(Exchange exchange) {
+        return client.lpushx(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange));
+    }
+
+    @InvokeOnHeader("LRANGE")
+    public List<Object> invokeLrange(Exchange exchange) {
+        return client.lrange(exchangeConverter.getKey(exchange), 
exchangeConverter.getStart(exchange),
+                exchangeConverter.getEnd(exchange));
+    }
+
+    @InvokeOnHeader("LREM")
+    public Long invokeLrem(Exchange exchange) {
+        return client.lrem(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange),
+                exchangeConverter.getCount(exchange));
+    }
+
+    @InvokeOnHeader("LSET")
+    public void invokeLset(Exchange exchange) {
+        client.lset(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange),
+                exchangeConverter.getIndex(exchange));
+    }
+
+    @InvokeOnHeader("LTRIM")
+    public void invokeLtrim(Exchange exchange) {
+        client.ltrim(exchangeConverter.getKey(exchange), 
exchangeConverter.getStart(exchange),
+                exchangeConverter.getEnd(exchange));
+    }
+
+    @InvokeOnHeader("RPOP")
+    public Object invokeRpop(Exchange exchange) {
+        return client.rpop(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("RPOPLPUSH")
+    public Object invokeRpoplpush(Exchange exchange) {
+        return client.rpoplpush(exchangeConverter.getKey(exchange), 
exchangeConverter.getDestination(exchange));
+    }
+
+    @InvokeOnHeader("RPUSH")
+    public Long invokeRpush(Exchange exchange) {
+        return client.rpush(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange));
+    }
+
+    @InvokeOnHeader("RPUSHX")
+    public Long invokeRpushx(Exchange exchange) {
+        return client.rpushx(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange));
+    }
+
+    @InvokeOnHeader("PUBLISH")
+    public void invokePublish(Exchange exchange) {
+        client.publish(exchangeConverter.getChannel(exchange), 
exchangeConverter.getMessage(exchange));
+    }
+
+    @InvokeOnHeader("SADD")
+    public Long invokeSadd(Exchange exchange) {
+        return client.sadd(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange));
+    }
+
+    @InvokeOnHeader("SCARD")
+    public Long invokeScard(Exchange exchange) {
+        return client.scard(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("SDIFF")
+    public Set<Object> invokeSdiff(Exchange exchange) {
+        return client.sdiff(exchangeConverter.getKey(exchange), 
exchangeConverter.getKeys(exchange));
+    }
+
+    @InvokeOnHeader("SDIFFSTORE")
+    public void invokeSdiffstore(Exchange exchange) {
+        client.sdiffstore(exchangeConverter.getKey(exchange), 
exchangeConverter.getKeys(exchange),
+                exchangeConverter.getDestination(exchange));
+    }
+
+    @InvokeOnHeader("SINTER")
+    public Set<Object> invokeSinter(Exchange exchange) {
+        return client.sinter(exchangeConverter.getKey(exchange), 
exchangeConverter.getKeys(exchange));
+    }
+
+    @InvokeOnHeader("SINTERSTORE")
+    public void invokeSinterstore(Exchange exchange) {
+        client.sinterstore(exchangeConverter.getKey(exchange), 
exchangeConverter.getKeys(exchange),
+                exchangeConverter.getDestination(exchange));
+    }
+
+    @InvokeOnHeader("SISMEMBER")
+    public Boolean invokeSismember(Exchange exchange) {
+        return client.sismember(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange));
+    }
+
+    @InvokeOnHeader("SMEMBERS")
+    public Set<Object> invokeSmembers(Exchange exchange) {
+        return client.smembers(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("SMOVE")
+    public Boolean invokeSmove(Exchange exchange) {
+        return client.smove(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange),
+                exchangeConverter.getDestination(exchange));
+    }
+
+    @InvokeOnHeader("SPOP")
+    public Object invokeSpop(Exchange exchange) {
+        return client.spop(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("SRANDMEMBER")
+    public Object invokeSrandmember(Exchange exchange) {
+        return client.srandmember(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("SREM")
+    public Long invokeSrem(Exchange exchange) {
+        return client.srem(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange));
+    }
+
+    @InvokeOnHeader("SUNION")
+    public Set<Object> invokeSunion(Exchange exchange) {
+        return client.sunion(exchangeConverter.getKey(exchange), 
exchangeConverter.getKeys(exchange));
+    }
+
+    @InvokeOnHeader("SUNIONSTORE")
+    public void invokeSunionstore(Exchange exchange) {
+        client.sunionstore(exchangeConverter.getKey(exchange), 
exchangeConverter.getKeys(exchange),
+                exchangeConverter.getDestination(exchange));
+    }
+
+    @InvokeOnHeader("ZADD")
+    public Boolean invokeZadd(Exchange exchange) {
+        return client.zadd(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange),
+                exchangeConverter.getScore(exchange));
+    }
+
+    @InvokeOnHeader("ZCARD")
+    public Long invokeZcard(Exchange exchange) {
+        return client.zcard(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("ZCOUNT")
+    public Long invokeZcount(Exchange exchange) {
+        return client.zcount(exchangeConverter.getKey(exchange), 
exchangeConverter.getMin(exchange),
+                exchangeConverter.getMax(exchange));
+    }
+
+    @InvokeOnHeader("ZINCRBY")
+    public Double invokeZincrby(Exchange exchange) {
+        return client.zincrby(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange),
+                exchangeConverter.getIncrement(exchange));
+    }
+
+    @InvokeOnHeader("ZINTERSTORE")
+    public void invokeZinterstore(Exchange exchange) {
+        client.zinterstore(exchangeConverter.getKey(exchange), 
exchangeConverter.getKeys(exchange),
+                exchangeConverter.getDestination(exchange));
+    }
+
+    @InvokeOnHeader("ZRANGE")
+    public Object invokeZrange(Exchange exchange) {
+        return client.zrange(exchangeConverter.getKey(exchange), 
exchangeConverter.getStart(exchange),
+                exchangeConverter.getEnd(exchange),
+                exchangeConverter.getWithScore(exchange));
+    }
+
+    @InvokeOnHeader("ZRANGEBYSCORE")
+    public Set<Object> invokeZrangebyscore(Exchange exchange) {
+        return client.zrangebyscore(exchangeConverter.getKey(exchange),
+                exchangeConverter.getMin(exchange),
+                exchangeConverter.getMax(exchange));
+    }
+
+    @InvokeOnHeader("ZRANK")
+    public Long invokeZrank(Exchange exchange) {
+        return client.zrank(exchangeConverter.getKey(exchange),
+                exchangeConverter.getValue(exchange));
+    }
+
+    @InvokeOnHeader("ZREM")
+    public Long invokeZrem(Exchange exchange) {
+        return client.zrem(exchangeConverter.getKey(exchange),
+                exchangeConverter.getValue(exchange));
+    }
+
+    @InvokeOnHeader("ZREMRANGEBYRANK")
+    public void invokeZremrangebyrank(Exchange exchange) {
+        client.zremrangebyrank(exchangeConverter.getKey(exchange),
+                exchangeConverter.getStart(exchange), 
exchangeConverter.getEnd(exchange));
+    }
+
+    @InvokeOnHeader("ZREMRANGEBYSCORE")
+    public void invokeZremrangebyscore(Exchange exchange) {
+        client.zremrangebyscore(exchangeConverter.getKey(exchange),
+                exchangeConverter.getStart(exchange), 
exchangeConverter.getEnd(exchange));
+    }
+
+    @InvokeOnHeader("ZREVRANGE")
+    public Object invokeZrevrange(Exchange exchange) {
+        return client.zrevrange(exchangeConverter.getKey(exchange),
+                exchangeConverter.getStart(exchange), 
exchangeConverter.getEnd(exchange),
+                exchangeConverter.getWithScore(exchange));
+    }
+
+    @InvokeOnHeader("ZREVRANGEBYSCORE")
+    public Set<Object> invokeZrevrangebyscore(Exchange exchange) {
+        return client.zrevrangebyscore(exchangeConverter.getKey(exchange),
+                exchangeConverter.getMin(exchange), 
exchangeConverter.getMax(exchange));
+    }
+
+    @InvokeOnHeader("ZREVRANK")
+    public Long invokeZrevrank(Exchange exchange) {
+        return client.zrevrank(exchangeConverter.getKey(exchange),
+                exchangeConverter.getValue(exchange));
+    }
+
+    @InvokeOnHeader("ZUNIONSTORE")
+    public void invokeZunionstore(Exchange exchange) {
+        client.zunionstore(exchangeConverter.getKey(exchange),
+                exchangeConverter.getKeys(exchange), 
exchangeConverter.getDestination(exchange));
+    }
+
+    @InvokeOnHeader("APPEND")
+    public Integer invokeAppend(Exchange exchange) {
+        return client.append(exchangeConverter.getKey(exchange), 
exchangeConverter.getStringValue(exchange));
+    }
+
+    @InvokeOnHeader("DECR")
+    public Long invokeDecr(Exchange exchange) {
+        return client.decr(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("DECRBY")
+    public Long invokeDecrby(Exchange exchange) {
+        return client.decrby(exchangeConverter.getKey(exchange), 
exchangeConverter.getLongValue(exchange));
+    }
+
+    @InvokeOnHeader("GET")
+    public Object invokeGet(Exchange exchange) {
+        return client.get(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("GETBIT")
+    public Boolean invokeGetbit(Exchange exchange) {
+        return client.getbit(exchangeConverter.getKey(exchange), 
exchangeConverter.getOffset(exchange));
+    }
+
+    @InvokeOnHeader("GETRANGE")
+    public String invokeGetrange(Exchange exchange) {
+        return client.getrange(exchangeConverter.getKey(exchange), 
exchangeConverter.getStart(exchange),
+                exchangeConverter.getEnd(exchange));
+    }
+
+    @InvokeOnHeader("SETRANGE")
+    public void invokeSetrange(Exchange exchange) {
+        client.setex(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange),
+                exchangeConverter.getOffset(exchange));
+    }
+
+    @InvokeOnHeader("GETSET")
+    public Object invokeGetset(Exchange exchange) {
+        return client.getset(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange));
+    }
+
+    @InvokeOnHeader("INCR")
+    public Long invokeIncr(Exchange exchange) {
+        return client.incr(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("INCRBY")
+    public Long invokeIncrby(Exchange exchange) {
+        return client.incrby(exchangeConverter.getKey(exchange), 
exchangeConverter.getLongValue(exchange));
+    }
+
+    @InvokeOnHeader("MGET")
+    public List<Object> invokeMget(Exchange exchange) {
+        return client.mget(exchangeConverter.getFields(exchange));
+    }
+
+    @InvokeOnHeader("MSET")
+    public void invokeMset(Exchange exchange) {
+        client.mset(exchangeConverter.getValuesAsMap(exchange));
+    }
+
+    @InvokeOnHeader("MSETNX")
+    public void invokeMsetnx(Exchange exchange) {
+        client.msetnx(exchangeConverter.getValuesAsMap(exchange));
+    }
+
+    @InvokeOnHeader("SET")
+    public void invokeSet(Exchange exchange) {
+        client.set(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange));
+    }
+
+    @InvokeOnHeader("SETBIT")
+    public void invokeSetbit(Exchange exchange) {
+        client.setbit(exchangeConverter.getKey(exchange), 
exchangeConverter.getOffset(exchange),
+                exchangeConverter.getBooleanValue(exchange));
+    }
+
+    @InvokeOnHeader("SETEX")
+    public void invokeSetex(Exchange exchange) {
+        client.setex(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange),
+                exchangeConverter.getTimeout(exchange), TimeUnit.SECONDS);
+    }
+
+    @InvokeOnHeader("SETNX")
+    public Boolean invokeSetnx(Exchange exchange) {
+        return client.setnx(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange));
+    }
+
+    @InvokeOnHeader("STRLEN")
+    public Long invokeStrlen(Exchange exchange) {
+        return client.strlen(exchangeConverter.getKey(exchange));
+    }
+
+    @InvokeOnHeader("DISCARD")
+    public void invokeDiscard(Exchange exchange) {
+        client.discard();
+    }
+
+    @InvokeOnHeader("EXEC")
+    public void invokeExec(Exchange exchange) {
+        client.exec();
+    }
+
+    @InvokeOnHeader("MULTI")
+    public void invokeMulti(Exchange exchange) {
+        client.multi();
+    }
+
+    @InvokeOnHeader("WATCH")
+    public void invokeWatch(Exchange exchange) {
+        client.watch(exchangeConverter.getKeys(exchange));
+    }
+
+    @InvokeOnHeader("UNWATCH")
+    public void invokeUnwatch(Exchange exchange) {
+        client.unwatch();
+    }
+
+    @InvokeOnHeader("GEOADD")
+    public Long invokeGeoadd(Exchange exchange) {
+        return client.geoadd(exchangeConverter.getKey(exchange), 
exchangeConverter.getLongitude(exchange),
+                exchangeConverter.getLatitude(exchange), 
exchangeConverter.getValue(exchange));
+    }
+
+    @InvokeOnHeader("GEODIST")
+    public Distance invokeGeodist(Exchange exchange) {
+        return client.geodist(exchangeConverter.getKey(exchange),
+                exchangeConverter.getValuesAsCollection(exchange).toArray()[0],
+                
exchangeConverter.getValuesAsCollection(exchange).toArray()[1]);
+    }
+
+    @InvokeOnHeader("GEOHASH")
+    public List<String> invokeGeohash(Exchange exchange) {
+        return client.geohash(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange));
+    }
+
+    @InvokeOnHeader("GEOPOS")
+    public List<Point> invokeGeopos(Exchange exchange) {
+        return client.geopos(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange));
+    }
+
+    @InvokeOnHeader("GEORADIUS")
+    public GeoResults<RedisGeoCommands.GeoLocation<Object>> 
invokeGeoradius(Exchange exchange) {
+        return client.georadius(exchangeConverter.getKey(exchange), 
exchangeConverter.getLongitude(exchange),
+                exchangeConverter.getLatitude(exchange),
+                exchangeConverter.getRadius(exchange), 
exchangeConverter.getCount(exchange));
+    }
 
-        for (Map.Entry<Command, Processor> entry : 
redisProcessorsCreator.getRedisProcessors().entrySet()) {
-            bind(entry.getKey().name(), entry.getValue());
-        }
+    @InvokeOnHeader("GEORADIUSBYMEMBER")
+    public GeoResults<RedisGeoCommands.GeoLocation<Object>> 
invokeGeoradiusbymember(Exchange exchange) {
+        return client.georadius(exchangeConverter.getKey(exchange), 
exchangeConverter.getValue(exchange),
+                exchangeConverter.getRadius(exchange), 
exchangeConverter.getCount(exchange));
     }
 
 }
diff --git 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/SetsRedisProcessorsCreator.java
 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/SetsRedisProcessorsCreator.java
deleted file mode 100644
index af68c5a..0000000
--- 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/SetsRedisProcessorsCreator.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.component.redis;
-
-import java.util.Map;
-
-import org.apache.camel.Processor;
-
-public final class SetsRedisProcessorsCreator extends 
AbstractRedisProcessorCreator {
-
-    Map<Command, Processor> getProcessors(RedisClient redisClient, 
ExchangeConverter exchangeConverter) {
-        bind(Command.SADD, wrap(exchange -> 
redisClient.sadd(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange))));
-        bind(Command.SCARD, wrap(exchange -> 
redisClient.scard(exchangeConverter.getKey(exchange))));
-        bind(Command.SDIFF, wrap(exchange -> 
redisClient.sdiff(exchangeConverter.getKey(exchange),
-                exchangeConverter.getKeys(exchange))));
-        bind(Command.SDIFFSTORE, exchange -> 
redisClient.sdiffstore(exchangeConverter.getKey(exchange),
-                exchangeConverter.getKeys(exchange),
-                exchangeConverter.getDestination(exchange)));
-        bind(Command.SINTER, wrap(exchange -> 
redisClient.sinter(exchangeConverter.getKey(exchange),
-                exchangeConverter.getKeys(exchange))));
-        bind(Command.SINTERSTORE, exchange -> 
redisClient.sinterstore(exchangeConverter.getKey(exchange),
-                exchangeConverter.getKeys(exchange),
-                exchangeConverter.getDestination(exchange)));
-        bind(Command.SISMEMBER, wrap(exchange -> 
redisClient.sismember(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange))));
-        bind(Command.SMEMBERS, wrap(exchange -> 
redisClient.smembers(exchangeConverter.getKey(exchange))));
-        bind(Command.SMOVE, wrap(exchange -> 
redisClient.smove(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange),
-                exchangeConverter.getDestination(exchange))));
-        bind(Command.SPOP, wrap(exchange -> 
redisClient.spop(exchangeConverter.getKey(exchange))));
-        bind(Command.SRANDMEMBER, wrap(exchange -> 
redisClient.srandmember(exchangeConverter.getKey(exchange))));
-        bind(Command.SREM, wrap(exchange -> 
redisClient.srem(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange))));
-        bind(Command.SUNION, wrap(exchange -> 
redisClient.sunion(exchangeConverter.getKey(exchange),
-                exchangeConverter.getKeys(exchange))));
-        bind(Command.SUNIONSTORE, exchange -> 
redisClient.sunionstore(exchangeConverter.getKey(exchange),
-                exchangeConverter.getKeys(exchange),
-                exchangeConverter.getDestination(exchange)));
-        //missing command sscan
-
-        return result;
-    }
-
-}
diff --git 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/SortedSetsRedisProcessorsCreator.java
 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/SortedSetsRedisProcessorsCreator.java
deleted file mode 100644
index c3cb45f..0000000
--- 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/SortedSetsRedisProcessorsCreator.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.component.redis;
-
-import java.util.Map;
-
-import org.apache.camel.Processor;
-
-public final class SortedSetsRedisProcessorsCreator extends 
AbstractRedisProcessorCreator {
-
-    Map<Command, Processor> getProcessors(RedisClient redisClient, 
ExchangeConverter exchangeConverter) {
-        bind(Command.ZADD, wrap(exchange -> 
redisClient.zadd(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange),
-                exchangeConverter.getScore(exchange))));
-        bind(Command.ZCARD, wrap(exchange -> 
redisClient.zcard(exchangeConverter.getKey(exchange))));
-        bind(Command.ZCOUNT, wrap(exchange -> 
redisClient.zcount(exchangeConverter.getKey(exchange),
-                exchangeConverter.getMin(exchange),
-                exchangeConverter.getMax(exchange))));
-        bind(Command.ZINCRBY, wrap(exchange -> 
redisClient.zincrby(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange),
-                exchangeConverter.getIncrement(exchange))));
-        bind(Command.ZINTERSTORE, exchange -> 
redisClient.zinterstore(exchangeConverter.getKey(exchange),
-                exchangeConverter.getKeys(exchange),
-                exchangeConverter.getDestination(exchange)));
-        bind(Command.ZRANGE, wrap(exchange -> 
redisClient.zrange(exchangeConverter.getKey(exchange),
-                exchangeConverter.getStart(exchange),
-                exchangeConverter.getEnd(exchange),
-                exchangeConverter.getWithScore(exchange))));
-        bind(Command.ZRANGEBYSCORE, wrap(exchange -> 
redisClient.zrangebyscore(exchangeConverter.getKey(exchange),
-                exchangeConverter.getMin(exchange),
-                exchangeConverter.getMax(exchange))));
-        bind(Command.ZRANK, wrap(exchange -> 
redisClient.zrank(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange))));
-        bind(Command.ZREM, wrap(exchange -> 
redisClient.zrem(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange))));
-        bind(Command.ZREMRANGEBYRANK, exchange -> 
redisClient.zremrangebyrank(exchangeConverter.getKey(exchange),
-                exchangeConverter.getStart(exchange),
-                exchangeConverter.getEnd(exchange)));
-        bind(Command.ZREMRANGEBYSCORE, exchange -> 
redisClient.zremrangebyscore(exchangeConverter.getKey(exchange),
-                exchangeConverter.getStart(exchange),
-                exchangeConverter.getEnd(exchange)));
-        bind(Command.ZREVRANGE, wrap(exchange -> 
redisClient.zrevrange(exchangeConverter.getKey(exchange),
-                exchangeConverter.getStart(exchange),
-                exchangeConverter.getEnd(exchange),
-                exchangeConverter.getWithScore(exchange))));
-        bind(Command.ZREVRANGEBYSCORE, wrap(exchange -> 
redisClient.zrevrangebyscore(exchangeConverter.getKey(exchange),
-                exchangeConverter.getMin(exchange),
-                exchangeConverter.getMax(exchange))));
-        bind(Command.ZREVRANK, wrap(exchange -> 
redisClient.zrevrank(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange))));
-        bind(Command.ZUNIONSTORE, exchange -> 
redisClient.zunionstore(exchangeConverter.getKey(exchange),
-                exchangeConverter.getKeys(exchange),
-                exchangeConverter.getDestination(exchange)));
-        //missing zlexcount, zrangebylex, zrevrangebylex, zremrangebylex, 
zscore, zscan
-
-        return result;
-    }
-
-}
diff --git 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/StringsRedisProcessorsCreator.java
 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/StringsRedisProcessorsCreator.java
deleted file mode 100644
index 0a54aa6..0000000
--- 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/StringsRedisProcessorsCreator.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.component.redis;
-
-import java.util.Map;
-import java.util.concurrent.TimeUnit;
-
-import org.apache.camel.Processor;
-
-public final class StringsRedisProcessorsCreator extends 
AbstractRedisProcessorCreator {
-
-    Map<Command, Processor> getProcessors(RedisClient redisClient, 
ExchangeConverter exchangeConverter) {
-        bind(Command.APPEND, wrap(exchange -> 
redisClient.append(exchangeConverter.getKey(exchange),
-                exchangeConverter.getStringValue(exchange))));
-        bind(Command.DECR, wrap(exchange -> 
redisClient.decr(exchangeConverter.getKey(exchange))));
-        bind(Command.DECRBY, wrap(exchange -> 
redisClient.decrby(exchangeConverter.getKey(exchange),
-                exchangeConverter.getLongValue(exchange))));
-        bind(Command.GET, wrap(exchange -> 
redisClient.get(exchangeConverter.getKey(exchange))));
-        bind(Command.GETBIT, wrap(exchange -> 
redisClient.getbit(exchangeConverter.getKey(exchange),
-                exchangeConverter.getOffset(exchange))));
-        bind(Command.GETRANGE, wrap(exchange -> 
redisClient.getrange(exchangeConverter.getKey(exchange),
-                exchangeConverter.getStart(exchange),
-                exchangeConverter.getEnd(exchange))));
-        bind(Command.GETSET, wrap(exchange -> 
redisClient.getset(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange))));
-        bind(Command.INCR, wrap(exchange -> 
redisClient.incr(exchangeConverter.getKey(exchange))));
-        bind(Command.INCRBY, wrap(exchange -> 
redisClient.incrby(exchangeConverter.getKey(exchange),
-                exchangeConverter.getLongValue(exchange))));
-        bind(Command.MGET, wrap(exchange -> 
redisClient.mget(exchangeConverter.getFields(exchange))));
-        bind(Command.MSET, exchange -> 
redisClient.mset(exchangeConverter.getValuesAsMap(exchange)));
-        bind(Command.MSETNX, exchange -> 
redisClient.msetnx(exchangeConverter.getValuesAsMap(exchange)));
-        bind(Command.SET, exchange -> 
redisClient.set(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange)));
-        bind(Command.SETBIT, exchange -> 
redisClient.setbit(exchangeConverter.getKey(exchange),
-                exchangeConverter.getOffset(exchange),
-                exchangeConverter.getBooleanValue(exchange)));
-        bind(Command.SETEX, exchange -> 
redisClient.setex(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange),
-                exchangeConverter.getTimeout(exchange),
-                TimeUnit.SECONDS));
-        bind(Command.SETNX, wrap(exchange -> 
redisClient.setnx(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange))));
-        bind(Command.SETRANGE, exchange -> 
redisClient.setex(exchangeConverter.getKey(exchange),
-                exchangeConverter.getValue(exchange),
-                exchangeConverter.getOffset(exchange)));
-        bind(Command.STRLEN, wrap(exchange -> 
redisClient.strlen(exchangeConverter.getKey(exchange))));
-        //missing bitcount, bitfield, bitop, bitpos, incrbyfloat, psetex
-
-        return result;
-    }
-
-}
diff --git 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/TransactionRedisProcessorsCreator.java
 
b/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/TransactionRedisProcessorsCreator.java
deleted file mode 100644
index 4b94fd8..0000000
--- 
a/components/camel-spring-redis/src/main/java/org/apache/camel/component/redis/TransactionRedisProcessorsCreator.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.camel.component.redis;
-
-import java.util.Map;
-
-import org.apache.camel.Processor;
-
-public final class TransactionRedisProcessorsCreator extends 
AbstractRedisProcessorCreator {
-
-    Map<Command, Processor> getProcessors(RedisClient redisClient, 
ExchangeConverter exchangeConverter) {
-        bind(Command.DISCARD, exchange -> redisClient.discard());
-        bind(Command.EXEC, exchange -> redisClient.exec());
-        bind(Command.MULTI, exchange -> redisClient.multi());
-        bind(Command.WATCH, exchange -> 
redisClient.watch(exchangeConverter.getKeys(exchange)));
-        bind(Command.UNWATCH, exchange -> redisClient.unwatch());
-
-        return result;
-    }
-
-}
diff --git 
a/core/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/dsl/SpringRedisComponentBuilderFactory.java
 
b/core/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/dsl/SpringRedisComponentBuilderFactory.java
index 153cdf3..64755d9 100644
--- 
a/core/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/dsl/SpringRedisComponentBuilderFactory.java
+++ 
b/core/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/dsl/SpringRedisComponentBuilderFactory.java
@@ -51,6 +51,22 @@ public interface SpringRedisComponentBuilderFactory {
             extends
                 ComponentBuilder<RedisComponent> {
         /**
+         * Reference to a pre-configured RedisTemplate instance to use.
+         * 
+         * The option is a:
+         * 
&lt;code&gt;org.springframework.data.redis.core.RedisTemplate&lt;/code&gt; type.
+         * 
+         * Group: common
+         * 
+         * @param redisTemplate the value to set
+         * @return the dsl builder
+         */
+        default SpringRedisComponentBuilder redisTemplate(
+                org.springframework.data.redis.core.RedisTemplate 
redisTemplate) {
+            doSetProperty("redisTemplate", redisTemplate);
+            return this;
+        }
+        /**
          * Allows for bridging the consumer to the Camel routing Error Handler,
          * which mean any exceptions occurred while the consumer is trying to
          * pickup incoming messages, or the likes, will now be processed as a
@@ -134,6 +150,7 @@ public interface SpringRedisComponentBuilderFactory {
                 String name,
                 Object value) {
             switch (name) {
+            case "redisTemplate": ((RedisComponent) 
component).setRedisTemplate((org.springframework.data.redis.core.RedisTemplate) 
value); return true;
             case "bridgeErrorHandler": ((RedisComponent) 
component).setBridgeErrorHandler((boolean) value); return true;
             case "lazyStartProducer": ((RedisComponent) 
component).setLazyStartProducer((boolean) value); return true;
             case "autowiredEnabled": ((RedisComponent) 
component).setAutowiredEnabled((boolean) value); return true;
diff --git 
a/core/camel-support/src/main/java/org/apache/camel/support/HeaderSelectorProducer.java
 
b/core/camel-support/src/main/java/org/apache/camel/support/HeaderSelectorProducer.java
index 0e83ef4..f03c8dc 100644
--- 
a/core/camel-support/src/main/java/org/apache/camel/support/HeaderSelectorProducer.java
+++ 
b/core/camel-support/src/main/java/org/apache/camel/support/HeaderSelectorProducer.java
@@ -164,29 +164,16 @@ public abstract class HeaderSelectorProducer extends 
DefaultAsyncProducer implem
             LOGGER.debug("Invoking @InvokeOnHeader method: {}", action);
             Object answer = strategy.invoke(target, action, exchange, 
callback);
             LOGGER.trace("Invoked @InvokeOnHeader method: {} -> {}", action, 
answer);
-
-            if (answer == null) {
-                // strategy invoked synchronously so trigger callback and 
return true
-                callback.done(true);
-                return true;
-            } else if (answer instanceof Boolean) {
-                boolean bool = (boolean) answer;
-                if (bool) {
-                    // strategy invoked synchronously so trigger callback and 
return true
-                    callback.done(true);
-                    return true;
-                } else {
-                    // strategy is invoking this asynchronously so return false
-                    return false;
-                }
+            if (answer != null) {
+                exchange.getMessage().setBody(answer);
             }
+
         } catch (Exception e) {
             exchange.setException(e);
-            callback.done(true);
-            return true;
         }
 
-        return false;
+        callback.done(true);
+        return true;
     }
 
 }
diff --git a/docs/components/modules/ROOT/pages/spring-redis-component.adoc 
b/docs/components/modules/ROOT/pages/spring-redis-component.adoc
index f6d4cd5..b7f50fc 100644
--- a/docs/components/modules/ROOT/pages/spring-redis-component.adoc
+++ b/docs/components/modules/ROOT/pages/spring-redis-component.adoc
@@ -46,13 +46,14 @@ You can append query options to the URI in the following 
format,
 
 
 // component options: START
-The Spring Redis component supports 3 options, which are listed below.
+The Spring Redis component supports 4 options, which are listed below.
 
 
 
 [width="100%",cols="2,5,^1,2",options="header"]
 |===
 | Name | Description | Default | Type
+| *redisTemplate* (common) | *Autowired* Reference to a pre-configured 
RedisTemplate instance to use. |  | RedisTemplate
 | *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the 
Camel routing Error Handler, which mean any exceptions occurred while the 
consumer is trying to pickup incoming messages, or the likes, will now be 
processed as a message and handled by the routing Error Handler. By default the 
consumer will use the org.apache.camel.spi.ExceptionHandler to deal with 
exceptions, that will be logged at WARN or ERROR level and ignored. | false | 
boolean
 | *lazyStartProducer* (producer) | Whether the producer should be started lazy 
(on the first message). By starting lazy you can use this to allow CamelContext 
and routes to startup in situations where a producer may otherwise fail during 
starting and cause the route to fail being started. By deferring this startup 
to be lazy then the startup failure can be handled during routing messages via 
Camel's routing error handlers. Beware that when the first message is processed 
then creating and [...]
 | *autowiredEnabled* (advanced) | Whether autowiring is enabled. This is used 
for automatic autowiring options (the option must be marked as autowired) by 
looking up in the registry to find if there is a single instance of matching 
type, which then gets configured on the component. This can be used for 
automatic configuring JDBC data sources, JMS connection factories, AWS Clients, 
etc. | true | boolean
diff --git 
a/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/GenerateInvokeOnHeaderMojo.java
 
b/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/GenerateInvokeOnHeaderMojo.java
index badc18d..3a4b27c 100644
--- 
a/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/GenerateInvokeOnHeaderMojo.java
+++ 
b/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/GenerateInvokeOnHeaderMojo.java
@@ -68,6 +68,7 @@ public class GenerateInvokeOnHeaderMojo extends 
AbstractGeneratorMojo {
         private String methodName;
         private boolean isVoid;
         private boolean callback;
+        private boolean exchange;
 
         public String getKey() {
             return key;
@@ -100,6 +101,14 @@ public class GenerateInvokeOnHeaderMojo extends 
AbstractGeneratorMojo {
         public void setCallback(boolean callback) {
             this.callback = callback;
         }
+
+        public boolean isExchange() {
+            return exchange;
+        }
+
+        public void setExchange(boolean exchange) {
+            this.exchange = exchange;
+        }
     }
 
     public GenerateInvokeOnHeaderMojo() {
@@ -136,6 +145,7 @@ public class GenerateInvokeOnHeaderMojo extends 
AbstractGeneratorMojo {
             String methodName = a.target().asMethod().name();
             boolean isVoid = Type.Kind.VOID == 
a.target().asMethod().returnType().kind();
             boolean callback = a.target().asMethod().parameters().size() == 2;
+            boolean exchange = 
"org.apache.camel.Exchange".equals(a.target().asMethod().parameters().get(0).name().toString());
             Set<InvokeOnHeaderModel> set = 
classes.computeIfAbsent(currentClass,
                     k -> new 
TreeSet<>(Comparator.comparing(InvokeOnHeaderModel::getKey)));
             InvokeOnHeaderModel model = new InvokeOnHeaderModel();
@@ -143,6 +153,7 @@ public class GenerateInvokeOnHeaderMojo extends 
AbstractGeneratorMojo {
             model.setMethodName(methodName);
             model.setVoid(isVoid);
             model.setCallback(callback);
+            model.setExchange(exchange);
             set.add(model);
         });
 
@@ -211,10 +222,12 @@ public class GenerateInvokeOnHeaderMojo extends 
AbstractGeneratorMojo {
             w.write("        switch (key) {\n");
             for (InvokeOnHeaderModel option : models) {
                 String invoke;
-                if (option.isCallback()) {
-                    invoke = "target." + option.getMethodName() + 
"(exchange.getMessage(), callback)";
+                String arg1 = option.isExchange() ? "exchange" : 
"exchange.getMessage()";
+                String arg2 = option.isCallback() ? "callback" : null;
+                if (arg2 != null) {
+                    invoke = "target." + option.getMethodName() + "(" + arg1 + 
", " + arg2 + ")";
                 } else {
-                    invoke = "target." + option.getMethodName() + 
"(exchange.getMessage())";
+                    invoke = "target." + option.getMethodName() + "(" + arg1 + 
")";
                 }
                 if (!option.getKey().toLowerCase().equals(option.getKey())) {
                     w.write(String.format("        case \"%s\":\n", 
option.getKey().toLowerCase()));

Reply via email to