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;
018
019 import java.util.Map;
020
021 /**
022 * Template (named like Spring's TransactionTemplate & JmsTemplate
023 * et al) for working with Camel and sending {@link Message} instances in an
024 * {@link Exchange} to an {@link Endpoint}.
025 *
026 * @version $Revision: 659422 $
027 */
028 public interface ProducerTemplate<E extends Exchange> extends Service {
029
030 /**
031 * Sends the exchange to the default endpoint
032 *
033 * @param exchange the exchange to send
034 */
035 E send(E exchange);
036
037 /**
038 * Sends an exchange to the default endpoint using a supplied
039 *
040 * @param processor the transformer used to populate the new exchange
041 * {@link Processor} to populate the exchange
042 */
043 E send(Processor processor);
044
045 /**
046 * Sends the body to the default endpoint and returns the result content
047 *
048 * @param body the body to send
049 * @return the returned message body
050 */
051 Object sendBody(Object body);
052
053 /**
054 * Sends the body to the default endpoint with a specified header and header
055 * value
056 *
057 * @param body the payload send
058 * @param header the header name
059 * @param headerValue the header value
060 * @return the result
061 */
062 Object sendBodyAndHeader(Object body, String header, Object headerValue);
063
064 /**
065 * Sends the body to the default endpoint with the specified headers and
066 * header values
067 *
068 * @param body the payload send
069 * @return the result
070 */
071 Object sendBodyAndHeaders(Object body, Map<String, Object> headers);
072
073 // Allow sending to arbitrary endpoints
074 // -----------------------------------------------------------------------
075
076 /**
077 * Sends the exchange to the given endpoint
078 *
079 * @param endpointUri the endpoint URI to send the exchange to
080 * @param exchange the exchange to send
081 */
082 E send(String endpointUri, E exchange);
083
084 /**
085 * Sends an exchange to an endpoint using a supplied processor
086 *
087 * @param endpointUri the endpoint URI to send the exchange to
088 * @param processor the transformer used to populate the new exchange
089 * {@link Processor} to populate the exchange
090 */
091 E send(String endpointUri, Processor processor);
092
093 /**
094 * Sends an exchange to an endpoint using a supplied processor
095 *
096 * @param endpointUri the endpoint URI to send the exchange to
097 * @param pattern the message {@link ExchangePattern} such as
098 * {@link ExchangePattern#InOnly} or {@link ExchangePattern#InOut}
099 * @param processor the transformer used to populate the new exchange
100 * {@link Processor} to populate the exchange
101 */
102 E send(String endpointUri, ExchangePattern pattern, Processor processor);
103
104 /**
105 * Sends an exchange to an endpoint using a supplied processor
106 *
107 * @param endpointUri the endpoint URI to send the exchange to
108 * @param processor the transformer used to populate the new exchange
109 * {@link Processor} to populate the exchange.
110 * @param callback the callback will be called when the exchange is completed.
111 */
112 E send(String endpointUri, Processor processor, AsyncCallback callback);
113
114 /**
115 * Sends the exchange to the given endpoint
116 *
117 * @param endpoint the endpoint to send the exchange to
118 * @param exchange the exchange to send
119 */
120 E send(Endpoint<E> endpoint, E exchange);
121
122 /**
123 * Sends an exchange to an endpoint using a supplied processor
124 *
125 * @param endpoint the endpoint to send the exchange to
126 * @param processor the transformer used to populate the new exchange
127 * {@link Processor} to populate the exchange
128 */
129 E send(Endpoint<E> endpoint, Processor processor);
130
131 /**
132 * Sends an exchange to an endpoint using a supplied processor
133 *
134 * @param endpoint the endpoint to send the exchange to
135 * @param pattern the message {@link ExchangePattern} such as
136 * {@link ExchangePattern#InOnly} or {@link ExchangePattern#InOut}
137 * @param processor the transformer used to populate the new exchange
138 * {@link Processor} to populate the exchange
139 */
140 E send(Endpoint<E> endpoint, ExchangePattern pattern, Processor processor);
141
142 /**
143 * Sends an exchange to an endpoint using a supplied processor
144 *
145 * @param endpoint the endpoint to send the exchange to
146 * @param processor the transformer used to populate the new exchange
147 * {@link Processor} to populate the exchange.
148 * @param callback the callback will be called when the exchange is completed.
149 */
150 E send(Endpoint<E> endpoint, Processor processor, AsyncCallback callback);
151
152 /**
153 * Send the body to an endpoint returning any result output body
154 *
155 * @param endpoint the endpoint to send the exchange to
156 * @param body the payload
157 * @return the result
158 */
159 Object sendBody(Endpoint<E> endpoint, Object body);
160
161 /**
162 * Send the body to an endpoint returning any result output body
163 *
164 * @param endpointUri the endpoint URI to send the exchange to
165 * @param body the payload
166 * @return the result
167 */
168 Object sendBody(String endpointUri, Object body);
169
170 /**
171 * Send the body to an endpoint with the given {@link ExchangePattern}
172 * returning any result output body
173 *
174 * @param endpoint the endpoint to send the exchange to
175 * @param body the payload
176 * @param pattern the message {@link ExchangePattern} such as
177 * {@link ExchangePattern#InOnly} or {@link ExchangePattern#InOut}
178 * @return the result
179 */
180 Object sendBody(Endpoint<E> endpoint, ExchangePattern pattern, Object body);
181
182 /**
183 * Send the body to an endpoint returning any result output body
184 *
185 * @param endpointUri the endpoint URI to send the exchange to
186 * @param pattern the message {@link ExchangePattern} such as
187 * {@link ExchangePattern#InOnly} or {@link ExchangePattern#InOut}
188 * @param body the payload
189 * @return the result
190 */
191 Object sendBody(String endpointUri, ExchangePattern pattern, Object body);
192
193 /**
194 * Sends the body to an endpoint with a specified header and header value
195 *
196 * @param endpointUri the endpoint URI to send to
197 * @param body the payload send
198 * @param header the header name
199 * @param headerValue the header value
200 * @return the result
201 */
202 Object sendBodyAndHeader(String endpointUri, Object body, String header,
203 Object headerValue);
204
205 /**
206 * Sends the body to an endpoint with a specified header and header value
207 *
208 * @param endpoint the Endpoint to send to
209 * @param body the payload send
210 * @param header the header name
211 * @param headerValue the header value
212 * @return the result
213 */
214 Object sendBodyAndHeader(Endpoint endpoint, Object body, String header,
215 Object headerValue);
216
217 /**
218 * Sends the body to an endpoint with a specified header and header value
219 *
220 * @param endpoint the Endpoint to send to
221 * @param pattern the message {@link ExchangePattern} such as
222 * {@link ExchangePattern#InOnly} or {@link ExchangePattern#InOut}
223 * @param body the payload send
224 * @param header the header name
225 * @param headerValue the header value
226 * @return the result
227 */
228 Object sendBodyAndHeader(Endpoint endpoint, ExchangePattern pattern, Object body, String header,
229 Object headerValue);
230
231 /**
232 * Sends the body to an endpoint with a specified header and header value
233 *
234 * @param endpoint the Endpoint URI to send to
235 * @param pattern the message {@link ExchangePattern} such as
236 * {@link ExchangePattern#InOnly} or {@link ExchangePattern#InOut}
237 * @param body the payload send
238 * @param header the header name
239 * @param headerValue the header value
240 * @return the result
241 */
242 Object sendBodyAndHeader(String endpoint, ExchangePattern pattern, Object body, String header,
243 Object headerValue);
244
245 /**
246 * Sends the body to an endpoint with the specified headers and header
247 * values
248 *
249 * @param endpointUri the endpoint URI to send to
250 * @param body the payload send
251 * @return the result
252 */
253 Object sendBodyAndHeaders(String endpointUri, Object body, Map<String, Object> headers);
254
255 /**
256 * Sends the body to an endpoint with the specified headers and header
257 * values
258 *
259 * @param endpoint the endpoint URI to send to
260 * @param body the payload send
261 * @return the result
262 */
263 Object sendBodyAndHeaders(Endpoint endpoint, Object body, Map<String, Object> headers);
264
265
266 // Methods using an InOut ExchangePattern
267 // -----------------------------------------------------------------------
268
269 /**
270 * Send the body to an endpoint returning any result output body.
271 * Uses an {@link ExchangePattern#InOut} message exchange pattern.
272 *
273 * @param endpoint the Endpoint to send to
274 * @param processor the processor which will populate the exchange before sending
275 * @return the result
276 */
277 E request(Endpoint<E> endpoint, Processor processor);
278
279 /**
280 * Send the body to an endpoint returning any result output body.
281 * Uses an {@link ExchangePattern#InOut} message exchange pattern.
282 *
283 * @param endpoint the Endpoint to send to
284 * @param body the payload
285 * @return the result
286 */
287 Object requestBody(Endpoint<E> endpoint, Object body);
288
289 /**
290 * Send the body to an endpoint returning any result output body.
291 * Uses an {@link ExchangePattern#InOut} message exchange pattern.
292 *
293 * @param endpoint the Endpoint to send to
294 * @param body the payload
295 * @param header the header name
296 * @param headerValue the header value
297 * @return the result
298 */
299 Object requestBodyAndHeader(Endpoint<E> endpoint, Object body, String header, Object headerValue);
300
301 /**
302 * Send the body to an endpoint returning any result output body.
303 * Uses an {@link ExchangePattern#InOut} message exchange pattern.
304 *
305 * @param endpointUri the endpoint URI to send to
306 * @param processor the processor which will populate the exchange before sending
307 * @return the result
308 */
309 E request(String endpointUri, Processor processor);
310
311 /**
312 * Send the body to an endpoint returning any result output body.
313 * Uses an {@link ExchangePattern#InOut} message exchange pattern.
314 *
315 * @param endpointUri the endpoint URI to send to
316 * @param body the payload
317 * @return the result
318 */
319 Object requestBody(String endpointUri, Object body);
320
321 /**
322 * Send the body to an endpoint returning any result output body.
323 * Uses an {@link ExchangePattern#InOut} message exchange pattern.
324 *
325 * @param endpointUri the endpoint URI to send to
326 * @param body the payload
327 * @param header the header name
328 * @param headerValue the header value
329 * @return the result
330 */
331 Object requestBodyAndHeader(String endpointUri, Object body, String header, Object headerValue);
332
333 }