This is an automated email from the ASF dual-hosted git repository.
orpiske pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
The following commit(s) were added to refs/heads/main by this push:
new 83ed8676293 (chores) camel-bean: break the process method (#11171)
83ed8676293 is described below
commit 83ed8676293f072259b7c1b8255f6447a388d71c
Author: Otavio Rodolfo Piske <[email protected]>
AuthorDate: Tue Aug 22 16:15:06 2023 +0200
(chores) camel-bean: break the process method (#11171)
This should provide better reports in profilers
---
.../component/bean/AbstractBeanProcessor.java | 103 ++++++++++++---------
1 file changed, 61 insertions(+), 42 deletions(-)
diff --git
a/components/camel-bean/src/main/java/org/apache/camel/component/bean/AbstractBeanProcessor.java
b/components/camel-bean/src/main/java/org/apache/camel/component/bean/AbstractBeanProcessor.java
index f681f96c960..ff287aeba53 100644
---
a/components/camel-bean/src/main/java/org/apache/camel/component/bean/AbstractBeanProcessor.java
+++
b/components/camel-bean/src/main/java/org/apache/camel/component/bean/AbstractBeanProcessor.java
@@ -59,18 +59,14 @@ public abstract class AbstractBeanProcessor extends
AsyncProcessorSupport {
@Override
public boolean process(Exchange exchange, AsyncCallback callback) {
// do we have an explicit method name we always should invoke (either
configured on endpoint or as a header)
- String explicitMethodName =
exchange.getIn().getHeader(BeanConstants.BEAN_METHOD_NAME, method,
String.class);
+ final String explicitMethodName =
exchange.getIn().getHeader(BeanConstants.BEAN_METHOD_NAME, method,
String.class);
- Object bean;
- BeanInfo beanInfo;
+ final Object beanInstance;
+ final BeanInfo beanInfo;
try {
- bean = beanHolder.getBean(exchange);
+ beanInstance = beanHolder.getBean(exchange);
// get bean info for this bean instance (to avoid thread issue)
- beanInfo = beanHolder.getBeanInfo(bean);
- if (beanInfo == null) {
- // fallback and use old way
- beanInfo = beanHolder.getBeanInfo();
- }
+ beanInfo = doGetBeanInfo(beanInstance);
} catch (Exception e) {
exchange.setException(e);
callback.done(true);
@@ -81,51 +77,29 @@ public abstract class AbstractBeanProcessor extends
AsyncProcessorSupport {
// but only do this if allowed
// we need to check beanHolder is Processor is support, to avoid the
bean cached issue
if (allowProcessor(explicitMethodName, beanInfo)) {
- Processor target = getProcessor();
- if (target == null) {
- // only attempt to lookup the processor once or nearly once
- // allow cache by default or if the scope is singleton
- boolean allowCache = scope == null || scope ==
BeanScope.Singleton;
- if (allowCache) {
- if (!lookupProcessorDone) {
- synchronized (lock) {
- lookupProcessorDone = true;
- // so if there is a custom type converter for the
bean to processor
- target =
exchange.getContext().getTypeConverter().tryConvertTo(Processor.class,
exchange, bean);
- processor = target;
- }
- }
- } else {
- // so if there is a custom type converter for the bean to
processor
- target =
exchange.getContext().getTypeConverter().tryConvertTo(Processor.class,
exchange, bean);
- }
- }
+ final Processor target = getCustomAdapter(exchange, beanInstance);
if (target != null) {
- if (LOG.isTraceEnabled()) {
- LOG.trace("Using a custom adapter as bean invocation: {}",
target);
- }
- try {
- target.process(exchange);
- } catch (AssertionError | Exception e) {
- exchange.setException(e);
- } finally {
- callback.done(true);
- }
+ useCustomAdapter(exchange, callback, target);
return true;
}
}
- Message in = exchange.getIn();
+ return useMethodInvocation(exchange, callback, explicitMethodName,
beanInfo, beanInstance);
+ }
+
+ private static boolean useMethodInvocation(
+ Exchange exchange, AsyncCallback callback, String
explicitMethodName, BeanInfo beanInfo, Object beanInstance) {
+ final Message in = exchange.getIn();
// set explicit method name to invoke as a header, which is how
BeanInfo can detect it
if (explicitMethodName != null) {
in.setHeader(BeanConstants.BEAN_METHOD_NAME, explicitMethodName);
}
- MethodInvocation invocation;
+ final MethodInvocation invocation;
try {
- invocation = beanInfo.createInvocation(bean, exchange);
+ invocation = beanInfo.createInvocation(beanInstance, exchange);
} catch (Exception e) {
exchange.setException(e);
callback.done(true);
@@ -139,7 +113,7 @@ public abstract class AbstractBeanProcessor extends
AsyncProcessorSupport {
if (invocation == null) {
exchange.setException(new IllegalStateException(
- "No method invocation could be created, no matching method
could be found on: " + bean));
+ "No method invocation could be created, no matching method
could be found on: " + beanInstance));
callback.done(true);
return true;
}
@@ -148,6 +122,51 @@ public abstract class AbstractBeanProcessor extends
AsyncProcessorSupport {
return invocation.proceed(callback);
}
+ private Processor getCustomAdapter(Exchange exchange, Object beanTmp) {
+ Processor target = getProcessor();
+ if (target == null) {
+ // only attempt to lookup the processor once or nearly once
+ // allow cache by default or if the scope is singleton
+ boolean allowCache = scope == null || scope == BeanScope.Singleton;
+ if (allowCache) {
+ if (!lookupProcessorDone) {
+ synchronized (lock) {
+ lookupProcessorDone = true;
+ // so if there is a custom type converter for the bean
to processor
+ target =
exchange.getContext().getTypeConverter().tryConvertTo(Processor.class,
exchange, beanTmp);
+ processor = target;
+ }
+ }
+ } else {
+ // so if there is a custom type converter for the bean to
processor
+ target =
exchange.getContext().getTypeConverter().tryConvertTo(Processor.class,
exchange, beanTmp);
+ }
+ }
+ return target;
+ }
+
+ private static void useCustomAdapter(Exchange exchange, AsyncCallback
callback, Processor target) {
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("Using a custom adapter as bean invocation: {}", target);
+ }
+ try {
+ target.process(exchange);
+ } catch (AssertionError | Exception e) {
+ exchange.setException(e);
+ } finally {
+ callback.done(true);
+ }
+ }
+
+ private BeanInfo doGetBeanInfo(Object beanTmp) {
+ BeanInfo beanInfo = beanHolder.getBeanInfo(beanTmp);
+ if (beanInfo == null) {
+ // fallback and use old way
+ beanInfo = beanHolder.getBeanInfo();
+ }
+ return beanInfo;
+ }
+
protected Processor getProcessor() {
return processor;
}