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.Collection; 020 import java.util.List; 021 import java.util.Map; 022 import java.util.concurrent.Callable; 023 024 import org.apache.camel.builder.ErrorHandlerBuilder; 025 import org.apache.camel.model.RouteDefinition; 026 import org.apache.camel.model.dataformat.DataFormatDefinition; 027 import org.apache.camel.spi.ClassResolver; 028 import org.apache.camel.spi.ExchangeConverter; 029 import org.apache.camel.spi.Injector; 030 import org.apache.camel.spi.InterceptStrategy; 031 import org.apache.camel.spi.Language; 032 import org.apache.camel.spi.LifecycleStrategy; 033 import org.apache.camel.spi.PackageScanClassResolver; 034 import org.apache.camel.spi.Registry; 035 import org.apache.camel.spi.TypeConverterRegistry; 036 import org.apache.camel.util.FactoryFinder; 037 038 /** 039 * Interface used to represent the context used to configure routes and the 040 * policies to use during message exchanges between endpoints. 041 * 042 * @version $Revision: 752893 $ 043 */ 044 public interface CamelContext extends Service { 045 046 /** 047 * Gets the name of the this context. 048 * 049 * @return the name 050 */ 051 String getName(); 052 053 // Component Management Methods 054 //----------------------------------------------------------------------- 055 056 /** 057 * Adds a component to the context. 058 * 059 * @param componentName the name the component is registered as 060 * @param component the component 061 */ 062 void addComponent(String componentName, Component component); 063 064 /** 065 * Gets a component from the context by name. 066 * 067 * @param componentName the name of the component 068 * @return the component 069 */ 070 Component getComponent(String componentName); 071 072 /** 073 * Gets a component from the context by name and specifying the expected type of component. 074 * 075 * @param name the name to lookup 076 * @param componentType the expected type 077 * @return the component 078 */ 079 <T extends Component> T getComponent(String name, Class<T> componentType); 080 081 /** 082 * Gets a readonly list of names of the components currently registered 083 * 084 * @return a readonly list with the names of the the componens. 085 */ 086 List<String> getComponentNames(); 087 088 /** 089 * Removes a previously added component. 090 * 091 * @param componentName the component name to remove 092 * @return the previously added component or null if it had not been previously added. 093 */ 094 Component removeComponent(String componentName); 095 096 /** 097 * Gets the a previously added component by name or lazily creates the component 098 * using the factory Callback. 099 * 100 * @param componentName the name of the component 101 * @param factory used to create a new component instance if the component was not previously added. 102 * @return the component 103 */ 104 Component getOrCreateComponent(String componentName, Callable<Component> factory); 105 106 // Endpoint Management Methods 107 //----------------------------------------------------------------------- 108 109 /** 110 * Resolves the given URI to an {@link Endpoint}. If the URI has a singleton endpoint 111 * registered, then the singleton is returned. Otherwise, a new {@link Endpoint} is created 112 * and if the endpoint is a singleton it is registered as a singleton endpoint. 113 * 114 * @param uri the URI of the endpoint 115 * @return the endpoint 116 */ 117 Endpoint getEndpoint(String uri); 118 119 /** 120 * Resolves the given name to an {@link Endpoint} of the specified type. 121 * If the name has a singleton endpoint registered, then the singleton is returned. 122 * Otherwise, a new {@link Endpoint} is created and if the endpoint is a 123 * singleton it is registered as a singleton endpoint. 124 * 125 * @param name the name of the endpoint 126 * @param endpointType the expected type 127 * @return the endpoint 128 */ 129 <T extends Endpoint> T getEndpoint(String name, Class<T> endpointType); 130 131 /** 132 * Returns the collection of all registered endpoints. 133 * 134 * @return all endpoints 135 */ 136 Collection<Endpoint> getEndpoints(); 137 138 /** 139 * Returns a new Map containing all of the active endpoints with the key of the map being their 140 * unique key. 141 * 142 * @return map of active endpoints 143 */ 144 Map<String, Endpoint> getEndpointMap(); 145 146 /** 147 * Returns the collection of all registered endpoints for a uri or an empty collection. 148 * For a singleton endpoint the collection will contain exactly one element. 149 * 150 * @param uri the URI of the endpoints 151 * @return collection of endpoints 152 */ 153 Collection<Endpoint> getEndpoints(String uri); 154 155 /** 156 * Returns the collection of all registered singleton endpoints. 157 * 158 * @return all the singleton endpoints 159 */ 160 Collection<Endpoint> getSingletonEndpoints(); 161 162 /** 163 * Adds the endpoint to the context using the given URI. 164 * 165 * @param uri the URI to be used to resolve this endpoint 166 * @param endpoint the endpoint to be added to the context 167 * @return the old endpoint that was previously registered to the context if 168 * there was already an singleton endpoint for that URI or null 169 * @throws Exception if the new endpoint could not be started or the old 170 * singleton endpoint could not be stopped 171 */ 172 Endpoint addEndpoint(String uri, Endpoint endpoint) throws Exception; 173 174 /** 175 * Removes all endpoints with the given URI 176 * 177 * @param uri the URI to be used to remove 178 * @return a collection of endpoints removed or null if there are no endpoints for this URI 179 * @throws Exception if at least one endpoint could not be stopped 180 */ 181 Collection<Endpoint> removeEndpoints(String uri) throws Exception; 182 183 // Route Management Methods 184 //----------------------------------------------------------------------- 185 186 /** 187 * Returns a list of the current route definitions 188 * 189 * @return list of the current route definitions 190 */ 191 List<RouteDefinition> getRouteDefinitions(); 192 193 /** 194 * Returns the current routes in this context 195 * 196 * @return the current routes 197 */ 198 List<Route> getRoutes(); 199 200 /** 201 * Adds a collection of routes to this context using the given builder 202 * to build them 203 * 204 * @param builder the builder which will create the routes and add them to this context 205 * @throws Exception if the routes could not be created for whatever reason 206 */ 207 void addRoutes(Routes builder) throws Exception; 208 209 /** 210 * Adds a collection of route definitions to the context 211 * 212 * @param routeDefinitions the route definitions to add 213 * @throws Exception if the route definition could not be created for whatever reason 214 */ 215 void addRouteDefinitions(Collection<RouteDefinition> routeDefinitions) throws Exception; 216 217 /** 218 * Removes a collection of route definitions from the context - stopping any previously running 219 * routes if any of them are actively running 220 */ 221 void removeRouteDefinitions(Collection<RouteDefinition> routeDefinitions) throws Exception; 222 223 /** 224 * Starts the given route if it has been previously stopped 225 */ 226 void startRoute(RouteDefinition route) throws Exception; 227 228 /** 229 * Stops the given route. It will remain in the list of route definitions return by {@link #getRouteDefinitions()} 230 * unless you use the {@link #removeRouteDefinitions(java.util.Collection)} 231 */ 232 void stopRoute(RouteDefinition route) throws Exception; 233 234 235 // Properties 236 //----------------------------------------------------------------------- 237 238 /** 239 * Returns the converter of exchanges from one type to another 240 * 241 * @return the converter 242 */ 243 ExchangeConverter getExchangeConverter(); 244 245 /** 246 * Returns the type converter used to coerce types from one type to another 247 * 248 * @return the converter 249 */ 250 TypeConverter getTypeConverter(); 251 252 /** 253 * Returns the type converter registry where type converters can be added or looked up 254 * 255 * @return the type converter registry 256 */ 257 TypeConverterRegistry getTypeConverterRegistry(); 258 259 /** 260 * Returns the registry used to lookup components by name and type such as the Spring ApplicationContext, 261 * JNDI or the OSGi Service Registry 262 * 263 * @return the registry 264 */ 265 Registry getRegistry(); 266 267 /** 268 * Returns the injector used to instantiate objects by type 269 * 270 * @return the injector 271 */ 272 Injector getInjector(); 273 274 /** 275 * Returns the lifecycle strategy used to handle lifecycle notification 276 * 277 * @return the lifecycle strategy 278 */ 279 LifecycleStrategy getLifecycleStrategy(); 280 281 /** 282 * Resolves a language for creating expressions 283 * 284 * @param language name of the language 285 * @return the resolved language 286 */ 287 Language resolveLanguage(String language); 288 289 /** 290 * Gets a readonly list with the names of the languages currently registered. 291 * 292 * @return a readonly list with the names of the the languages. 293 */ 294 List<String> getLanguageNames(); 295 296 /** 297 * Creates a new ProducerTemplate. 298 * <p/> 299 * See this FAQ before use: <a href="http://camel.apache.org/why-does-camel-use-too-many-threads-with-producertemplate.html"> 300 * Why does Camel use too many threads with ProducerTemplate?</a> 301 * 302 * @return the template 303 */ 304 ProducerTemplate createProducerTemplate(); 305 306 /** 307 * Adds the given interceptor strategy 308 * 309 * @param interceptStrategy the strategy 310 */ 311 void addInterceptStrategy(InterceptStrategy interceptStrategy); 312 313 /** 314 * Gets the interceptor strategies 315 * 316 * @return the list of current interceptor strategies 317 */ 318 List<InterceptStrategy> getInterceptStrategies(); 319 320 /** 321 * Gets the default error handler builder which is inherited by the routes 322 * 323 * @return the builder 324 */ 325 ErrorHandlerBuilder getErrorHandlerBuilder(); 326 327 /** 328 * Sets the default error handler builder which is inherited by the routes 329 * 330 * @param errorHandlerBuilder the builder 331 */ 332 void setErrorHandlerBuilder(ErrorHandlerBuilder errorHandlerBuilder); 333 334 /** 335 * Sets the data formats that can be referenced in the routes. 336 * @param dataFormats the data formats 337 */ 338 void setDataFormats(Map<String, DataFormatDefinition> dataFormats); 339 340 /** 341 * Gets the data formats that can be referenced in the routes. 342 * 343 * @return the data formats available 344 */ 345 Map<String, DataFormatDefinition> getDataFormats(); 346 347 /** 348 * Sets the properties that can be referenced in the camel context 349 */ 350 void setProperties(Map<String, String> properties); 351 352 /** 353 * Gets the properties that can be referenced in the camel context 354 */ 355 Map<String, String> getProperties(); 356 357 /** 358 * Create a FactoryFinder which will be used for the loading the factory class from META-INF 359 * @return the factory finder 360 */ 361 FactoryFinder createFactoryFinder(); 362 363 /** 364 * Create a FactoryFinder which will be used for the loading the factory class from META-INF 365 * @param path the META-INF path 366 * @return the factory finder 367 */ 368 FactoryFinder createFactoryFinder(String path); 369 370 /** 371 * Returns the current status of the given route 372 */ 373 ServiceStatus getRouteStatus(RouteDefinition route); 374 375 /** 376 * Returns the class resolver to be used for loading/lookup of classes. 377 */ 378 ClassResolver getClassResolver(); 379 380 /** 381 * Returns the package scanning class resolver 382 */ 383 PackageScanClassResolver getPackageScanClassResolver(); 384 385 /** 386 * Sets the class resolver to be use 387 */ 388 void setClassResolver(ClassResolver resolver); 389 390 /** 391 * Sets the package scanning class resolver to use 392 */ 393 void setPackageScanClassResolver(PackageScanClassResolver resolver); 394 395 }