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.util.ArrayList;
020    import java.util.Arrays;
021    import java.util.List;
022    
023    import org.apache.camel.CamelContext;
024    import org.apache.camel.Endpoint;
025    import org.apache.camel.Expression;
026    import org.apache.camel.LoggingLevel;
027    import org.apache.camel.NoSuchEndpointException;
028    import org.apache.camel.builder.xml.XPathBuilder;
029    import org.apache.camel.model.ModelCamelContext;
030    import org.apache.camel.model.language.HeaderExpression;
031    import org.apache.camel.model.language.MethodCallExpression;
032    import org.apache.camel.model.language.PropertyExpression;
033    import org.apache.camel.util.ObjectHelper;
034    import org.slf4j.Logger;
035    import org.slf4j.LoggerFactory;
036    
037    /**
038     * Base class for implementation inheritance for different clauses in the <a
039     * href="http://camel.apache.org/dsl.html">Java DSL</a>
040     *
041     * @version 
042     */
043    public abstract class BuilderSupport {
044        private ModelCamelContext context;
045        private ErrorHandlerBuilder errorHandlerBuilder;
046    
047        protected BuilderSupport(CamelContext context) {
048            this.context = (ModelCamelContext)context;
049        }
050    
051        // Builder methods
052        // -------------------------------------------------------------------------
053    
054        /**
055         * Returns a value builder for the given header
056         */
057        public ValueBuilder header(String name) {
058            HeaderExpression expression = new HeaderExpression(name);
059            return new ValueBuilder(expression);
060        }
061    
062        /**
063         * Returns a value builder for the given property
064         */
065        public ValueBuilder property(String name) {
066            PropertyExpression expression = new PropertyExpression(name);
067            return new ValueBuilder(expression);
068        }
069        
070        /**
071         * Returns a predicate and value builder for the inbound body on an exchange
072         */
073        public ValueBuilder body() {
074            return Builder.body();
075        }
076    
077        /**
078         * Returns a predicate and value builder for the inbound message body as a
079         * specific type
080         */
081        public <T> ValueBuilder body(Class<T> type) {
082            return Builder.bodyAs(type);
083        }
084    
085        /**
086         * Returns a predicate and value builder for the outbound body on an
087         * exchange
088         */
089        public ValueBuilder outBody() {
090            return Builder.outBody();
091        }
092    
093        /**
094         * Returns a predicate and value builder for the outbound message body as a
095         * specific type
096         */
097        public <T> ValueBuilder outBody(Class<T> type) {
098            return Builder.outBodyAs(type);
099        }
100    
101        /**
102         * Returns a predicate and value builder for the fault body on an
103         * exchange
104         */
105        public ValueBuilder faultBody() {
106            return Builder.faultBody();
107        }
108    
109        /**
110         * Returns a predicate and value builder for the fault message body as a
111         * specific type
112         */
113        public <T> ValueBuilder faultBodyAs(Class<T> type) {
114            return Builder.faultBodyAs(type);
115        }
116                                 
117        /**
118         * Returns a value builder for the given system property
119         */
120        public ValueBuilder systemProperty(String name) {
121            return Builder.systemProperty(name);
122        }
123    
124        /**
125         * Returns a value builder for the given system property
126         */
127        public ValueBuilder systemProperty(String name, String defaultValue) {
128            return Builder.systemProperty(name, defaultValue);
129        }
130    
131        /**
132         * Returns a constant expression value builder
133         */
134        public ValueBuilder constant(Object value) {
135            return Builder.constant(value);
136        }
137        
138        /**
139         * Returns a simple expression value builder
140         */
141        public SimpleBuilder simple(String value) {
142            return SimpleBuilder.simple(value);
143        }
144        
145        /**
146         * Returns a simple expression value builder
147         */
148        public SimpleBuilder simple(String value, Class<?> resultType) {
149            return SimpleBuilder.simple(value, resultType);
150        }
151    
152        /**
153         * Returns a xpath expression value builder
154         */
155        public XPathBuilder xpath(String value) {
156            return XPathBuilder.xpath(value);
157        }
158    
159        /**
160         * Returns a <a href="http://camel.apache.org/bean-language.html">method call expression</a>
161         * value builder
162         * <p/>
163         * This method accepts dual parameters. Either an bean instance or a reference to a bean (String).
164         *
165         * @param beanOrBeanRef  either an instanceof a bean or a reference to bean to lookup in the Registry
166         * @return the builder
167         * @deprecated use {@link #method(Object)} instead
168         */
169        @Deprecated
170        public ValueBuilder bean(Object beanOrBeanRef) {
171            return bean(beanOrBeanRef, null);
172        }
173        
174        /**
175         * Returns a <a href="http://camel.apache.org/bean-language.html">method call expression</a>
176         * value builder
177         * <p/>
178         * This method accepts dual parameters. Either an bean instance or a reference to a bean (String).
179         *
180         * @param beanOrBeanRef  either an instanceof a bean or a reference to bean to lookup in the Registry
181         * @param method   name of method to invoke
182         * @return the builder
183         * @deprecated use {@link #method(Object, String)} instead
184         */
185        @Deprecated
186        public ValueBuilder bean(Object beanOrBeanRef, String method) {
187            MethodCallExpression expression;
188            if (beanOrBeanRef instanceof String) {
189                expression = new MethodCallExpression((String) beanOrBeanRef, method);
190            } else {
191                expression = new MethodCallExpression(beanOrBeanRef, method);
192            }
193            return new ValueBuilder(expression);
194        }
195    
196        /**
197         * Returns a <a href="http://camel.apache.org/bean-language.html">method call expression</a>
198         * value builder
199         *
200         * @param beanType the Class of the bean which we want to invoke
201         * @return the builder
202         * @deprecated use {@link #method(Class)} instead
203         */
204        @Deprecated
205        public ValueBuilder bean(Class<?> beanType) {
206            MethodCallExpression expression = new MethodCallExpression(beanType);
207            return new ValueBuilder(expression);
208        }
209        
210        /**
211         * Returns a <a href="http://camel.apache.org/bean-language.html">method call expression</a>
212         * value builder
213         *
214         * @param beanType the Class of the bean which we want to invoke
215         * @param method   name of method to invoke
216         * @return the builder
217         * @deprecated use {@link #method(Class, String)} instead
218         */
219        @Deprecated
220        public ValueBuilder bean(Class<?> beanType, String method) {
221            MethodCallExpression expression = new MethodCallExpression(beanType, method);
222            return new ValueBuilder(expression);
223        }
224    
225        /**
226         * Returns a <a href="http://camel.apache.org/bean-language.html">method call expression</a>
227         * value builder
228         * <p/>
229         * This method accepts dual parameters. Either an bean instance or a reference to a bean (String).
230         *
231         * @param beanOrBeanRef  either an instanceof a bean or a reference to bean to lookup in the Registry
232         * @return the builder
233         */
234        public ValueBuilder method(Object beanOrBeanRef) {
235            return method(beanOrBeanRef, null);
236        }
237    
238        /**
239         * Returns a <a href="http://camel.apache.org/bean-language.html">method call expression</a>
240         * value builder
241         * <p/>
242         * This method accepts dual parameters. Either an bean instance or a reference to a bean (String).
243         *
244         * @param beanOrBeanRef  either an instanceof a bean or a reference to bean to lookup in the Registry
245         * @param method   name of method to invoke
246         * @return the builder
247         */
248        public ValueBuilder method(Object beanOrBeanRef, String method) {
249            MethodCallExpression expression;
250            if (beanOrBeanRef instanceof String) {
251                expression = new MethodCallExpression((String) beanOrBeanRef, method);
252            } else {
253                expression = new MethodCallExpression(beanOrBeanRef, method);
254            }
255            return new ValueBuilder(expression);
256        }
257    
258        /**
259         * Returns a <a href="http://camel.apache.org/bean-language.html">method call expression</a>
260         * value builder
261         *
262         * @param beanType the Class of the bean which we want to invoke
263         * @return the builder
264         */
265        public ValueBuilder method(Class<?> beanType) {
266            MethodCallExpression expression = new MethodCallExpression(beanType);
267            return new ValueBuilder(expression);
268        }
269    
270        /**
271         * Returns a <a href="http://camel.apache.org/bean-language.html">method call expression</a>
272         * value builder
273         *
274         * @param beanType the Class of the bean which we want to invoke
275         * @param method   name of method to invoke
276         * @return the builder
277         */
278        public ValueBuilder method(Class<?> beanType, String method) {
279            MethodCallExpression expression = new MethodCallExpression(beanType, method);
280            return new ValueBuilder(expression);
281        }
282    
283        /**
284         * Returns an expression processing the exchange to the given endpoint uri
285         *
286         * @param uri endpoint uri to send the exchange to
287         * @return the builder
288         */
289        public ValueBuilder sendTo(String uri) {
290            return Builder.sendTo(uri);
291        }
292    
293        /**
294         * Returns an expression value builder that replaces all occurrences of the 
295         * regular expression with the given replacement
296         */
297        public ValueBuilder regexReplaceAll(Expression content, String regex, String replacement) {
298            return Builder.regexReplaceAll(content, regex, replacement);
299        }
300    
301        /**
302         * Returns an expression value builder that replaces all occurrences of the 
303         * regular expression with the given replacement
304         */
305        public ValueBuilder regexReplaceAll(Expression content, String regex, Expression replacement) {
306            return Builder.regexReplaceAll(content, regex, replacement);
307        }    
308        
309        /**
310         * Returns a exception expression value builder
311         */
312        public ValueBuilder exceptionMessage() {
313            return Builder.exceptionMessage();
314        }
315    
316        /**
317         * Resolves the given URI to an endpoint
318         *
319         * @param uri  the uri to resolve
320         * @throws NoSuchEndpointException if the endpoint URI could not be resolved
321         * @return the endpoint
322         */
323        public Endpoint endpoint(String uri) throws NoSuchEndpointException {
324            ObjectHelper.notNull(uri, "uri");
325            Endpoint endpoint = getContext().getEndpoint(uri);
326            if (endpoint == null) {
327                throw new NoSuchEndpointException(uri);
328            }
329            return endpoint;
330        }
331    
332        /**
333         * Resolves the given URI to an endpoint of the specified type
334         *
335         * @param uri  the uri to resolve
336         * @param type the excepted type of the endpoint
337         * @throws NoSuchEndpointException if the endpoint URI could not be resolved
338         * @return the endpoint
339         */
340        public <T extends Endpoint> T endpoint(String uri, Class<T> type) throws NoSuchEndpointException {
341            ObjectHelper.notNull(uri, "uri");
342            T endpoint = getContext().getEndpoint(uri, type);
343            if (endpoint == null) {
344                throw new NoSuchEndpointException(uri);
345            }
346            return endpoint;
347        }
348    
349        /**
350         * Resolves the list of URIs into a list of {@link Endpoint} instances
351         *
352         * @param uris  list of endpoints to resolve
353         * @throws NoSuchEndpointException if an endpoint URI could not be resolved
354         * @return list of endpoints
355         */
356        public List<Endpoint> endpoints(String... uris) throws NoSuchEndpointException {
357            List<Endpoint> endpoints = new ArrayList<Endpoint>();
358            for (String uri : uris) {
359                endpoints.add(endpoint(uri));
360            }
361            return endpoints;
362        }
363    
364        /**
365         * Helper method to create a list of {@link Endpoint} instances
366         *
367         * @param endpoints  endpoints
368         * @return list of the given endpoints
369         */
370        public List<Endpoint> endpoints(Endpoint... endpoints) {
371            List<Endpoint> answer = new ArrayList<Endpoint>();
372            answer.addAll(Arrays.asList(endpoints));
373            return answer;
374        }
375    
376        /**
377         * Creates a default <a href="http://camel.apache.org/error-handler.html">error handler</a>.
378         *
379         * @return the builder
380         */
381        public DefaultErrorHandlerBuilder defaultErrorHandler() {
382            return new DefaultErrorHandlerBuilder();
383        }
384    
385        /**
386         * Creates a disabled <a href="http://camel.apache.org/error-handler.html">error handler</a>
387         * for removing the default error handler
388         *
389         * @return the builder
390         */
391        public NoErrorHandlerBuilder noErrorHandler() {
392            return new NoErrorHandlerBuilder();
393        }
394    
395        /**
396         * Creates an <a href="http://camel.apache.org/error-handler.html">error handler</a>
397         * which just logs errors
398         *
399         * @return the builder
400         */
401        public LoggingErrorHandlerBuilder loggingErrorHandler() {
402            return new LoggingErrorHandlerBuilder();
403        }
404    
405        /**
406         * Creates an <a href="http://camel.apache.org/error-handler.html">error handler</a>
407         * which just logs errors
408         *
409         * @return the builder
410         */
411        public LoggingErrorHandlerBuilder loggingErrorHandler(String log) {
412            return loggingErrorHandler(LoggerFactory.getLogger(log));
413        }
414    
415        /**
416         * Creates an <a href="http://camel.apache.org/error-handler.html">error handler</a>
417         * which just logs errors
418         *
419         * @return the builder
420         */
421        public LoggingErrorHandlerBuilder loggingErrorHandler(Logger log) {
422            return new LoggingErrorHandlerBuilder(log);
423        }
424    
425        /**
426         * Creates an <a href="http://camel.apache.org/error-handler.html">error handler</a>
427         * which just logs errors
428         *
429         * @return the builder
430         */
431        public LoggingErrorHandlerBuilder loggingErrorHandler(Logger log, LoggingLevel level) {
432            return new LoggingErrorHandlerBuilder(log, level);
433        }
434    
435        /**
436         * <a href="http://camel.apache.org/dead-letter-channel.html">Dead Letter Channel EIP:</a>
437         * is a error handler for handling messages that could not be delivered to it's intended destination.
438         *
439         * @param deadLetterUri  uri to the dead letter endpoint storing dead messages
440         * @return the builder
441         */
442        public DeadLetterChannelBuilder deadLetterChannel(String deadLetterUri) {
443            return deadLetterChannel(endpoint(deadLetterUri));
444        }
445    
446        /**
447         * <a href="http://camel.apache.org/dead-letter-channel.html">Dead Letter Channel EIP:</a>
448         * is a error handler for handling messages that could not be delivered to it's intended destination.
449         *
450         * @param deadLetterEndpoint  dead letter endpoint storing dead messages
451         * @return the builder
452         */
453        public DeadLetterChannelBuilder deadLetterChannel(Endpoint deadLetterEndpoint) {
454            return new DeadLetterChannelBuilder(deadLetterEndpoint);
455        }
456    
457        // Properties
458        // -------------------------------------------------------------------------
459    
460        public ModelCamelContext getContext() {
461            return context;
462        }
463        
464        @Deprecated
465        public void setContext(CamelContext context) {
466            this.context = (ModelCamelContext)context;
467        }
468    
469        public void setContext(ModelCamelContext context) {
470            this.context = context;
471        }
472    
473        public ErrorHandlerBuilder getErrorHandlerBuilder() {
474            if (errorHandlerBuilder == null) {
475                errorHandlerBuilder = createErrorHandlerBuilder();
476            }
477            return errorHandlerBuilder;
478        }
479    
480        protected ErrorHandlerBuilder createErrorHandlerBuilder() {
481            return new DefaultErrorHandlerBuilder();
482        }
483    
484        /**
485         * Sets the error handler to use with processors created by this builder
486         */
487        public void setErrorHandlerBuilder(ErrorHandlerBuilder errorHandlerBuilder) {
488            this.errorHandlerBuilder = errorHandlerBuilder;
489        }
490    
491    }