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.List; 021 022 import org.apache.camel.CamelContext; 023 import org.apache.camel.Endpoint; 024 import org.apache.camel.NoSuchEndpointException; 025 import org.apache.camel.processor.LoggingLevel; 026 import org.apache.camel.processor.SendProcessor; 027 import org.apache.camel.util.ObjectHelper; 028 import org.apache.commons.logging.Log; 029 import org.apache.commons.logging.LogFactory; 030 031 /** 032 * Base class for implementation inheritance for different clauses in the <a 033 * href="http://activemq.apache.org/camel/dsl.html">Java DSL</a> 034 * 035 * @version $Revision: 36321 $ 036 */ 037 public abstract class BuilderSupport { 038 private CamelContext context; 039 private ErrorHandlerBuilder errorHandlerBuilder; 040 private boolean inheritErrorHandler = true; 041 042 protected BuilderSupport(CamelContext context) { 043 this.context = context; 044 } 045 046 protected BuilderSupport(BuilderSupport parent) { 047 this.context = parent.getContext(); 048 this.inheritErrorHandler = parent.inheritErrorHandler; 049 if (inheritErrorHandler && parent.errorHandlerBuilder != null) { 050 this.errorHandlerBuilder = parent.errorHandlerBuilder.copy(); 051 } 052 } 053 054 // Builder methods 055 // ------------------------------------------------------------------------- 056 057 /** 058 * Returns a value builder for the given header 059 */ 060 public ValueBuilder header(String name) { 061 return Builder.header(name); 062 } 063 064 /** 065 * Returns a predicate and value builder for the inbound body on an exchange 066 */ 067 public ValueBuilder body() { 068 return Builder.body(); 069 } 070 071 /** 072 * Returns a predicate and value builder for the inbound message body as a 073 * specific type 074 */ 075 public <T> ValueBuilder body(Class<T> type) { 076 return Builder.bodyAs(type); 077 } 078 079 /** 080 * Returns a predicate and value builder for the outbound body on an 081 * exchange 082 */ 083 public ValueBuilder outBody() { 084 return Builder.outBody(); 085 } 086 087 /** 088 * Returns a predicate and value builder for the outbound message body as a 089 * specific type 090 */ 091 public <T> ValueBuilder outBody(Class<T> type) { 092 return Builder.outBodyAs(type); 093 } 094 095 /** 096 * Returns a predicate and value builder for the fault body on an 097 * exchange 098 */ 099 public ValueBuilder faultBody() { 100 return Builder.faultBody(); 101 } 102 103 /** 104 * Returns a predicate and value builder for the fault message body as a 105 * specific type 106 */ 107 public <T> ValueBuilder faultBodyAs(Class<T> type) { 108 return Builder.faultBodyAs(type); 109 } 110 111 112 /** 113 * Returns a value builder for the given system property 114 */ 115 public ValueBuilder systemProperty(String name) { 116 return Builder.systemProperty(name); 117 } 118 119 /** 120 * Returns a value builder for the given system property 121 */ 122 public ValueBuilder systemProperty(String name, String defaultValue) { 123 return Builder.systemProperty(name, defaultValue); 124 } 125 126 /** 127 * Returns a constant expression value builder 128 */ 129 public ValueBuilder constant(Object value) { 130 return Builder.constant(value); 131 } 132 133 /** 134 * Resolves the given URI to an endpoint 135 * 136 * @throws NoSuchEndpointException if the endpoint URI could not be resolved 137 */ 138 public Endpoint endpoint(String uri) throws NoSuchEndpointException { 139 ObjectHelper.notNull(uri, "uri"); 140 Endpoint endpoint = getContext().getEndpoint(uri); 141 if (endpoint == null) { 142 throw new NoSuchEndpointException(uri); 143 } 144 return endpoint; 145 } 146 147 /** 148 * Resolves the given URI to an endpoint of the specified type 149 * 150 * @throws NoSuchEndpointException if the endpoint URI could not be resolved 151 */ 152 public <T extends Endpoint> T endpoint(String uri, Class<T> type) throws NoSuchEndpointException { 153 ObjectHelper.notNull(uri, "uri"); 154 T endpoint = getContext().getEndpoint(uri, type); 155 if (endpoint == null) { 156 throw new NoSuchEndpointException(uri); 157 } 158 return endpoint; 159 } 160 161 /** 162 * Resolves the list of URIs into a list of {@link Endpoint} instances 163 * 164 * @throws NoSuchEndpointException if an endpoint URI could not be resolved 165 */ 166 public List<Endpoint> endpoints(String... uris) throws NoSuchEndpointException { 167 List<Endpoint> endpoints = new ArrayList<Endpoint>(); 168 for (String uri : uris) { 169 endpoints.add(endpoint(uri)); 170 } 171 return endpoints; 172 } 173 174 /** 175 * Helper method to create a list of {@link Endpoint} instances 176 */ 177 public List<Endpoint> endpoints(Endpoint... endpoints) { 178 List<Endpoint> answer = new ArrayList<Endpoint>(); 179 for (Endpoint endpoint : endpoints) { 180 answer.add(endpoint); 181 } 182 return answer; 183 } 184 185 /** 186 * Creates a disabled error handler for removing the default error handler 187 */ 188 public NoErrorHandlerBuilder noErrorHandler() { 189 return new NoErrorHandlerBuilder(); 190 } 191 192 /** 193 * Creates an error handler which just logs errors 194 */ 195 public LoggingErrorHandlerBuilder loggingErrorHandler() { 196 return new LoggingErrorHandlerBuilder(); 197 } 198 199 /** 200 * Creates an error handler which just logs errors 201 */ 202 public LoggingErrorHandlerBuilder loggingErrorHandler(String log) { 203 return loggingErrorHandler(LogFactory.getLog(log)); 204 } 205 206 /** 207 * Creates an error handler which just logs errors 208 */ 209 public LoggingErrorHandlerBuilder loggingErrorHandler(Log log) { 210 return new LoggingErrorHandlerBuilder(log); 211 } 212 213 /** 214 * Creates an error handler which just logs errors 215 */ 216 public LoggingErrorHandlerBuilder loggingErrorHandler(Log log, LoggingLevel level) { 217 return new LoggingErrorHandlerBuilder(log, level); 218 } 219 220 public DeadLetterChannelBuilder deadLetterChannel() { 221 return new DeadLetterChannelBuilder(); 222 } 223 224 public DeadLetterChannelBuilder deadLetterChannel(String deadLetterUri) { 225 return deadLetterChannel(endpoint(deadLetterUri)); 226 } 227 228 public DeadLetterChannelBuilder deadLetterChannel(Endpoint deadLetterEndpoint) { 229 return new DeadLetterChannelBuilder(new SendProcessor(deadLetterEndpoint)); 230 } 231 232 // Properties 233 // ------------------------------------------------------------------------- 234 public CamelContext getContext() { 235 return context; 236 } 237 238 public void setContext(CamelContext context) { 239 this.context = context; 240 } 241 242 public ErrorHandlerBuilder getErrorHandlerBuilder() { 243 if (errorHandlerBuilder == null) { 244 errorHandlerBuilder = createErrorHandlerBuilder(); 245 } 246 return errorHandlerBuilder; 247 } 248 249 protected ErrorHandlerBuilder createErrorHandlerBuilder() { 250 if (isInheritErrorHandler()) { 251 return new DeadLetterChannelBuilder(); 252 } else { 253 return new NoErrorHandlerBuilder(); 254 } 255 } 256 257 /** 258 * Sets the error handler to use with processors created by this builder 259 */ 260 public void setErrorHandlerBuilder(ErrorHandlerBuilder errorHandlerBuilder) { 261 this.errorHandlerBuilder = errorHandlerBuilder; 262 } 263 264 public boolean isInheritErrorHandler() { 265 return inheritErrorHandler; 266 } 267 268 public void setInheritErrorHandler(boolean inheritErrorHandler) { 269 this.inheritErrorHandler = inheritErrorHandler; 270 } 271 }