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