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.language.bean;
018    
019    import org.apache.camel.Expression;
020    import org.apache.camel.IsSingleton;
021    import org.apache.camel.Predicate;
022    import org.apache.camel.builder.PredicateBuilder;
023    import org.apache.camel.spi.Language;
024    import org.apache.camel.util.ObjectHelper;
025    
026    /**
027     * A <a href="http://camel.apache.org/bean-language.html">bean language</a>
028     * which uses a simple text notation to invoke methods on beans to evaluate predicates or expressions
029     * <p/>
030     * The notation is essentially <code>beanName.methodName</code> which is then invoked using the
031     * beanName to lookup in the <a href="http://camel.apache.org/registry.html>registry</a>
032     * then the method is invoked to evaluate the expression using the
033     * <a href="http://camel.apache.org/bean-integration.html">bean integration</a> to bind the
034     * {@link org.apache.camel.Exchange} to the method arguments.
035     * <p/>
036     * As of Camel 1.5 the bean language also supports invoking a provided bean by
037     * its classname or the bean itself.
038     *
039     * @version $Revision: 752893 $
040     */
041    public class BeanLanguage implements Language, IsSingleton {
042    
043        /**
044         * Creates the expression based on the string syntax.
045         *
046         * @param expression the string syntax <tt>beanRef.methodName</tt> where methodName can be omitted
047         * @return the expression
048         */
049        public static Expression bean(String expression) {
050            BeanLanguage language = new BeanLanguage();
051            return language.createExpression(expression);
052        }
053    
054        /**
055         * Creates the expression for invoking the bean type.
056         *
057         * @param beanType  the bean type to invoke
058         * @param method optional name of method to invoke for instance to avoid ambiguity
059         * @return the expression
060         */
061        @SuppressWarnings("unchecked")
062        public static Expression bean(Class beanType, String method) {
063            Object bean = ObjectHelper.newInstance(beanType);
064            return bean(bean, method);
065        }
066    
067        /**
068         * Creates the expression for invoking the bean type.
069         *
070         * @param bean  the bean to invoke
071         * @param method optional name of method to invoke for instance to avoid ambiguity
072         * @return the expression
073         */
074        public static Expression bean(Object bean, String method) {
075            BeanLanguage language = new BeanLanguage();
076            return language.createExpression(bean, method);
077        }
078    
079        public Predicate createPredicate(String expression) {
080            return PredicateBuilder.toPredicate(createExpression(expression));
081        }
082    
083        public Expression createExpression(String expression) {
084            ObjectHelper.notNull(expression, "expression");
085    
086            String beanName = expression;
087            String method = null;
088    
089            // we support both the .method name and the ?method= syntax
090            // as the ?method= syntax is very common for the bean component
091            int idx = expression.lastIndexOf('.');
092            if (idx > 0) {
093                beanName = expression.substring(0, idx);
094                method = expression.substring(idx + 1);
095            } else if (expression.contains("?method=")) {
096                beanName = ObjectHelper.before(expression, "?");
097                method = ObjectHelper.after(expression, "?method=");
098            }
099            
100            return new BeanExpression(beanName, method);
101        }
102    
103        public Expression createExpression(Object bean, String method) {
104            ObjectHelper.notNull(bean, "bean");
105            return new BeanExpression(bean, method);
106        }
107    
108        public boolean isSingleton() {
109            return true;
110        }
111    }