You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by da...@apache.org on 2020/10/02 08:50:40 UTC
[camel] branch master updated (f7180d2 -> 26efb9f)
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git.
from f7180d2 Camel-AWS2-Lambda: Added localstack test for PublishVersion
new eb06b1f CAMEL-15605: Languages should be singleton for better performance.
new 7d07d3b CAMEL-15605: Languages should be singleton for better performance.
new 3f0349f CAMEL-15605: Languages should be singleton for better performance.
new d9cacc7 CAMEL-15605: Languages should be singleton for better performance.
new 70f16b8 CAMEL-15605: Languages should be singleton for better performance.
new d7ea35b CAMEL-15605: Languages should be singleton for better performance.
new fd8084f CAMEL-15605: Languages should be singleton for better performance.
new ab08acf Upgrade saxon
new 06bd29a CAMEL-15605: Languages should be singleton for better performance.
new 376bc05 CAMEL-15605: Languages should be singleton for better performance.
new 7bfaccb CAMEL-15605: Languages should be singleton for better performance.
new bbeb0c7 Regen
new c15c30e CAMEL-15605: Languages should be singleton for better performance.
new 26efb9f Flaky test
The 14 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
camel-dependencies/pom.xml | 2 +-
.../camel/catalog/docs/jsonpath-language.adoc | 3 +-
.../apache/camel/catalog/languages/jsonpath.json | 1 +
.../org/apache/camel/catalog/models/jsonpath.json | 1 +
.../apache/camel/language/bean/BeanExpression.java | 16 ----
.../apache/camel/language/bean/BeanLanguage.java | 58 ++++++--------
.../org/apache/camel/jsonpath/jsonpath.json | 1 +
.../src/main/docs/jsonpath-language.adoc | 3 +-
.../apache/camel/jsonpath/JsonPathExpression.java | 39 +--------
.../apache/camel/jsonpath/JsonPathLanguage.java | 92 ++++++++++++++++++----
.../camel/jsonpath/JsonPathLanguageTest.java | 2 +-
.../camel/component/xquery/XQueryBuilder.java | 23 +-----
.../camel/language/xquery/XQueryLanguage.java | 62 ++++++++++++++-
.../SpringManagedCustomProcessorTest.java | 2 +
.../apache/camel/language/xpath/XPathBuilder.java | 47 +----------
.../apache/camel/language/xpath/XPathLanguage.java | 72 +++++++++++++++--
.../main/java/org/apache/camel/spi/Language.java | 28 +++++++
.../camel/impl/engine/AbstractCamelContext.java | 2 +
.../org/apache/camel/model/language/jsonpath.json | 1 +
.../org/apache/camel/builder/SimpleBuilder.java | 19 +----
.../camel/model/language/JsonPathExpression.java | 14 ++++
.../camel/model/language/MethodCallExpression.java | 6 +-
.../camel/reifier/language/ExpressionReifier.java | 13 ++-
.../language/JsonPathExpressionReifier.java | 44 +++++++----
.../language/MethodCallExpressionReifier.java | 36 +++++++--
.../reifier/language/SimpleExpressionReifier.java | 34 ++++++--
.../language/TokenizerExpressionReifier.java | 37 +++++----
.../language/XMLTokenizerExpressionReifier.java | 39 ++++++---
.../reifier/language/XPathExpressionReifier.java | 89 +++++++++++++++++----
.../reifier/language/XQueryExpressionReifier.java | 43 +++++++---
.../camel/language/tokenizer/TokenizeLanguage.java | 91 +++++++--------------
.../apache/camel/language/LanguageServiceTest.java | 18 -----
.../org/apache/camel/language/TokenizerTest.java | 4 +-
.../java/org/apache/camel/language/XPathTest.java | 4 +-
.../org/apache/camel/support/CustomizersTest.java | 9 ++-
.../support/ExpressionToPredicateAdapter.java | 3 +
.../org/apache/camel/support/LanguageSupport.java | 76 ++++++++++++++++++
.../support/PredicateToExpressionAdapter.java | 3 +
.../camel/support/builder/ExpressionBuilder.java | 14 ++--
.../java/org/apache/camel/xml/in/ModelParser.java | 1 +
.../language/xtokenizer/XMLTokenizeLanguage.java | 23 +++++-
.../modules/languages/pages/jsonpath-language.adoc | 3 +-
parent/pom.xml | 2 +-
43 files changed, 691 insertions(+), 389 deletions(-)
[camel] 02/14: CAMEL-15605: Languages should be singleton for
better performance.
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 7d07d3ba7ddbede6b8fff54034dcc2197096da0c
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Thu Oct 1 15:27:57 2020 +0200
CAMEL-15605: Languages should be singleton for better performance.
---
.../camel/catalog/docs/jsonpath-language.adoc | 3 +-
.../apache/camel/language/bean/BeanExpression.java | 16 ----
.../apache/camel/language/bean/BeanLanguage.java | 45 +++++++++++
.../org/apache/camel/jsonpath/jsonpath.json | 1 +
.../src/main/docs/jsonpath-language.adoc | 3 +-
.../apache/camel/jsonpath/JsonPathExpression.java | 40 +---------
.../apache/camel/jsonpath/JsonPathLanguage.java | 92 ++++++++++++++++++----
.../camel/jsonpath/JsonPathLanguageTest.java | 2 +-
.../main/java/org/apache/camel/spi/Language.java | 8 +-
.../org/apache/camel/model/language/jsonpath.json | 1 +
.../camel/model/language/JsonPathExpression.java | 14 ++++
.../language/JsonPathExpressionReifier.java | 42 ++++++----
.../org/apache/camel/support/LanguageSupport.java | 72 +++++++++++++++++
.../java/org/apache/camel/xml/in/ModelParser.java | 1 +
.../modules/languages/pages/jsonpath-language.adoc | 3 +-
15 files changed, 250 insertions(+), 93 deletions(-)
diff --git a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/jsonpath-language.adoc b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/jsonpath-language.adoc
index 806aca9..87ae77d 100644
--- a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/jsonpath-language.adoc
+++ b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/jsonpath-language.adoc
@@ -29,7 +29,7 @@ from("queue:books.new")
// language options: START
-The JsonPath language supports 7 options, which are listed below.
+The JsonPath language supports 8 options, which are listed below.
@@ -42,6 +42,7 @@ The JsonPath language supports 7 options, which are listed below.
| allowEasyPredicate | true | Boolean | Whether to allow using the easy predicate parser to pre-parse predicates.
| writeAsString | false | Boolean | Whether to write the output of each row/element as a JSON String value instead of a Map/POJO value.
| headerName | | String | Name of header to use as input, instead of the message body
+| option | | String | To configure additional options on json path. Multiple values can be separated by comma.
| trim | true | Boolean | Whether to trim the value to remove leading and trailing whitespaces and line breaks
|===
// language options: END
diff --git a/components/camel-bean/src/main/java/org/apache/camel/language/bean/BeanExpression.java b/components/camel-bean/src/main/java/org/apache/camel/language/bean/BeanExpression.java
index 6fdaafa..9d2038e 100644
--- a/components/camel-bean/src/main/java/org/apache/camel/language/bean/BeanExpression.java
+++ b/components/camel-bean/src/main/java/org/apache/camel/language/bean/BeanExpression.java
@@ -81,34 +81,18 @@ public class BeanExpression implements Expression, Predicate, AfterPropertiesCon
return bean;
}
- public void setBean(Object bean) {
- this.bean = bean;
- }
-
public String getBeanName() {
return beanName;
}
- public void setBeanName(String beanName) {
- this.beanName = beanName;
- }
-
public Class<?> getType() {
return type;
}
- public void setType(Class<?> type) {
- this.type = type;
- }
-
public String getMethod() {
return method;
}
- public void setMethod(String method) {
- this.method = method;
- }
-
@Override
public void init(CamelContext context) {
}
diff --git a/components/camel-bean/src/main/java/org/apache/camel/language/bean/BeanLanguage.java b/components/camel-bean/src/main/java/org/apache/camel/language/bean/BeanLanguage.java
index 70d6692..d59e676d 100644
--- a/components/camel-bean/src/main/java/org/apache/camel/language/bean/BeanLanguage.java
+++ b/components/camel-bean/src/main/java/org/apache/camel/language/bean/BeanLanguage.java
@@ -38,9 +38,46 @@ import org.apache.camel.util.StringHelper;
@org.apache.camel.spi.annotations.Language("bean")
public class BeanLanguage extends LanguageSupport {
+ private Object bean;
+ private Class<?> beanType;
+ private String ref;
+ private String method;
+
public BeanLanguage() {
}
+ public Object getBean() {
+ return bean;
+ }
+
+ public void setBean(Object bean) {
+ this.bean = bean;
+ }
+
+ public Class<?> getBeanType() {
+ return beanType;
+ }
+
+ public void setBeanType(Class<?> beanType) {
+ this.beanType = beanType;
+ }
+
+ public String getRef() {
+ return ref;
+ }
+
+ public void setRef(String ref) {
+ this.ref = ref;
+ }
+
+ public String getMethod() {
+ return method;
+ }
+
+ public void setMethod(String method) {
+ this.method = method;
+ }
+
@Override
public Predicate createPredicate(String expression) {
return ExpressionToPredicateAdapter.toPredicate(createExpression(expression));
@@ -72,6 +109,14 @@ public class BeanLanguage extends LanguageSupport {
@Override
public Expression createExpression(String expression) {
// favour using the configured options
+ if (bean != null) {
+ return new BeanExpression(bean, method);
+ } else if (beanType != null) {
+ return new BeanExpression(beanType, method);
+ } else if (ref != null) {
+ return new BeanExpression(ref, method);
+ }
+
String beanName = expression;
String method = null;
diff --git a/components/camel-jsonpath/src/generated/resources/org/apache/camel/jsonpath/jsonpath.json b/components/camel-jsonpath/src/generated/resources/org/apache/camel/jsonpath/jsonpath.json
index a97e759..c5fab68 100644
--- a/components/camel-jsonpath/src/generated/resources/org/apache/camel/jsonpath/jsonpath.json
+++ b/components/camel-jsonpath/src/generated/resources/org/apache/camel/jsonpath/jsonpath.json
@@ -23,6 +23,7 @@
"allowEasyPredicate": { "kind": "attribute", "displayName": "Allow Easy Predicate", "required": false, "type": "boolean", "javaType": "java.lang.Boolean", "deprecated": false, "secret": false, "defaultValue": true, "description": "Whether to allow using the easy predicate parser to pre-parse predicates." },
"writeAsString": { "kind": "attribute", "displayName": "Write As String", "required": false, "type": "boolean", "javaType": "java.lang.Boolean", "deprecated": false, "secret": false, "defaultValue": false, "description": "Whether to write the output of each row\/element as a JSON String value instead of a Map\/POJO value." },
"headerName": { "kind": "attribute", "displayName": "Header Name", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "secret": false, "description": "Name of header to use as input, instead of the message body" },
+ "option": { "kind": "attribute", "displayName": "Option", "required": false, "type": "enum", "javaType": "java.lang.String", "enum": [ "ALWAYS_RETURN_LIST", "AS_PATH_LIST", "DEFAULT_PATH_LEAF_TO_NULL", "REQUIRE_PROPERTIES", "SUPPRESS_EXCEPTIONS" ], "deprecated": false, "secret": false, "description": "To configure additional options on json path. Multiple values can be separated by comma." },
"trim": { "kind": "attribute", "displayName": "Trim", "required": false, "type": "boolean", "javaType": "java.lang.Boolean", "deprecated": false, "secret": false, "defaultValue": true, "description": "Whether to trim the value to remove leading and trailing whitespaces and line breaks" },
"id": { "kind": "attribute", "displayName": "Id", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "secret": false, "description": "Sets the id of this node" }
}
diff --git a/components/camel-jsonpath/src/main/docs/jsonpath-language.adoc b/components/camel-jsonpath/src/main/docs/jsonpath-language.adoc
index 806aca9..87ae77d 100644
--- a/components/camel-jsonpath/src/main/docs/jsonpath-language.adoc
+++ b/components/camel-jsonpath/src/main/docs/jsonpath-language.adoc
@@ -29,7 +29,7 @@ from("queue:books.new")
// language options: START
-The JsonPath language supports 7 options, which are listed below.
+The JsonPath language supports 8 options, which are listed below.
@@ -42,6 +42,7 @@ The JsonPath language supports 7 options, which are listed below.
| allowEasyPredicate | true | Boolean | Whether to allow using the easy predicate parser to pre-parse predicates.
| writeAsString | false | Boolean | Whether to write the output of each row/element as a JSON String value instead of a Map/POJO value.
| headerName | | String | Name of header to use as input, instead of the message body
+| option | | String | To configure additional options on json path. Multiple values can be separated by comma.
| trim | true | Boolean | Whether to trim the value to remove leading and trailing whitespaces and line breaks
|===
// language options: END
diff --git a/components/camel-jsonpath/src/main/java/org/apache/camel/jsonpath/JsonPathExpression.java b/components/camel-jsonpath/src/main/java/org/apache/camel/jsonpath/JsonPathExpression.java
index 60954f9..7dfb850 100644
--- a/components/camel-jsonpath/src/main/java/org/apache/camel/jsonpath/JsonPathExpression.java
+++ b/components/camel-jsonpath/src/main/java/org/apache/camel/jsonpath/JsonPathExpression.java
@@ -26,13 +26,11 @@ import org.apache.camel.Exchange;
import org.apache.camel.ExpressionEvaluationException;
import org.apache.camel.ExpressionIllegalSyntaxException;
import org.apache.camel.jsonpath.easypredicate.EasyPredicateParser;
-import org.apache.camel.spi.GeneratedPropertyConfigurer;
import org.apache.camel.support.ExpressionAdapter;
-import org.apache.camel.support.component.PropertyConfigurerSupport;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class JsonPathExpression extends ExpressionAdapter implements AfterPropertiesConfigured, GeneratedPropertyConfigurer {
+public class JsonPathExpression extends ExpressionAdapter implements AfterPropertiesConfigured {
private static final Logger LOG = LoggerFactory.getLogger(JsonPathExpression.class);
@@ -46,47 +44,13 @@ public class JsonPathExpression extends ExpressionAdapter implements AfterProper
private boolean allowEasyPredicate = true;
private boolean writeAsString;
private String headerName;
+ private String option;
private Option[] options;
public JsonPathExpression(String expression) {
this.expression = expression;
}
- @Override
- public boolean configure(CamelContext camelContext, Object target, String name, Object value, boolean ignoreCase) {
- if (target != this) {
- throw new IllegalStateException("Can only configure our own instance !");
- }
- switch (ignoreCase ? name.toLowerCase() : name) {
- case "resulttype":
- case "resultType":
- setResultType(PropertyConfigurerSupport.property(camelContext, Class.class, value));
- return true;
- case "suppressexceptions":
- case "suppressExceptions":
- setSuppressExceptions(PropertyConfigurerSupport.property(camelContext, Boolean.class, value));
- return true;
- case "allowsimple":
- case "allowSimple":
- setAllowSimple(PropertyConfigurerSupport.property(camelContext, Boolean.class, value));
- return true;
- case "alloweasypredicate":
- case "allowEasyPredicate":
- setAllowEasyPredicate(PropertyConfigurerSupport.property(camelContext, Boolean.class, value));
- return true;
- case "writeasstring":
- case "writeAsString":
- setWriteAsString(PropertyConfigurerSupport.property(camelContext, Boolean.class, value));
- return true;
- case "headername":
- case "headerName":
- setHeaderName(PropertyConfigurerSupport.property(camelContext, String.class, value));
- return true;
- default:
- return false;
- }
- }
-
public boolean isPredicate() {
return predicate;
}
diff --git a/components/camel-jsonpath/src/main/java/org/apache/camel/jsonpath/JsonPathLanguage.java b/components/camel-jsonpath/src/main/java/org/apache/camel/jsonpath/JsonPathLanguage.java
index 0873981..e04bb94 100644
--- a/components/camel-jsonpath/src/main/java/org/apache/camel/jsonpath/JsonPathLanguage.java
+++ b/components/camel-jsonpath/src/main/java/org/apache/camel/jsonpath/JsonPathLanguage.java
@@ -16,6 +16,10 @@
*/
package org.apache.camel.jsonpath;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
import com.jayway.jsonpath.Option;
import org.apache.camel.Expression;
import org.apache.camel.Predicate;
@@ -27,6 +31,10 @@ public class JsonPathLanguage extends LanguageSupport {
private Class<?> resultType;
private boolean suppressExceptions;
+ private boolean allowSimple = true;
+ private boolean allowEasyPredicate = true;
+ private boolean writeAsString;
+ private String headerName;
private Option[] options;
public Class<?> getResultType() {
@@ -45,43 +53,95 @@ public class JsonPathLanguage extends LanguageSupport {
this.suppressExceptions = suppressExceptions;
}
- public Option[] getOptions() {
- return options;
+ public boolean isAllowSimple() {
+ return allowSimple;
+ }
+
+ public void setAllowSimple(boolean allowSimple) {
+ this.allowSimple = allowSimple;
+ }
+
+ public boolean isAllowEasyPredicate() {
+ return allowEasyPredicate;
+ }
+
+ public void setAllowEasyPredicate(boolean allowEasyPredicate) {
+ this.allowEasyPredicate = allowEasyPredicate;
+ }
+
+ public boolean isWriteAsString() {
+ return writeAsString;
+ }
+
+ public void setWriteAsString(boolean writeAsString) {
+ this.writeAsString = writeAsString;
+ }
+
+ public String getHeaderName() {
+ return headerName;
}
- public void setOption(Option option) {
- this.options = new Option[] { option };
+ public void setHeaderName(String headerName) {
+ this.headerName = headerName;
}
- public void setOptions(Option[] options) {
+ public Option[] getOptions() {
+ return options;
+ }
+
+ public void setOptions(Option... options) {
this.options = options;
}
@Override
- public Predicate createPredicate(final String predicate) {
- JsonPathExpression answer = new JsonPathExpression(predicate);
+ public Predicate createPredicate(String expression) {
+ JsonPathExpression answer = (JsonPathExpression) createExpression(expression);
answer.setPredicate(true);
- answer.setResultType(resultType);
- answer.setSuppressExceptions(suppressExceptions);
- answer.setOptions(options);
- answer.afterPropertiesConfigured(getCamelContext());
return answer;
}
@Override
- public Expression createExpression(final String expression) {
+ public Expression createExpression(String expression) {
JsonPathExpression answer = new JsonPathExpression(expression);
- answer.setPredicate(false);
answer.setResultType(resultType);
answer.setSuppressExceptions(suppressExceptions);
+ answer.setAllowSimple(allowSimple);
+ answer.setAllowEasyPredicate(allowEasyPredicate);
+ answer.setHeaderName(headerName);
+ answer.setWriteAsString(writeAsString);
+ answer.setHeaderName(headerName);
answer.setOptions(options);
answer.afterPropertiesConfigured(getCamelContext());
return answer;
}
@Override
- public boolean isSingleton() {
- // cannot be singleton due options
- return false;
+ public Predicate createPredicate(Map<String, Object> properties) {
+ JsonPathExpression json = (JsonPathExpression) createExpression(properties);
+ json.setPredicate(true);
+ return json;
}
+
+ @Override
+ public Expression createExpression(Map<String, Object> properties) {
+ String exp = (String) properties.get("expression");
+ JsonPathExpression answer = new JsonPathExpression(exp);
+ answer.setResultType(property(Class.class, properties, "resultType", null));
+ answer.setSuppressExceptions(property(boolean.class, properties, "suppressExceptions", true));
+ answer.setAllowEasyPredicate(property(boolean.class, properties, "allowEasyPredicate", true));
+ answer.setAllowSimple(property(boolean.class, properties, "allowSimple", true));
+ answer.setWriteAsString(property(boolean.class, properties, "writeAsString", false));
+ answer.setHeaderName(property(String.class, properties, "headerName", null));
+ String option = (String) properties.get("option");
+ if (option != null) {
+ List<Option> list = new ArrayList<>();
+ for (String s : option.split(",")) {
+ list.add(getCamelContext().getTypeConverter().convertTo(Option.class, s));
+ }
+ answer.setOptions(list.toArray(new Option[list.size()]));
+ }
+ answer.afterPropertiesConfigured(getCamelContext());
+ return answer;
+ }
+
}
diff --git a/components/camel-jsonpath/src/test/java/org/apache/camel/jsonpath/JsonPathLanguageTest.java b/components/camel-jsonpath/src/test/java/org/apache/camel/jsonpath/JsonPathLanguageTest.java
index 7f9769f..e6bea51 100644
--- a/components/camel-jsonpath/src/test/java/org/apache/camel/jsonpath/JsonPathLanguageTest.java
+++ b/components/camel-jsonpath/src/test/java/org/apache/camel/jsonpath/JsonPathLanguageTest.java
@@ -128,7 +128,7 @@ public class JsonPathLanguageTest extends CamelTestSupport {
exchange.getIn().setBody(new File("src/test/resources/type.json"));
JsonPathLanguage lan = (JsonPathLanguage) context.resolveLanguage("jsonpath");
- lan.setOption(Option.SUPPRESS_EXCEPTIONS);
+ lan.setOptions(Option.SUPPRESS_EXCEPTIONS);
Expression exp = lan.createExpression("$.foo");
String nofoo = exp.evaluate(exchange, String.class);
diff --git a/core/camel-api/src/main/java/org/apache/camel/spi/Language.java b/core/camel-api/src/main/java/org/apache/camel/spi/Language.java
index 1376c76..b046242 100644
--- a/core/camel-api/src/main/java/org/apache/camel/spi/Language.java
+++ b/core/camel-api/src/main/java/org/apache/camel/spi/Language.java
@@ -45,8 +45,8 @@ public interface Language {
/**
* Creates an expression based on the given inputs properties
*
- * This is used for languages that have been configured with custom properties
- * most noticeable for xpath/xquery/tokenizer languages that have several options.
+ * This is used for languages that have been configured with custom properties most noticeable for
+ * xpath/xquery/tokenizer languages that have several options.
*
* @param properties arguments
* @return the created predicate
@@ -58,8 +58,8 @@ public interface Language {
/**
* Creates an expression based on the given inputs properties
*
- * This is used for languages that have been configured with custom properties
- * most noticeable for xpath/xquery/tokenizer languages that have several options.
+ * This is used for languages that have been configured with custom properties most noticeable for
+ * xpath/xquery/tokenizer languages that have several options.
*
* @param properties arguments
* @return the created expression
diff --git a/core/camel-core-engine/src/generated/resources/org/apache/camel/model/language/jsonpath.json b/core/camel-core-engine/src/generated/resources/org/apache/camel/model/language/jsonpath.json
index 532aef0..d30d808 100644
--- a/core/camel-core-engine/src/generated/resources/org/apache/camel/model/language/jsonpath.json
+++ b/core/camel-core-engine/src/generated/resources/org/apache/camel/model/language/jsonpath.json
@@ -19,6 +19,7 @@
"allowEasyPredicate": { "kind": "attribute", "displayName": "Allow Easy Predicate", "required": false, "type": "boolean", "javaType": "java.lang.Boolean", "deprecated": false, "secret": false, "defaultValue": true, "description": "Whether to allow using the easy predicate parser to pre-parse predicates." },
"writeAsString": { "kind": "attribute", "displayName": "Write As String", "required": false, "type": "boolean", "javaType": "java.lang.Boolean", "deprecated": false, "secret": false, "defaultValue": false, "description": "Whether to write the output of each row\/element as a JSON String value instead of a Map\/POJO value." },
"headerName": { "kind": "attribute", "displayName": "Header Name", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "secret": false, "description": "Name of header to use as input, instead of the message body" },
+ "option": { "kind": "attribute", "displayName": "Option", "required": false, "type": "enum", "javaType": "java.lang.String", "enum": [ "ALWAYS_RETURN_LIST", "AS_PATH_LIST", "DEFAULT_PATH_LEAF_TO_NULL", "REQUIRE_PROPERTIES", "SUPPRESS_EXCEPTIONS" ], "deprecated": false, "secret": false, "description": "To configure additional options on json path. Multiple values can be separated by comma." },
"trim": { "kind": "attribute", "displayName": "Trim", "required": false, "type": "boolean", "javaType": "java.lang.Boolean", "deprecated": false, "secret": false, "defaultValue": true, "description": "Whether to trim the value to remove leading and trailing whitespaces and line breaks" },
"id": { "kind": "attribute", "displayName": "Id", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "secret": false, "description": "Sets the id of this node" }
}
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/model/language/JsonPathExpression.java b/core/camel-core-engine/src/main/java/org/apache/camel/model/language/JsonPathExpression.java
index 81947b4..732b24f 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/model/language/JsonPathExpression.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/model/language/JsonPathExpression.java
@@ -50,6 +50,9 @@ public class JsonPathExpression extends ExpressionDefinition {
private String writeAsString;
@XmlAttribute
private String headerName;
+ @XmlAttribute
+ @Metadata(enums = "DEFAULT_PATH_LEAF_TO_NULL,ALWAYS_RETURN_LIST,AS_PATH_LIST,SUPPRESS_EXCEPTIONS,REQUIRE_PROPERTIES")
+ private String option;
public JsonPathExpression() {
}
@@ -135,6 +138,17 @@ public class JsonPathExpression extends ExpressionDefinition {
this.headerName = headerName;
}
+ public String getOption() {
+ return option;
+ }
+
+ /**
+ * To configure additional options on json path. Multiple values can be separated by comma.
+ */
+ public void setOption(String option) {
+ this.option = option;
+ }
+
@Override
public String getLanguage() {
return "jsonpath";
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/JsonPathExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/JsonPathExpressionReifier.java
index 669386d..b04303e 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/JsonPathExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/JsonPathExpressionReifier.java
@@ -22,38 +22,50 @@ import java.util.Map;
import org.apache.camel.CamelContext;
import org.apache.camel.Expression;
import org.apache.camel.Predicate;
+import org.apache.camel.RuntimeCamelException;
import org.apache.camel.model.language.ExpressionDefinition;
import org.apache.camel.model.language.JsonPathExpression;
+import org.apache.camel.spi.Language;
public class JsonPathExpressionReifier extends ExpressionReifier<JsonPathExpression> {
- // TODO: Update me
-
public JsonPathExpressionReifier(CamelContext camelContext, ExpressionDefinition definition) {
super(camelContext, (JsonPathExpression) definition);
}
@Override
- protected void configureExpression(Expression expression) {
- bindProperties(expression);
- super.configureExpression(expression);
+ protected void configureLanguage(Language language) {
+ if (definition.getResultType() == null && definition.getResultTypeName() != null) {
+ try {
+ Class<?> clazz = camelContext.getClassResolver().resolveMandatoryClass(definition.getResultTypeName());
+ definition.setResultType(clazz);
+ } catch (ClassNotFoundException e) {
+ throw RuntimeCamelException.wrapRuntimeException(e);
+ }
+ }
}
- @Override
- protected void configurePredicate(Predicate predicate) {
- bindProperties(predicate);
- super.configurePredicate(predicate);
- }
-
- private void bindProperties(Object target) {
- Map<String, Object> properties = new HashMap<>();
- properties.put("resultType", or(definition.getResultType(), definition.getResultTypeName()));
+ private Map<String, Object> createProperties(String exp) {
+ Map<String, Object> properties = new HashMap<>(8);
+ properties.put("expression", exp);
+ properties.put("resultType", definition.getResultType());
properties.put("suppressExceptions", definition.getSuppressExceptions());
properties.put("allowSimple", definition.getAllowSimple());
properties.put("allowEasyPredicate", definition.getAllowEasyPredicate());
properties.put("writeAsString", definition.getWriteAsString());
properties.put("headerName", definition.getHeaderName());
- setProperties(target, properties);
+ properties.put("option", definition.getOption());
+ return properties;
+ }
+
+ @Override
+ protected Expression createExpression(Language language, String exp) {
+ return language.createExpression(createProperties(exp));
+ }
+
+ @Override
+ protected Predicate createPredicate(Language language, String exp) {
+ return language.createPredicate(createProperties(exp));
}
}
diff --git a/core/camel-support/src/main/java/org/apache/camel/support/LanguageSupport.java b/core/camel-support/src/main/java/org/apache/camel/support/LanguageSupport.java
index e762093..6bd6c12 100644
--- a/core/camel-support/src/main/java/org/apache/camel/support/LanguageSupport.java
+++ b/core/camel-support/src/main/java/org/apache/camel/support/LanguageSupport.java
@@ -17,13 +17,17 @@
package org.apache.camel.support;
import java.io.InputStream;
+import java.util.List;
+import java.util.Map;
import org.apache.camel.CamelContext;
import org.apache.camel.CamelContextAware;
import org.apache.camel.ExpressionIllegalSyntaxException;
import org.apache.camel.IsSingleton;
+import org.apache.camel.NoSuchBeanException;
import org.apache.camel.spi.Language;
import org.apache.camel.util.IOHelper;
+import org.apache.camel.util.TimeUtils;
/**
* Base language for {@link Language} implementations.
@@ -91,4 +95,72 @@ public abstract class LanguageSupport implements Language, IsSingleton, CamelCon
return false;
}
+ /**
+ * Converts the property to the expected type
+ *
+ * @param type the expected type
+ * @param properties the options
+ * @param key name of the property
+ * @param defaultValue optional default value
+ * @return the value converted to the expected type
+ */
+ protected <T> T property(Class<T> type, Map<String, Object> properties, String key, Object defaultValue) {
+ Object value = properties.get(key);
+ if (value == null) {
+ value = defaultValue;
+ }
+
+ // if the type is not string based and the value is a bean reference, then we need to lookup
+ // the bean from the registry
+ if (value instanceof String && String.class != type) {
+ String text = value.toString();
+
+ if (EndpointHelper.isReferenceParameter(text)) {
+ Object obj;
+ // special for a list where we refer to beans which can be either a list or a single element
+ // so use Object.class as type
+ if (type == List.class) {
+ obj = EndpointHelper.resolveReferenceListParameter(camelContext, text, Object.class);
+ } else {
+ obj = EndpointHelper.resolveReferenceParameter(camelContext, text, type);
+ }
+ if (obj == null) {
+ // no bean found so throw an exception
+ throw new NoSuchBeanException(text, type.getName());
+ }
+ value = obj;
+ } else if (type == long.class || type == Long.class || type == int.class || type == Integer.class) {
+ Object obj = null;
+ // string to long/int then it may be a duration where we can convert the value to milli seconds
+ // it may be a time pattern, such as 5s for 5 seconds = 5000
+ try {
+ long num = TimeUtils.toMilliSeconds(text);
+ if (type == int.class || type == Integer.class) {
+ // need to cast to int
+ obj = (int) num;
+ } else {
+ obj = num;
+ }
+ } catch (IllegalArgumentException e) {
+ // ignore
+ }
+ if (obj != null) {
+ value = obj;
+ }
+ }
+ }
+
+ // special for boolean values with string values as we only want to accept "true" or "false"
+ if ((type == Boolean.class || type == boolean.class) && value instanceof String) {
+ String text = (String) value;
+ if (!text.equalsIgnoreCase("true") && !text.equalsIgnoreCase("false")) {
+ throw new IllegalArgumentException(
+ "Cannot convert the String value: " + value + " to type: " + type
+ + " as the value is not true or false");
+ }
+ }
+
+ return camelContext.getTypeConverter().convertTo(type, value);
+ }
+
}
diff --git a/core/camel-xml-io/src/generated/java/org/apache/camel/xml/in/ModelParser.java b/core/camel-xml-io/src/generated/java/org/apache/camel/xml/in/ModelParser.java
index 354617f..31cea3a 100644
--- a/core/camel-xml-io/src/generated/java/org/apache/camel/xml/in/ModelParser.java
+++ b/core/camel-xml-io/src/generated/java/org/apache/camel/xml/in/ModelParser.java
@@ -2350,6 +2350,7 @@ public class ModelParser extends BaseParser {
case "allowEasyPredicate": def.setAllowEasyPredicate(val); break;
case "allowSimple": def.setAllowSimple(val); break;
case "headerName": def.setHeaderName(val); break;
+ case "option": def.setOption(val); break;
case "resultType": def.setResultTypeName(val); break;
case "suppressExceptions": def.setSuppressExceptions(val); break;
case "writeAsString": def.setWriteAsString(val); break;
diff --git a/docs/components/modules/languages/pages/jsonpath-language.adoc b/docs/components/modules/languages/pages/jsonpath-language.adoc
index 0e57f87..7bfa539 100644
--- a/docs/components/modules/languages/pages/jsonpath-language.adoc
+++ b/docs/components/modules/languages/pages/jsonpath-language.adoc
@@ -31,7 +31,7 @@ from("queue:books.new")
// language options: START
-The JsonPath language supports 7 options, which are listed below.
+The JsonPath language supports 8 options, which are listed below.
@@ -44,6 +44,7 @@ The JsonPath language supports 7 options, which are listed below.
| allowEasyPredicate | true | Boolean | Whether to allow using the easy predicate parser to pre-parse predicates.
| writeAsString | false | Boolean | Whether to write the output of each row/element as a JSON String value instead of a Map/POJO value.
| headerName | | String | Name of header to use as input, instead of the message body
+| option | | String | To configure additional options on json path. Multiple values can be separated by comma.
| trim | true | Boolean | Whether to trim the value to remove leading and trailing whitespaces and line breaks
|===
// language options: END
[camel] 09/14: CAMEL-15605: Languages should be singleton for
better performance.
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 06bd29a18172cd99add420d2fc22eeaa3847b2e2
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Thu Oct 1 21:51:22 2020 +0200
CAMEL-15605: Languages should be singleton for better performance.
---
.../org/apache/camel/reifier/language/XPathExpressionReifier.java | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java
index b033b14..2e425f6 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java
@@ -69,10 +69,10 @@ public class XPathExpressionReifier extends ExpressionReifier<XPathExpression> {
Map<String, Object> properties = new HashMap<>(9);
properties.put("expression", expression);
properties.put("documentType", definition.getDocumentType());
- properties.put("XPathTest", asQName(definition.getResultTypeName()));
+ properties.put("resultQName", asQName(definition.getResultTypeName()));
properties.put("resultType", definition.getResultType());
properties.put("useSaxon", definition.getSaxon());
- properties.put("xPathFactory", definition.getXPathFactory());
+ properties.put("xpathFactory", definition.getXPathFactory());
properties.put("objectModelUri", definition.getObjectModel());
properties.put("threadSafety", definition.getThreadSafety());
properties.put("logNamespaces", definition.getLogNamespaces());
[camel] 04/14: CAMEL-15605: Languages should be singleton for
better performance.
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit d9cacc72f6b46a576b8279c1491cdc02c0c28bc5
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Thu Oct 1 17:23:31 2020 +0200
CAMEL-15605: Languages should be singleton for better performance.
---
.../src/test/java/org/apache/camel/support/CustomizersTest.java | 1 -
1 file changed, 1 deletion(-)
diff --git a/core/camel-core/src/test/java/org/apache/camel/support/CustomizersTest.java b/core/camel-core/src/test/java/org/apache/camel/support/CustomizersTest.java
index d978540..2bfd53e 100644
--- a/core/camel-core/src/test/java/org/apache/camel/support/CustomizersTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/support/CustomizersTest.java
@@ -42,7 +42,6 @@ import static org.apache.camel.util.CollectionHelper.propertiesOf;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
-import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
[camel] 13/14: CAMEL-15605: Languages should be singleton for
better performance.
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit c15c30e30ee57146487de8c5c533786906e132fa
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Fri Oct 2 10:49:00 2020 +0200
CAMEL-15605: Languages should be singleton for better performance.
---
.../org/apache/camel/builder/SimpleBuilder.java | 19 +------------------
.../language/JsonPathExpressionReifier.java | 14 +++++++-------
.../language/MethodCallExpressionReifier.java | 6 +++---
.../reifier/language/SimpleExpressionReifier.java | 17 +++++++++++++----
.../language/TokenizerExpressionReifier.java | 22 ++++++++++------------
.../language/XMLTokenizerExpressionReifier.java | 12 +++++-------
.../reifier/language/XPathExpressionReifier.java | 14 +++++++-------
.../reifier/language/XQueryExpressionReifier.java | 4 ++--
.../org/apache/camel/support/LanguageSupport.java | 4 ++++
.../language/xtokenizer/XMLTokenizeLanguage.java | 8 +++++---
10 files changed, 57 insertions(+), 63 deletions(-)
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/builder/SimpleBuilder.java b/core/camel-core-engine/src/main/java/org/apache/camel/builder/SimpleBuilder.java
index 9a46338..61a7c12 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/builder/SimpleBuilder.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/builder/SimpleBuilder.java
@@ -23,10 +23,8 @@ import org.apache.camel.Expression;
import org.apache.camel.Predicate;
import org.apache.camel.spi.ExpressionResultTypeAware;
import org.apache.camel.spi.Language;
-import org.apache.camel.spi.PropertyConfigurer;
import org.apache.camel.support.PredicateToExpressionAdapter;
import org.apache.camel.support.ScriptHelper;
-import org.apache.camel.support.component.PropertyConfigurerSupport;
/**
* Creates an {@link org.apache.camel.language.simple.Simple} language builder.
@@ -34,7 +32,7 @@ import org.apache.camel.support.component.PropertyConfigurerSupport;
* This builder is available in the Java DSL from the {@link RouteBuilder} which means that using simple language for
* {@link Expression}s or {@link Predicate}s is very easy with the help of this builder.
*/
-public class SimpleBuilder implements Predicate, Expression, ExpressionResultTypeAware, PropertyConfigurer {
+public class SimpleBuilder implements Predicate, Expression, ExpressionResultTypeAware {
private final String text;
private Class<?> resultType;
@@ -64,21 +62,6 @@ public class SimpleBuilder implements Predicate, Expression, ExpressionResultTyp
return simple(String.format(formatText, values), resultType);
}
- @Override
- public boolean configure(CamelContext camelContext, Object target, String name, Object value, boolean ignoreCase) {
- if (target != this) {
- throw new IllegalStateException("Can only configure our own instance !");
- }
- switch (ignoreCase ? name.toLowerCase() : name) {
- case "resulttype":
- case "resultType":
- setResultType(PropertyConfigurerSupport.property(camelContext, Class.class, value));
- return true;
- default:
- return false;
- }
- }
-
public String getText() {
return text;
}
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/JsonPathExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/JsonPathExpressionReifier.java
index b04303e..3b5dbf8 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/JsonPathExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/JsonPathExpressionReifier.java
@@ -47,14 +47,14 @@ public class JsonPathExpressionReifier extends ExpressionReifier<JsonPathExpress
private Map<String, Object> createProperties(String exp) {
Map<String, Object> properties = new HashMap<>(8);
- properties.put("expression", exp);
+ properties.put("expression", parseString(exp));
properties.put("resultType", definition.getResultType());
- properties.put("suppressExceptions", definition.getSuppressExceptions());
- properties.put("allowSimple", definition.getAllowSimple());
- properties.put("allowEasyPredicate", definition.getAllowEasyPredicate());
- properties.put("writeAsString", definition.getWriteAsString());
- properties.put("headerName", definition.getHeaderName());
- properties.put("option", definition.getOption());
+ properties.put("suppressExceptions", parseBoolean(definition.getSuppressExceptions()));
+ properties.put("allowSimple", parseBoolean(definition.getAllowSimple()));
+ properties.put("allowEasyPredicate", parseBoolean(definition.getAllowEasyPredicate()));
+ properties.put("writeAsString", parseBoolean(definition.getWriteAsString()));
+ properties.put("headerName", parseString(definition.getHeaderName()));
+ properties.put("option", parseString(definition.getOption()));
return properties;
}
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/MethodCallExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/MethodCallExpressionReifier.java
index e6c3b52..66e6ea5 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/MethodCallExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/MethodCallExpressionReifier.java
@@ -36,9 +36,9 @@ public class MethodCallExpressionReifier extends ExpressionReifier<MethodCallExp
protected Map<String, Object> createProperties() {
Map<String, Object> properties = new HashMap<>(4);
properties.put("bean", definition.getInstance());
- properties.put("beanType", or(definition.getBeanType(), definition.getBeanTypeName()));
- properties.put("ref", definition.getRef());
- properties.put("method", definition.getMethod());
+ properties.put("beanType", definition.getBeanType());
+ properties.put("ref", parseString(definition.getRef()));
+ properties.put("method", parseString(definition.getMethod()));
return properties;
}
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/SimpleExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/SimpleExpressionReifier.java
index 2bc0a3b..e14bf79 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/SimpleExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/SimpleExpressionReifier.java
@@ -67,10 +67,7 @@ public class SimpleExpressionReifier extends ExpressionReifier<SimpleExpression>
protected SimpleBuilder createBuilder() {
String exp = parseString(definition.getExpression());
// should be true by default
- boolean isTrim = true;
- if (definition.getTrim() != null) {
- isTrim = parseBoolean(definition.getTrim());
- }
+ boolean isTrim = parseBoolean(definition.getTrim(), true);
if (exp != null && isTrim) {
exp = exp.trim();
}
@@ -80,6 +77,18 @@ public class SimpleExpressionReifier extends ExpressionReifier<SimpleExpression>
}
@Override
+ protected Expression createExpression(Language language, String exp) {
+ definition.setExpression(exp);
+ return createBuilder();
+ }
+
+ @Override
+ protected Predicate createPredicate(Language language, String exp) {
+ definition.setExpression(exp);
+ return createBuilder();
+ }
+
+ @Override
protected void configureLanguage(Language language) {
if (definition.getResultType() == null && definition.getResultTypeName() != null) {
Class<?> clazz;
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/TokenizerExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/TokenizerExpressionReifier.java
index 02576d4..7cdaf26 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/TokenizerExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/TokenizerExpressionReifier.java
@@ -41,16 +41,16 @@ public class TokenizerExpressionReifier extends ExpressionReifier<TokenizerExpre
if (token.startsWith("\\n")) {
token = '\n' + token.substring(2);
}
- properties.put("token", token);
- properties.put("endToken", definition.getEndToken());
- properties.put("inheritNamespaceTagName", definition.getInheritNamespaceTagName());
- properties.put("headerName", definition.getHeaderName());
- properties.put("groupDelimiter", definition.getGroupDelimiter());
- properties.put("regex", definition.getRegex());
- properties.put("xml", definition.getXml());
- properties.put("includeTokens", definition.getIncludeTokens());
- properties.put("group", definition.getGroup());
- properties.put("skipFirst", definition.getSkipFirst());
+ properties.put("token", parseString(token));
+ properties.put("endToken", parseString(definition.getEndToken()));
+ properties.put("inheritNamespaceTagName", parseString(definition.getInheritNamespaceTagName()));
+ properties.put("headerName", parseString(definition.getHeaderName()));
+ properties.put("groupDelimiter", parseString(definition.getGroupDelimiter()));
+ properties.put("regex", parseBoolean(definition.getRegex()));
+ properties.put("xml", parseBoolean(definition.getXml()));
+ properties.put("includeTokens", parseBoolean(definition.getIncludeTokens()));
+ properties.put("group", parseString(definition.getGroup()));
+ properties.put("skipFirst", parseBoolean(definition.getSkipFirst()));
return properties;
}
@@ -62,13 +62,11 @@ public class TokenizerExpressionReifier extends ExpressionReifier<TokenizerExpre
@Override
protected Expression createExpression(Language language, String exp) {
- // method call does not use the string exp so its not in use
return language.createExpression(createProperties());
}
@Override
protected Predicate createPredicate(Language language, String exp) {
- // method call does not use the string exp so its not in use
return language.createPredicate(createProperties());
}
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XMLTokenizerExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XMLTokenizerExpressionReifier.java
index 331a075..71f4d59 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XMLTokenizerExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XMLTokenizerExpressionReifier.java
@@ -42,13 +42,11 @@ public class XMLTokenizerExpressionReifier extends ExpressionReifier<XMLTokenize
@Override
protected Expression createExpression(Language language, String exp) {
- // method call does not use the string exp so its not in use
return language.createExpression(createProperties());
}
@Override
protected Predicate createPredicate(Language language, String exp) {
- // method call does not use the string exp so its not in use
return language.createPredicate(createProperties());
}
@@ -70,11 +68,11 @@ public class XMLTokenizerExpressionReifier extends ExpressionReifier<XMLTokenize
}
protected Map<String, Object> createProperties() {
- Map<String, Object> properties = new HashMap<>(3);
- properties.put("headerName", definition.getHeaderName());
- properties.put("mode", definition.getMode());
- properties.put("group", definition.getGroup());
- properties.put("path", definition.getExpression());
+ Map<String, Object> properties = new HashMap<>(4);
+ properties.put("headerName", parseString(definition.getHeaderName()));
+ properties.put("mode", parseString(definition.getMode()));
+ properties.put("group", parseInt(definition.getGroup()));
+ properties.put("path", parseString(definition.getExpression()));
return properties;
}
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java
index 4fb3b6f..70e0085 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java
@@ -66,8 +66,8 @@ public class XPathExpressionReifier extends ExpressionReifier<XPathExpression> {
}
protected Map<String, Object> createProperties(String expression) {
- Map<String, Object> properties = new HashMap<>(9);
- properties.put("expression", expression);
+ Map<String, Object> properties = new HashMap<>(10);
+ properties.put("expression", parseString(expression));
properties.put("documentType", definition.getDocumentType());
// resultType can either point to a QName or it can be a regular class that influence the qname
// so we need this special logic to set resultQName and resultType accordingly
@@ -78,12 +78,12 @@ public class XPathExpressionReifier extends ExpressionReifier<XPathExpression> {
} else {
properties.put("resultType", definition.getResultType());
}
- properties.put("useSaxon", definition.getSaxon());
+ properties.put("useSaxon", parseBoolean(definition.getSaxon()));
properties.put("xpathFactory", definition.getXPathFactory());
- properties.put("objectModelUri", definition.getObjectModel());
- properties.put("threadSafety", definition.getThreadSafety());
- properties.put("logNamespaces", definition.getLogNamespaces());
- properties.put("headerName", definition.getHeaderName());
+ properties.put("objectModelUri", parseString(definition.getObjectModel()));
+ properties.put("threadSafety", parseBoolean(definition.getThreadSafety()));
+ properties.put("logNamespaces", parseBoolean(definition.getLogNamespaces()));
+ properties.put("headerName", parseString(definition.getHeaderName()));
return properties;
}
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XQueryExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XQueryExpressionReifier.java
index 0996ce1..ea4e97a 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XQueryExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XQueryExpressionReifier.java
@@ -63,9 +63,9 @@ public class XQueryExpressionReifier extends ExpressionReifier<XQueryExpression>
protected Map<String, Object> createProperties(String expression) {
Map<String, Object> properties = new HashMap<>(3);
- properties.put("expression", expression);
+ properties.put("expression", parseString(expression));
properties.put("resultType", definition.getResultType());
- properties.put("headerName", definition.getHeaderName());
+ properties.put("headerName", parseString(definition.getHeaderName()));
return properties;
}
diff --git a/core/camel-support/src/main/java/org/apache/camel/support/LanguageSupport.java b/core/camel-support/src/main/java/org/apache/camel/support/LanguageSupport.java
index 6bd6c12..4f0c60e 100644
--- a/core/camel-support/src/main/java/org/apache/camel/support/LanguageSupport.java
+++ b/core/camel-support/src/main/java/org/apache/camel/support/LanguageSupport.java
@@ -110,6 +110,10 @@ public abstract class LanguageSupport implements Language, IsSingleton, CamelCon
value = defaultValue;
}
+ if (value instanceof String) {
+ value = getCamelContext().resolvePropertyPlaceholders(value.toString());
+ }
+
// if the type is not string based and the value is a bean reference, then we need to lookup
// the bean from the registry
if (value instanceof String && String.class != type) {
diff --git a/core/camel-xml-jaxp/src/main/java/org/apache/camel/language/xtokenizer/XMLTokenizeLanguage.java b/core/camel-xml-jaxp/src/main/java/org/apache/camel/language/xtokenizer/XMLTokenizeLanguage.java
index 0cd0447..ed0f8f9 100644
--- a/core/camel-xml-jaxp/src/main/java/org/apache/camel/language/xtokenizer/XMLTokenizeLanguage.java
+++ b/core/camel-xml-jaxp/src/main/java/org/apache/camel/language/xtokenizer/XMLTokenizeLanguage.java
@@ -41,8 +41,8 @@ public class XMLTokenizeLanguage extends LanguageSupport {
private String headerName;
private String path;
- private char mode = 'i';
- private int group = 1;
+ private char mode;
+ private int group;
private Namespaces namespaces;
public static Expression tokenize(String path) {
@@ -98,7 +98,9 @@ public class XMLTokenizeLanguage extends LanguageSupport {
public Expression createExpression(Map<String, Object> properties) {
XMLTokenizeLanguage answer = new XMLTokenizeLanguage();
answer.setHeaderName(property(String.class, properties, "headerName", headerName));
- answer.setMode(property(char.class, properties, "mode", mode));
+ if (properties.get("mode") != null) {
+ answer.setMode(property(char.class, properties, "mode", 'i'));
+ }
answer.setGroup(property(int.class, properties, "group", group));
String path = property(String.class, properties, "path", null);
return answer.createExpression(path);
[camel] 06/14: CAMEL-15605: Languages should be singleton for
better performance.
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit d7ea35b7bbf072655337ab48faa84a3fc4a4338f
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Thu Oct 1 20:41:26 2020 +0200
CAMEL-15605: Languages should be singleton for better performance.
---
.../apache/camel/language/xpath/XPathLanguage.java | 17 +++++++++++++
.../reifier/language/XPathExpressionReifier.java | 28 +++++++++++++++-------
.../java/org/apache/camel/language/XPathTest.java | 4 ++--
3 files changed, 39 insertions(+), 10 deletions(-)
diff --git a/components/camel-xpath/src/main/java/org/apache/camel/language/xpath/XPathLanguage.java b/components/camel-xpath/src/main/java/org/apache/camel/language/xpath/XPathLanguage.java
index fd90f94..5c6ccd5 100644
--- a/components/camel-xpath/src/main/java/org/apache/camel/language/xpath/XPathLanguage.java
+++ b/components/camel-xpath/src/main/java/org/apache/camel/language/xpath/XPathLanguage.java
@@ -18,6 +18,7 @@ package org.apache.camel.language.xpath;
import java.util.Map;
+import javax.xml.namespace.QName;
import javax.xml.xpath.XPathFactory;
import org.apache.camel.Expression;
@@ -31,6 +32,7 @@ import org.apache.camel.support.LanguageSupport;
@Language("xpath")
public class XPathLanguage extends LanguageSupport {
private Class<?> resultType;
+ private QName resultQName;
private Class<?> documentType;
private XPathFactory xpathFactory;
private Boolean useSaxon;
@@ -75,6 +77,10 @@ public class XPathLanguage extends LanguageSupport {
if (clazz != null) {
setResultType(clazz);
}
+ QName qname = property(QName.class, properties, "resultQName", null);
+ if (qname != null) {
+ setResultQName(qname);
+ }
setUseSaxon(property(Boolean.class, properties, "useSaxon", null));
setObjectModelUri(property(String.class, properties, "objectModelUri", null));
setThreadSafety(property(Boolean.class, properties, "threadSafety", null));
@@ -91,6 +97,14 @@ public class XPathLanguage extends LanguageSupport {
return resultType;
}
+ public void setResultQName(QName qName) {
+ this.resultQName = qName;
+ }
+
+ public QName getResultQName() {
+ return resultQName;
+ }
+
public void setResultType(Class<?> resultType) {
this.resultType = resultType;
}
@@ -159,6 +173,9 @@ public class XPathLanguage extends LanguageSupport {
if (threadSafety != null) {
builder.setThreadSafety(threadSafety);
}
+ if (resultQName != null) {
+ builder.setResultQName(resultQName);
+ }
if (resultType != null) {
builder.setResultType(resultType);
}
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java
index c49f1f0..b033b14 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java
@@ -19,6 +19,7 @@ package org.apache.camel.reifier.language;
import java.util.HashMap;
import java.util.Map;
+import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathFactory;
import org.apache.camel.CamelContext;
@@ -68,6 +69,7 @@ public class XPathExpressionReifier extends ExpressionReifier<XPathExpression> {
Map<String, Object> properties = new HashMap<>(9);
properties.put("expression", expression);
properties.put("documentType", definition.getDocumentType());
+ properties.put("XPathTest", asQName(definition.getResultTypeName()));
properties.put("resultType", definition.getResultType());
properties.put("useSaxon", definition.getSaxon());
properties.put("xPathFactory", definition.getXPathFactory());
@@ -78,16 +80,26 @@ public class XPathExpressionReifier extends ExpressionReifier<XPathExpression> {
return properties;
}
+ private Object asQName(String resultTypeName) {
+ if (resultTypeName == null) {
+ return null;
+ }
+ if ("NUMBER".equalsIgnoreCase(resultTypeName)) {
+ return XPathConstants.NUMBER;
+ } else if ("STRING".equalsIgnoreCase(resultTypeName)) {
+ return XPathConstants.STRING;
+ } else if ("BOOLEAN".equalsIgnoreCase(resultTypeName)) {
+ return XPathConstants.BOOLEAN;
+ } else if ("NODESET".equalsIgnoreCase(resultTypeName)) {
+ return XPathConstants.NODESET;
+ } else if ("NODE".equalsIgnoreCase(resultTypeName)) {
+ return XPathConstants.NODE;
+ }
+ return null;
+ }
+
@Override
protected void configureLanguage(Language language) {
- if (definition.getResultType() == null && definition.getResultTypeName() != null) {
- try {
- Class<?> clazz = camelContext.getClassResolver().resolveMandatoryClass(definition.getResultTypeName());
- definition.setResultType(clazz);
- } catch (ClassNotFoundException e) {
- throw RuntimeCamelException.wrapRuntimeException(e);
- }
- }
if (definition.getDocumentType() == null && definition.getDocumentTypeName() != null) {
try {
Class<?> clazz = camelContext.getClassResolver().resolveMandatoryClass(definition.getDocumentTypeName());
diff --git a/core/camel-core/src/test/java/org/apache/camel/language/XPathTest.java b/core/camel-core/src/test/java/org/apache/camel/language/XPathTest.java
index 3b2ee7f..e07322d 100644
--- a/core/camel-core/src/test/java/org/apache/camel/language/XPathTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/language/XPathTest.java
@@ -56,8 +56,8 @@ public class XPathTest extends LanguageTestSupport {
@Override
protected Language assertResolveLanguage(String languageName) {
XPathLanguage answer = new XPathLanguage();
- answer.setResultType(XPathConstants.STRING);
- assertEquals(XPathConstants.STRING, answer.getResultType());
+ answer.setResultQName(XPathConstants.STRING);
+ assertEquals(XPathConstants.STRING, answer.getResultQName());
return answer;
}
}
[camel] 03/14: CAMEL-15605: Languages should be singleton for
better performance.
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 3f0349f79be94141afacb4edfd44a25b7deb2296
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Thu Oct 1 17:06:04 2020 +0200
CAMEL-15605: Languages should be singleton for better performance.
---
.../language/TokenizerExpressionReifier.java | 41 ++++++-----
.../language/XMLTokenizerExpressionReifier.java | 37 +++++++---
.../camel/language/tokenizer/TokenizeLanguage.java | 82 +++++++---------------
.../apache/camel/language/LanguageServiceTest.java | 18 -----
.../org/apache/camel/language/TokenizerTest.java | 4 +-
.../org/apache/camel/support/CustomizersTest.java | 8 ++-
.../support/PredicateToExpressionAdapter.java | 3 +
.../language/xtokenizer/XMLTokenizeLanguage.java | 21 ++++--
8 files changed, 103 insertions(+), 111 deletions(-)
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/TokenizerExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/TokenizerExpressionReifier.java
index 0f12413..02576d4 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/TokenizerExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/TokenizerExpressionReifier.java
@@ -29,32 +29,29 @@ import org.apache.camel.support.ExpressionToPredicateAdapter;
public class TokenizerExpressionReifier extends ExpressionReifier<TokenizerExpression> {
- // TODO: Update me
-
public TokenizerExpressionReifier(CamelContext camelContext, ExpressionDefinition definition) {
super(camelContext, (TokenizerExpression) definition);
}
- @Override
- protected void configureLanguage(Language language) {
- Map<String, Object> props = new HashMap<>();
+ protected Map<String, Object> createProperties() {
+ Map<String, Object> properties = new HashMap<>(10);
// special for new line tokens, if defined from XML then its 2
// characters, so we replace that back to a single char
String token = definition.getToken();
if (token.startsWith("\\n")) {
token = '\n' + token.substring(2);
}
- props.put("token", token);
- props.put("endToken", definition.getEndToken());
- props.put("inheritNamespaceTagName", definition.getInheritNamespaceTagName());
- props.put("headerName", definition.getHeaderName());
- props.put("groupDelimiter", definition.getGroupDelimiter());
- props.put("regex", definition.getRegex());
- props.put("xml", definition.getXml());
- props.put("includeTokens", definition.getIncludeTokens());
- props.put("group", definition.getGroup());
- props.put("skipFirst", definition.getSkipFirst());
- setProperties(language, props);
+ properties.put("token", token);
+ properties.put("endToken", definition.getEndToken());
+ properties.put("inheritNamespaceTagName", definition.getInheritNamespaceTagName());
+ properties.put("headerName", definition.getHeaderName());
+ properties.put("groupDelimiter", definition.getGroupDelimiter());
+ properties.put("regex", definition.getRegex());
+ properties.put("xml", definition.getXml());
+ properties.put("includeTokens", definition.getIncludeTokens());
+ properties.put("group", definition.getGroup());
+ properties.put("skipFirst", definition.getSkipFirst());
+ return properties;
}
@Override
@@ -63,4 +60,16 @@ public class TokenizerExpressionReifier extends ExpressionReifier<TokenizerExpre
return ExpressionToPredicateAdapter.toPredicate(exp);
}
+ @Override
+ protected Expression createExpression(Language language, String exp) {
+ // method call does not use the string exp so its not in use
+ return language.createExpression(createProperties());
+ }
+
+ @Override
+ protected Predicate createPredicate(Language language, String exp) {
+ // method call does not use the string exp so its not in use
+ return language.createPredicate(createProperties());
+ }
+
}
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XMLTokenizerExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XMLTokenizerExpressionReifier.java
index aac9085..331a075 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XMLTokenizerExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XMLTokenizerExpressionReifier.java
@@ -24,28 +24,42 @@ import org.apache.camel.Expression;
import org.apache.camel.Predicate;
import org.apache.camel.model.language.ExpressionDefinition;
import org.apache.camel.model.language.XMLTokenizerExpression;
+import org.apache.camel.spi.Language;
import org.apache.camel.spi.NamespaceAware;
+import org.apache.camel.support.ExpressionToPredicateAdapter;
public class XMLTokenizerExpressionReifier extends ExpressionReifier<XMLTokenizerExpression> {
- // TODO: Update me
-
public XMLTokenizerExpressionReifier(CamelContext camelContext, ExpressionDefinition definition) {
super(camelContext, (XMLTokenizerExpression) definition);
}
@Override
- protected void configureExpression(Expression expression) {
- bindProperties(expression);
- configureNamespaceAware(expression);
- super.configureExpression(expression);
+ public Predicate createPredicate() {
+ Expression exp = createExpression();
+ return ExpressionToPredicateAdapter.toPredicate(exp);
+ }
+
+ @Override
+ protected Expression createExpression(Language language, String exp) {
+ // method call does not use the string exp so its not in use
+ return language.createExpression(createProperties());
+ }
+
+ @Override
+ protected Predicate createPredicate(Language language, String exp) {
+ // method call does not use the string exp so its not in use
+ return language.createPredicate(createProperties());
}
@Override
protected void configurePredicate(Predicate predicate) {
- bindProperties(predicate);
configureNamespaceAware(predicate);
- super.configurePredicate(predicate);
+ }
+
+ @Override
+ protected void configureExpression(Expression expression) {
+ configureNamespaceAware(expression);
}
protected void configureNamespaceAware(Object builder) {
@@ -55,12 +69,13 @@ public class XMLTokenizerExpressionReifier extends ExpressionReifier<XMLTokenize
}
}
- protected void bindProperties(Object target) {
- Map<String, Object> properties = new HashMap<>();
+ protected Map<String, Object> createProperties() {
+ Map<String, Object> properties = new HashMap<>(3);
properties.put("headerName", definition.getHeaderName());
properties.put("mode", definition.getMode());
properties.put("group", definition.getGroup());
- setProperties(target, properties);
+ properties.put("path", definition.getExpression());
+ return properties;
}
}
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/tokenizer/TokenizeLanguage.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/tokenizer/TokenizeLanguage.java
index 20df970..aa087ae 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/tokenizer/TokenizeLanguage.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/tokenizer/TokenizeLanguage.java
@@ -16,15 +16,13 @@
*/
package org.apache.camel.language.tokenizer;
-import org.apache.camel.CamelContext;
+import java.util.Map;
+
import org.apache.camel.Expression;
-import org.apache.camel.IsSingleton;
import org.apache.camel.Predicate;
-import org.apache.camel.spi.Language;
-import org.apache.camel.spi.PropertyConfigurer;
import org.apache.camel.support.ExpressionToPredicateAdapter;
+import org.apache.camel.support.LanguageSupport;
import org.apache.camel.support.builder.ExpressionBuilder;
-import org.apache.camel.support.component.PropertyConfigurerSupport;
import org.apache.camel.util.ObjectHelper;
/**
@@ -40,7 +38,7 @@ import org.apache.camel.util.ObjectHelper;
* <tt>token</tt> and <tt>endToken</tt>. And the <tt>xml</tt> mode supports the <tt>inheritNamespaceTagName</tt> option.
*/
@org.apache.camel.spi.annotations.Language("tokenize")
-public class TokenizeLanguage implements Language, IsSingleton, PropertyConfigurer {
+public class TokenizeLanguage extends LanguageSupport {
private String token;
private String endToken;
@@ -93,53 +91,6 @@ public class TokenizeLanguage implements Language, IsSingleton, PropertyConfigur
}
@Override
- public boolean configure(CamelContext camelContext, Object target, String name, Object value, boolean ignoreCase) {
- if (target != this) {
- throw new IllegalStateException("Can only configure our own instance !");
- }
- switch (ignoreCase ? name.toLowerCase() : name) {
- case "token":
- setToken(PropertyConfigurerSupport.property(camelContext, String.class, value));
- return true;
- case "endtoken":
- case "endToken":
- setEndToken(PropertyConfigurerSupport.property(camelContext, String.class, value));
- return true;
- case "inheritnamespacetagname":
- case "inheritNamespaceTagName":
- setInheritNamespaceTagName(PropertyConfigurerSupport.property(camelContext, String.class, value));
- return true;
- case "headername":
- case "headerName":
- setHeaderName(PropertyConfigurerSupport.property(camelContext, String.class, value));
- return true;
- case "regex":
- setRegex(PropertyConfigurerSupport.property(camelContext, Boolean.class, value));
- return true;
- case "xml":
- setXml(PropertyConfigurerSupport.property(camelContext, Boolean.class, value));
- return true;
- case "includetokens":
- case "includeTokens":
- setIncludeTokens(PropertyConfigurerSupport.property(camelContext, Boolean.class, value));
- return true;
- case "group":
- setGroup(PropertyConfigurerSupport.property(camelContext, String.class, value));
- return true;
- case "groupdelimiter":
- case "groupDelimiter":
- setGroupDelimiter(PropertyConfigurerSupport.property(camelContext, String.class, value));
- return true;
- case "skipfirst":
- case "skipFirst":
- setSkipFirst(PropertyConfigurerSupport.property(camelContext, Boolean.class, value));
- return true;
- default:
- return false;
- }
- }
-
- @Override
public Predicate createPredicate(String expression) {
return ExpressionToPredicateAdapter.toPredicate(createExpression(expression));
}
@@ -201,6 +152,27 @@ public class TokenizeLanguage implements Language, IsSingleton, PropertyConfigur
return createExpression();
}
+ @Override
+ public Predicate createPredicate(Map<String, Object> properties) {
+ return ExpressionToPredicateAdapter.toPredicate(createExpression(properties));
+ }
+
+ @Override
+ public Expression createExpression(Map<String, Object> properties) {
+ TokenizeLanguage answer = new TokenizeLanguage();
+ answer.setInheritNamespaceTagName(property(String.class, properties, "inheritNamespaceTagName", null));
+ answer.setToken(property(String.class, properties, "token", null));
+ answer.setEndToken(property(String.class, properties, "endToken", null));
+ answer.setHeaderName(property(String.class, properties, "headerName", null));
+ answer.setRegex(property(boolean.class, properties, "regex", false));
+ answer.setXml(property(boolean.class, properties, "xml", false));
+ answer.setIncludeTokens(property(boolean.class, properties, "includeTokens", false));
+ answer.setGroup(property(String.class, properties, "group", null));
+ answer.setGroupDelimiter(property(String.class, properties, "groupDelimiter", null));
+ answer.setSkipFirst(property(boolean.class, properties, "skipFirst", false));
+ return answer.createExpression();
+ }
+
public String getToken() {
return token;
}
@@ -281,8 +253,4 @@ public class TokenizeLanguage implements Language, IsSingleton, PropertyConfigur
this.skipFirst = skipFirst;
}
- @Override
- public boolean isSingleton() {
- return false;
- }
}
diff --git a/core/camel-core/src/test/java/org/apache/camel/language/LanguageServiceTest.java b/core/camel-core/src/test/java/org/apache/camel/language/LanguageServiceTest.java
index 6eb339a..fe5d3d0 100644
--- a/core/camel-core/src/test/java/org/apache/camel/language/LanguageServiceTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/language/LanguageServiceTest.java
@@ -61,24 +61,6 @@ public class LanguageServiceTest extends ContextTestSupport {
assertTrue(context.getLanguageNames().isEmpty());
}
- @Test
- public void testNonSingletonLanguage() throws Exception {
- Language tol = context.resolveLanguage("tokenize");
- assertNotNull(tol);
- // simple language is resolved by default hence why there is 2
- assertEquals(2, context.getLanguageNames().size());
-
- // resolve again, should find another instance
- Language tol2 = context.resolveLanguage("tokenize");
- assertNotNull(tol2);
- assertNotSame(tol, tol2);
- // simple language is resolved by default hence why there is 2
- assertEquals(2, context.getLanguageNames().size());
-
- context.stop();
- assertTrue(context.getLanguageNames().isEmpty());
- }
-
public class MyLanguage extends ServiceSupport implements Language, IsSingleton {
private String state;
diff --git a/core/camel-core/src/test/java/org/apache/camel/language/TokenizerTest.java b/core/camel-core/src/test/java/org/apache/camel/language/TokenizerTest.java
index 3931b72..40debe8 100644
--- a/core/camel-core/src/test/java/org/apache/camel/language/TokenizerTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/language/TokenizerTest.java
@@ -37,7 +37,7 @@ public class TokenizerTest extends ExchangeTestSupport {
}
@Test
- public void testTokenizeHeaderWithStringContructor() throws Exception {
+ public void testTokenizeHeaderWithStringConstructor() throws Exception {
TokenizerExpression definition = new TokenizerExpression(",");
definition.setHeaderName("names");
@@ -119,7 +119,7 @@ public class TokenizerTest extends ExchangeTestSupport {
assertEquals("names", lan.getHeaderName());
assertEquals(",", lan.getToken());
assertEquals(false, lan.isRegex());
- assertEquals(false, lan.isSingleton());
+ assertEquals(true, lan.isSingleton());
}
@Test
diff --git a/core/camel-core/src/test/java/org/apache/camel/support/CustomizersTest.java b/core/camel-core/src/test/java/org/apache/camel/support/CustomizersTest.java
index 151f67d..d978540 100644
--- a/core/camel-core/src/test/java/org/apache/camel/support/CustomizersTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/support/CustomizersTest.java
@@ -351,15 +351,16 @@ public class CustomizersTest {
"tokenize-customizer",
LanguageCustomizer.forType(TokenizeLanguage.class, target -> target.setGroup("" + counter.incrementAndGet())));
+ // singleton language so its customized once
Language l1 = context.resolveLanguage("tokenize");
assertTrue(l1 instanceof TokenizeLanguage);
assertEquals("1", ((TokenizeLanguage) l1).getGroup());
Language l2 = context.resolveLanguage("tokenize");
assertTrue(l2 instanceof TokenizeLanguage);
- assertEquals("2", ((TokenizeLanguage) l2).getGroup());
+ assertEquals("1", ((TokenizeLanguage) l2).getGroup());
- assertNotSame(l1, l2);
+ assertSame(l1, l2);
}
@Test
@@ -374,6 +375,7 @@ public class CustomizersTest {
"tokenize-customizer",
LanguageCustomizer.forType(TokenizeLanguage.class, target -> target.setGroup("" + counter.incrementAndGet())));
+ // singleton language so its customized once
Language l1 = context.resolveLanguage("tokenize");
assertTrue(l1 instanceof TokenizeLanguage);
assertNull(((TokenizeLanguage) l1).getGroup());
@@ -382,7 +384,7 @@ public class CustomizersTest {
assertTrue(l2 instanceof TokenizeLanguage);
assertNull(((TokenizeLanguage) l2).getGroup());
- assertNotSame(l1, l2);
+ assertSame(l1, l2);
}
@ParameterizedTest
diff --git a/core/camel-support/src/main/java/org/apache/camel/support/PredicateToExpressionAdapter.java b/core/camel-support/src/main/java/org/apache/camel/support/PredicateToExpressionAdapter.java
index 6e6f138..13f8b16 100644
--- a/core/camel-support/src/main/java/org/apache/camel/support/PredicateToExpressionAdapter.java
+++ b/core/camel-support/src/main/java/org/apache/camel/support/PredicateToExpressionAdapter.java
@@ -45,6 +45,9 @@ public final class PredicateToExpressionAdapter implements Expression {
* Converts the given predicate into an {@link org.apache.camel.Expression}
*/
public static Expression toExpression(final Predicate predicate) {
+ if (predicate instanceof Expression) {
+ return (Expression) predicate;
+ }
return new PredicateToExpressionAdapter(predicate);
}
diff --git a/core/camel-xml-jaxp/src/main/java/org/apache/camel/language/xtokenizer/XMLTokenizeLanguage.java b/core/camel-xml-jaxp/src/main/java/org/apache/camel/language/xtokenizer/XMLTokenizeLanguage.java
index 50fbeef..876957a 100644
--- a/core/camel-xml-jaxp/src/main/java/org/apache/camel/language/xtokenizer/XMLTokenizeLanguage.java
+++ b/core/camel-xml-jaxp/src/main/java/org/apache/camel/language/xtokenizer/XMLTokenizeLanguage.java
@@ -16,6 +16,8 @@
*/
package org.apache.camel.language.xtokenizer;
+import java.util.Map;
+
import org.apache.camel.Expression;
import org.apache.camel.Predicate;
import org.apache.camel.spi.annotations.Language;
@@ -87,6 +89,21 @@ public class XMLTokenizeLanguage extends LanguageSupport {
return expr;
}
+ @Override
+ public Predicate createPredicate(Map<String, Object> properties) {
+ return ExpressionToPredicateAdapter.toPredicate(createExpression(properties));
+ }
+
+ @Override
+ public Expression createExpression(Map<String, Object> properties) {
+ XMLTokenizeLanguage answer = new XMLTokenizeLanguage();
+ answer.setHeaderName(property(String.class, properties, "headerName", null));
+ answer.setMode(property(char.class, properties, "mode", 'i'));
+ answer.setGroup(property(int.class, properties, "group", 1));
+ String path = property(String.class, properties, "path", null);
+ return answer.createExpression(path);
+ }
+
public String getHeaderName() {
return headerName;
}
@@ -127,8 +144,4 @@ public class XMLTokenizeLanguage extends LanguageSupport {
this.namespaces = namespaces;
}
- @Override
- public boolean isSingleton() {
- return false;
- }
}
[camel] 12/14: Regen
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit bbeb0c78b916aaf13297239a485e0f032e3b25c3
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Fri Oct 2 07:06:05 2020 +0200
Regen
---
camel-dependencies/pom.xml | 2 +-
.../resources/org/apache/camel/catalog/languages/jsonpath.json | 1 +
.../generated/resources/org/apache/camel/catalog/models/jsonpath.json | 1 +
3 files changed, 3 insertions(+), 1 deletion(-)
diff --git a/camel-dependencies/pom.xml b/camel-dependencies/pom.xml
index 957e021..3b2654e 100644
--- a/camel-dependencies/pom.xml
+++ b/camel-dependencies/pom.xml
@@ -501,7 +501,7 @@
<rome-version>1.15.0</rome-version>
<rxjava-version>1.3.8</rxjava-version>
<rxjava2-version>2.2.19</rxjava2-version>
- <saxon-version>9.9.1-6</saxon-version>
+ <saxon-version>9.9.1-7</saxon-version>
<scala-version>2.11.7</scala-version>
<scribe-version>1.3.7</scribe-version>
<servicemix-specs-version>2.9.0</servicemix-specs-version>
diff --git a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/languages/jsonpath.json b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/languages/jsonpath.json
index a97e759..c5fab68 100644
--- a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/languages/jsonpath.json
+++ b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/languages/jsonpath.json
@@ -23,6 +23,7 @@
"allowEasyPredicate": { "kind": "attribute", "displayName": "Allow Easy Predicate", "required": false, "type": "boolean", "javaType": "java.lang.Boolean", "deprecated": false, "secret": false, "defaultValue": true, "description": "Whether to allow using the easy predicate parser to pre-parse predicates." },
"writeAsString": { "kind": "attribute", "displayName": "Write As String", "required": false, "type": "boolean", "javaType": "java.lang.Boolean", "deprecated": false, "secret": false, "defaultValue": false, "description": "Whether to write the output of each row\/element as a JSON String value instead of a Map\/POJO value." },
"headerName": { "kind": "attribute", "displayName": "Header Name", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "secret": false, "description": "Name of header to use as input, instead of the message body" },
+ "option": { "kind": "attribute", "displayName": "Option", "required": false, "type": "enum", "javaType": "java.lang.String", "enum": [ "ALWAYS_RETURN_LIST", "AS_PATH_LIST", "DEFAULT_PATH_LEAF_TO_NULL", "REQUIRE_PROPERTIES", "SUPPRESS_EXCEPTIONS" ], "deprecated": false, "secret": false, "description": "To configure additional options on json path. Multiple values can be separated by comma." },
"trim": { "kind": "attribute", "displayName": "Trim", "required": false, "type": "boolean", "javaType": "java.lang.Boolean", "deprecated": false, "secret": false, "defaultValue": true, "description": "Whether to trim the value to remove leading and trailing whitespaces and line breaks" },
"id": { "kind": "attribute", "displayName": "Id", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "secret": false, "description": "Sets the id of this node" }
}
diff --git a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/models/jsonpath.json b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/models/jsonpath.json
index 532aef0..d30d808 100644
--- a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/models/jsonpath.json
+++ b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/models/jsonpath.json
@@ -19,6 +19,7 @@
"allowEasyPredicate": { "kind": "attribute", "displayName": "Allow Easy Predicate", "required": false, "type": "boolean", "javaType": "java.lang.Boolean", "deprecated": false, "secret": false, "defaultValue": true, "description": "Whether to allow using the easy predicate parser to pre-parse predicates." },
"writeAsString": { "kind": "attribute", "displayName": "Write As String", "required": false, "type": "boolean", "javaType": "java.lang.Boolean", "deprecated": false, "secret": false, "defaultValue": false, "description": "Whether to write the output of each row\/element as a JSON String value instead of a Map\/POJO value." },
"headerName": { "kind": "attribute", "displayName": "Header Name", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "secret": false, "description": "Name of header to use as input, instead of the message body" },
+ "option": { "kind": "attribute", "displayName": "Option", "required": false, "type": "enum", "javaType": "java.lang.String", "enum": [ "ALWAYS_RETURN_LIST", "AS_PATH_LIST", "DEFAULT_PATH_LEAF_TO_NULL", "REQUIRE_PROPERTIES", "SUPPRESS_EXCEPTIONS" ], "deprecated": false, "secret": false, "description": "To configure additional options on json path. Multiple values can be separated by comma." },
"trim": { "kind": "attribute", "displayName": "Trim", "required": false, "type": "boolean", "javaType": "java.lang.Boolean", "deprecated": false, "secret": false, "defaultValue": true, "description": "Whether to trim the value to remove leading and trailing whitespaces and line breaks" },
"id": { "kind": "attribute", "displayName": "Id", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "secret": false, "description": "Sets the id of this node" }
}
[camel] 07/14: CAMEL-15605: Languages should be singleton for
better performance.
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit fd8084fed1b904a5205e82b82797d7e6094681e9
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Thu Oct 1 21:19:29 2020 +0200
CAMEL-15605: Languages should be singleton for better performance.
---
.../camel/component/xquery/XQueryBuilder.java | 23 +-------
.../camel/language/xquery/XQueryLanguage.java | 62 +++++++++++++++++++++-
.../reifier/language/XQueryExpressionReifier.java | 43 ++++++++++-----
3 files changed, 92 insertions(+), 36 deletions(-)
diff --git a/components/camel-saxon/src/main/java/org/apache/camel/component/xquery/XQueryBuilder.java b/components/camel-saxon/src/main/java/org/apache/camel/component/xquery/XQueryBuilder.java
index 4c4227c..4803f9e 100644
--- a/components/camel-saxon/src/main/java/org/apache/camel/component/xquery/XQueryBuilder.java
+++ b/components/camel-saxon/src/main/java/org/apache/camel/component/xquery/XQueryBuilder.java
@@ -69,10 +69,8 @@ import org.apache.camel.NoTypeConversionAvailableException;
import org.apache.camel.Predicate;
import org.apache.camel.Processor;
import org.apache.camel.RuntimeExpressionException;
-import org.apache.camel.spi.GeneratedPropertyConfigurer;
import org.apache.camel.spi.NamespaceAware;
import org.apache.camel.support.MessageHelper;
-import org.apache.camel.support.component.PropertyConfigurerSupport;
import org.apache.camel.util.IOHelper;
import org.apache.camel.util.ObjectHelper;
import org.apache.camel.util.xml.BytesSource;
@@ -86,7 +84,7 @@ import org.slf4j.LoggerFactory;
* The XQueryExpression, as you would expect, can be executed repeatedly, as often as you want, in the same or in
* different threads.
*/
-public abstract class XQueryBuilder implements Expression, Predicate, NamespaceAware, Processor, GeneratedPropertyConfigurer {
+public abstract class XQueryBuilder implements Expression, Predicate, NamespaceAware, Processor {
private static final Logger LOG = LoggerFactory.getLogger(XQueryBuilder.class);
private Configuration configuration;
private Map<String, Object> configurationProperties = new HashMap<>();
@@ -104,25 +102,6 @@ public abstract class XQueryBuilder implements Expression, Predicate, NamespaceA
private String headerName;
@Override
- public boolean configure(CamelContext camelContext, Object target, String name, Object value, boolean ignoreCase) {
- if (target != this) {
- throw new IllegalStateException("Can only configure our own instance !");
- }
- switch (ignoreCase ? name.toLowerCase() : name) {
- case "resulttype":
- case "resultType":
- setResultType(PropertyConfigurerSupport.property(camelContext, Class.class, value));
- return true;
- case "headername":
- case "headerName":
- setHeaderName(PropertyConfigurerSupport.property(camelContext, String.class, value));
- return true;
- default:
- return false;
- }
- }
-
- @Override
public String toString() {
return "XQuery[" + expression + "]";
}
diff --git a/components/camel-saxon/src/main/java/org/apache/camel/language/xquery/XQueryLanguage.java b/components/camel-saxon/src/main/java/org/apache/camel/language/xquery/XQueryLanguage.java
index b7e0c12..edf2742 100644
--- a/components/camel-saxon/src/main/java/org/apache/camel/language/xquery/XQueryLanguage.java
+++ b/components/camel-saxon/src/main/java/org/apache/camel/language/xquery/XQueryLanguage.java
@@ -16,6 +16,8 @@
*/
package org.apache.camel.language.xquery;
+import java.util.Map;
+
import org.apache.camel.Expression;
import org.apache.camel.Predicate;
import org.apache.camel.component.xquery.XQueryBuilder;
@@ -25,15 +27,71 @@ import org.apache.camel.support.LanguageSupport;
@Language("xquery")
public class XQueryLanguage extends LanguageSupport {
+ private Class<?> resultType;
+ private String headerName;
+
+ public Class<?> getResultType() {
+ return resultType;
+ }
+
+ public void setResultType(Class<?> resultType) {
+ this.resultType = resultType;
+ }
+
+ public String getHeaderName() {
+ return headerName;
+ }
+
+ public void setHeaderName(String headerName) {
+ this.headerName = headerName;
+ }
+
@Override
public Predicate createPredicate(String expression) {
expression = loadResource(expression);
- return XQueryBuilder.xquery(expression);
+
+ XQueryBuilder builder = XQueryBuilder.xquery(expression);
+ configureBuilder(builder);
+ return builder;
}
@Override
public Expression createExpression(String expression) {
expression = loadResource(expression);
- return XQueryBuilder.xquery(expression);
+
+ XQueryBuilder builder = XQueryBuilder.xquery(expression);
+ configureBuilder(builder);
+ return builder;
+ }
+
+ @Override
+ public Predicate createPredicate(Map<String, Object> properties) {
+ return (Predicate) createExpression(properties);
+ }
+
+ @Override
+ public Expression createExpression(Map<String, Object> properties) {
+ String expression = (String) properties.get("expression");
+ expression = loadResource(expression);
+
+ Class<?> clazz = property(Class.class, properties, "resultType", null);
+ if (clazz != null) {
+ setResultType(clazz);
+ }
+ setHeaderName(property(String.class, properties, "headerName", null));
+
+ XQueryBuilder builder = XQueryBuilder.xquery(expression);
+ configureBuilder(builder);
+ return builder;
}
+
+ protected void configureBuilder(XQueryBuilder builder) {
+ if (resultType != null) {
+ builder.setResultType(resultType);
+ }
+ if (headerName != null) {
+ builder.setHeaderName(headerName);
+ }
+ }
+
}
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XQueryExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XQueryExpressionReifier.java
index 4fb2ee2..0996ce1 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XQueryExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XQueryExpressionReifier.java
@@ -22,30 +22,36 @@ import java.util.Map;
import org.apache.camel.CamelContext;
import org.apache.camel.Expression;
import org.apache.camel.Predicate;
+import org.apache.camel.RuntimeCamelException;
import org.apache.camel.model.language.ExpressionDefinition;
import org.apache.camel.model.language.XQueryExpression;
+import org.apache.camel.spi.Language;
import org.apache.camel.spi.NamespaceAware;
public class XQueryExpressionReifier extends ExpressionReifier<XQueryExpression> {
- // TODO: Update me
-
public XQueryExpressionReifier(CamelContext camelContext, ExpressionDefinition definition) {
super(camelContext, (XQueryExpression) definition);
}
@Override
- protected void configureExpression(Expression expression) {
- bindProperties(expression);
- configureNamespaceAware(expression);
- super.configureExpression(expression);
+ protected Expression createExpression(Language language, String exp) {
+ return language.createExpression(createProperties(exp));
+ }
+
+ @Override
+ protected Predicate createPredicate(Language language, String exp) {
+ return language.createPredicate(createProperties(exp));
}
@Override
protected void configurePredicate(Predicate predicate) {
- bindProperties(predicate);
configureNamespaceAware(predicate);
- super.configurePredicate(predicate);
+ }
+
+ @Override
+ protected void configureExpression(Expression expression) {
+ configureNamespaceAware(expression);
}
protected void configureNamespaceAware(Object builder) {
@@ -55,11 +61,24 @@ public class XQueryExpressionReifier extends ExpressionReifier<XQueryExpression>
}
}
- protected void bindProperties(Object target) {
- Map<String, Object> properties = new HashMap<>();
- properties.put("resultType", or(definition.getResultType(), definition.getType()));
+ protected Map<String, Object> createProperties(String expression) {
+ Map<String, Object> properties = new HashMap<>(3);
+ properties.put("expression", expression);
+ properties.put("resultType", definition.getResultType());
properties.put("headerName", definition.getHeaderName());
- setProperties(target, properties);
+ return properties;
+ }
+
+ @Override
+ protected void configureLanguage(Language language) {
+ if (definition.getResultType() == null && definition.getType() != null) {
+ try {
+ Class<?> clazz = camelContext.getClassResolver().resolveMandatoryClass(definition.getType());
+ definition.setResultType(clazz);
+ } catch (ClassNotFoundException e) {
+ throw RuntimeCamelException.wrapRuntimeException(e);
+ }
+ }
}
}
[camel] 05/14: CAMEL-15605: Languages should be singleton for
better performance.
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 70f16b82295de1eb6880f10ac4daacbe64e2ba57
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Thu Oct 1 18:33:31 2020 +0200
CAMEL-15605: Languages should be singleton for better performance.
---
.../apache/camel/language/xpath/XPathBuilder.java | 47 +---------------
.../apache/camel/language/xpath/XPathLanguage.java | 57 ++++++++++++++++----
.../reifier/language/XPathExpressionReifier.java | 62 +++++++++++++++++-----
3 files changed, 97 insertions(+), 69 deletions(-)
diff --git a/components/camel-xpath/src/main/java/org/apache/camel/language/xpath/XPathBuilder.java b/components/camel-xpath/src/main/java/org/apache/camel/language/xpath/XPathBuilder.java
index a2f4531..42e2ee3 100644
--- a/components/camel-xpath/src/main/java/org/apache/camel/language/xpath/XPathBuilder.java
+++ b/components/camel-xpath/src/main/java/org/apache/camel/language/xpath/XPathBuilder.java
@@ -57,7 +57,6 @@ import org.apache.camel.RuntimeCamelException;
import org.apache.camel.RuntimeExpressionException;
import org.apache.camel.WrappedFile;
import org.apache.camel.spi.ExpressionResultTypeAware;
-import org.apache.camel.spi.GeneratedPropertyConfigurer;
import org.apache.camel.spi.Language;
import org.apache.camel.spi.NamespaceAware;
import org.apache.camel.support.DefaultExchange;
@@ -65,7 +64,6 @@ import org.apache.camel.support.ExchangeHelper;
import org.apache.camel.support.MessageHelper;
import org.apache.camel.support.builder.Namespaces;
import org.apache.camel.support.builder.xml.XMLConverterHelper;
-import org.apache.camel.support.component.PropertyConfigurerSupport;
import org.apache.camel.support.service.ServiceSupport;
import org.apache.camel.util.IOHelper;
import org.apache.camel.util.ObjectHelper;
@@ -96,7 +94,7 @@ import static org.apache.camel.support.builder.Namespaces.isMatchingNamespaceOrE
*/
public class XPathBuilder extends ServiceSupport
implements CamelContextAware, Expression, Predicate,
- NamespaceAware, ExpressionResultTypeAware, GeneratedPropertyConfigurer {
+ NamespaceAware, ExpressionResultTypeAware {
private static final Logger LOG = LoggerFactory.getLogger(XPathBuilder.class);
private static final String SAXON_OBJECT_MODEL_URI = "http://saxon.sf.net/jaxp/xpath/om";
private static final String SAXON_FACTORY_CLASS_NAME = "net.sf.saxon.xpath.XPathFactoryImpl";
@@ -171,49 +169,6 @@ public class XPathBuilder extends ServiceSupport
}
@Override
- public boolean configure(CamelContext camelContext, Object target, String name, Object value, boolean ignoreCase) {
- if (target != this) {
- throw new IllegalStateException("Can only configure our own instance !");
- }
- switch (ignoreCase ? name.toLowerCase() : name) {
- case "documenttype":
- case "documentType":
- setDocumentType(PropertyConfigurerSupport.property(camelContext, Class.class, value));
- return true;
- case "resulttype":
- case "resultType":
- setResultType(PropertyConfigurerSupport.property(camelContext, Class.class, value));
- return true;
- case "usesaxon":
- case "useSaxon":
- setUseSaxon(PropertyConfigurerSupport.property(camelContext, Boolean.class, value));
- return true;
- case "xpathfactory":
- case "xPathFactory":
- setXPathFactory(PropertyConfigurerSupport.property(camelContext, XPathFactory.class, value));
- return true;
- case "objectmodeluri":
- case "objectModelUri":
- setObjectModelUri(PropertyConfigurerSupport.property(camelContext, String.class, value));
- return true;
- case "threadsafety":
- case "threadSafety":
- setThreadSafety(PropertyConfigurerSupport.property(camelContext, Boolean.class, value));
- return true;
- case "lognamespaces":
- case "logNamespaces":
- setLogNamespaces(PropertyConfigurerSupport.property(camelContext, Boolean.class, value));
- return true;
- case "headername":
- case "headerName":
- setHeaderName(PropertyConfigurerSupport.property(camelContext, String.class, value));
- return true;
- default:
- return false;
- }
- }
-
- @Override
public String toString() {
return "XPath: " + text;
}
diff --git a/components/camel-xpath/src/main/java/org/apache/camel/language/xpath/XPathLanguage.java b/components/camel-xpath/src/main/java/org/apache/camel/language/xpath/XPathLanguage.java
index f035027..fd90f94 100644
--- a/components/camel-xpath/src/main/java/org/apache/camel/language/xpath/XPathLanguage.java
+++ b/components/camel-xpath/src/main/java/org/apache/camel/language/xpath/XPathLanguage.java
@@ -16,7 +16,8 @@
*/
package org.apache.camel.language.xpath;
-import javax.xml.namespace.QName;
+import java.util.Map;
+
import javax.xml.xpath.XPathFactory;
import org.apache.camel.Expression;
@@ -29,7 +30,8 @@ import org.apache.camel.support.LanguageSupport;
*/
@Language("xpath")
public class XPathLanguage extends LanguageSupport {
- private QName resultType;
+ private Class<?> resultType;
+ private Class<?> documentType;
private XPathFactory xpathFactory;
private Boolean useSaxon;
private String objectModelUri;
@@ -55,14 +57,52 @@ public class XPathLanguage extends LanguageSupport {
return builder;
}
- public QName getResultType() {
+ @Override
+ public Predicate createPredicate(Map<String, Object> properties) {
+ return (Predicate) createExpression(properties);
+ }
+
+ @Override
+ public Expression createExpression(Map<String, Object> properties) {
+ String expression = (String) properties.get("expression");
+ expression = loadResource(expression);
+
+ Class<?> clazz = property(Class.class, properties, "documentType", null);
+ if (clazz != null) {
+ setDocumentType(clazz);
+ }
+ clazz = property(Class.class, properties, "resultType", null);
+ if (clazz != null) {
+ setResultType(clazz);
+ }
+ setUseSaxon(property(Boolean.class, properties, "useSaxon", null));
+ setObjectModelUri(property(String.class, properties, "objectModelUri", null));
+ setThreadSafety(property(Boolean.class, properties, "threadSafety", null));
+ setLogNamespaces(property(Boolean.class, properties, "logNamespaces", null));
+ setHeaderName(property(String.class, properties, "headerName", null));
+ setXpathFactory(property(XPathFactory.class, properties, "xpathFactory", null));
+
+ XPathBuilder builder = XPathBuilder.xpath(expression);
+ configureBuilder(builder);
+ return builder;
+ }
+
+ public Class<?> getResultType() {
return resultType;
}
- public void setResultType(QName resultType) {
+ public void setResultType(Class<?> resultType) {
this.resultType = resultType;
}
+ public Class<?> getDocumentType() {
+ return documentType;
+ }
+
+ public void setDocumentType(Class<?> documentType) {
+ this.documentType = documentType;
+ }
+
public XPathFactory getXpathFactory() {
return xpathFactory;
}
@@ -120,7 +160,7 @@ public class XPathLanguage extends LanguageSupport {
builder.setThreadSafety(threadSafety);
}
if (resultType != null) {
- builder.setResultQName(resultType);
+ builder.setResultType(resultType);
}
if (logNamespaces != null) {
builder.setLogNamespaces(logNamespaces);
@@ -128,6 +168,9 @@ public class XPathLanguage extends LanguageSupport {
if (headerName != null) {
builder.setHeaderName(headerName);
}
+ if (documentType != null) {
+ builder.setDocumentType(documentType);
+ }
if (isUseSaxon()) {
builder.enableSaxon();
@@ -141,8 +184,4 @@ public class XPathLanguage extends LanguageSupport {
}
}
- @Override
- public boolean isSingleton() {
- return false;
- }
}
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java
index a34af0f..c49f1f0 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java
@@ -19,33 +19,42 @@ package org.apache.camel.reifier.language;
import java.util.HashMap;
import java.util.Map;
+import javax.xml.xpath.XPathFactory;
+
import org.apache.camel.CamelContext;
import org.apache.camel.Expression;
import org.apache.camel.Predicate;
+import org.apache.camel.RuntimeCamelException;
import org.apache.camel.model.language.ExpressionDefinition;
import org.apache.camel.model.language.XPathExpression;
+import org.apache.camel.spi.Language;
import org.apache.camel.spi.NamespaceAware;
+import org.apache.camel.support.CamelContextHelper;
public class XPathExpressionReifier extends ExpressionReifier<XPathExpression> {
- // TODO: Update me
-
public XPathExpressionReifier(CamelContext camelContext, ExpressionDefinition definition) {
super(camelContext, (XPathExpression) definition);
}
@Override
- protected void configureExpression(Expression expression) {
- bindProperties(expression);
- configureNamespaceAware(expression);
- super.configureExpression(expression);
+ protected Expression createExpression(Language language, String exp) {
+ return language.createExpression(createProperties(exp));
+ }
+
+ @Override
+ protected Predicate createPredicate(Language language, String exp) {
+ return language.createPredicate(createProperties(exp));
}
@Override
protected void configurePredicate(Predicate predicate) {
- bindProperties(predicate);
configureNamespaceAware(predicate);
- super.configurePredicate(predicate);
+ }
+
+ @Override
+ protected void configureExpression(Expression expression) {
+ configureNamespaceAware(expression);
}
protected void configureNamespaceAware(Object builder) {
@@ -55,17 +64,42 @@ public class XPathExpressionReifier extends ExpressionReifier<XPathExpression> {
}
}
- protected void bindProperties(Object target) {
- Map<String, Object> properties = new HashMap<>();
- properties.put("documentType", or(definition.getDocumentType(), definition.getDocumentTypeName()));
- properties.put("resultType", or(definition.getResultType(), definition.getResultTypeName()));
+ protected Map<String, Object> createProperties(String expression) {
+ Map<String, Object> properties = new HashMap<>(9);
+ properties.put("expression", expression);
+ properties.put("documentType", definition.getDocumentType());
+ properties.put("resultType", definition.getResultType());
properties.put("useSaxon", definition.getSaxon());
- properties.put("xPathFactory", or(definition.getXPathFactory(), asRef(definition.getFactoryRef())));
+ properties.put("xPathFactory", definition.getXPathFactory());
properties.put("objectModelUri", definition.getObjectModel());
properties.put("threadSafety", definition.getThreadSafety());
properties.put("logNamespaces", definition.getLogNamespaces());
properties.put("headerName", definition.getHeaderName());
- setProperties(target, properties);
+ return properties;
+ }
+
+ @Override
+ protected void configureLanguage(Language language) {
+ if (definition.getResultType() == null && definition.getResultTypeName() != null) {
+ try {
+ Class<?> clazz = camelContext.getClassResolver().resolveMandatoryClass(definition.getResultTypeName());
+ definition.setResultType(clazz);
+ } catch (ClassNotFoundException e) {
+ throw RuntimeCamelException.wrapRuntimeException(e);
+ }
+ }
+ if (definition.getDocumentType() == null && definition.getDocumentTypeName() != null) {
+ try {
+ Class<?> clazz = camelContext.getClassResolver().resolveMandatoryClass(definition.getDocumentTypeName());
+ definition.setDocumentType(clazz);
+ } catch (ClassNotFoundException e) {
+ throw RuntimeCamelException.wrapRuntimeException(e);
+ }
+ }
+ if (definition.getXPathFactory() == null && definition.getFactoryRef() != null) {
+ definition.setXPathFactory(
+ CamelContextHelper.mandatoryLookupAndConvert(camelContext, definition.getFactoryRef(), XPathFactory.class));
+ }
}
}
[camel] 14/14: Flaky test
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 26efb9f2fe5d5b9c5037559506693e9dbc56ead5
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Fri Oct 2 10:49:09 2020 +0200
Flaky test
---
.../camel/spring/management/SpringManagedCustomProcessorTest.java | 2 ++
1 file changed, 2 insertions(+)
diff --git a/components/camel-spring/src/test/java/org/apache/camel/spring/management/SpringManagedCustomProcessorTest.java b/components/camel-spring/src/test/java/org/apache/camel/spring/management/SpringManagedCustomProcessorTest.java
index 98ec905..1737572 100644
--- a/components/camel-spring/src/test/java/org/apache/camel/spring/management/SpringManagedCustomProcessorTest.java
+++ b/components/camel-spring/src/test/java/org/apache/camel/spring/management/SpringManagedCustomProcessorTest.java
@@ -23,6 +23,7 @@ import javax.management.ObjectName;
import org.apache.camel.Exchange;
import org.apache.camel.Processor;
import org.apache.camel.spring.SpringTestSupport;
+import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.springframework.context.support.AbstractXmlApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
@@ -31,6 +32,7 @@ import org.springframework.jmx.export.annotation.ManagedResource;
import static org.junit.jupiter.api.Assertions.assertEquals;
+@Disabled("Flaky test")
public class SpringManagedCustomProcessorTest extends SpringTestSupport {
@Override
[camel] 10/14: CAMEL-15605: Languages should be singleton for
better performance.
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 376bc05a27a8702a2cee804966c5b5e6057f1872
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Thu Oct 1 22:15:51 2020 +0200
CAMEL-15605: Languages should be singleton for better performance.
---
.../apache/camel/jsonpath/JsonPathExpression.java | 1 -
.../org/apache/camel/jsonpath/JsonPathLanguage.java | 12 ++++++------
.../camel/language/xquery/XQueryLanguage.java | 2 +-
.../apache/camel/language/xpath/XPathLanguage.java | 12 ++++++------
.../camel/language/tokenizer/TokenizeLanguage.java | 21 +++++++++++----------
.../language/xtokenizer/XMLTokenizeLanguage.java | 10 +++++-----
6 files changed, 29 insertions(+), 29 deletions(-)
diff --git a/components/camel-jsonpath/src/main/java/org/apache/camel/jsonpath/JsonPathExpression.java b/components/camel-jsonpath/src/main/java/org/apache/camel/jsonpath/JsonPathExpression.java
index 7dfb850..e3b7230 100644
--- a/components/camel-jsonpath/src/main/java/org/apache/camel/jsonpath/JsonPathExpression.java
+++ b/components/camel-jsonpath/src/main/java/org/apache/camel/jsonpath/JsonPathExpression.java
@@ -44,7 +44,6 @@ public class JsonPathExpression extends ExpressionAdapter implements AfterProper
private boolean allowEasyPredicate = true;
private boolean writeAsString;
private String headerName;
- private String option;
private Option[] options;
public JsonPathExpression(String expression) {
diff --git a/components/camel-jsonpath/src/main/java/org/apache/camel/jsonpath/JsonPathLanguage.java b/components/camel-jsonpath/src/main/java/org/apache/camel/jsonpath/JsonPathLanguage.java
index e04bb94..58d8f52 100644
--- a/components/camel-jsonpath/src/main/java/org/apache/camel/jsonpath/JsonPathLanguage.java
+++ b/components/camel-jsonpath/src/main/java/org/apache/camel/jsonpath/JsonPathLanguage.java
@@ -126,12 +126,12 @@ public class JsonPathLanguage extends LanguageSupport {
public Expression createExpression(Map<String, Object> properties) {
String exp = (String) properties.get("expression");
JsonPathExpression answer = new JsonPathExpression(exp);
- answer.setResultType(property(Class.class, properties, "resultType", null));
- answer.setSuppressExceptions(property(boolean.class, properties, "suppressExceptions", true));
- answer.setAllowEasyPredicate(property(boolean.class, properties, "allowEasyPredicate", true));
- answer.setAllowSimple(property(boolean.class, properties, "allowSimple", true));
- answer.setWriteAsString(property(boolean.class, properties, "writeAsString", false));
- answer.setHeaderName(property(String.class, properties, "headerName", null));
+ answer.setResultType(property(Class.class, properties, "resultType", resultType));
+ answer.setSuppressExceptions(property(boolean.class, properties, "suppressExceptions", suppressExceptions));
+ answer.setAllowEasyPredicate(property(boolean.class, properties, "allowEasyPredicate", allowEasyPredicate));
+ answer.setAllowSimple(property(boolean.class, properties, "allowSimple", allowSimple));
+ answer.setWriteAsString(property(boolean.class, properties, "writeAsString", writeAsString));
+ answer.setHeaderName(property(String.class, properties, "headerName", headerName));
String option = (String) properties.get("option");
if (option != null) {
List<Option> list = new ArrayList<>();
diff --git a/components/camel-saxon/src/main/java/org/apache/camel/language/xquery/XQueryLanguage.java b/components/camel-saxon/src/main/java/org/apache/camel/language/xquery/XQueryLanguage.java
index edf2742..520f7b3 100644
--- a/components/camel-saxon/src/main/java/org/apache/camel/language/xquery/XQueryLanguage.java
+++ b/components/camel-saxon/src/main/java/org/apache/camel/language/xquery/XQueryLanguage.java
@@ -78,7 +78,7 @@ public class XQueryLanguage extends LanguageSupport {
if (clazz != null) {
setResultType(clazz);
}
- setHeaderName(property(String.class, properties, "headerName", null));
+ setHeaderName(property(String.class, properties, "headerName", headerName));
XQueryBuilder builder = XQueryBuilder.xquery(expression);
configureBuilder(builder);
diff --git a/components/camel-xpath/src/main/java/org/apache/camel/language/xpath/XPathLanguage.java b/components/camel-xpath/src/main/java/org/apache/camel/language/xpath/XPathLanguage.java
index 5c6ccd5..6339f1c 100644
--- a/components/camel-xpath/src/main/java/org/apache/camel/language/xpath/XPathLanguage.java
+++ b/components/camel-xpath/src/main/java/org/apache/camel/language/xpath/XPathLanguage.java
@@ -81,12 +81,12 @@ public class XPathLanguage extends LanguageSupport {
if (qname != null) {
setResultQName(qname);
}
- setUseSaxon(property(Boolean.class, properties, "useSaxon", null));
- setObjectModelUri(property(String.class, properties, "objectModelUri", null));
- setThreadSafety(property(Boolean.class, properties, "threadSafety", null));
- setLogNamespaces(property(Boolean.class, properties, "logNamespaces", null));
- setHeaderName(property(String.class, properties, "headerName", null));
- setXpathFactory(property(XPathFactory.class, properties, "xpathFactory", null));
+ setUseSaxon(property(Boolean.class, properties, "useSaxon", useSaxon));
+ setObjectModelUri(property(String.class, properties, "objectModelUri", objectModelUri));
+ setThreadSafety(property(Boolean.class, properties, "threadSafety", threadSafety));
+ setLogNamespaces(property(Boolean.class, properties, "logNamespaces", logNamespaces));
+ setHeaderName(property(String.class, properties, "headerName", headerName));
+ setXpathFactory(property(XPathFactory.class, properties, "xpathFactory", xpathFactory));
XPathBuilder builder = XPathBuilder.xpath(expression);
configureBuilder(builder);
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/tokenizer/TokenizeLanguage.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/tokenizer/TokenizeLanguage.java
index aa087ae..7021f3b 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/tokenizer/TokenizeLanguage.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/tokenizer/TokenizeLanguage.java
@@ -160,16 +160,17 @@ public class TokenizeLanguage extends LanguageSupport {
@Override
public Expression createExpression(Map<String, Object> properties) {
TokenizeLanguage answer = new TokenizeLanguage();
- answer.setInheritNamespaceTagName(property(String.class, properties, "inheritNamespaceTagName", null));
- answer.setToken(property(String.class, properties, "token", null));
- answer.setEndToken(property(String.class, properties, "endToken", null));
- answer.setHeaderName(property(String.class, properties, "headerName", null));
- answer.setRegex(property(boolean.class, properties, "regex", false));
- answer.setXml(property(boolean.class, properties, "xml", false));
- answer.setIncludeTokens(property(boolean.class, properties, "includeTokens", false));
- answer.setGroup(property(String.class, properties, "group", null));
- answer.setGroupDelimiter(property(String.class, properties, "groupDelimiter", null));
- answer.setSkipFirst(property(boolean.class, properties, "skipFirst", false));
+ answer.setInheritNamespaceTagName(
+ property(String.class, properties, "inheritNamespaceTagName", inheritNamespaceTagName));
+ answer.setToken(property(String.class, properties, "token", token));
+ answer.setEndToken(property(String.class, properties, "endToken", endToken));
+ answer.setHeaderName(property(String.class, properties, "headerName", headerName));
+ answer.setRegex(property(boolean.class, properties, "regex", regex));
+ answer.setXml(property(boolean.class, properties, "xml", xml));
+ answer.setIncludeTokens(property(boolean.class, properties, "includeTokens", includeTokens));
+ answer.setGroup(property(String.class, properties, "group", group));
+ answer.setGroupDelimiter(property(String.class, properties, "groupDelimiter", groupDelimiter));
+ answer.setSkipFirst(property(boolean.class, properties, "skipFirst", skipFirst));
return answer.createExpression();
}
diff --git a/core/camel-xml-jaxp/src/main/java/org/apache/camel/language/xtokenizer/XMLTokenizeLanguage.java b/core/camel-xml-jaxp/src/main/java/org/apache/camel/language/xtokenizer/XMLTokenizeLanguage.java
index 876957a..0cd0447 100644
--- a/core/camel-xml-jaxp/src/main/java/org/apache/camel/language/xtokenizer/XMLTokenizeLanguage.java
+++ b/core/camel-xml-jaxp/src/main/java/org/apache/camel/language/xtokenizer/XMLTokenizeLanguage.java
@@ -41,8 +41,8 @@ public class XMLTokenizeLanguage extends LanguageSupport {
private String headerName;
private String path;
- private char mode;
- private int group;
+ private char mode = 'i';
+ private int group = 1;
private Namespaces namespaces;
public static Expression tokenize(String path) {
@@ -97,9 +97,9 @@ public class XMLTokenizeLanguage extends LanguageSupport {
@Override
public Expression createExpression(Map<String, Object> properties) {
XMLTokenizeLanguage answer = new XMLTokenizeLanguage();
- answer.setHeaderName(property(String.class, properties, "headerName", null));
- answer.setMode(property(char.class, properties, "mode", 'i'));
- answer.setGroup(property(int.class, properties, "group", 1));
+ answer.setHeaderName(property(String.class, properties, "headerName", headerName));
+ answer.setMode(property(char.class, properties, "mode", mode));
+ answer.setGroup(property(int.class, properties, "group", group));
String path = property(String.class, properties, "path", null);
return answer.createExpression(path);
}
[camel] 08/14: Upgrade saxon
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit ab08acf14d923aacfc09ff6b823126d83b5b7aa1
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Thu Oct 1 21:19:36 2020 +0200
Upgrade saxon
---
parent/pom.xml | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/parent/pom.xml b/parent/pom.xml
index 073e306..894c7aa 100644
--- a/parent/pom.xml
+++ b/parent/pom.xml
@@ -489,7 +489,7 @@
<rome-version>1.15.0</rome-version>
<rxjava-version>1.3.8</rxjava-version>
<rxjava2-version>2.2.19</rxjava2-version>
- <saxon-version>9.9.1-6</saxon-version>
+ <saxon-version>9.9.1-7</saxon-version>
<scala-version>2.11.7</scala-version>
<scribe-version>1.3.7</scribe-version>
<servicemix-specs-version>2.9.0</servicemix-specs-version>
[camel] 01/14: CAMEL-15605: Languages should be singleton for
better performance.
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit eb06b1f4ba8e65356fb0162cdeb514f0f3f53868
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Thu Oct 1 13:10:52 2020 +0200
CAMEL-15605: Languages should be singleton for better performance.
---
.../apache/camel/language/bean/BeanLanguage.java | 89 +++++-----------------
.../main/java/org/apache/camel/spi/Language.java | 28 +++++++
.../camel/impl/engine/AbstractCamelContext.java | 2 +
.../camel/model/language/MethodCallExpression.java | 6 +-
.../camel/reifier/language/ExpressionReifier.java | 13 +++-
.../language/JsonPathExpressionReifier.java | 2 +
.../language/MethodCallExpressionReifier.java | 30 ++++++--
.../reifier/language/SimpleExpressionReifier.java | 27 +++++--
.../language/TokenizerExpressionReifier.java | 2 +
.../language/XMLTokenizerExpressionReifier.java | 2 +
.../reifier/language/XPathExpressionReifier.java | 2 +
.../reifier/language/XQueryExpressionReifier.java | 2 +
.../camel/language/tokenizer/TokenizeLanguage.java | 8 +-
.../support/ExpressionToPredicateAdapter.java | 3 +
.../camel/support/builder/ExpressionBuilder.java | 14 ++--
15 files changed, 133 insertions(+), 97 deletions(-)
diff --git a/components/camel-bean/src/main/java/org/apache/camel/language/bean/BeanLanguage.java b/components/camel-bean/src/main/java/org/apache/camel/language/bean/BeanLanguage.java
index c85395d..70d6692 100644
--- a/components/camel-bean/src/main/java/org/apache/camel/language/bean/BeanLanguage.java
+++ b/components/camel-bean/src/main/java/org/apache/camel/language/bean/BeanLanguage.java
@@ -16,13 +16,12 @@
*/
package org.apache.camel.language.bean;
-import org.apache.camel.CamelContext;
+import java.util.Map;
+
import org.apache.camel.Expression;
import org.apache.camel.Predicate;
-import org.apache.camel.spi.GeneratedPropertyConfigurer;
import org.apache.camel.support.ExpressionToPredicateAdapter;
import org.apache.camel.support.LanguageSupport;
-import org.apache.camel.support.component.PropertyConfigurerSupport;
import org.apache.camel.util.StringHelper;
/**
@@ -37,88 +36,42 @@ import org.apache.camel.util.StringHelper;
* As of Camel 1.5 the bean language also supports invoking a provided bean by its classname or the bean itself.
*/
@org.apache.camel.spi.annotations.Language("bean")
-public class BeanLanguage extends LanguageSupport implements GeneratedPropertyConfigurer {
-
- private Object bean;
- private Class<?> beanType;
- private String ref;
- private String method;
+public class BeanLanguage extends LanguageSupport {
public BeanLanguage() {
}
@Override
- public boolean configure(CamelContext camelContext, Object target, String name, Object value, boolean ignoreCase) {
- if (target != this) {
- throw new IllegalStateException("Can only configure our own instance !");
- }
- switch (ignoreCase ? name.toLowerCase() : name) {
- case "bean":
- setBean(PropertyConfigurerSupport.property(camelContext, Object.class, value));
- return true;
- case "beantype":
- case "beanType":
- setBeanType(PropertyConfigurerSupport.property(camelContext, Class.class, value));
- return true;
- case "ref":
- setRef(PropertyConfigurerSupport.property(camelContext, String.class, value));
- return true;
- case "method":
- setMethod(PropertyConfigurerSupport.property(camelContext, String.class, value));
- return true;
- default:
- return false;
- }
- }
-
- public Object getBean() {
- return bean;
- }
-
- public void setBean(Object bean) {
- this.bean = bean;
- }
-
- public Class<?> getBeanType() {
- return beanType;
- }
-
- public void setBeanType(Class<?> beanType) {
- this.beanType = beanType;
- }
-
- public String getRef() {
- return ref;
- }
-
- public void setRef(String ref) {
- this.ref = ref;
- }
-
- public String getMethod() {
- return method;
- }
-
- public void setMethod(String method) {
- this.method = method;
+ public Predicate createPredicate(String expression) {
+ return ExpressionToPredicateAdapter.toPredicate(createExpression(expression));
}
@Override
- public Predicate createPredicate(String expression) {
- return ExpressionToPredicateAdapter.toPredicate(createExpression(expression));
+ public Predicate createPredicate(Map<String, Object> properties) {
+ return ExpressionToPredicateAdapter.toPredicate(createExpression(properties));
}
@Override
- public Expression createExpression(String expression) {
- // favour using the configured options
+ public Expression createExpression(Map<String, Object> properties) {
+ Object bean = properties.get("bean");
+ Class<?> beanType = (Class<?>) properties.get("beanType");
+ String ref = (String) properties.get("ref");
+ String method = (String) properties.get("method");
+
if (bean != null) {
return new BeanExpression(bean, method);
} else if (beanType != null) {
return new BeanExpression(beanType, method);
} else if (ref != null) {
return new BeanExpression(ref, method);
+ } else {
+ throw new IllegalArgumentException("Bean language requires bean, beanType, or ref argument");
}
+ }
+ @Override
+ public Expression createExpression(String expression) {
+ // favour using the configured options
String beanName = expression;
String method = null;
@@ -147,8 +100,4 @@ public class BeanLanguage extends LanguageSupport implements GeneratedPropertyCo
return new BeanExpression(beanName, method);
}
- @Override
- public boolean isSingleton() {
- return false;
- }
}
diff --git a/core/camel-api/src/main/java/org/apache/camel/spi/Language.java b/core/camel-api/src/main/java/org/apache/camel/spi/Language.java
index a666d4d5..1376c76 100644
--- a/core/camel-api/src/main/java/org/apache/camel/spi/Language.java
+++ b/core/camel-api/src/main/java/org/apache/camel/spi/Language.java
@@ -16,6 +16,8 @@
*/
package org.apache.camel.spi;
+import java.util.Map;
+
import org.apache.camel.Expression;
import org.apache.camel.Predicate;
@@ -39,4 +41,30 @@ public interface Language {
* @return the created expression
*/
Expression createExpression(String expression);
+
+ /**
+ * Creates an expression based on the given inputs properties
+ *
+ * This is used for languages that have been configured with custom properties
+ * most noticeable for xpath/xquery/tokenizer languages that have several options.
+ *
+ * @param properties arguments
+ * @return the created predicate
+ */
+ default Predicate createPredicate(Map<String, Object> properties) {
+ return null;
+ }
+
+ /**
+ * Creates an expression based on the given inputs properties
+ *
+ * This is used for languages that have been configured with custom properties
+ * most noticeable for xpath/xquery/tokenizer languages that have several options.
+ *
+ * @param properties arguments
+ * @return the created expression
+ */
+ default Expression createExpression(Map<String, Object> properties) {
+ return null;
+ }
}
diff --git a/core/camel-base/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java b/core/camel-base/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
index e80f52f..93c92b5 100644
--- a/core/camel-base/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
+++ b/core/camel-base/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
@@ -1637,6 +1637,8 @@ public abstract class AbstractCamelContext extends BaseService
@Override
public Language resolveLanguage(String language) {
+ LOG.debug("Resolving language: {}", language);
+
Language answer;
synchronized (languages) {
// as first iteration, check if there is a language instance for the given name
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/model/language/MethodCallExpression.java b/core/camel-core-engine/src/main/java/org/apache/camel/model/language/MethodCallExpression.java
index 82870b0..4be866e 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/model/language/MethodCallExpression.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/model/language/MethodCallExpression.java
@@ -51,7 +51,7 @@ public class MethodCallExpression extends ExpressionDefinition {
}
public MethodCallExpression(String beanName, String method) {
- super((String) null); // we dont use @XmlValue but the attributes instead
+ super(""); // we dont use @XmlValue but the attributes instead
if (beanName != null && beanName.startsWith("ref:")) {
beanName = beanName.substring(4);
} else if (beanName != null && beanName.startsWith("bean:")) {
@@ -66,7 +66,7 @@ public class MethodCallExpression extends ExpressionDefinition {
}
public MethodCallExpression(Object instance, String method) {
- super((String) null); // we dont use @XmlValue but the attributes instead
+ super(""); // we dont use @XmlValue but the attributes instead
// must use setter as they have special logic
setInstance(instance);
setMethod(method);
@@ -77,7 +77,7 @@ public class MethodCallExpression extends ExpressionDefinition {
}
public MethodCallExpression(Class<?> type, String method) {
- super((String) null); // we dont use @XmlValue but the attributes instead
+ super(""); // we dont use @XmlValue but the attributes instead
setBeanType(type);
setBeanTypeName(type.getName());
setMethod(method);
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/ExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/ExpressionReifier.java
index 01e7714..526615d 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/ExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/ExpressionReifier.java
@@ -132,7 +132,7 @@ public class ExpressionReifier<T extends ExpressionDefinition> extends AbstractR
// the classpath/file etc
exp = ScriptHelper.resolveOptionalExternalScript(camelContext, exp);
configureLanguage(language);
- expression = language.createExpression(exp);
+ expression = createExpression(language, exp);
configureExpression(expression);
}
}
@@ -168,7 +168,7 @@ public class ExpressionReifier<T extends ExpressionDefinition> extends AbstractR
// the classpath/file etc
exp = ScriptHelper.resolveOptionalExternalScript(camelContext, exp);
configureLanguage(language);
- predicate = language.createPredicate(exp);
+ predicate = createPredicate(language, exp);
configurePredicate(predicate);
}
}
@@ -180,6 +180,14 @@ public class ExpressionReifier<T extends ExpressionDefinition> extends AbstractR
return predicate;
}
+ protected Expression createExpression(Language language, String exp) {
+ return language.createExpression(exp);
+ }
+
+ protected Predicate createPredicate(Language language, String exp) {
+ return language.createPredicate(exp);
+ }
+
protected void configureLanguage(Language language) {
}
@@ -201,6 +209,7 @@ public class ExpressionReifier<T extends ExpressionDefinition> extends AbstractR
}
}
+ @Deprecated
protected void setProperties(Object target, Map<String, Object> properties) {
properties.entrySet().removeIf(e -> e.getValue() == null);
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/JsonPathExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/JsonPathExpressionReifier.java
index 471c0c3..669386d 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/JsonPathExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/JsonPathExpressionReifier.java
@@ -27,6 +27,8 @@ import org.apache.camel.model.language.JsonPathExpression;
public class JsonPathExpressionReifier extends ExpressionReifier<JsonPathExpression> {
+ // TODO: Update me
+
public JsonPathExpressionReifier(CamelContext camelContext, ExpressionDefinition definition) {
super(camelContext, (JsonPathExpression) definition);
}
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/MethodCallExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/MethodCallExpressionReifier.java
index b736416..e6c3b52 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/MethodCallExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/MethodCallExpressionReifier.java
@@ -20,7 +20,9 @@ import java.util.HashMap;
import java.util.Map;
import org.apache.camel.CamelContext;
+import org.apache.camel.Expression;
import org.apache.camel.Predicate;
+import org.apache.camel.RuntimeCamelException;
import org.apache.camel.model.language.ExpressionDefinition;
import org.apache.camel.model.language.MethodCallExpression;
import org.apache.camel.spi.Language;
@@ -31,18 +33,36 @@ public class MethodCallExpressionReifier extends ExpressionReifier<MethodCallExp
super(camelContext, (MethodCallExpression) definition);
}
- protected void configureLanguage(Language language) {
- Map<String, Object> properties = new HashMap<>();
+ protected Map<String, Object> createProperties() {
+ Map<String, Object> properties = new HashMap<>(4);
properties.put("bean", definition.getInstance());
properties.put("beanType", or(definition.getBeanType(), definition.getBeanTypeName()));
properties.put("ref", definition.getRef());
properties.put("method", definition.getMethod());
- setProperties(language, properties);
+ return properties;
}
@Override
- public Predicate createPredicate() {
- return (Predicate) createExpression();
+ protected void configureLanguage(Language language) {
+ if (definition.getBeanType() == null && definition.getBeanTypeName() != null) {
+ try {
+ Class<?> clazz = camelContext.getClassResolver().resolveMandatoryClass(definition.getBeanTypeName());
+ definition.setBeanType(clazz);
+ } catch (ClassNotFoundException e) {
+ throw RuntimeCamelException.wrapRuntimeException(e);
+ }
+ }
}
+ @Override
+ protected Expression createExpression(Language language, String exp) {
+ // method call does not use the string exp so its not in use
+ return language.createExpression(createProperties());
+ }
+
+ @Override
+ protected Predicate createPredicate(Language language, String exp) {
+ // method call does not use the string exp so its not in use
+ return language.createPredicate(createProperties());
+ }
}
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/SimpleExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/SimpleExpressionReifier.java
index f740b3b..2bc0a3b 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/SimpleExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/SimpleExpressionReifier.java
@@ -16,16 +16,15 @@
*/
package org.apache.camel.reifier.language;
-import java.util.HashMap;
-import java.util.Map;
-
import org.apache.camel.CamelContext;
import org.apache.camel.Exchange;
import org.apache.camel.Expression;
import org.apache.camel.Predicate;
+import org.apache.camel.RuntimeCamelException;
import org.apache.camel.builder.SimpleBuilder;
import org.apache.camel.model.language.ExpressionDefinition;
import org.apache.camel.model.language.SimpleExpression;
+import org.apache.camel.spi.Language;
public class SimpleExpressionReifier extends ExpressionReifier<SimpleExpression> {
@@ -68,15 +67,29 @@ public class SimpleExpressionReifier extends ExpressionReifier<SimpleExpression>
protected SimpleBuilder createBuilder() {
String exp = parseString(definition.getExpression());
// should be true by default
- boolean isTrim = parseBoolean(definition.getTrim(), true);
+ boolean isTrim = true;
+ if (definition.getTrim() != null) {
+ isTrim = parseBoolean(definition.getTrim());
+ }
if (exp != null && isTrim) {
exp = exp.trim();
}
SimpleBuilder answer = new SimpleBuilder(exp);
- Map<String, Object> props = new HashMap<>();
- props.put("resultType", or(definition.getResultType(), definition.getResultTypeName()));
- setProperties(answer, props);
+ answer.setResultType(definition.getResultType());
return answer;
}
+ @Override
+ protected void configureLanguage(Language language) {
+ if (definition.getResultType() == null && definition.getResultTypeName() != null) {
+ Class<?> clazz;
+ try {
+ clazz = camelContext.getClassResolver().resolveMandatoryClass(definition.getResultTypeName());
+ } catch (ClassNotFoundException e) {
+ throw RuntimeCamelException.wrapRuntimeException(e);
+ }
+ definition.setResultType(clazz);
+ }
+ }
+
}
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/TokenizerExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/TokenizerExpressionReifier.java
index ef08490..0f12413 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/TokenizerExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/TokenizerExpressionReifier.java
@@ -29,6 +29,8 @@ import org.apache.camel.support.ExpressionToPredicateAdapter;
public class TokenizerExpressionReifier extends ExpressionReifier<TokenizerExpression> {
+ // TODO: Update me
+
public TokenizerExpressionReifier(CamelContext camelContext, ExpressionDefinition definition) {
super(camelContext, (TokenizerExpression) definition);
}
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XMLTokenizerExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XMLTokenizerExpressionReifier.java
index 2676560..aac9085 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XMLTokenizerExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XMLTokenizerExpressionReifier.java
@@ -28,6 +28,8 @@ import org.apache.camel.spi.NamespaceAware;
public class XMLTokenizerExpressionReifier extends ExpressionReifier<XMLTokenizerExpression> {
+ // TODO: Update me
+
public XMLTokenizerExpressionReifier(CamelContext camelContext, ExpressionDefinition definition) {
super(camelContext, (XMLTokenizerExpression) definition);
}
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java
index 6cae1e0..a34af0f 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java
@@ -28,6 +28,8 @@ import org.apache.camel.spi.NamespaceAware;
public class XPathExpressionReifier extends ExpressionReifier<XPathExpression> {
+ // TODO: Update me
+
public XPathExpressionReifier(CamelContext camelContext, ExpressionDefinition definition) {
super(camelContext, (XPathExpression) definition);
}
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XQueryExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XQueryExpressionReifier.java
index 2e0985a..4fb2ee2 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XQueryExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XQueryExpressionReifier.java
@@ -28,6 +28,8 @@ import org.apache.camel.spi.NamespaceAware;
public class XQueryExpressionReifier extends ExpressionReifier<XQueryExpression> {
+ // TODO: Update me
+
public XQueryExpressionReifier(CamelContext camelContext, ExpressionDefinition definition) {
super(camelContext, (XQueryExpression) definition);
}
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/tokenizer/TokenizeLanguage.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/tokenizer/TokenizeLanguage.java
index 3007be6..20df970 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/tokenizer/TokenizeLanguage.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/tokenizer/TokenizeLanguage.java
@@ -61,7 +61,7 @@ public class TokenizeLanguage implements Language, IsSingleton, PropertyConfigur
TokenizeLanguage language = new TokenizeLanguage();
language.setToken(token);
language.setRegex(regex);
- return language.createExpression(null);
+ return language.createExpression((String) null);
}
public static Expression tokenize(String headerName, String token) {
@@ -73,7 +73,7 @@ public class TokenizeLanguage implements Language, IsSingleton, PropertyConfigur
language.setHeaderName(headerName);
language.setToken(token);
language.setRegex(regex);
- return language.createExpression(null);
+ return language.createExpression((String) null);
}
public static Expression tokenizePair(String startToken, String endToken, boolean includeTokens) {
@@ -81,7 +81,7 @@ public class TokenizeLanguage implements Language, IsSingleton, PropertyConfigur
language.setToken(startToken);
language.setEndToken(endToken);
language.setIncludeTokens(includeTokens);
- return language.createExpression(null);
+ return language.createExpression((String) null);
}
public static Expression tokenizeXML(String tagName, String inheritNamespaceTagName) {
@@ -89,7 +89,7 @@ public class TokenizeLanguage implements Language, IsSingleton, PropertyConfigur
language.setToken(tagName);
language.setInheritNamespaceTagName(inheritNamespaceTagName);
language.setXml(true);
- return language.createExpression(null);
+ return language.createExpression((String) null);
}
@Override
diff --git a/core/camel-support/src/main/java/org/apache/camel/support/ExpressionToPredicateAdapter.java b/core/camel-support/src/main/java/org/apache/camel/support/ExpressionToPredicateAdapter.java
index f8e3808..e2ecf1f 100644
--- a/core/camel-support/src/main/java/org/apache/camel/support/ExpressionToPredicateAdapter.java
+++ b/core/camel-support/src/main/java/org/apache/camel/support/ExpressionToPredicateAdapter.java
@@ -54,6 +54,9 @@ public final class ExpressionToPredicateAdapter implements Predicate, CamelConte
* Converts the given expression into an {@link Predicate}
*/
public static Predicate toPredicate(final Expression expression) {
+ if (expression instanceof Predicate) {
+ return (Predicate) expression;
+ }
return new ExpressionToPredicateAdapter(expression);
}
diff --git a/core/camel-support/src/main/java/org/apache/camel/support/builder/ExpressionBuilder.java b/core/camel-support/src/main/java/org/apache/camel/support/builder/ExpressionBuilder.java
index 19b8fa4..c180124 100644
--- a/core/camel-support/src/main/java/org/apache/camel/support/builder/ExpressionBuilder.java
+++ b/core/camel-support/src/main/java/org/apache/camel/support/builder/ExpressionBuilder.java
@@ -20,6 +20,7 @@ import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.Collection;
import java.util.Comparator;
+import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
@@ -1529,17 +1530,18 @@ public class ExpressionBuilder {
};
}
- public static Expression beanExpression(final Object bean, final String expression) {
+ public static Expression beanExpression(final Object bean, final String method) {
return new ExpressionAdapter() {
public Object evaluate(Exchange exchange) {
Language language = exchange.getContext().resolveLanguage("bean");
- setProperty(exchange.getContext(), language, "bean", bean);
- setProperty(exchange.getContext(), language, "method", expression);
- return language.createExpression(null).evaluate(exchange, Object.class);
+ Map<String, Object> properties = new HashMap<>(2);
+ properties.put("bean", bean);
+ properties.put("method", method);
+ return language.createExpression(properties).evaluate(exchange, Object.class);
}
public String toString() {
- return "bean(" + bean + ", " + expression + ")";
+ return "bean(" + bean + ", " + method + ")";
}
};
}
@@ -1623,7 +1625,7 @@ public class ExpressionBuilder {
setProperty(exchange.getContext(), language, "namespaces", namespaces);
}
setProperty(exchange.getContext(), language, "path", path);
- return language.createExpression(null).evaluate(exchange, Object.class);
+ return language.createExpression((String)null).evaluate(exchange, Object.class);
}
@Override
[camel] 11/14: CAMEL-15605: Languages should be singleton for
better performance.
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 7bfaccb2415df09ebfeda810359c6ac52e04d2da
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Thu Oct 1 22:35:23 2020 +0200
CAMEL-15605: Languages should be singleton for better performance.
---
.../apache/camel/reifier/language/XPathExpressionReifier.java | 11 +++++++++--
1 file changed, 9 insertions(+), 2 deletions(-)
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java
index 2e425f6..4fb3b6f 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/XPathExpressionReifier.java
@@ -69,8 +69,15 @@ public class XPathExpressionReifier extends ExpressionReifier<XPathExpression> {
Map<String, Object> properties = new HashMap<>(9);
properties.put("expression", expression);
properties.put("documentType", definition.getDocumentType());
- properties.put("resultQName", asQName(definition.getResultTypeName()));
- properties.put("resultType", definition.getResultType());
+ // resultType can either point to a QName or it can be a regular class that influence the qname
+ // so we need this special logic to set resultQName and resultType accordingly
+ Object qname = asQName(definition.getResultTypeName());
+ properties.put("resultQName", qname);
+ if (definition.getResultType() == null && qname == null && definition.getResultTypeName() != null) {
+ properties.put("resultType", definition.getResultTypeName());
+ } else {
+ properties.put("resultType", definition.getResultType());
+ }
properties.put("useSaxon", definition.getSaxon());
properties.put("xpathFactory", definition.getXPathFactory());
properties.put("objectModelUri", definition.getObjectModel());