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
The following commit(s) were added to refs/heads/master by this push:
new 900ab2c CAMEL-15636: camel-bean - optimize to not resolve simple
language per message if ongl method call expressions.
900ab2c is described below
commit 900ab2cd3fb639ab5f89eb258ae435063c7c70c9
Author: Claus Ibsen <claus.ib...@gmail.com>
AuthorDate: Tue Oct 6 21:46:30 2020 +0200
CAMEL-15636: camel-bean - optimize to not resolve simple language per
message if ongl method call expressions.
---
.../apache/camel/language/bean/BeanExpression.java | 37 +++++++++++++---------
.../apache/camel/language/bean/BeanLanguage.java | 5 +++
.../language/simple/SimpleExpressionBuilder.java | 24 +++++++++++---
3 files changed, 46 insertions(+), 20 deletions(-)
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 7ead3d5..5a8982e 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
@@ -27,6 +27,7 @@ import org.apache.camel.ExpressionIllegalSyntaxException;
import org.apache.camel.NoSuchBeanException;
import org.apache.camel.Predicate;
import org.apache.camel.RuntimeCamelException;
+import org.apache.camel.TypeConverter;
import org.apache.camel.component.bean.BeanExpressionProcessor;
import org.apache.camel.component.bean.BeanHolder;
import org.apache.camel.component.bean.BeanInfo;
@@ -53,13 +54,13 @@ import static
org.apache.camel.util.ObjectHelper.hasDefaultPublicNoArgConstructo
public class BeanExpression implements Expression, Predicate {
private ParameterMappingStrategy parameterMappingStrategy;
+ private Language simple;
private Object bean;
private String beanName;
private Class<?> type;
private String method;
private BeanHolder beanHolder;
- private Language simple;
private boolean ognlMethod;
public BeanExpression(Object bean, String method) {
@@ -107,6 +108,14 @@ public class BeanExpression implements Expression,
Predicate {
this.parameterMappingStrategy = parameterMappingStrategy;
}
+ public Language getSimple() {
+ return simple;
+ }
+
+ public void setSimple(Language simple) {
+ this.simple = simple;
+ }
+
@Override
public void init(CamelContext context) {
if (parameterMappingStrategy == null) {
@@ -139,12 +148,6 @@ public class BeanExpression implements Expression,
Predicate {
}
ognlMethod = OgnlHelper.isValidOgnlExpression(method);
- if (ognlMethod) {
- // ognl may use simple language
- if (simple == null) {
- simple = context.resolveLanguage("simple");
- }
- }
}
@Override
@@ -238,12 +241,12 @@ public class BeanExpression implements Expression,
Predicate {
}
if (bean != null) {
- BeanInfo info = new BeanInfo(context, bean.getClass());
+ BeanInfo info = new BeanInfo(context, bean.getClass(),
parameterMappingStrategy);
if (!info.hasMethod(method)) {
throw RuntimeCamelException.wrapRuntimeCamelException(new
MethodNotFoundException(null, bean, method));
}
} else {
- BeanInfo info = new BeanInfo(context, type);
+ BeanInfo info = new BeanInfo(context, type,
parameterMappingStrategy);
// must be a static method as we do not have a bean instance to
invoke
if (!info.hasStaticMethod(method)) {
throw RuntimeCamelException.wrapRuntimeCamelException(new
MethodNotFoundException(null, type, method, true));
@@ -307,7 +310,7 @@ public class BeanExpression implements Expression,
Predicate {
if (resultExchange.hasProperties()) {
exchange.getProperties().putAll(resultExchange.getProperties());
}
- if (resultExchange.getOut().hasHeaders()) {
+ if (resultExchange.hasOut() &&
resultExchange.getOut().hasHeaders()) {
exchange.getIn().getHeaders().putAll(resultExchange.getOut().getHeaders());
}
@@ -415,7 +418,9 @@ public class BeanExpression implements Expression,
Predicate {
if (key != null) {
// if key is a nested simple expression then re-evaluate that
again
if (LanguageSupport.hasSimpleFunction(key)) {
- key = simple.createExpression(key).evaluate(exchange,
String.class);
+ Expression exp = simple.createExpression(key);
+ exp.init(exchange.getContext());
+ key = exp.evaluate(exchange, String.class);
}
if (key != null) {
result = lookupResult(resultExchange, key, result,
nullSafe, ognlPath, holder.getBean(exchange));
@@ -439,6 +444,8 @@ public class BeanExpression implements Expression,
Predicate {
Exchange exchange, String key, Object result, boolean nullSafe,
String ognlPath, Object bean) {
StringHelper.notEmpty(key, "key", "in Simple language ognl path: " +
ognlPath);
+ final TypeConverter typeConverter =
exchange.getContext().getTypeConverter();
+
// trim key
key = key.trim();
@@ -446,17 +453,17 @@ public class BeanExpression implements Expression,
Predicate {
key = StringHelper.removeLeadingAndEndingQuotes(key);
// try map first
- Map<?, ?> map =
exchange.getContext().getTypeConverter().convertTo(Map.class, result);
+ Map<?, ?> map = typeConverter.convertTo(Map.class, result);
if (map != null) {
return map.get(key);
}
// special for list is last keyword
- Integer num =
exchange.getContext().getTypeConverter().tryConvertTo(Integer.class, key);
+ Integer num = typeConverter.tryConvertTo(Integer.class, key);
boolean checkList = key.startsWith("last") || num != null;
if (checkList) {
- List<?> list =
exchange.getContext().getTypeConverter().convertTo(List.class, result);
+ List<?> list = typeConverter.convertTo(List.class, result);
if (list != null) {
if (key.startsWith("last")) {
num = list.size() - 1;
@@ -464,7 +471,7 @@ public class BeanExpression implements Expression,
Predicate {
// maybe its an expression to subtract a number after last
String after = StringHelper.after(key, "-");
if (after != null) {
- Integer redux =
exchange.getContext().getTypeConverter().tryConvertTo(Integer.class,
after.trim());
+ Integer redux =
typeConverter.tryConvertTo(Integer.class, after.trim());
if (redux != null) {
num -= redux;
} else {
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 6dc1b3c..c1da63f 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
@@ -24,6 +24,7 @@ import org.apache.camel.RuntimeCamelException;
import org.apache.camel.StaticService;
import org.apache.camel.component.bean.ParameterMappingStrategy;
import org.apache.camel.component.bean.ParameterMappingStrategyHelper;
+import org.apache.camel.spi.Language;
import org.apache.camel.support.ExpressionToPredicateAdapter;
import org.apache.camel.support.LanguageSupport;
import org.apache.camel.util.StringHelper;
@@ -43,6 +44,7 @@ import org.apache.camel.util.StringHelper;
public class BeanLanguage extends LanguageSupport implements StaticService {
private volatile ParameterMappingStrategy parameterMappingStrategy;
+ private volatile Language simple;
private Object bean;
private Class<?> beanType;
@@ -113,6 +115,7 @@ public class BeanLanguage extends LanguageSupport
implements StaticService {
}
answer.setParameterMappingStrategy(parameterMappingStrategy);
+ answer.setSimple(simple);
answer.init(getCamelContext());
return answer;
}
@@ -167,6 +170,7 @@ public class BeanLanguage extends LanguageSupport
implements StaticService {
}
answer.setParameterMappingStrategy(parameterMappingStrategy);
+ answer.setSimple(simple);
answer.init(getCamelContext());
return answer;
}
@@ -174,6 +178,7 @@ public class BeanLanguage extends LanguageSupport
implements StaticService {
@Override
public void start() {
parameterMappingStrategy =
ParameterMappingStrategyHelper.createParameterMappingStrategy(getCamelContext());
+ simple = getCamelContext().resolveLanguage("simple");
}
@Override
diff --git
a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleExpressionBuilder.java
b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleExpressionBuilder.java
index fea7544..0ab00ed 100644
---
a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleExpressionBuilder.java
+++
b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleExpressionBuilder.java
@@ -19,8 +19,10 @@ package org.apache.camel.language.simple;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
+import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
+import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.TimeZone;
@@ -36,6 +38,7 @@ import org.apache.camel.InvalidPayloadException;
import org.apache.camel.RuntimeCamelException;
import org.apache.camel.spi.ClassResolver;
import org.apache.camel.spi.ExchangeFormatter;
+import org.apache.camel.spi.Language;
import org.apache.camel.support.CamelContextHelper;
import org.apache.camel.support.ExpressionAdapter;
import org.apache.camel.support.MessageHelper;
@@ -835,8 +838,10 @@ public final class SimpleExpressionBuilder {
private final KeyedEntityRetrievalStrategy
keyedEntityRetrievalStrategy;
private String key;
private String keySuffix;
+ private String method;
private Expression keyExpression;
private Expression ognlExpression;
+ private Language beanLanguage;
KeyedOgnlExpressionAdapter(String ognl, String toStringValue,
KeyedEntityRetrievalStrategy
keyedEntityRetrievalStrategy) {
@@ -858,15 +863,16 @@ public final class SimpleExpressionBuilder {
}
// remove any OGNL operators so we got the pure key name
key = OgnlHelper.removeOperators(key);
+ // and this may be the last remainder method to try as OGNL if
there are no exchange properties with those key names
+ method = StringHelper.after(ognl, key + keySuffix);
}
@Override
public void init(CamelContext context) {
+ beanLanguage = context.resolveLanguage("bean");
ognlExpression = ExpressionBuilder.simpleExpression(ognl);
ognlExpression.init(context);
// key must be lazy eval as it only used in special situations
- // keyExpression = ExpressionBuilder.simpleExpression(key);
- // keyExpression.init(context);
}
@Override
@@ -887,9 +893,17 @@ public final class SimpleExpressionBuilder {
if (property == null) {
return null;
}
- // the remainder is the rest of the ognl without the key
- String remainder = StringHelper.after(ognl, key + keySuffix);
- return ExpressionBuilder.beanExpression(property,
remainder).evaluate(exchange, Object.class);
+ if (method != null) {
+ // okay we have a property value, the remainder is OGNL method
call on it
+ Map<String, Object> properties = new HashMap<>(2);
+ properties.put("bean", property);
+ properties.put("method", method);
+ Expression exp = beanLanguage.createExpression(null,
properties);
+ exp.init(exchange.getContext());
+ return exp.evaluate(exchange, Object.class);
+ } else {
+ return property;
+ }
}
@Override
