001 /** 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.camel.builder; 018 019 import java.text.SimpleDateFormat; 020 import java.util.Collection; 021 import java.util.Collections; 022 import java.util.Comparator; 023 import java.util.Date; 024 import java.util.Iterator; 025 import java.util.List; 026 import java.util.Scanner; 027 import java.util.regex.Pattern; 028 029 import org.apache.camel.Endpoint; 030 import org.apache.camel.Exchange; 031 import org.apache.camel.Expression; 032 import org.apache.camel.Message; 033 import org.apache.camel.NoSuchEndpointException; 034 import org.apache.camel.Producer; 035 import org.apache.camel.impl.ExpressionAdapter; 036 import org.apache.camel.language.bean.BeanLanguage; 037 import org.apache.camel.spi.Language; 038 import org.apache.camel.util.ExchangeHelper; 039 import org.apache.camel.util.ObjectHelper; 040 041 /** 042 * A helper class for working with <a href="http://camel.apache.org/expression.html">expressions</a>. 043 * 044 * @version $Revision: 788778 $ 045 */ 046 public final class ExpressionBuilder { 047 048 /** 049 * Utility classes should not have a public constructor. 050 */ 051 private ExpressionBuilder() { 052 } 053 054 /** 055 * Returns an expression for the header value with the given name 056 * 057 * @param headerName the name of the header the expression will return 058 * @return an expression object which will return the header value 059 */ 060 public static Expression headerExpression(final String headerName) { 061 return new ExpressionAdapter() { 062 public Object evaluate(Exchange exchange) { 063 Object header = exchange.getIn().getHeader(headerName); 064 if (header == null) { 065 // fall back on a property 066 header = exchange.getProperty(headerName); 067 } 068 return header; 069 } 070 071 @Override 072 public String toString() { 073 return "header(" + headerName + ")"; 074 } 075 }; 076 } 077 078 /** 079 * Returns an expression for the inbound message headers 080 * 081 * @return an expression object which will return the inbound headers 082 */ 083 public static Expression headersExpression() { 084 return new ExpressionAdapter() { 085 public Object evaluate(Exchange exchange) { 086 return exchange.getIn().getHeaders(); 087 } 088 089 @Override 090 public String toString() { 091 return "headers"; 092 } 093 }; 094 } 095 096 /** 097 * Returns an expression for the out header value with the given name 098 * 099 * @param headerName the name of the header the expression will return 100 * @return an expression object which will return the header value 101 */ 102 public static Expression outHeaderExpression(final String headerName) { 103 return new ExpressionAdapter() { 104 public Object evaluate(Exchange exchange) { 105 if (!exchange.hasOut()) { 106 return null; 107 } 108 109 Message out = exchange.getOut(); 110 Object header = out.getHeader(headerName); 111 if (header == null) { 112 // lets try the exchange header 113 header = exchange.getProperty(headerName); 114 } 115 return header; 116 } 117 118 @Override 119 public String toString() { 120 return "outHeader(" + headerName + ")"; 121 } 122 }; 123 } 124 125 /** 126 * Returns an expression for the outbound message headers 127 * 128 * @return an expression object which will return the headers 129 */ 130 public static Expression outHeadersExpression() { 131 return new ExpressionAdapter() { 132 public Object evaluate(Exchange exchange) { 133 return exchange.getOut().getHeaders(); 134 } 135 136 @Override 137 public String toString() { 138 return "outHeaders"; 139 } 140 }; 141 } 142 143 /** 144 * Returns an expression for an exception set on the exchange 145 * 146 * @see Exchange#getException() 147 * @return an expression object which will return the exception set on the exchange 148 */ 149 public static Expression exchangeExceptionExpression() { 150 return new ExpressionAdapter() { 151 public Object evaluate(Exchange exchange) { 152 Exception exception = exchange.getException(); 153 if (exception == null) { 154 exception = exchange.getProperty(Exchange.EXCEPTION_CAUGHT, Exception.class); 155 } 156 return exception; 157 } 158 159 @Override 160 public String toString() { 161 return "exchangeException"; 162 } 163 }; 164 } 165 166 /** 167 * Returns an expression for an exception set on the exchange 168 * <p/> 169 * Is used to get the caused exception that typically have been wrapped in some sort 170 * of Camel wrapper exception 171 * @param type the exception type 172 * @see Exchange#getException(Class) 173 * @return an expression object which will return the exception set on the exchange 174 */ 175 public static Expression exchangeExceptionExpression(final Class<Exception> type) { 176 return new ExpressionAdapter() { 177 public Object evaluate(Exchange exchange) { 178 Exception exception = exchange.getException(type); 179 if (exception == null) { 180 exception = exchange.getProperty(Exchange.EXCEPTION_CAUGHT, Exception.class); 181 // must use exception iterator to walk it and find the type we are looking for 182 Iterator<Throwable> it = ObjectHelper.createExceptionIterator(exception); 183 while (it.hasNext()) { 184 Throwable e = it.next(); 185 if (type.isInstance(e)) { 186 return type.cast(e); 187 } 188 } 189 // not found 190 return null; 191 192 } 193 return exception; 194 } 195 196 @Override 197 public String toString() { 198 return "exchangeException[" + type + "]"; 199 } 200 }; 201 } 202 203 /** 204 * Returns an expression for the type converter 205 * 206 * @return an expression object which will return the type converter 207 */ 208 public static Expression typeConverterExpression() { 209 return new ExpressionAdapter() { 210 public Object evaluate(Exchange exchange) { 211 return exchange.getContext().getTypeConverter(); 212 } 213 214 @Override 215 public String toString() { 216 return "typeConverter"; 217 } 218 }; 219 } 220 221 /** 222 * Returns an expression for the {@link org.apache.camel.spi.Registry} 223 * 224 * @return an expression object which will return the registry 225 */ 226 public static Expression registryExpression() { 227 return new ExpressionAdapter() { 228 public Object evaluate(Exchange exchange) { 229 return exchange.getContext().getRegistry(); 230 } 231 232 @Override 233 public String toString() { 234 return "registry"; 235 } 236 }; 237 } 238 239 /** 240 * Returns an expression for the {@link org.apache.camel.CamelContext} 241 * 242 * @return an expression object which will return the camel context 243 */ 244 public static Expression camelContextExpression() { 245 return new ExpressionAdapter() { 246 public Object evaluate(Exchange exchange) { 247 return exchange.getContext(); 248 } 249 250 @Override 251 public String toString() { 252 return "camelContext"; 253 } 254 }; 255 } 256 257 /** 258 * Returns an expression for an exception message set on the exchange 259 * 260 * @see <tt>Exchange.getException().getMessage()</tt> 261 * @return an expression object which will return the exception message set on the exchange 262 */ 263 public static Expression exchangeExceptionMessageExpression() { 264 return new ExpressionAdapter() { 265 public Object evaluate(Exchange exchange) { 266 Exception exception = exchange.getException(); 267 if (exception == null) { 268 exception = exchange.getProperty(Exchange.EXCEPTION_CAUGHT, Exception.class); 269 } 270 return exception != null ? exception.getMessage() : null; 271 } 272 273 @Override 274 public String toString() { 275 return "exchangeExceptionMessage"; 276 } 277 }; 278 } 279 280 /** 281 * Returns an expression for the property value of exchange with the given name 282 * 283 * @param propertyName the name of the property the expression will return 284 * @return an expression object which will return the property value 285 */ 286 public static Expression propertyExpression(final String propertyName) { 287 return new ExpressionAdapter() { 288 public Object evaluate(Exchange exchange) { 289 return exchange.getProperty(propertyName); 290 } 291 292 @Override 293 public String toString() { 294 return "property(" + propertyName + ")"; 295 } 296 }; 297 } 298 299 /** 300 * Returns an expression for the properties of exchange 301 * 302 * @return an expression object which will return the properties 303 */ 304 public static Expression propertiesExpression() { 305 return new ExpressionAdapter() { 306 public Object evaluate(Exchange exchange) { 307 return exchange.getProperties(); 308 } 309 310 @Override 311 public String toString() { 312 return "properties"; 313 } 314 }; 315 } 316 317 /** 318 * Returns an expression for the properties of the camel context 319 * 320 * @return an expression object which will return the properties 321 */ 322 public static Expression camelContextPropertiesExpression() { 323 return new ExpressionAdapter() { 324 public Object evaluate(Exchange exchange) { 325 return exchange.getContext().getProperties(); 326 } 327 328 @Override 329 public String toString() { 330 return "camelContextProperties"; 331 } 332 }; 333 } 334 335 /** 336 * Returns an expression for the property value of the camel context with the given name 337 * 338 * @param propertyName the name of the property the expression will return 339 * @return an expression object which will return the property value 340 */ 341 public static Expression camelContextPropertyExpression(final String propertyName) { 342 return new ExpressionAdapter() { 343 public Object evaluate(Exchange exchange) { 344 return exchange.getContext().getProperties().get(propertyName); 345 } 346 347 @Override 348 public String toString() { 349 return "camelContextProperty(" + propertyName + ")"; 350 } 351 }; 352 } 353 354 /** 355 * Returns an expression for a system property value with the given name 356 * 357 * @param propertyName the name of the system property the expression will return 358 * @return an expression object which will return the system property value 359 */ 360 public static Expression systemPropertyExpression(final String propertyName) { 361 return systemPropertyExpression(propertyName, null); 362 } 363 364 /** 365 * Returns an expression for a system property value with the given name 366 * 367 * @param propertyName the name of the system property the expression will return 368 * @param defaultValue default value to return if no system property exists 369 * @return an expression object which will return the system property value 370 */ 371 public static Expression systemPropertyExpression(final String propertyName, 372 final String defaultValue) { 373 return new ExpressionAdapter() { 374 public Object evaluate(Exchange exchange) { 375 return System.getProperty(propertyName, defaultValue); 376 } 377 378 @Override 379 public String toString() { 380 return "systemProperty(" + propertyName + ")"; 381 } 382 }; 383 } 384 385 /** 386 * Returns an expression for the constant value 387 * 388 * @param value the value the expression will return 389 * @return an expression object which will return the constant value 390 */ 391 public static Expression constantExpression(final Object value) { 392 return new ExpressionAdapter() { 393 public Object evaluate(Exchange exchange) { 394 return value; 395 } 396 397 @Override 398 public String toString() { 399 return "" + value; 400 } 401 }; 402 } 403 404 /** 405 * Returns the expression for the exchanges inbound message body 406 */ 407 public static Expression bodyExpression() { 408 return new ExpressionAdapter() { 409 public Object evaluate(Exchange exchange) { 410 return exchange.getIn().getBody(); 411 } 412 413 @Override 414 public String toString() { 415 return "body"; 416 } 417 }; 418 } 419 420 /** 421 * Returns the expression for the exchanges inbound message body converted 422 * to the given type 423 */ 424 public static <T> Expression bodyExpression(final Class<T> type) { 425 return new ExpressionAdapter() { 426 public Object evaluate(Exchange exchange) { 427 return exchange.getIn().getBody(type); 428 } 429 430 @Override 431 public String toString() { 432 return "bodyAs[" + type.getName() + "]"; 433 } 434 }; 435 } 436 437 /** 438 * Returns the expression for the exchanges inbound message body type 439 */ 440 public static Expression bodyTypeExpression() { 441 return new ExpressionAdapter() { 442 public Object evaluate(Exchange exchange) { 443 return exchange.getIn().getBody().getClass(); 444 } 445 446 @Override 447 public String toString() { 448 return "bodyType"; 449 } 450 }; 451 } 452 453 /** 454 * Returns the expression for the out messages body 455 */ 456 public static Expression outBodyExpression() { 457 return new ExpressionAdapter() { 458 public Object evaluate(Exchange exchange) { 459 if (exchange.hasOut()) { 460 return exchange.getOut().getBody(); 461 } else { 462 return null; 463 } 464 } 465 466 @Override 467 public String toString() { 468 return "outBody"; 469 } 470 }; 471 } 472 473 /** 474 * Returns the expression for the exchanges outbound message body converted 475 * to the given type 476 */ 477 public static <T> Expression outBodyExpression(final Class<T> type) { 478 return new ExpressionAdapter() { 479 public Object evaluate(Exchange exchange) { 480 if (exchange.hasOut()) { 481 return exchange.getOut().getBody(type); 482 } else { 483 return null; 484 } 485 } 486 487 @Override 488 public String toString() { 489 return "outBodyAs[" + type.getName() + "]"; 490 } 491 }; 492 } 493 494 /** 495 * Returns the expression for the fault messages body 496 */ 497 public static Expression faultBodyExpression() { 498 return new ExpressionAdapter() { 499 public Object evaluate(Exchange exchange) { 500 return exchange.getFault().getBody(); 501 } 502 503 @Override 504 public String toString() { 505 return "faultBody"; 506 } 507 }; 508 } 509 510 /** 511 * Returns the expression for the exchanges fault message body converted 512 * to the given type 513 */ 514 public static <T> Expression faultBodyExpression(final Class<T> type) { 515 return new ExpressionAdapter() { 516 public Object evaluate(Exchange exchange) { 517 return exchange.getFault().getBody(type); 518 } 519 520 @Override 521 public String toString() { 522 return "faultBodyAs[" + type.getName() + "]"; 523 } 524 }; 525 } 526 527 /** 528 * Returns the expression for the exchange 529 */ 530 public static Expression exchangeExpression() { 531 return new ExpressionAdapter() { 532 public Object evaluate(Exchange exchange) { 533 return exchange; 534 } 535 536 @Override 537 public String toString() { 538 return "exchange"; 539 } 540 }; 541 } 542 543 /** 544 * Returns the expression for the IN message 545 */ 546 public static Expression inMessageExpression() { 547 return new ExpressionAdapter() { 548 public Object evaluate(Exchange exchange) { 549 return exchange.getIn(); 550 } 551 552 @Override 553 public String toString() { 554 return "inMessage"; 555 } 556 }; 557 } 558 559 /** 560 * Returns the expression for the OUT message 561 */ 562 public static Expression outMessageExpression() { 563 return new ExpressionAdapter() { 564 public Object evaluate(Exchange exchange) { 565 return exchange.getOut(); 566 } 567 568 @Override 569 public String toString() { 570 return "outMessage"; 571 } 572 }; 573 } 574 575 /** 576 * Returns an expression which converts the given expression to the given type 577 */ 578 @SuppressWarnings("unchecked") 579 public static Expression convertToExpression(final Expression expression, final Class type) { 580 return new ExpressionAdapter() { 581 public Object evaluate(Exchange exchange) { 582 return expression.evaluate(exchange, type); 583 } 584 585 @Override 586 public String toString() { 587 return "" + expression + ".convertTo(" + type.getCanonicalName() + ".class)"; 588 } 589 }; 590 } 591 592 /** 593 * Returns an expression which converts the given expression to the given type the type 594 * expression is evaluted to 595 */ 596 public static Expression convertToExpression(final Expression expression, final Expression type) { 597 return new ExpressionAdapter() { 598 public Object evaluate(Exchange exchange) { 599 return expression.evaluate(exchange, type.evaluate(exchange, Object.class).getClass()); 600 } 601 602 @Override 603 public String toString() { 604 return "" + expression + ".convertToEvaluatedType(" + type + ")"; 605 } 606 }; 607 } 608 609 /** 610 * Returns a tokenize expression which will tokenize the string with the 611 * given token 612 */ 613 public static Expression tokenizeExpression(final Expression expression, 614 final String token) { 615 return new ExpressionAdapter() { 616 public Object evaluate(Exchange exchange) { 617 Object value = expression.evaluate(exchange, Object.class); 618 Scanner scanner = ObjectHelper.getScanner(exchange, value); 619 scanner.useDelimiter(token); 620 return scanner; 621 } 622 623 @Override 624 public String toString() { 625 return "tokenize(" + expression + ", " + token + ")"; 626 } 627 }; 628 } 629 630 /** 631 * Returns a tokenize expression which will tokenize the string with the 632 * given regex 633 */ 634 public static Expression regexTokenizeExpression(final Expression expression, 635 final String regexTokenizer) { 636 final Pattern pattern = Pattern.compile(regexTokenizer); 637 return new ExpressionAdapter() { 638 public Object evaluate(Exchange exchange) { 639 Object value = expression.evaluate(exchange, Object.class); 640 Scanner scanner = ObjectHelper.getScanner(exchange, value); 641 scanner.useDelimiter(regexTokenizer); 642 return scanner; 643 } 644 645 @Override 646 public String toString() { 647 return "regexTokenize(" + expression + ", " + pattern.pattern() + ")"; 648 } 649 }; 650 } 651 652 /** 653 * Returns a sort expression which will sort the expression with the given comparator. 654 * <p/> 655 * The expression is evaluted as a {@link List} object to allow sorting. 656 */ 657 @SuppressWarnings("unchecked") 658 public static Expression sortExpression(final Expression expression, final Comparator comparator) { 659 return new ExpressionAdapter() { 660 public Object evaluate(Exchange exchange) { 661 List list = expression.evaluate(exchange, List.class); 662 Collections.sort(list, comparator); 663 return list; 664 } 665 666 @Override 667 public String toString() { 668 return "sort(" + expression + " by: " + comparator + ")"; 669 } 670 }; 671 } 672 673 /** 674 * Transforms the expression into a String then performs the regex 675 * replaceAll to transform the String and return the result 676 */ 677 public static Expression regexReplaceAll(final Expression expression, 678 final String regex, final String replacement) { 679 final Pattern pattern = Pattern.compile(regex); 680 return new ExpressionAdapter() { 681 public Object evaluate(Exchange exchange) { 682 String text = expression.evaluate(exchange, String.class); 683 if (text == null) { 684 return null; 685 } 686 return pattern.matcher(text).replaceAll(replacement); 687 } 688 689 @Override 690 public String toString() { 691 return "regexReplaceAll(" + expression + ", " + pattern.pattern() + ")"; 692 } 693 }; 694 } 695 696 /** 697 * Transforms the expression into a String then performs the regex 698 * replaceAll to transform the String and return the result 699 */ 700 public static Expression regexReplaceAll(final Expression expression, 701 final String regex, final Expression replacementExpression) { 702 703 final Pattern pattern = Pattern.compile(regex); 704 return new ExpressionAdapter() { 705 public Object evaluate(Exchange exchange) { 706 String text = expression.evaluate(exchange, String.class); 707 String replacement = replacementExpression.evaluate(exchange, String.class); 708 if (text == null || replacement == null) { 709 return null; 710 } 711 return pattern.matcher(text).replaceAll(replacement); 712 } 713 714 @Override 715 public String toString() { 716 return "regexReplaceAll(" + expression + ", " + pattern.pattern() + ")"; 717 } 718 }; 719 } 720 721 /** 722 * Appends the String evaluations of the two expressions together 723 */ 724 public static Expression append(final Expression left, final Expression right) { 725 return new ExpressionAdapter() { 726 public Object evaluate(Exchange exchange) { 727 return left.evaluate(exchange, String.class) + right.evaluate(exchange, String.class); 728 } 729 730 @Override 731 public String toString() { 732 return "append(" + left + ", " + right + ")"; 733 } 734 }; 735 } 736 737 /** 738 * Prepends the String evaluations of the two expressions together 739 */ 740 public static Expression prepend(final Expression left, final Expression right) { 741 return new ExpressionAdapter() { 742 public Object evaluate(Exchange exchange) { 743 return right.evaluate(exchange, String.class) + left.evaluate(exchange, String.class); 744 } 745 746 @Override 747 public String toString() { 748 return "prepend(" + left + ", " + right + ")"; 749 } 750 }; 751 } 752 753 /** 754 * Returns an expression which returns the string concatenation value of the various 755 * expressions 756 * 757 * @param expressions the expression to be concatenated dynamically 758 * @return an expression which when evaluated will return the concatenated values 759 */ 760 public static Expression concatExpression(final Collection<Expression> expressions) { 761 return concatExpression(expressions, null); 762 } 763 764 /** 765 * Returns an expression which returns the string concatenation value of the various 766 * expressions 767 * 768 * @param expressions the expression to be concatenated dynamically 769 * @param expression the text description of the expression 770 * @return an expression which when evaluated will return the concatenated values 771 */ 772 public static Expression concatExpression(final Collection<Expression> expressions, final String expression) { 773 return new ExpressionAdapter() { 774 public Object evaluate(Exchange exchange) { 775 StringBuffer buffer = new StringBuffer(); 776 for (Expression expression : expressions) { 777 String text = expression.evaluate(exchange, String.class); 778 if (text != null) { 779 buffer.append(text); 780 } 781 } 782 return buffer.toString(); 783 } 784 785 @Override 786 public String toString() { 787 if (expression != null) { 788 return expression; 789 } else { 790 return "concat" + expressions; 791 } 792 } 793 }; 794 } 795 796 /** 797 * Returns an Expression for the inbound message id 798 */ 799 public static Expression messageIdExpression() { 800 return new ExpressionAdapter() { 801 public Object evaluate(Exchange exchange) { 802 return exchange.getIn().getMessageId(); 803 } 804 805 @Override 806 public String toString() { 807 return "messageId"; 808 } 809 }; 810 } 811 812 public static Expression dateExpression(final String command, final String pattern) { 813 return new ExpressionAdapter() { 814 public Object evaluate(Exchange exchange) { 815 Date date; 816 if ("now".equals(command)) { 817 date = new Date(); 818 } else if (command.startsWith("header.") || command.startsWith("in.header.")) { 819 String key = command.substring(command.lastIndexOf('.') + 1); 820 date = exchange.getIn().getHeader(key, Date.class); 821 if (date == null) { 822 throw new IllegalArgumentException("Cannot find java.util.Date object at " + command); 823 } 824 } else if (command.startsWith("out.header.")) { 825 String key = command.substring(command.lastIndexOf('.') + 1); 826 date = exchange.getOut().getHeader(key, Date.class); 827 if (date == null) { 828 throw new IllegalArgumentException("Cannot find java.util.Date object at " + command); 829 } 830 } else { 831 throw new IllegalArgumentException("Command not supported for dateExpression: " + command); 832 } 833 834 SimpleDateFormat df = new SimpleDateFormat(pattern); 835 return df.format(date); 836 } 837 838 @Override 839 public String toString() { 840 return "date(" + command + ":" + pattern + ")"; 841 } 842 }; 843 } 844 845 public static Expression simpleExpression(final String expression) { 846 return new ExpressionAdapter() { 847 public Object evaluate(Exchange exchange) { 848 // resolve language using context to have a clear separation of packages 849 // must call evalute to return the nested langauge evaluate when evaluating 850 // stacked expressions 851 Language language = exchange.getContext().resolveLanguage("simple"); 852 return language.createExpression(expression).evaluate(exchange, Object.class); 853 } 854 855 @Override 856 public String toString() { 857 return "simple(" + expression + ")"; 858 } 859 }; 860 } 861 862 public static Expression beanExpression(final String expression) { 863 return new ExpressionAdapter() { 864 public Object evaluate(Exchange exchange) { 865 // resolve language using context to have a clear separation of packages 866 // must call evaluate to return the nested language evaluate when evaluating 867 // stacked expressions 868 Language language = exchange.getContext().resolveLanguage("bean"); 869 return language.createExpression(expression).evaluate(exchange, Object.class); 870 } 871 872 @Override 873 public String toString() { 874 return "bean(" + expression + ")"; 875 } 876 }; 877 } 878 879 public static Expression beanExpression(final Class beanType, final String methodName) { 880 return BeanLanguage.bean(beanType, methodName); 881 } 882 883 public static Expression beanExpression(final String beanRef, final String methodName) { 884 String expression = methodName != null ? beanRef + "." + methodName : beanRef; 885 return beanExpression(expression); 886 } 887 888 /** 889 * Returns an expression processing the exchange to the given endpoint uri 890 * 891 * @param uri endpoint uri to send the exchange to 892 * @return an expression object which will return the OUT body 893 */ 894 public static Expression toExpression(final String uri) { 895 return new ExpressionAdapter() { 896 public Object evaluate(Exchange exchange) { 897 Endpoint endpoint = exchange.getContext().getEndpoint(uri); 898 if (endpoint == null) { 899 throw new NoSuchEndpointException(uri); 900 } 901 902 Producer producer; 903 try { 904 producer = endpoint.createProducer(); 905 producer.start(); 906 producer.process(exchange); 907 producer.stop(); 908 } catch (Exception e) { 909 throw ObjectHelper.wrapRuntimeCamelException(e); 910 } 911 912 // return the OUT body, but check for exchange pattern 913 if (ExchangeHelper.isOutCapable(exchange)) { 914 return exchange.getOut().getBody(); 915 } else { 916 return exchange.getIn().getBody(); 917 } 918 } 919 920 @Override 921 public String toString() { 922 return "to(" + uri + ")"; 923 } 924 }; 925 } 926 927 928 }