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.processor.SendProcessor; 029 import org.apache.camel.util.ObjectHelper; 030 import org.apache.commons.logging.Log; 031 import org.apache.commons.logging.LogFactory; 032 033 /** 034 * Base class for implementation inheritance for different clauses in the <a 035 * href="http://camel.apache.org/dsl.html">Java DSL</a> 036 * 037 * @version $Revision: 749227 $ 038 */ 039 public abstract class BuilderSupport { 040 private CamelContext context; 041 private ErrorHandlerBuilder errorHandlerBuilder; 042 private boolean inheritErrorHandler = true; 043 044 protected BuilderSupport(CamelContext context) { 045 this.context = context; 046 } 047 048 protected BuilderSupport(BuilderSupport parent) { 049 this.context = parent.getContext(); 050 this.inheritErrorHandler = parent.inheritErrorHandler; 051 if (inheritErrorHandler && parent.errorHandlerBuilder != null) { 052 this.errorHandlerBuilder = parent.errorHandlerBuilder.copy(); 053 } 054 } 055 056 // Builder methods 057 // ------------------------------------------------------------------------- 058 059 /** 060 * Returns a value builder for the given header 061 */ 062 public ValueBuilder header(String name) { 063 return Builder.header(name); 064 } 065 066 /** 067 * Returns a value builder for the given property 068 */ 069 public ValueBuilder property(String name) { 070 return Builder.property(name); 071 } 072 073 /** 074 * Returns a predicate and value builder for the inbound body on an exchange 075 */ 076 public ValueBuilder body() { 077 return Builder.body(); 078 } 079 080 /** 081 * Returns a predicate and value builder for the inbound message body as a 082 * specific type 083 */ 084 public <T> ValueBuilder body(Class<T> type) { 085 return Builder.bodyAs(type); 086 } 087 088 /** 089 * Returns a predicate and value builder for the outbound body on an 090 * exchange 091 */ 092 public ValueBuilder outBody() { 093 return Builder.outBody(); 094 } 095 096 /** 097 * Returns a predicate and value builder for the outbound message body as a 098 * specific type 099 */ 100 public <T> ValueBuilder outBody(Class<T> type) { 101 return Builder.outBodyAs(type); 102 } 103 104 /** 105 * Returns a predicate and value builder for the fault body on an 106 * exchange 107 */ 108 public ValueBuilder faultBody() { 109 return Builder.faultBody(); 110 } 111 112 /** 113 * Returns a predicate and value builder for the fault message body as a 114 * specific type 115 */ 116 public <T> ValueBuilder faultBodyAs(Class<T> type) { 117 return Builder.faultBodyAs(type); 118 } 119 120 /** 121 * Returns a value builder for the given system property 122 */ 123 public ValueBuilder systemProperty(String name) { 124 return Builder.systemProperty(name); 125 } 126 127 /** 128 * Returns a value builder for the given system property 129 */ 130 public ValueBuilder systemProperty(String name, String defaultValue) { 131 return Builder.systemProperty(name, defaultValue); 132 } 133 134 /** 135 * Returns a constant expression value builder 136 */ 137 public ValueBuilder constant(Object value) { 138 return Builder.constant(value); 139 } 140 141 /** 142 * Returns a <a href="http://camel.apache.org/bean-language.html">bean expression</a> 143 * value builder 144 * 145 * @param beanRef reference to bean to lookup in the Registry 146 * @return the builder 147 */ 148 public ValueBuilder bean(String beanRef) { 149 return Builder.bean(beanRef, null); 150 } 151 152 /** 153 * Returns an expression value builder that replaces all occurrences of the 154 * regular expression with the given replacement 155 */ 156 public ValueBuilder regexReplaceAll(Expression content, String regex, String replacement) { 157 return Builder.regexReplaceAll(content, regex, replacement); 158 } 159 160 /** 161 * Returns an expression value builder that replaces all occurrences of the 162 * regular expression with the given replacement 163 */ 164 public ValueBuilder regexReplaceAll(Expression content, String regex, Expression replacement) { 165 return Builder.regexReplaceAll(content, regex, replacement); 166 } 167 168 /** 169 * Returns a <a href="http://camel.apache.org/bean-language.html">bean expression</a> 170 * value builder 171 * 172 * @param beanRef reference to bean to lookup in the Registry 173 * @param method name of method to invoke 174 * @return the builder 175 */ 176 public ValueBuilder bean(String beanRef, String method) { 177 return Builder.bean(beanRef, method); 178 } 179 180 /** 181 * Returns a exception expression value builder 182 */ 183 public ValueBuilder exceptionMessage() { 184 return Builder.exceptionMessage(); 185 } 186 187 /** 188 * Resolves the given URI to an endpoint 189 * 190 * @param uri the uri to resolve 191 * @throws NoSuchEndpointException if the endpoint URI could not be resolved 192 * @return the endpoint 193 */ 194 public Endpoint endpoint(String uri) throws NoSuchEndpointException { 195 ObjectHelper.notNull(uri, "uri"); 196 Endpoint endpoint = getContext().getEndpoint(uri); 197 if (endpoint == null) { 198 throw new NoSuchEndpointException(uri); 199 } 200 return endpoint; 201 } 202 203 /** 204 * Resolves the given URI to an endpoint of the specified type 205 * 206 * @param uri the uri to resolve 207 * @param type the excepted type of the endpoint 208 * @throws NoSuchEndpointException if the endpoint URI could not be resolved 209 * @return the endpoint 210 */ 211 public <T extends Endpoint> T endpoint(String uri, Class<T> type) throws NoSuchEndpointException { 212 ObjectHelper.notNull(uri, "uri"); 213 T endpoint = getContext().getEndpoint(uri, type); 214 if (endpoint == null) { 215 throw new NoSuchEndpointException(uri); 216 } 217 return endpoint; 218 } 219 220 /** 221 * Resolves the list of URIs into a list of {@link Endpoint} instances 222 * 223 * @param uris list of endpoints to resolve 224 * @throws NoSuchEndpointException if an endpoint URI could not be resolved 225 * @return list of endpoints 226 */ 227 public List<Endpoint> endpoints(String... uris) throws NoSuchEndpointException { 228 List<Endpoint> endpoints = new ArrayList<Endpoint>(); 229 for (String uri : uris) { 230 endpoints.add(endpoint(uri)); 231 } 232 return endpoints; 233 } 234 235 /** 236 * Helper method to create a list of {@link Endpoint} instances 237 * 238 * @param endpoints endpoints 239 * @return list of the given endpoints 240 */ 241 public List<Endpoint> endpoints(Endpoint... endpoints) { 242 List<Endpoint> answer = new ArrayList<Endpoint>(); 243 answer.addAll(Arrays.asList(endpoints)); 244 return answer; 245 } 246 247 /** 248 * Creates a disabled <a href="http://camel.apache.org/error-handler.html">error handler</a> 249 * for removing the default error handler 250 * 251 * @return the builder 252 */ 253 public NoErrorHandlerBuilder noErrorHandler() { 254 return new NoErrorHandlerBuilder(); 255 } 256 257 /** 258 * Creates an <a href="http://camel.apache.org/error-handler.html">error handler</a> 259 * which just logs errors 260 * 261 * @return the builder 262 */ 263 public LoggingErrorHandlerBuilder loggingErrorHandler() { 264 return new LoggingErrorHandlerBuilder(); 265 } 266 267 /** 268 * Creates an <a href="http://camel.apache.org/error-handler.html">error handler</a> 269 * which just logs errors 270 * 271 * @return the builder 272 */ 273 public LoggingErrorHandlerBuilder loggingErrorHandler(String log) { 274 return loggingErrorHandler(LogFactory.getLog(log)); 275 } 276 277 /** 278 * Creates an <a href="http://camel.apache.org/error-handler.html">error handler</a> 279 * which just logs errors 280 * 281 * @return the builder 282 */ 283 public LoggingErrorHandlerBuilder loggingErrorHandler(Log log) { 284 return new LoggingErrorHandlerBuilder(log); 285 } 286 287 /** 288 * Creates an <a href="http://camel.apache.org/error-handler.html">error handler</a> 289 * which just logs errors 290 * 291 * @return the builder 292 */ 293 public LoggingErrorHandlerBuilder loggingErrorHandler(Log log, LoggingLevel level) { 294 return new LoggingErrorHandlerBuilder(log, level); 295 } 296 297 /** 298 * <a href="http://camel.apache.org/dead-letter-channel.html">Dead Letter Channel EIP:</a> 299 * is a error handler for handling messages that could not be delivered to it's intented destination. 300 * 301 * @return the builder 302 */ 303 public DeadLetterChannelBuilder deadLetterChannel() { 304 return new DeadLetterChannelBuilder(); 305 } 306 307 /** 308 * <a href="http://camel.apache.org/dead-letter-channel.html">Dead Letter Channel EIP:</a> 309 * is a error handler for handling messages that could not be delivered to it's intented destination. 310 * 311 * @param deadLetterUri uri to the dead letter endpoint storing dead messages 312 * @return the builder 313 */ 314 public DeadLetterChannelBuilder deadLetterChannel(String deadLetterUri) { 315 return deadLetterChannel(endpoint(deadLetterUri)); 316 } 317 318 /** 319 * <a href="http://camel.apache.org/dead-letter-channel.html">Dead Letter Channel EIP:</a> 320 * is a error handler for handling messages that could not be delivered to it's intented destination. 321 * 322 * @param deadLetterEndpoint dead letter endpoint storing dead messages 323 * @return the builder 324 */ 325 public DeadLetterChannelBuilder deadLetterChannel(Endpoint deadLetterEndpoint) { 326 return new DeadLetterChannelBuilder(new SendProcessor(deadLetterEndpoint)); 327 } 328 329 // Properties 330 // ------------------------------------------------------------------------- 331 public CamelContext getContext() { 332 return context; 333 } 334 335 public void setContext(CamelContext context) { 336 this.context = context; 337 } 338 339 public ErrorHandlerBuilder getErrorHandlerBuilder() { 340 if (errorHandlerBuilder == null) { 341 errorHandlerBuilder = createErrorHandlerBuilder(); 342 } 343 return errorHandlerBuilder; 344 } 345 346 protected ErrorHandlerBuilder createErrorHandlerBuilder() { 347 if (isInheritErrorHandler()) { 348 return new DeadLetterChannelBuilder(); 349 } else { 350 return new NoErrorHandlerBuilder(); 351 } 352 } 353 354 /** 355 * Sets the error handler to use with processors created by this builder 356 */ 357 public void setErrorHandlerBuilder(ErrorHandlerBuilder errorHandlerBuilder) { 358 this.errorHandlerBuilder = errorHandlerBuilder; 359 } 360 361 public boolean isInheritErrorHandler() { 362 return inheritErrorHandler; 363 } 364 365 public void setInheritErrorHandler(boolean inheritErrorHandler) { 366 this.inheritErrorHandler = inheritErrorHandler; 367 } 368 }