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 <orpi...@users.noreply.github.com> 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; }