一 快速启动
1.1 快速使用
在项目的pom.xml文件中加入以下依赖
1 | <dependencyManagement> |
接下来加入必须的核心依赖camel-spring-boot-starter
1 | <dependencies> |
再按照项目的需要加入需要的组件,例如加上ActiveMQ支持。
1 | <dependencies> |
为了确保Spring Boot应用程序在停止或JVM终止之前保持运行,通常只在运行Spring Boot standalone时才需要,即在web容器保持JVM运行时不使用Spring Boot starter web,请在配置中设置camel.springboot.main run-controller=true
属性。例如,在application.properties中加入以下配置
1 | # to keep the JVM running |
每个启动器都列出了可以在标准application.properties或application.yml文件中配置的配置参数。这些参数的形式为camel.component.[componentname].[parameter]
。例如,要配置ActiveMQ代理的URL,可以设置:
1 | tcp://localhost:61616 = |
在Spring应用程序上下文中检测到Camel路由,例如,将加载一个用org.springframework.stereotype.Component
注释的路由,将其添加到Camel上下文中并运行。
1 | import org.apache.camel.builder.RouteBuilder; |
1.2 可选配置
可以进一步为Spring Boot应用程序所需 starter
1 | <dependency> |
在这里,我们添加了三个依赖于使用servlet、jackson和swagger组件的启动器,它们将执行以下功能:
- servlet组件将提供基于HTTP 接口。
- jackson组件用于java和json对象的转换。
- swagger根据controller接口反向生成接口文档。
二 springboot 自动化配置
2.1 基础支持
确保在项目里加入以下依赖
1 | <dependency> |
支持的224个组件如下:
Name | Description | Default | Type |
---|---|---|---|
camel.cloud.enabled | 启用/禁用骆驼云支持的全局选项,默认值为true。 | true | Boolean |
camel.cloud.load-balancer.enabled | 启用/禁用Camel云负载平衡器的全局选项,默认值为true。 | true | Boolean |
camel.cloud.service-call.component | 用于调用服务的Camel组件。默认为http组件。 | String | |
camel.cloud.service-call.default-load-balancer | Determine if the default load balancer should be used instead of any auto discovered one. | false | Boolean |
camel.cloud.service-call.expression | The expression to use. | String | |
camel.cloud.service-call.expression-language | The expression language to use, default is ref. | ref | String |
camel.cloud.service-call.load-balancer | A reference to the org.apache.camel.cloud.ServiceLoadBalancer to use. | String | |
camel.cloud.service-call.service-chooser | A reference to the org.apache.camel.cloud.ServiceChooser to use. | String | |
camel.cloud.service-call.service-discovery | A reference to the org.apache.camel.cloud.ServiceDiscovery to use. | String | |
camel.cloud.service-call.service-filter | A reference to the org.apache.camel.cloud.ServiceFilter to use. | String | |
camel.cloud.service-call.uri | The uri of the endpoint to send to. The uri can be dynamic computed using the simple language expression. | String | |
camel.cloud.service-chooser.enabled | Global option to enable/disable Camel cloud service chooser, default is true. | true | Boolean |
camel.cloud.service-discovery.configurations | Configure the service discovery rules. | Map | |
camel.cloud.service-discovery.enabled | Global option to enable/disable Camel cloud service discovery, default is true. | true | Boolean |
camel.cloud.service-discovery.service-definitions | Configure static service discovery with distinct id, host, port, and metadata properties. | Map | |
camel.cloud.service-discovery.services | Configure static service discovery using simple host:port strings. | Map | |
camel.cloud.service-filter.blacklist | Configure service filter blacklists. | Map | |
camel.cloud.service-filter.configurations | Configure the service filtering rules. | Map | |
camel.cloud.service-filter.enabled | Global option to enable/disable Camel cloud service filter, default is true. | true | Boolean |
camel.cloud.service-registry.enabled | Configure if service registry should be enabled or not, default true. | true | Boolean |
camel.cloud.service-registry.service-host | Configure the service listening address. | String | |
camel.clustered.controller.cluster-service | The cluster service. | CamelClusterService | |
camel.clustered.controller.enabled | Global option to enable/disable Camel clustered route controller, default is false. | false | Boolean |
camel.clustered.controller.initial-delay | Set the amount of time (in millis) the route controller should wait before to start the routes after the camel context is started or after the route is initialized if the route is created after the camel context is started. | String | |
camel.clustered.controller.namespace | The default namespace. | String | |
camel.clustered.controller.routes | Routes configuration. | Map | |
camel.component.enabled | Global option to enable/disable component auto-configuration, default is true. | true | Boolean |
camel.component.properties.auto-discover-properties-sources | Whether to automatically discovery instances of PropertiesSource from registry and service factory. | true | Boolean |
camel.component.properties.default-fallback-enabled | If false, the component does not attempt to find a default for the key by looking after the colon separator. | true | Boolean |
camel.component.properties.encoding | Encoding to use when loading properties file from the file system or classpath. If no encoding has been set, then the properties files is loaded using ISO-8859-1 encoding (latin-1) as documented by java.util.Properties#load(java.io.InputStream). | String | |
camel.component.properties.environment-variable-mode | Sets the OS environment variables mode (0 = never, 1 = fallback, 2 = override). The default mode (override) is to use OS environment variables if present, and override any existing properties. OS environment variable mode is checked before JVM system property mode. | 2 | Integer |
camel.component.properties.ignore-missing-location | Whether to silently ignore if a location cannot be located, such as a properties file not found. | false | Boolean |
camel.component.properties.initial-properties | Sets initial properties which will be used before any locations are resolved. The option is a java.util.Properties type. | String | |
camel.component.properties.location | A list of locations to load properties. You can use comma to separate multiple locations. This option will override any default locations and only use the locations from this option. | String | |
camel.component.properties.nested-placeholder | Whether to support nested property placeholders. A nested placeholder, means that a placeholder, has also a placeholder, that should be resolved (recursively). | false | Boolean |
camel.component.properties.override-properties | Sets a special list of override properties that take precedence and will use first, if a property exist. The option is a java.util.Properties type. | String | |
camel.component.properties.properties-parser | To use a custom PropertiesParser. The option is a org.apache.camel.component.properties.PropertiesParser type. | String | |
camel.component.properties.system-properties-mode | Sets the JVM system property mode (0 = never, 1 = fallback, 2 = override). The default mode (override) is to use system properties if present, and override any existing properties. OS environment variable mode is checked before JVM system property mode. | 2 | Integer |
camel.dataformat.enabled | Global option to enable/disable dataformat auto-configuration, default is true. | true | Boolean |
camel.health.components-enabled | Whether components health check is enabled. Is default enabled. |
Boolean | |
camel.health.consumers-enabled | Whether consumers health check is enabled. Is default enabled. |
Boolean | |
camel.health.enabled | Whether health check is enabled globally. Is default enabled. |
Boolean | |
camel.health.exclude-pattern | Pattern to exclude health checks from being invoked by Camel when checking healths. Multiple patterns can be separated by comma. | String | |
camel.health.exposure-level | 设置由于调用健康检查而暴露的详细信息级别。有以下级别:完整、默认、单行。完整级别将包括所有调用的健康检查的所有详细信息和状态。如果一切正常,默认级别将报告UP,并且只包括DOWN的健康检查的详细信息。单线级别仅报告UP或DOWN。 | default | String |
camel.health.initial-state | 健康检查的初始状态(准备就绪)。有以下状态:UP、DOWN、UNKNOWN。默认情况下,状态为DOWN,被视为悲观/谨慎。这意味着,在启动期间,整体健康检查可能会报告为DOWN,然后只有当一切正常运行时,才会报告为up。将初始状态设置为UP被认为是乐观的。这意味着,在启动期间,整体健康检查可能会报告为UP,然后如果消费者或其他服务实际上不健康,那么健康检查会反转为DOWN。将状态设置为UNKNOWN意味着某些运行状况检查将以未知状态报告,特别是在早期引导期间,消费者可能未完全初始化或验证到远程系统的连接。此选项允许预配置不同模式的状态。 | down | String |
camel.health.registry-enabled | Whether registry health check is enabled. Is default enabled. |
Boolean | |
camel.health.routes-enabled | Whether routes health check is enabled. Is default enabled. |
Boolean | |
camel.language.enabled | Global option to enable/disable language auto-configuration, default is true. | true | Boolean |
camel.routetemplate.config | Route template configurations. | List | |
camel.springboot.allow-use-original-message | 设置是允许从Camel的错误处理程序访问原始消息,还是从org.apache.cacame.spi.UnitOfWork.getOriginalInMessage()访问原始消息。关闭此选项可以优化性能,因为不需要原始消息的防御性副本。默认值为false。 | false | Boolean |
camel.springboot.auto-startup | 设置骆驼启动时对象是否应自动启动。重要提示:当前只能禁用路由,因为CamelContext始终处于启动状态。注意:当在CamelContext上设置自动启动为false时,该设置优先,并且不启动路由。您需要使用org.apache.cacamel.CamelContext.start()方法显式启动CamelContext,以启动上下文,然后需要使用CamelContext.getRouteController().startRoute(String)手动启动路由。默认值为true,始终启动。 | true | Boolean |
camel.springboot.autowired-enabled | 是否启用自动布线。这用于自动自动布线选项(该选项必须标记为自动布线),方法是在注册表中查找是否存在匹配类型的单个实例,然后在组件上配置该实例。这可用于自动配置JDBC数据源、JMS连接工厂、AWS客户端等。默认值为true。 | true | Boolean |
camel.springboot.backlog-tracing | Sets whether backlog tracing is enabled or not. Default is false. | false | Boolean |
camel.springboot.backlog-tracing-standby | Boolean | ||
camel.springboot.bean-introspection-extended-statistics | Sets whether bean introspection uses extended statistics. The default is false. | false | Boolean |
camel.springboot.bean-introspection-logging-level | Sets the logging level used by bean introspection, logging activity of its usage. The default is TRACE. | LoggingLevel | |
camel.springboot.bean-post-processor-enabled | Can be used to turn off bean post processing. Be careful to turn this off, as this means that beans that use Camel annotations such as org.apache.camel.EndpointInject, org.apache.camel.ProducerTemplate, org.apache.camel.Produce, org.apache.camel.Consume etc will not be injected and in use. Turning this off should only be done if you are sure you do not use any of these Camel features. Not all runtimes allow turning this off (such as camel-blueprint or camel-cdi with XML). The default value is true (enabled). | true | Boolean |
camel.springboot.camel-events-timestamp-enabled | Whether to include timestamps for all emitted Camel Events. Enabling this allows to know fine-grained at what time each event was emitted, which can be used for reporting to report exactly the time of the events. This is by default false to avoid the overhead of including this information. | false | Boolean |
camel.springboot.case-insensitive-headers | Whether to use case sensitive or insensitive headers. Important: When using case sensitive (this is set to false). Then the map is case sensitive which means headers such as content-type and Content-Type are two different keys which can be a problem for some protocols such as HTTP based, which rely on case insensitive headers. However case sensitive implementations can yield faster performance. Therefore use case sensitive implementation with care. Default is true. | true | Boolean |
camel.springboot.consumer-template-cache-size | Consumer template endpoints cache size. | 1000 | Integer |
camel.springboot.context-reload-enabled | Used for enabling context reloading. If enabled then Camel allow external systems such as security vaults (AWS secrets manager, etc.) to trigger refreshing Camel by updating property placeholders and reload all existing routes to take changes into effect. | false | Boolean |
camel.springboot.debugging | Sets whether debugging is enabled or not. Default is false. | false | Boolean |
camel.springboot.description | Sets the description (intended for humans) of the Camel application. | String | |
camel.springboot.dev-console-enabled | Whether to enable developer console (requires camel-console on classpath). The developer console is only for assisting during development. This is NOT for production usage. | false | Boolean |
camel.springboot.dump-routes | If dumping is enabled then Camel will during startup dump all loaded routes (incl rests and route templates) represented as XML DSL into the log. This is intended for trouble shooting or to assist during development. Sensitive information that may be configured in the route endpoints could potentially be included in the dump output and is therefore not recommended to be used for production usage. This requires to have camel-xml-jaxb on the classpath to be able to dump the routes as XML. | false | Boolean |
camel.springboot.duration-max-action | Controls whether the Camel application should shutdown the JVM, or stop all routes, when duration max is triggered. | shutdown | String |
camel.springboot.duration-max-idle-seconds | To specify for how long time in seconds Camel can be idle before automatic terminating the JVM. You can use this to run Spring Boot for a short while. | 0 | Integer |
camel.springboot.duration-max-messages | To specify how many messages to process by Camel before automatic terminating the JVM. You can use this to run Spring Boot for a short while. | 0 | Integer |
camel.springboot.duration-max-seconds | To specify for how long time in seconds to keep running the JVM before automatic terminating the JVM. You can use this to run Spring Boot for a short while. | 0 | Integer |
camel.springboot.endpoint-bridge-error-handler | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN/ERROR level and ignored. The default value is false. | false | Boolean |
camel.springboot.endpoint-lazy-start-producer | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel’s routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. The default value is false. | false | Boolean |
camel.springboot.endpoint-runtime-statistics-enabled | Sets whether endpoint runtime statistics is enabled (gathers runtime usage of each incoming and outgoing endpoints). The default value is false. | false | Boolean |
camel.springboot.exchange-factory | Controls whether to pool (reuse) exchanges or create new exchanges (prototype). Using pooled will reduce JVM garbage collection overhead by avoiding to re-create Exchange instances per message each consumer receives. The default is prototype mode. | default | String |
camel.springboot.exchange-factory-capacity | The capacity the pool (for each consumer) uses for storing exchanges. The default capacity is 100. | 100 | Integer |
camel.springboot.exchange-factory-statistics-enabled | Configures whether statistics is enabled on exchange factory. | false | Boolean |
camel.springboot.file-configurations | Directory to load additional configuration files that contains configuration values that takes precedence over any other configuration. This can be used to refer to files that may have secret configuration that has been mounted on the file system for containers. You must use either file: or classpath: as prefix to load from file system or classpath. Then you can specify a pattern to load from sub directories and a name pattern such as file:/var/app/secret/*.properties. | String | |
camel.springboot.global-options | Sets global options that can be referenced in the camel context Important: This has nothing to do with property placeholders, and is just a plain set of key/value pairs which are used to configure global options on CamelContext, such as a maximum debug logging length etc. | Map | |
camel.springboot.include-non-singletons | Whether to include non-singleton beans (prototypes) when scanning for RouteBuilder instances. By default only singleton beans is included in the context scan. | false | Boolean |
camel.springboot.inflight-repository-browse-enabled | Sets whether the inflight repository should allow browsing each inflight exchange. This is by default disabled as there is a very slight performance overhead when enabled. | false | Boolean |
camel.springboot.java-routes-exclude-pattern | Used for exclusive filtering RouteBuilder classes which are collected from the registry or via classpath scanning. The exclusive filtering takes precedence over inclusive filtering. The pattern is using Ant-path style pattern. Multiple patterns can be specified separated by comma. For example to exclude all classes starting with Bar use: /Bar To exclude all routes form a specific package use: com/mycompany/bar/ To exclude all routes form a specific package and its sub-packages use double wildcards: com/mycompany/bar/ And to exclude all routes from two specific packages use: com/mycompany/bar/,com/mycompany/stuff/. | String | |
camel.springboot.java-routes-include-pattern | Used for inclusive filtering RouteBuilder classes which are collected from the registry or via classpath scanning. The exclusive filtering takes precedence over inclusive filtering. The pattern is using Ant-path style pattern. Multiple patterns can be specified separated by comma. Multiple patterns can be specified separated by comma. For example to include all classes starting with Foo use: /Foo To include all routes form a specific package use: com/mycompany/foo/ To include all routes form a specific package and its sub-packages use double wildcards: com/mycompany/foo/ And to include all routes from two specific packages use: com/mycompany/foo/,com/mycompany/stuff/. | String | |
camel.springboot.jmx-enabled | Enable JMX in your Camel application. | true | Boolean |
camel.springboot.jmx-management-m-beans-level | Sets the JMX statistics level The level can be set to Extended to gather additional information The default value is Default. | ManagementMBeansLevel | |
camel.springboot.jmx-management-name-pattern | The naming pattern for creating the CamelContext JMX management name. The default pattern is name. | name | String |
camel.springboot.jmx-management-statistics-level | Sets the JMX statistics level The level can be set to Extended to gather additional information The default value is Default. | ManagementStatisticsLevel | |
camel.springboot.lightweight | Experimental: Configure the context to be lightweight. This will trigger some optimizations and memory reduction options. Lightweight context has some limitations. At this moment, dynamic endpoint destinations are not supported. | false | Boolean |
camel.springboot.load-health-checks | Whether to load custom health checks by scanning classpath. | false | Boolean |
camel.springboot.load-statistics-enabled | Sets whether context load statistics is enabled (something like the unix load average). The statistics requires to have camel-management on the classpath as JMX is required. The default value is false. | false | Boolean |
camel.springboot.load-type-converters | Whether to load custom type converters by scanning classpath. This is used for backwards compatibility with Camel 2.x. Its recommended to migrate to use fast type converter loading by setting <tt>@Converter(generateLoader = true)</tt> on your custom type converter classes. | true | Boolean |
camel.springboot.log-debug-max-chars | Is used to limit the maximum length of the logging Camel message bodies. If the message body is longer than the limit, the log message is clipped. Use -1 to have unlimited length. Use for example 1000 to log at most 1000 characters. | 0 | Integer |
camel.springboot.log-exhausted-message-body | Sets whether to log exhausted message body with message history. Default is false. | false | Boolean |
camel.springboot.log-mask | Sets whether log mask is enabled or not. Default is false. | false | Boolean |
camel.springboot.main-run-controller | Whether to use the main run controller to ensure the Spring-Boot application keeps running until being stopped or the JVM terminated. You typically only need this if you run Spring-Boot standalone. If you run Spring-Boot with spring-boot-starter-web then the web container keeps the JVM running. | false | Boolean |
camel.springboot.mdc-logging-keys-pattern | Sets the pattern used for determining which custom MDC keys to propagate during message routing when the routing engine continues routing asynchronously for the given message. Setting this pattern to will propagate all custom keys. Or setting the pattern to foo,bar will propagate any keys starting with either foo or bar. Notice that a set of standard Camel MDC keys are always propagated which starts with camel. as key name. The match rules are applied in this order (case insensitive): 1. exact match, returns true 2. wildcard match (pattern ends with a and the name starts with the pattern), returns true 3. regular expression match, returns true 4. otherwise returns false. | String | |
camel.springboot.message-history | Sets whether message history is enabled or not. Default is true. | true | Boolean |
camel.springboot.modeline | Whether camel-k style modeline is also enabled when not using camel-k. Enabling this allows to use a camel-k like experience by being able to configure various settings using modeline directly in your route source code. | false | Boolean |
camel.springboot.name | Sets the name of the CamelContext. | String | |
camel.springboot.producer-template-cache-size | Producer template endpoints cache size. | 1000 | Integer |
camel.springboot.route-controller-back-off-delay | Backoff delay in millis when restarting a route that failed to startup. | 2000 | Long |
camel.springboot.route-controller-back-off-max-attempts | Backoff maximum number of attempts to restart a route that failed to startup. When this threshold has been exceeded then the controller will give up attempting to restart the route, and the route will remain as stopped. | 0 | Long |
camel.springboot.route-controller-back-off-max-delay | Backoff maximum delay in millis when restarting a route that failed to startup. | 0 | Long |
camel.springboot.route-controller-back-off-max-elapsed-time | Backoff maximum elapsed time in millis, after which the backoff should be considered exhausted and no more attempts should be made. | 0 | Long |
camel.springboot.route-controller-back-off-multiplier | Backoff multiplier to use for exponential backoff. This is used to extend the delay between restart attempts. | 1 | Double |
camel.springboot.route-controller-exclude-routes | Pattern for filtering routes to be included as supervised. The pattern is matching on route id, and endpoint uri for the route. Multiple patterns can be separated by comma. For example to include all kafka routes, you can say kafka:*. And to include routes with specific route ids myRoute,myOtherRoute. The pattern supports wildcards and uses the matcher from org.apache.camel.support.PatternHelper#matchPattern. | String | |
camel.springboot.route-controller-include-routes | Pattern for filtering routes to be excluded as supervised. The pattern is matching on route id, and endpoint uri for the route. Multiple patterns can be separated by comma. For example to exclude all JMS routes, you can say jms:*. And to exclude routes with specific route ids mySpecialRoute,myOtherSpecialRoute. The pattern supports wildcards and uses the matcher from org.apache.camel.support.PatternHelper#matchPattern. | String | |
camel.springboot.route-controller-initial-delay | Initial delay in milli seconds before the route controller starts, after CamelContext has been started. | 0 | Long |
camel.springboot.route-controller-supervise-enabled | To enable using supervising route controller which allows Camel to startup and then the controller takes care of starting the routes in a safe manner. This can be used when you want to startup Camel despite a route may otherwise fail fast during startup and cause Camel to fail to startup as well. By delegating the route startup to the supervising route controller then it manages the startup using a background thread. The controller allows to be configured with various settings to attempt to restart failing routes. | false | Boolean |
camel.springboot.route-controller-thread-pool-size | The number of threads used by the route controller scheduled thread pool that are used for restarting routes. The pool uses 1 thread by default, but you can increase this to allow the controller to concurrently attempt to restart multiple routes in case more than one route has problems starting. | 1 | Integer |
camel.springboot.route-controller-unhealthy-on-exhausted | Whether to mark the route as unhealthy (down) when all restarting attempts (backoff) have failed and the route is not successfully started and the route manager is giving up. Setting this to true allows health checks to know about this and can report the Camel application as DOWN. The default is false. | false | Boolean |
camel.springboot.route-filter-exclude-pattern | Used for filtering routes matching the given pattern, which follows the following rules: - Match by route id - Match by route input endpoint uri The matching is using exact match, by wildcard and regular expression. For example to only include routes which starts with foo in their route id’s, use: include=foo And to exclude routes which starts from JMS endpoints, use: exclude=jms: Multiple patterns can be separated by comma, for example to exclude both foo and bar routes, use: exclude=foo,bar Exclude takes precedence over include. | String | |
camel.springboot.route-filter-include-pattern | Used for filtering routes matching the given pattern, which follows the following rules: - Match by route id - Match by route input endpoint uri The matching is using exact match, by wildcard and regular expression. For example to only include routes which starts with foo in their route id’s, use: include=foo And to exclude routes which starts from JMS endpoints, use: exclude=jms: Multiple patterns can be separated by comma, for example to exclude both foo and bar routes, use: exclude=foo,bar Exclude takes precedence over include. | String | |
camel.springboot.routes-collector-enabled | Whether the routes collector is enabled or not. When enabled Camel will auto-discover routes (RouteBuilder instances from the registry and also load additional routes from the file system). The routes collector is default enabled. | true | Boolean |
camel.springboot.routes-exclude-pattern | Used for exclusive filtering of routes from directories. The exclusive filtering takes precedence over inclusive filtering. The pattern is using Ant-path style pattern. Multiple patterns can be specified separated by comma, as example, to exclude all the routes from a directory whose name contains foo use: /foo**. | String | |
camel.springboot.routes-include-pattern | Used for inclusive filtering of routes from directories. The exclusive filtering takes precedence over inclusive filtering. The pattern is using Ant-path style pattern. Multiple patterns can be specified separated by comma, as example, to include all the routes from a directory whose name contains foo use: /foo**. | classpath:camel/,classpath:camel-template/,classpath:camel-rest/* | String |
camel.springboot.routes-reload-directory | Directory to scan (incl subdirectories) for route changes. Camel cannot scan the classpath, so this must be configured to a file directory. Development with Maven as build tool, you can configure the directory to be src/main/resources to scan for Camel routes in XML or YAML files. | src/main/resources | String |
camel.springboot.routes-reload-directory-recursive | Whether the directory to scan should include sub directories. Depending on the number of sub directories, then this can cause the JVM to startup slower as Camel uses the JDK file-watch service to scan for file changes. | false | Boolean |
camel.springboot.routes-reload-enabled | Used for enabling automatic routes reloading. If enabled then Camel will watch for file changes in the given reload directory, and trigger reloading routes if files are changed. | false | Boolean |
camel.springboot.routes-reload-pattern | Used for inclusive filtering of routes from directories. Typical used for specifying to accept routes in XML or YAML files. Multiple patterns can be specified separated by comma. | camel/* | String |
camel.springboot.routes-reload-remove-all-routes | When reloading routes should all existing routes be stopped and removed. By default, Camel will stop and remove all existing routes before reloading routes. This ensures that only the reloaded routes will be active. If disabled then only routes with the same route id is updated, and any existing routes are continued to run. | true | Boolean |
camel.springboot.routes-reload-restart-duration | Whether to restart max duration when routes are reloaded. For example if max duration is 60 seconds, and a route is reloaded after 25 seconds, then this will restart the count and wait 60 seconds again. | false | Boolean |
camel.springboot.shutdown-log-inflight-exchanges-on-timeout | Sets whether to log information about the inflight Exchanges which are still running during a shutdown which didn’t complete without the given timeout. This requires to enable the option inflightRepositoryExchangeEnabled. | true | Boolean |
camel.springboot.shutdown-now-on-timeout | Sets whether to force shutdown of all consumers when a timeout occurred and thus not all consumers was shutdown within that period. You should have good reasons to set this option to false as it means that the routes keep running and is halted abruptly when CamelContext has been shutdown. | true | Boolean |
camel.springboot.shutdown-routes-in-reverse-order | Sets whether routes should be shutdown in reverse or the same order as they where started. | true | Boolean |
camel.springboot.shutdown-suppress-logging-on-timeout | Whether Camel should try to suppress logging during shutdown and timeout was triggered, meaning forced shutdown is happening. And during forced shutdown we want to avoid logging errors/warnings et all in the logs as a side-effect of the forced timeout. Notice the suppress is a best effort as there may still be some logs coming from 3rd party libraries and whatnot, which Camel cannot control. This option is default false. | false | Boolean |
camel.springboot.shutdown-timeout | Timeout in seconds to graceful shutdown Camel. | 300 | Integer |
camel.springboot.source-location-enabled | Whether to capture precise source location:line-number for all EIPs in Camel routes. Enabling this will impact parsing Java based routes (also Groovy, Kotlin, etc.) on startup as this uses JDK StackTraceElement to calculate the location from the Camel route, which comes with a performance cost. This only impact startup, not the performance of the routes at runtime. | false | Boolean |
camel.springboot.startup-recorder | To use startup recorder for capturing execution time during starting Camel. The recorder can be one of: false (or off), logging, java-flight-recorder (or jfr). | String | |
camel.springboot.startup-recorder-dir | Directory to store the recording. By default the user home directory will be used. Use false to turn off saving recording to disk. | String | |
camel.springboot.startup-recorder-duration | How long time to run the startup recorder. Use 0 (default) to keep the recorder running until the JVM is exited. Use -1 to stop the recorder right after Camel has been started (to only focus on potential Camel startup performance bottlenecks) Use a positive value to keep recording for N seconds. When the recorder is stopped then the recording is auto saved to disk (note: save to disk can be disabled by setting startupRecorderDir to false). | 0 | Long |
camel.springboot.startup-recorder-max-depth | To filter our sub steps at a maximum depth. Use -1 for no maximum. Use 0 for no sub steps. Use 1 for max 1 sub step, and so forth. The default is -1. | -1 | Integer |
camel.springboot.startup-recorder-profile | To use a specific Java Flight Recorder profile configuration, such as default or profile. The default is default. | default | String |
camel.springboot.startup-recorder-recording | To enable Java Flight Recorder to start a recording and automatic dump the recording to disk after startup is complete. This requires that camel-jfr is on the classpath, and to enable this option. | false | Boolean |
camel.springboot.startup-summary-level | Controls the level of information logged during startup (and shutdown) of CamelContext. | StartupSummaryLevel | |
camel.springboot.stream-caching-any-spool-rules | Sets whether if just any of the org.apache.camel.spi.StreamCachingStrategy.SpoolRule rules returns true then shouldSpoolCache(long) returns true, to allow spooling to disk. If this option is false, then all the org.apache.camel.spi.StreamCachingStrategy.SpoolRule must return true. The default value is false which means that all the rules must return true. | false | Boolean |
camel.springboot.stream-caching-buffer-size | Sets the stream caching buffer size to use when allocating in-memory buffers used for in-memory stream caches. The default size is 4096. | 0 | Integer |
camel.springboot.stream-caching-enabled | Sets whether stream caching is enabled or not. While stream types (like StreamSource, InputStream and Reader) are commonly used in messaging for performance reasons, they also have an important drawback: they can only be read once. In order to be able to work with message content multiple times, the stream needs to be cached. Streams are cached in memory only (by default). If streamCachingSpoolEnabled=true, then, for large stream messages (over 128 KB by default) will be cached in a temporary file instead, and Camel will handle deleting the temporary file once the cached stream is no longer necessary. Default is true. | true | Boolean |
camel.springboot.stream-caching-remove-spool-directory-when-stopping | Whether to remove stream caching temporary directory when stopping. This option is default true. | true | Boolean |
camel.springboot.stream-caching-spool-cipher | Sets a stream caching cipher name to use when spooling to disk to write with encryption. By default the data is not encrypted. | String | |
camel.springboot.stream-caching-spool-directory | Sets the stream caching spool (temporary) directory to use for overflow and spooling to disk. If no spool directory has been explicit configured, then a temporary directory is created in the java.io.tmpdir directory. | String | |
camel.springboot.stream-caching-spool-enabled | To enable stream caching spooling to disk. This means, for large stream messages (over 128 KB by default) will be cached in a temporary file instead, and Camel will handle deleting the temporary file once the cached stream is no longer necessary. Default is false. | false | Boolean |
camel.springboot.stream-caching-spool-threshold | Stream caching threshold in bytes when overflow to disk is activated. The default threshold is 128kb. Use -1 to disable overflow to disk. | 0 | Long |
camel.springboot.stream-caching-spool-used-heap-memory-limit | Sets what the upper bounds should be when streamCachingSpoolUsedHeapMemoryThreshold is in use. | String | |
camel.springboot.stream-caching-spool-used-heap-memory-threshold | Sets a percentage (1-99) of used heap memory threshold to activate stream caching spooling to disk. | 0 | Integer |
camel.springboot.stream-caching-statistics-enabled | Sets whether stream caching statistics is enabled. | false | Boolean |
camel.springboot.thread-name-pattern | Sets the thread name pattern used for creating the full thread name. The default pattern is: Camel (camelId) thread #counter - name Where camelId is the name of the CamelContext. and counter is a unique incrementing counter. and name is the regular thread name. You can also use longName which is the long thread name which can includes endpoint parameters etc. | String | |
camel.springboot.tracing | Sets whether tracing is enabled or not. Default is false. | false | Boolean |
camel.springboot.tracing-logging-format | To use a custom tracing logging format. The default format (arrow, routeId, label) is: %-4.4s [%-12.12s] [%-33.33s]. | String | |
camel.springboot.tracing-pattern | Tracing pattern to match which node EIPs to trace. For example to match all To EIP nodes, use to*. The pattern matches by node and route id’s Multiple patterns can be separated by comma. | String | |
camel.springboot.tracing-standby | Whether to set tracing on standby. If on standby then the tracer is installed and made available. Then the tracer can be enabled later at runtime via JMX or via Tracer.setEnabled(true). | false | Boolean |
camel.springboot.type-converter-statistics-enabled | Sets whether type converter statistics is enabled. By default the type converter utilization statistics is disabled. Notice: If enabled then there is a slight performance impact under very heavy load. | false | Boolean |
camel.springboot.use-breadcrumb | Set whether breadcrumb is enabled. The default value is false. | false | Boolean |
camel.springboot.use-data-type | Whether to enable using data type on Camel messages. Data type are automatic turned on if one or more routes has been explicit configured with input and output types. Otherwise data type is default off. | false | Boolean |
camel.springboot.use-mdc-logging | To turn on MDC logging. | false | Boolean |
camel.springboot.uuid-generator | UUID generator to use. default (32 bytes), short (16 bytes), classic (32 bytes or longer), simple (long incrementing counter), off (turned off for exchanges - only intended for performance profiling). | default | String |
camel.springboot.warn-on-early-shutdown | Whether to log a WARN if Camel on Spring Boot was immediately shutdown after starting which very likely is because there is no JVM thread to keep the application running. | true | Boolean |
camel.ssl.cert-alias | An optional certificate alias to use. This is useful when the keystore has multiple certificates. | String | |
camel.ssl.cipher-suites | The optional explicitly configured cipher suites for this configuration. | CipherSuitesParameters | |
camel.ssl.cipher-suites-filter | The optional cipher suite filter configuration for this configuration. | FilterParameters | |
camel.ssl.client-parameters | The optional configuration options to be applied purely to the client side settings of the SSLContext. Settings specified here override any duplicate settings provided at the overall level by this class. These parameters apply to SSLSocketFactory and SSLEngine produced by the SSLContext produced from this class as well as to the SSLContext itself. | SSLContextClientParameters | |
camel.ssl.config | Global Camel security configuration. | SSLContextParameters | |
camel.ssl.key-managers | The optional key manager configuration for creating the KeyManager used in constructing an SSLContext. | KeyManagersParameters | |
camel.ssl.provider | The optional provider identifier for the JSSE implementation to use when constructing an SSLContext. | String | |
camel.ssl.secure-random | The optional secure random configuration options to use for constructing the SecureRandom used in the creation of an SSLContext. | SecureRandomParameters | |
camel.ssl.secure-socket-protocol | The optional protocol for the secure sockets created by the SSLContext represented by this instance’s configuration. See Appendix A in the Java Secure Socket Extension Reference Guide for information about standard protocol names. | String | |
camel.ssl.secure-socket-protocols | The optional explicitly configured secure socket protocol names for this configuration. | SecureSocketProtocolsParameters | |
camel.ssl.secure-socket-protocols-filter | The option secure socket protocol name filter configuration for this configuration. | FilterParameters | |
camel.ssl.server-parameters | The optional configuration options to be applied purely to the server side settings of the SSLContext. Settings specified here override any duplicate settings provided at the overall level by this class. These parameters apply to SSLServerSocketFactory and SSLEngine produced by the SSLContext produced from this class as well as to the SSLContext itself. | SSLContextServerParameters | |
camel.ssl.session-timeout | The optional SSLSessionContext timeout time for javax.net.ssl.SSLSession in seconds. | String | |
camel.ssl.trust-managers | The optional trust manager configuration for creating the TrustManager used in constructing an SSLContext. | TrustManagersParameters | |
camel.threadpool.allow-core-thread-time-out | Sets default whether to allow core threads to timeout. | Boolean | |
camel.threadpool.config | Adds a configuration for a specific thread pool profile (inherits default values). | Map | |
camel.threadpool.config.allow-core-thread-time-out | Sets whether to allow core threads to timeout. | Boolean | |
camel.threadpool.config.id | Sets the id of this thread pool. | String | |
camel.threadpool.config.keep-alive-time | Sets the keep alive time for inactive threads. | Long | |
camel.threadpool.config.max-pool-size | Sets the maximum pool size. | Integer | |
camel.threadpool.config.max-queue-size | Sets the maximum number of tasks in the work queue. Use -1 or an unbounded queue. | Integer | |
camel.threadpool.config.pool-size | Sets the core pool size (threads to keep minimum in pool). | Integer | |
camel.threadpool.config.rejected-policy | Sets the handler for tasks which cannot be executed by the thread pool. | ThreadPoolRejectedPolicy | |
camel.threadpool.config.time-unit | Sets the time unit used for keep alive time. | TimeUnit | |
camel.threadpool.keep-alive-time | Sets the default keep alive time for inactive threads. | Long | |
camel.threadpool.max-pool-size | Sets the default maximum pool size. | Integer | |
camel.threadpool.max-queue-size | Sets the default maximum number of tasks in the work queue. Use -1 or an unbounded queue. | Integer | |
camel.threadpool.pool-size | Sets the default core pool size (threads to keep minimum in pool). | Integer | |
camel.threadpool.rejected-policy | Sets the default handler for tasks which cannot be executed by the thread pool. | ThreadPoolRejectedPolicy | |
camel.threadpool.time-unit | Sets the default time unit used for keep alive time. | TimeUnit | |
camel.vault.aws.access-key | The AWS access key. | String | |
camel.vault.aws.default-credentials-provider | Define if we want to use the AWS Default Credentials Provider or not. | false | Boolean |
camel.vault.aws.refresh-enabled | Define if we want to refresh the secrets on update. | false | Boolean |
camel.vault.aws.refresh-period | Define the refresh period. | 30000 | Long |
camel.vault.aws.region | The AWS region. | String | |
camel.vault.aws.secret-key | The AWS secret key. | String | |
camel.vault.aws.secrets | Define the secrets to look at. | String | |
camel.vault.azure.blob-access-key | The Eventhubs Blob Access Key for CheckpointStore purpose. | String | |
camel.vault.azure.blob-account-name | The Eventhubs Blob Account Name for CheckpointStore purpose. | String | |
camel.vault.azure.blob-container-name | The Eventhubs Blob Container Name for CheckpointStore purpose. | String | |
camel.vault.azure.client-id | The Client Id. | String | |
camel.vault.azure.client-secret | The Client secret. | String | |
camel.vault.azure.eventhub-connection-string | The Eventhubs connection String for Key Vault Secret events notifications. | String | |
camel.vault.azure.refresh-enabled | Whether to automatically reload Camel upon secrets being updated in Azure. | false | Boolean |
camel.vault.azure.refresh-period | The period (millis) between checking Azure for updated secrets. | 30000 | Long |
camel.vault.azure.secrets | Specify the secret names (or pattern) to check for updates. Multiple secrets can be separated by comma. | String | |
camel.vault.azure.tenant-id | The tenant Id. | String | |
camel.vault.azure.vault-name | The Vault Name. | String | |
camel.vault.gcp.project-id | The GCP Project ID. | String | |
camel.vault.gcp.refresh-enabled | Define if we want to refresh the secrets on update. | false | Boolean |
camel.vault.gcp.refresh-period | Define the refresh period. | 30000 | Long |
camel.vault.gcp.secrets | Define the secrets to look at. | String | |
camel.vault.gcp.service-account-key | The Service Account Key location. | String | |
camel.vault.gcp.subscription-name | Define the Google Pubsub subscription Name to be used when checking for updates. | String | |
camel.vault.gcp.use-default-instance | Define if we want to use the GCP Client Default Instance or not. | false | Boolean |
camel.vault.hashicorp.engine | The Hashicorp Vault Engine for accessing secrets. | String | |
camel.vault.hashicorp.host | The Hashicorp Vault Host for accessing the service. | String | |
camel.vault.hashicorp.port | The Hashicorp Vault port for accessing the service. | String | |
camel.vault.hashicorp.scheme | The Hashicorp Vault Scheme for accessing the service. | String | |
camel.vault.hashicorp.token | The Hashicorp Vault Token for accessing the service. | String | |
management.endpoint.camel.cache.time-to-live | Maximum time that a response can be cached. | 0ms | Duration |
management.endpoint.camel.enabled | Whether to enable the camel endpoint. | true | Boolean |
management.endpoint.camelroutecontroller.cache.time-to-live | Maximum time that a response can be cached. | 0ms | Duration |
management.endpoint.camelroutecontroller.enabled | Whether to enable the camelroutecontroller endpoint. | true | Boolean |
management.endpoint.camelroutes.cache.time-to-live | Maximum time that a response can be cached. | 0ms | Duration |
management.endpoint.camelroutes.enabled | Whether to enable the camelroutes endpoint. | true | Boolean |
management.endpoint.camelroutes.read-only | Whether Camel Routes actuator is in read-only mode. If not in read-only mode then operations to start/stop routes would be enabled. | true | Boolean |
management.info.camel.enabled | Whether to enable Camel info. | true | Boolean |
camel.springboot.route-controller-logging-level | Deprecated Sets the logging level used for logging route activity (such as starting and stopping routes). The default logging level is DEBUG. | LoggingLevel |
2.2 配置CAMEL 上下文
Camel自动配置提供的最重要的功能是CamelContext实例。Camel自动配置为您创建一个SpringCamelContext,并负责该上下文的正确初始化和关闭。创建的Camel上下文也注册在Spring应用程序上下文中(在camelContext bean名称下),因此您可以像访问任何其他Spring bean一样访问它。
1 |
|
2.2 自动探测CAMEL ROUTES
Camel自动配置从Spring上下文中收集所有RouteBuilder实例,并自动将它们注入到提供的CamelContext中。这意味着使用Spring Boot starter创建新的Camel路由就像将@Component
注释类添加到类路径一样简单:
1 |
|
或者在@Configuration
类中创建一个新的路由RouteBuilder bean:
1 |
|
2.3 CAMEL 配置
Spring Boot自动配置通过Camel财产支持自动连接到Spring Boot外部配置(如财产占位符、操作系统环境变量或系统财产)。它基本上意味着application.properties文件中定义的任何属性:
1 | jms:invoices = |
或者
1 | java -Droute.to=jms:processed.invoices -jar mySpringApp.jar |
然后在Camel route中使用
1 |
|
2.4 自定义CAMEL 上下文配置
如果您想对Camel自动配置创建的CamelContextbean执行一些操作,请在Spring上下文中注册CamelContextConfiguration实例:
1 |
|
方法beforeApplicationStart`将在Spring上下文启动之前调用,因此传递给此回调的CamelContext实例是完全自动配置的。您可以将CamelContextConfiguration的许多实例添加到Spring上下文中,所有这些实例都将被执行。
2.5 自动配置的使用者和生产者模板
Camel自动配置提供预配置的ConsumerTemplate
和ProducerTemplate
实例。您可以简单地将它们注入到Spring托管bean中:
1 |
|
默认情况下,使用者模板和生产者模板的端点缓存大小设置为1000。您可以通过以下Spring财产更改这些值:
1 | camel.springboot.consumer-template-cache-size = 100 |
2.6 自动配置TypeConverter
Camel自动配置在Spring上下文中注册名为TypeConverter的TypeConverter实例。
1 |
|
2.7 SPRING TYPE 转换API桥
Spring提供了强大的类型转换API。Spring API恰好与Camel类型的转换器API非常相似。由于这些API非常相似,Camel Spring Boot会自动注册一个桥转换器(SpringTypeConverter),该转换器将委托给Spring转换API。这意味着Camel会像Camel一样对待Spring转换器。使用这种方法,您可以享受通过Camel TypeConverter API访问的Camel和Spring转换器:
1 |
|
CamelSpringBoot将转换委托给应用程序上下文中可用的Spring的ConversionService实例。如果没有ConversionService实例可用,Camel Spring Boot自动配置将为您创建一个。
2.8 保持应用程序运行
具有此功能的Camel应用程序在启动时启动一个新线程,其唯一目的是通过防止JVM终止来保持应用程序的运行。这意味着在使用Spring Boot启动Camel应用程序后,应用程序等待Ctrl+C信号,不会立即退出。
可以使用camel.springboot.main-run-controller
将控制器线程激活为true。
1 | true = |
使用web模块的应用程序(例如导入org.springframework.boot:spring-boot-webstarter模块)通常不需要使用此功能,因为应用程序通过其他非守护程序线程的存在而保持活动。
2.9 添加xml路由
默认情况下,您可以将Camel XML路由放在Camel目录下的类路径中,Camel spring引导将自动检测并包含该路径。您可以配置目录名或使用配置选项将其关闭
1 | # turn off |
XML文件应该是Camel XML路由(而不是<CamelContext>),例如
1 | <routes xmlns="http://camel.apache.org/schema/spring"> |
2.10 通过JUNIT 5测试
1 | <dependency> |
要测试CamelSpringBoot应用程序,请使用@CamelSpringBootTest
注释测试类。这为您的应用程序带来了Camel的Spring Test支持,因此您可以使用Spring Boot测试约定编写测试。
要获取CamelContext
或ProducerTemplate
,可以使用@Autowired
以正常的Spring方式将它们注入到类中。
您还可以使用camel-test-spring-juit5
以声明方式配置测试。此示例使用@MockEndpoints
注释自动模拟端点:
1 |
|
三 Starters列表
如果该部分出现在(失败的)网站构建中,则用于生成主要camel组件文档的spring-boot部分的camel spring-starter json文件与那些主要camel部件文档页面中使用的名称不匹配。下面列出了未使用的spring boot starter json文件的名称。其中的每一个都需要在组件文档页面中用作camel-spring-boot-nameheader属性,如下所示:
1 | :camel-spring-boot-name: springdoc |
有340个spring-bootstarter json文件,其中341个用于组件、数据格式等。
3.1 CAMEL组件
Camel组件的数量:277个JAR工件中有337个(9个已弃用)
Component | Artifact | Support Level | Since | Description |
---|---|---|---|---|
camel-activemq-starter | Stable | 1.0 | Send messages to (or consume from) Apache ActiveMQ. This component extends the Camel JMS component. | |
camel-amqp-starter | Stable | 1.2 | Messaging with AMQP protocol using Apache QPid Client. | |
camel-arangodb-starter | Stable | 3.5 | Perform operations on ArangoDb when used as a Document Database, or as a Graph Database | |
camel-as2-starter | Stable | 2.22 | Transfer data securely and reliably using the AS2 protocol (RFC4130). | |
camel-asterisk-starter | Stable | 2.18 | Interact with Asterisk PBX Server. | |
camel-atlasmap-starter | Stable | 3.7 | Transforms the message using an AtlasMap transformation. | |
camel-atmos-starter | Stable | 2.15 | Integrate with EMC’s ViPR object data services using the Atmos Client. | |
camel-atmosphere-websocket-starter | Stable | 2.14 | Expose WebSocket endpoints using the Atmosphere framework. | |
camel-atom-starter | Stable | 1.2 | Poll Atom RSS feeds. | |
camel-avro-rpc-starter | Stable | 2.10 | Produce or consume Apache Avro RPC services. | |
camel-aws2-athena-starter | Stable | 3.4 | Access AWS Athena service using AWS SDK version 2.x. | |
camel-aws-cloudtrail-starter | Preview | 3.19 | Consume events from Amazon Cloudtrail using AWS SDK version 2.x. | |
camel-aws2-cw-starter | Stable | 3.1 | Sending metrics to AWS CloudWatch using AWS SDK version 2.x. | |
camel-aws2-ddb-starter | Stable | 3.1 | Store and retrieve data from AWS DynamoDB service using AWS SDK version 2.x. | |
camel-aws2-ddb-starter | Stable | 3.1 | Receive messages from AWS DynamoDB Stream service using AWS SDK version 2.x. | |
camel-aws2-ec2-starter | Stable | 3.1 | Manage AWS EC2 instances using AWS SDK version 2.x. | |
camel-aws2-ecs-starter | Stable | 3.1 | Manage AWS ECS cluster instances using AWS SDK version 2.x. | |
camel-aws2-eks-starter | Stable | 3.1 | Manage AWS EKS cluster instances using AWS SDK version 2.x. | |
camel-aws2-eventbridge-starter | Stable | 3.6 | Manage AWS Eventbridge cluster instances using AWS SDK version 2.x. | |
camel-aws2-iam-starter | Stable | 3.1 | Manage AWS IAM instances using AWS SDK version 2.x. | |
camel-aws2-kms-starter | Stable | 3.1 | Manage keys stored in AWS KMS instances using AWS SDK version 2.x. | |
camel-aws2-kinesis-starter | Stable | 3.2 | Consume and produce records from and to AWS Kinesis Streams using AWS SDK version 2.x. | |
camel-aws2-kinesis-starter | Stable | 3.2 | Produce data to AWS Kinesis Firehose streams using AWS SDK version 2.x. | |
camel-aws2-lambda-starter | Stable | 3.2 | Manage and invoke AWS Lambda functions using AWS SDK version 2.x. | |
camel-aws2-msk-starter | Stable | 3.1 | Manage AWS MSK instances using AWS SDK version 2.x. | |
camel-aws2-mq-starter | Stable | 3.1 | Manage AWS MQ instances using AWS SDK version 2.x. | |
camel-aws2-s3-starter | Stable | 3.2 | Store and retrieve objects from AWS S3 Storage Service using AWS SDK version 2.x. | |
camel-aws-secrets-manager-starter | Stable | 3.9 | Manage AWS Secrets Manager services using AWS SDK version 2.x. | |
camel-aws2-sts-starter | Stable | 3.5 | Manage AWS STS cluster instances using AWS SDK version 2.x. | |
camel-aws2-ses-starter | Stable | 3.1 | Send e-mails through AWS SES service using AWS SDK version 2.x. | |
camel-aws2-sns-starter | Stable | 3.1 | Send messages to an AWS Simple Notification Topic using AWS SDK version 2.x. | |
camel-aws2-sqs-starter | Stable | 3.1 | Send and receive messages to/from AWS SQS service using AWS SDK version 2.x. | |
camel-aws2-translate-starter | Stable | 3.1 | Translate texts using AWS Translate and AWS SDK version 2.x. | |
camel-azure-cosmosdb-starter | Stable | 3.10 | To read and write records to the CosmosDB database on Azure cloud platform. | |
camel-azure-eventhubs-starter | Stable | 3.5 | Send and receive events to/from Azure Event Hubs using AMQP protocol. | |
camel-azure-key-vault-starter | Stable | 3.17 | Manage secrets and keys in Azure Key Vault Service | |
camel-azure-servicebus-starter | Stable | 3.12 | Send and receive messages to/from Azure Event Bus. | |
camel-azure-storage-blob-starter | Stable | 3.3 | Store and retrieve blobs from Azure Storage Blob Service. | |
camel-azure-storage-datalake-starter | Stable | 3.8 | Sends and receives files to/from Azure DataLake Storage. | |
camel-azure-storage-queue-starter | Stable | 3.3 | Stores and retrieves messages to/from Azure Storage Queue. | |
camel-bean-starter | Stable | 1.0 | Invoke methods of Java beans stored in Camel registry. | |
camel-bean-validator-starter | Stable | 2.3 | Validate the message body using the Java Bean Validation API. | |
camel-bonita-starter | Stable | 2.19 | Communicate with a remote Bonita BPM process engine. | |
camel-box-starter | Stable | 2.14 | Upload, download and manage files, folders, groups, collaborations, etc. on box.com. | |
camel-braintree-starter | Stable | 2.17 | Process payments using Braintree Payments. | |
camel-browse-starter | Stable | 1.3 | Inspect the messages received on endpoints supporting BrowsableEndpoint. | |
camel-caffeine-starter | Stable | 2.20 | Perform caching operations using Caffeine Cache. | |
camel-caffeine-starter | Stable | 2.20 | Perform caching operations using Caffeine Cache with an attached CacheLoader. | |
camel-cassandraql-starter | Stable | 2.15 | Integrate with Cassandra 2.0 using the CQL3 API (not the Thrift API). Based on Cassandra Java Driver provided by DataStax. | |
camel-chatscript-starter | Stable | 3.0 | Chat with a ChatScript Server. | |
camel-chunk-starter | Stable | 2.15 | Transform messages using Chunk templating engine. | |
camel-bean-starter | Stable | 2.4 | Invoke methods of Java beans specified by class name. | |
camel-cm-sms-starter | Stable | 2.18 | Send SMS messages via CM SMS Gateway. | |
camel-cmis-starter | Stable-deprecated | 2.11 | Read and write data from to/from a CMIS compliant content repositories. | |
camel-coap-starter | Stable | 2.16 | Send and receive messages to/from COAP capable devices. | |
camel-cometd-starter | Stable | 2.0 | Offers publish/subscribe, peer-to-peer (via a server), and RPC style messaging using the CometD/Bayeux protocol. | |
camel-consul-starter | Stable | 2.18 | Integrate with Consul service discovery and configuration store. | |
camel-controlbus-starter | Stable | 2.11 | Manage and monitor Camel routes. | |
camel-corda-starter | Stable | 2.23 | Perform operations against Corda blockchain platform using corda-rpc library. | |
camel-couchbase-starter | Stable | 2.19 | Query Couchbase Views with a poll strategy and/or perform various operations against Couchbase databases. | |
camel-couchdb-starter | Stable | 2.11 | Consume changesets for inserts, updates and deletes in a CouchDB database, as well as get, save, update and delete documents from a CouchDB database. | |
camel-cron-starter | Stable | 3.1 | A generic interface for triggering events at times specified through the Unix cron syntax. | |
camel-crypto-starter | Stable | 2.3 | Sign and verify exchanges using the Signature Service of the Java Cryptographic Extension (JCE). | |
camel-cxf-soap-starter | Stable | 1.0 | Expose SOAP WebServices using Apache CXF or connect to external WebServices using CXF WS client. | |
camel-cxf-rest-starter | Stable | 2.0 | Expose JAX-RS REST services using Apache CXF or connect to external REST services using CXF REST client. | |
camel-dataformat-starter | Stable | 2.12 | Use a Camel Data Format as a regular Camel Component. | |
camel-dataset-starter | Stable | 1.3 | Provide data for load and soak testing of your Camel application. | |
camel-dataset-starter | Stable | 1.3 | Extends the mock component by pulling messages from another endpoint on startup to set the expected message bodies. | |
camel-debezium-db2-starter | Stable | 3.17 | Capture changes from a DB2 database. | |
camel-debezium-mongodb-starter | Stable | 3.0 | Capture changes from a MongoDB database. | |
camel-debezium-mysql-starter | Stable | 3.0 | Capture changes from a MySQL database. | |
camel-debezium-oracle-starter | Stable | 3.17 | Capture changes from a Oracle database. | |
camel-debezium-postgres-starter | Stable | 3.0 | Capture changes from a PostgresSQL database. | |
camel-debezium-sqlserver-starter | Stable | 3.0 | Capture changes from an SQL Server database. | |
camel-djl-starter | Stable | 3.3 | Infer Deep Learning models from message exchanges data using Deep Java Library (DJL). | |
camel-digitalocean-starter | Stable | 2.19 | Manage Droplets and resources within the DigitalOcean cloud. | |
camel-direct-starter | Stable | 1.0 | Call another endpoint from the same Camel Context synchronously. | |
camel-directvm-starter | Stable | 2.10 | Call another endpoint from any Camel Context in the same JVM synchronously. | |
camel-disruptor-starter | Stable | 2.12 | Provides asynchronous SEDA behavior using LMAX Disruptor. | |
camel-disruptor-starter | Stable | 2.12 | Provides asynchronous SEDA behavior using LMAX Disruptor. | |
camel-dns-starter | Stable | 2.7 | Perform DNS queries using DNSJava. | |
camel-docker-starter | Stable | 2.15 | Manage Docker containers. | |
camel-dozer-starter | Stable-deprecated | 2.15 | Map between Java beans using the Dozer mapping library. | |
camel-drill-starter | Stable | 2.19 | Perform queries against an Apache Drill cluster. | |
camel-dropbox-starter | Stable | 2.14 | Upload, download and manage files, folders, groups, collaborations, etc on Dropbox. | |
camel-dynamic-router-starter | Stable | 3.15 | The Dynamic Router component routes exchanges to recipients, and the recipients (and their rules) may change at runtime. | |
camel-ehcache-starter | Stable | 2.18 | Perform caching operations using Ehcache. | |
camel-elasticsearch-starter | Preview | 3.19 | Send requests to ElasticSearch via Java Client API. | |
camel-elasticsearch-rest-starter | Stable-deprecated | 2.21 | Send requests to ElasticSearch via REST API | |
camel-etcd3-starter | Preview | 3.19 | Get, set, delete or watch keys in etcd key-value store. | |
camel-exec-starter | Stable | 2.3 | Execute commands on the underlying operating system. | |
camel-facebook-starter | Stable | 2.14 | Send requests to Facebook APIs supported by Facebook4J. | |
camel-fhir-starter | Stable | 2.23 | Exchange information in the healthcare domain using the FHIR (Fast Healthcare Interoperability Resources) standard. | |
camel-file-starter | Stable | 1.0 | Read and write files. | |
camel-file-watch-starter | Stable | 3.0 | Get notified about file events in a directory using java.nio.file.WatchService. | |
camel-flatpack-starter | Stable | 1.4 | Parse fixed width and delimited files using the FlatPack library. | |
camel-flink-starter | Stable | 2.18 | Send DataSet jobs to an Apache Flink cluster. | |
camel-fop-starter | Stable | 2.10 | Render messages into PDF and other output formats supported by Apache FOP. | |
camel-freemarker-starter | Stable | 2.10 | Transform messages using FreeMarker templates. | |
camel-ftp-starter | Stable | 1.1 | Upload and download files to/from FTP servers. | |
camel-ftp-starter | Stable | 2.2 | Upload and download files to/from FTP servers supporting the FTPS protocol. | |
camel-geocoder-starter | Stable | 2.12 | Find geocodes (latitude and longitude) for a given address or the other way round. | |
camel-git-starter | Stable | 2.16 | Perform operations on git repositories. | |
camel-github-starter | Stable | 2.15 | Interact with the GitHub API. | |
camel-google-bigquery-starter | Stable | 2.20 | Google BigQuery data warehouse for analytics. | |
camel-google-bigquery-starter | Stable | 2.23 | Access Google Cloud BigQuery service using SQL queries. | |
camel-google-calendar-starter | Stable | 2.15 | Perform various operations on a Google Calendar. | |
camel-google-calendar-starter | Stable | 2.23 | Poll for changes in a Google Calendar. | |
camel-google-functions-starter | Stable | 3.9 | Manage and invoke Google Cloud Functions | |
camel-google-drive-starter | Stable | 2.14 | Manage files in Google Drive. | |
camel-google-mail-starter | Stable | 2.15 | Manage messages in Google Mail. | |
camel-google-mail-starter | Stable | 2.22 | Poll for incoming messages in Google Mail. | |
camel-google-pubsub-starter | Stable | 2.19 | Send and receive messages to/from Google Cloud Platform PubSub Service. | |
camel-google-secret-manager-starter | Stable | 3.16 | Manage Google Secret Manager Secrets | |
camel-google-sheets-starter | Stable | 2.23 | Manage spreadsheets in Google Sheets. | |
camel-google-sheets-starter | Stable | 2.23 | Poll for changes in Google Sheets. | |
camel-google-storage-starter | Stable | 3.9 | Store and retrieve objects from Google Cloud Storage Service using the google-cloud-storage library. | |
camel-gora-starter | Stable | 2.14 | Access NoSQL databases using the Apache Gora framework. | |
camel-grape-starter | Stable | 2.16 | Fetch, load and manage additional jars dynamically after Camel Context was started. | |
camel-graphql-starter | Stable | 3.0 | Send GraphQL queries and mutations to external systems. | |
camel-grpc-starter | Stable | 2.19 | Expose gRPC endpoints and access external gRPC endpoints. | |
camel-guava-eventbus-starter | Stable | 2.10 | Send and receive messages to/from Guava EventBus. | |
camel-hashicorp-vault-starter | Stable | 3.18 | Manage secrets in Hashicorp Vault Service | |
camel-hazelcast-starter | Stable | 2.7 | Increment, decrement, set, etc. Hazelcast atomic number (a grid wide number). | |
camel-hazelcast-starter | Stable | 2.7 | Consume join/leave events of a cache instance in a Hazelcast cluster. | |
camel-hazelcast-starter | Stable | 2.7 | Perform operations on Hazelcast distributed list. | |
camel-hazelcast-starter | Stable | 2.7 | Perform operations on Hazelcast distributed map. | |
camel-hazelcast-starter | Stable | 2.7 | Perform operations on Hazelcast distributed multimap. | |
camel-hazelcast-starter | Stable | 2.7 | Perform operations on Hazelcast distributed queue. | |
camel-hazelcast-starter | Stable | 2.16 | Perform operations on Hazelcast replicated map. | |
camel-hazelcast-starter | Stable | 2.16 | Perform operations on Hazelcast distributed ringbuffer. | |
camel-hazelcast-starter | Stable | 2.7 | Asynchronously send/receive Exchanges between Camel routes running on potentially distinct JVMs/hosts backed by Hazelcast BlockingQueue. | |
camel-hazelcast-starter | Stable | 2.7 | Perform operations on Hazelcast distributed set. | |
camel-hazelcast-starter | Stable | 2.15 | Send and receive messages to/from Hazelcast distributed topic. | |
camel-hbase-starter | Stable-deprecated | 2.10 | Reading and write from/to an HBase store (Hadoop database). | |
camel-hdfs-starter | Stable | 2.14 | Read and write from/to an HDFS filesystem using Hadoop 2.x. | |
camel-http-starter | Stable | 2.3 | Send requests to external HTTP servers using Apache HTTP Client 4.x. | |
camel-huaweicloud-frs-starter | Stable | 3.15 | Face Recognition Service (FRS) is an intelligent service that uses computers to process, analyze, and understand facial images based on human facial features. | |
camel-huaweicloud-imagerecognition-starter | Stable | 3.12 | To identify objects, scenes, and concepts in images on Huawei Cloud | |
camel-huaweicloud-dms-starter | Stable | 3.12 | To integrate with a fully managed, high-performance message queuing service on Huawei Cloud | |
camel-huaweicloud-functiongraph-starter | Stable | 3.11 | To call serverless functions on Huawei Cloud | |
camel-huaweicloud-iam-starter | Stable | 3.11 | To securely manage users on Huawei Cloud | |
camel-huaweicloud-obs-starter | Stable | 3.12 | To provide stable, secure, efficient, and easy-to-use cloud storage service on Huawei Cloud | |
camel-huaweicloud-smn-starter | Stable | 3.8 | To broadcast messages and connect cloud services through notifications on Huawei Cloud | |
camel-hyperledger-aries-starter | Preview | 3.19 | Camel support for Hyperledger Aries | |
camel-iec60870-starter | Stable | 2.20 | IEC 60870 supervisory control and data acquisition (SCADA) client using NeoSCADA implementation. | |
camel-iec60870-starter | Stable | 2.20 | IEC 60870 supervisory control and data acquisition (SCADA) server using NeoSCADA implementation. | |
camel-ignite-starter | Stable | 2.17 | Perform cache operations on an Ignite cache or consume changes from a continuous query. | |
camel-ignite-starter | Stable | 2.17 | Run compute operations on an Ignite cluster. | |
camel-ignite-starter | Stable | 2.17 | Receive events from an Ignite cluster by creating a local event listener. | |
camel-ignite-starter | Stable | 2.17 | Interact with Ignite Atomic Sequences and ID Generators . | |
camel-ignite-starter | Stable | 2.17 | Send and receive messages from an Ignite topic. | |
camel-ignite-starter | Stable | 2.17 | Interact with Ignite Queue data structures. | |
camel-ignite-starter | Stable | 2.17 | Interact with Ignite Set data structures. | |
camel-infinispan-starter | Stable | 2.13 | Read and write from/to Infinispan distributed key/value store and data grid. | |
camel-infinispan-embedded-starter | Stable | 2.13 | Read and write from/to Infinispan distributed key/value store and data grid. | |
camel-influxdb-starter | Stable | 2.18 | Interact with InfluxDB v1, a time series database. | |
camel-influxdb2-starter | Preview | 3.20 | Interact with InfluxDB v2, a time series database. | |
camel-iota-starter | Stable-deprecated | 2.23 | Manage financial transactions using IOTA distributed ledger. | |
camel-ipfs-starter | Stable-deprecated | 2.23 | Access the Interplanetary File System (IPFS). | |
camel-irc-starter | Stable | 1.1 | Send and receive messages to/from and IRC chat. | |
camel-ironmq-starter | Stable | 2.17 | Send and receive messages to/from IronMQ an elastic and durable hosted message queue as a service. | |
camel-websocket-jsr356-starter | Stable | 2.23 | Expose websocket endpoints using JSR356. | |
camel-jbpm-starter | Stable | 2.6 | Interact with jBPM workflow engine over REST. | |
camel-jcache-starter | Stable | 2.17 | Perform caching operations against JSR107/JCache. | |
camel-jclouds-starter | Stable | 2.9 | Interact with jclouds compute and blobstore service. | |
camel-jcr-starter | Stable | 1.3 | Read and write nodes to/from a JCR compliant content repository. | |
camel-jdbc-starter | Stable | 1.2 | Access databases through SQL and JDBC. | |
camel-jetty-starter | Stable | 1.2 | Expose HTTP endpoints using Jetty 9. | |
camel-websocket-starter | Stable | 2.10 | Expose websocket endpoints using Jetty. | |
camel-jgroups-starter | Stable | 2.13 | Exchange messages with JGroups clusters. | |
camel-jgroups-raft-starter | Stable | 2.24 | Exchange messages with JGroups-raft clusters. | |
camel-jira-starter | Stable | 3.0 | Interact with JIRA issue tracker. | |
camel-jms-starter | Stable | 1.0 | Sent and receive messages to/from a JMS Queue or Topic. | |
camel-jmx-starter | Stable | 2.6 | Receive JMX notifications. | |
camel-jolt-starter | Stable | 2.16 | JSON to JSON transformation using JOLT. | |
camel-jooq-starter | Stable | 3.0 | Store and retrieve Java objects from an SQL database using JOOQ. | |
camel-jpa-starter | Stable | 1.0 | Store and retrieve Java objects from databases using Java Persistence API (JPA). | |
camel-jslt-starter | Stable | 3.1 | Query or transform JSON payloads using an JSLT. | |
camel-json-validator-starter | Stable | 2.20 | Validate JSON payloads using NetworkNT JSON Schema. | |
camel-jsonata-starter | Stable | 3.5 | Transforms JSON payload using JSONata transformation. | |
camel-json-patch-starter | Stable | 3.12 | Transforms JSON using JSON patch (RFC 6902). | |
camel-jt400-starter | Stable | 1.5 | Exchanges messages with an IBM i system using data queues, message queues, or program call. IBM i is the replacement for AS/400 and iSeries servers. | |
camel-kafka-starter | Stable | 2.13 | Sent and receive messages to/from an Apache Kafka broker. | |
camel-kamelet-starter | Stable | 3.8 | To call Kamelets | |
camel-knative-starter | Stable | 3.15 | Send and receive events from Knative. | |
camel-kubernetes-starter | Stable | 2.17 | Perform operations on Kubernetes ConfigMaps and get notified on ConfigMaps changes. | |
camel-kubernetes-starter | Stable | 3.7 | Perform operations on Kubernetes Custom Resources and get notified on Deployment changes. | |
camel-kubernetes-starter | Stable | 2.20 | Perform operations on Kubernetes Deployments and get notified on Deployment changes. | |
camel-kubernetes-starter | Preview | 3.20 | Perform operations on Kubernetes Events and get notified on Events changes. | |
camel-kubernetes-starter | Stable | 2.23 | Perform operations on Kubernetes Horizontal Pod Autoscalers (HPA) and get notified on HPA changes. | |
camel-kubernetes-starter | Stable | 2.23 | Perform operations on Kubernetes Jobs. | |
camel-kubernetes-starter | Stable | 2.17 | Perform operations on Kubernetes Namespaces and get notified on Namespace changes. | |
camel-kubernetes-starter | Stable | 2.17 | Perform operations on Kubernetes Nodes and get notified on Node changes. | |
camel-kubernetes-starter | Stable | 2.17 | Perform operations on Kubernetes Persistent Volumes and get notified on Persistent Volume changes. | |
camel-kubernetes-starter | Stable | 2.17 | Perform operations on Kubernetes Persistent Volumes Claims and get notified on Persistent Volumes Claim changes. | |
camel-kubernetes-starter | Stable | 2.17 | Perform operations on Kubernetes Pods and get notified on Pod changes. | |
camel-kubernetes-starter | Stable | 2.17 | Perform operations on Kubernetes Replication Controllers and get notified on Replication Controllers changes. | |
camel-kubernetes-starter | Stable | 2.17 | Perform operations on Kubernetes Resources Quotas. | |
camel-kubernetes-starter | Stable | 2.17 | Perform operations on Kubernetes Secrets. | |
camel-kubernetes-starter | Stable | 2.17 | Perform operations on Kubernetes Service Accounts. | |
camel-kubernetes-starter | Stable | 2.17 | Perform operations on Kubernetes Services and get notified on Service changes. | |
camel-kudu-starter | Stable | 3.0 | Interact with Apache Kudu, a free and open source column-oriented data store of the Apache Hadoop ecosystem. | |
camel-language-starter | Stable | 2.5 | Execute scripts in any of the languages supported by Camel. | |
camel-ldap-starter | Stable | 1.5 | Perform searches on LDAP servers. | |
camel-ldif-starter | Stable | 2.20 | Perform updates on an LDAP server from an LDIF body content. | |
camel-log-starter | Stable | 1.1 | Log messages to the underlying logging mechanism. | |
camel-lucene-starter | Stable | 2.2 | Perform inserts or queries against Apache Lucene databases. | |
camel-lumberjack-starter | Stable | 2.18 | Receive logs messages using the Lumberjack protocol. | |
camel-mail-starter | Stable | 1.0 | Send and receive emails using imap, pop3 and smtp protocols. | |
camel-mapstruct-starter | Preview | 3.19 | Type Conversion using Mapstruct | |
camel-master-starter | Stable | 2.20 | Have only a single consumer in a cluster consuming from a given endpoint; with automatic failover if the JVM dies. | |
camel-metrics-starter | Stable | 2.14 | Collect various metrics directly from Camel routes using the DropWizard metrics library. | |
camel-micrometer-starter | Stable | 2.22 | Collect various metrics directly from Camel routes using the Micrometer library. | |
camel-mina-starter | Stable | 2.10 | Socket level networking using TCP or UDP with Apache Mina 2.x. | |
camel-minio-starter | Stable | 3.5 | Store and retrieve objects from Minio Storage Service using Minio SDK. | |
camel-mllp-starter | Stable | 2.17 | Communicate with external systems using the MLLP protocol. | |
camel-mock-starter | Stable | 1.0 | Test routes and mediation rules using mocks. | |
camel-mongodb-starter | Stable | 2.19 | Perform operations on MongoDB documents and collections. | |
camel-mongodb-gridfs-starter | Stable | 2.18 | Interact with MongoDB GridFS. | |
camel-mustache-starter | Stable | 2.12 | Transform messages using a Mustache template. | |
camel-mvel-starter | Stable | 2.12 | Transform messages using an MVEL template. | |
camel-mybatis-starter | Stable | 2.7 | Performs a query, poll, insert, update or delete in a relational database using MyBatis. | |
camel-mybatis-starter | Stable | 2.22 | Perform queries, inserts, updates or deletes in a relational database using MyBatis. | |
camel-nats-starter | Stable | 2.17 | Send and receive messages from NATS messaging system. | |
camel-netty-starter | Stable | 2.14 | Socket level networking using TCP or UDP with Netty 4.x. | |
camel-netty-http-starter | Stable | 2.14 | Netty HTTP server and client using the Netty 4.x. | |
camel-nitrite-starter | Stable | 3.0 | Access Nitrite databases. | |
camel-oaipmh-starter | Stable | 3.5 | Harvest metadata using OAI-PMH protocol | |
camel-olingo2-starter | Stable | 2.14 | Communicate with OData 2.0 services using Apache Olingo. | |
camel-olingo4-starter | Stable | 2.19 | Communicate with OData 4.0 services using Apache Olingo OData API. | |
camel-milo-starter | Stable | 3.15 | Connect to OPC UA servers using the binary protocol for browsing the node tree. | |
camel-milo-starter | Stable | 2.19 | Connect to OPC UA servers using the binary protocol for acquiring telemetry data. | |
camel-milo-starter | Stable | 2.19 | Make telemetry data available as an OPC UA server. | |
camel-kubernetes-starter | Stable | 2.17 | Perform operations on OpenShift Build Configs. | |
camel-kubernetes-starter | Stable | 2.17 | Perform operations on OpenShift Builds. | |
camel-kubernetes-starter | Stable | 3.18 | Perform operations on Openshift Deployment Configs and get notified on Deployment Config changes. | |
camel-openstack-starter | Stable | 2.19 | Access data in OpenStack Cinder block storage. | |
camel-openstack-starter | Stable | 2.19 | Manage VM images and metadata definitions in OpenStack Glance. | |
camel-openstack-starter | Stable | 2.19 | Access OpenStack Keystone for API client authentication, service discovery and distributed multi-tenant authorization. | |
camel-openstack-starter | Stable | 2.19 | Access OpenStack Neutron for network services. | |
camel-openstack-starter | Stable | 2.19 | Access OpenStack to manage compute resources. | |
camel-openstack-starter | Stable | 2.19 | Access OpenStack Swift object/blob store. | |
camel-optaplanner-starter | Stable | 2.13 | Solve planning problems with OptaPlanner. | |
camel-paho-starter | Stable | 2.16 | Communicate with MQTT message brokers using Eclipse Paho MQTT Client. | |
camel-paho-mqtt5-starter | Stable | 3.8 | Communicate with MQTT message brokers using Eclipse Paho MQTT v5 Client. | |
camel-pdf-starter | Stable | 2.16 | Create, modify or extract content from PDF documents. | |
camel-platform-http-starter | Stable | 3.0 | Expose HTTP endpoints using the HTTP server available in the current platform. | |
camel-plc4x-starter | Preview | 3.20 | Read and write to PLC devices | |
camel-pgevent-starter | Stable | 2.15 | Send and receive PostgreSQL events via LISTEN and NOTIFY commands. | |
camel-pg-replication-slot-starter | Stable | 3.0 | Poll for PostgreSQL Write-Ahead Log (WAL) records using Streaming Replication Slots. | |
camel-printer-starter | Stable | 2.1 | Send print jobs to printers. | |
camel-pubnub-starter | Stable | 2.19 | Send and receive messages to/from PubNub data stream network for connected devices. | |
camel-pulsar-starter | Stable | 2.24 | Send and receive messages from/to Apache Pulsar messaging system. | |
camel-quartz-starter | Stable | 2.12 | Schedule sending of messages using the Quartz 2.x scheduler. | |
camel-quickfix-starter | Stable | 2.1 | Open a Financial Interchange (FIX) session using an embedded QuickFix/J engine. | |
camel-rabbitmq-starter | Stable | 2.12 | Send and receive messages from RabbitMQ instances. | |
camel-reactive-streams-starter | Stable | 2.19 | Exchange messages with reactive stream processing libraries compatible with the reactive streams standard. | |
camel-ref-starter | Stable | 1.2 | Route messages to an endpoint looked up dynamically by name in the Camel Registry. | |
camel-rest-starter | Stable | 2.14 | Expose REST services or call external REST services. | |
camel-rest-starter | Stable | 2.16 | Expose OpenAPI Specification of the REST services defined using Camel REST DSL. | |
camel-rest-openapi-starter | Stable | 3.1 | Configure REST producers based on an OpenAPI specification document delegating to a component implementing the RestProducerFactory interface. | |
camel-rest-swagger-starter | Stable | 2.19 | Configure REST producers based on a Swagger (OpenAPI) specification document delegating to a component implementing the RestProducerFactory interface. | |
camel-resteasy-starter | Preview-deprecated | 3.4 | Expose REST endpoints and access external REST servers. | |
camel-robotframework-starter | Stable | 3.0 | Pass camel exchanges to acceptence test written in Robot DSL. | |
camel-rocketmq-starter | Preview | 3.20 | Send and receive messages from RocketMQ cluster. | |
camel-rss-starter | Stable | 2.0 | Poll RSS feeds. | |
camel-saga-starter | Stable | 2.21 | Execute custom actions within a route using the Saga EIP. | |
camel-salesforce-starter | Stable | 2.12 | Communicate with Salesforce using Java DTOs. | |
camel-sap-netweaver-starter | Stable | 2.12 | Send requests to SAP NetWeaver Gateway using HTTP. | |
camel-scheduler-starter | Stable | 2.15 | Generate messages in specified intervals using java.util.concurrent.ScheduledExecutorService. | |
camel-schematron-starter | Stable | 2.15 | Validate XML payload using the Schematron Library. | |
camel-jsch-starter | Stable | 2.10 | Copy files to/from remote hosts using the secure copy protocol (SCP). | |
camel-seda-starter | Stable | 1.1 | Asynchronously call another endpoint from any Camel Context in the same JVM. | |
camel-service-starter | Stable | 2.22 | Register a Camel endpoint to a Service Registry (such as Consul, Etcd) and delegate to it. | |
camel-servicenow-starter | Stable | 2.18 | Interact with ServiceNow via its REST API. | |
camel-servlet-starter | Stable | 2.0 | Serve HTTP requests by a Servlet. | |
camel-ftp-starter | Stable | 1.1 | Upload and download files to/from SFTP servers. | |
camel-sjms-starter | Stable | 2.11 | Send and receive messages to/from a JMS Queue or Topic using plain JMS 1.x API. | |
camel-sjms2-starter | Stable | 2.19 | Send and receive messages to/from a JMS Queue or Topic using plain JMS 2.x API. | |
camel-slack-starter | Stable | 2.16 | Send and receive messages to/from Slack. | |
camel-smpp-starter | Stable | 2.2 | Send and receive SMS messages using a SMSC (Short Message Service Center). | |
camel-snmp-starter | Stable | 2.1 | Receive traps and poll SNMP (Simple Network Management Protocol) capable devices. | |
camel-solr-starter | Stable | 2.9 | Perform operations against Apache Lucene Solr. | |
camel-spark-starter | Stable-deprecated | 2.17 | Send RDD or DataFrame jobs to Apache Spark clusters. | |
camel-splunk-starter | Stable | 2.13 | Publish or search for events in Splunk. | |
camel-splunk-hec-starter | Stable | 3.3 | The splunk component allows to publish events in Splunk using the HTTP Event Collector. | |
camel-spring-batch-starter | Stable | 2.10 | Send messages to Spring Batch for further processing. | |
camel-spring-starter | Stable | 1.4 | Listen for Spring Application Events. | |
camel-spring-integration-starter | Stable | 1.4 | Bridge Camel with Spring Integration. | |
camel-spring-jdbc-starter | Stable | 3.10 | Access databases through SQL and JDBC with Spring Transaction support. | |
camel-spring-ldap-starter | Stable | 2.11 | Perform searches in LDAP servers using filters as the message payload. | |
camel-spring-rabbitmq-starter | Stable | 3.8 | Send and receive messages from RabbitMQ using Spring RabbitMQ client. | |
camel-spring-redis-starter | Stable | 2.11 | Send and receive messages from Redis. | |
camel-spring-ws-starter | Stable | 2.6 | Access external web services as a client or expose your own web services. | |
camel-sql-starter | Stable | 1.4 | Perform SQL queries using Spring JDBC. | |
camel-sql-starter | Stable | 2.17 | Perform SQL queries as a JDBC Stored Procedures using Spring JDBC. | |
camel-ssh-starter | Stable | 2.10 | Execute commands on remote hosts using SSH. | |
camel-stax-starter | Stable | 2.9 | Process XML payloads by a SAX ContentHandler. | |
camel-stitch-starter | Stable | 3.8 | Stitch is a cloud ETL service that integrates various data sources into a central data warehouse through various integrations. | |
camel-stomp-starter | Stable | 2.12 | Send and rececive messages to/from STOMP (Simple Text Oriented Messaging Protocol) compliant message brokers. | |
camel-stream-starter | Stable | 1.3 | Read from system-in and write to system-out and system-err streams. | |
camel-stringtemplate-starter | Stable | 1.2 | Transform messages using StringTemplate engine. | |
camel-stub-starter | Stable | 2.10 | Stub out any physical endpoints while in development or testing. | |
camel-telegram-starter | Stable | 2.18 | Send and receive messages acting as a Telegram Bot Telegram Bot API. | |
camel-thrift-starter | Stable | 2.20 | Call and expose remote procedures (RPC) with Apache Thrift data format and serialization mechanism. | |
camel-tika-starter | Stable | 2.19 | Parse documents and extract metadata and text using Apache Tika. | |
camel-timer-starter | Stable | 1.0 | Generate messages in specified intervals using java.util.Timer. | |
camel-twilio-starter | Stable | 2.20 | Interact with Twilio REST APIs using Twilio Java SDK. | |
camel-twitter-starter | Stable | 2.10 | Send and receive Twitter direct messages. | |
camel-twitter-starter | Stable | 2.10 | Access Twitter Search. | |
camel-twitter-starter | Stable | 2.10 | Send tweets and receive tweets from user’s timeline. | |
camel-undertow-starter | Stable | 2.16 | Expose HTTP and WebSocket endpoints and access external HTTP/WebSocket servers. | |
camel-validator-starter | Stable | 1.1 | Validate the payload using XML Schema and JAXP Validation. | |
camel-velocity-starter | Stable | 1.2 | Transform messages using a Velocity template. | |
camel-vertx-starter | Stable | 2.12 | Send and receive messages to/from Vert.x Event Bus. | |
camel-vertx-http-starter | Stable | 3.5 | Send requests to external HTTP servers using Vert.x | |
camel-vertx-kafka-starter | Stable-deprecated | 3.7 | Sent and receive messages to/from an Apache Kafka broker using vert.x Kafka client | |
camel-vertx-websocket-starter | Stable | 3.5 | Expose WebSocket endpoints and connect to remote WebSocket servers using Vert.x | |
camel-vm-starter | Stable | 1.1 | Call another endpoint in the same CamelContext asynchronously. | |
camel-weather-starter | Stable | 2.12 | Poll the weather information from Open Weather Map. | |
camel-web3j-starter | Stable | 2.22 | Interact with Ethereum nodes using web3j client API. | |
camel-webhook-starter | Stable | 3.0 | Expose webhook endpoints to receive push notifications for other Camel components. | |
camel-weka-starter | Stable | 3.1 | Perform machine learning tasks using Weka. | |
camel-wordpress-starter | Stable | 2.21 | Manage posts and users using Wordpress API. | |
camel-workday-starter | Stable | 3.1 | Detect and parse documents using Workday. | |
camel-xchange-starter | Stable | 2.21 | Access market data and trade on Bitcoin and Altcoin exchanges. | |
camel-xj-starter | Stable | 3.0 | Transform JSON and XML message using a XSLT. | |
camel-xmlsecurity-starter | Stable | 2.12 | Sign XML payloads using the XML signature specification. | |
camel-xmlsecurity-starter | Stable | 2.12 | Verify XML payloads using the XML signature specification. | |
camel-xmpp-starter | Stable | 1.0 | Send and receive messages to/from an XMPP chat server. | |
camel-saxon-starter | Stable | 1.0 | Query and/or transform XML payloads using XQuery and Saxon. | |
camel-xslt-starter | Stable | 1.3 | Transforms XML payload using an XSLT template. | |
camel-xslt-saxon-starter | Stable | 3.0 | Transform XML payloads using an XSLT template using Saxon. | |
camel-zendesk-starter | Stable | 2.19 | Manage Zendesk tickets, users, organizations, etc. | |
camel-zookeeper-starter | Stable | 2.9 | Manage ZooKeeper clusters. | |
camel-zookeeper-master-starter | Stable | 2.19 | Have only a single consumer in a cluster consuming from a given endpoint; with automatic failover if the JVM dies. |
3.2 NON-SPRING-BOOT组件
Component | Artifact | Support Level | Since | Description |
---|---|---|---|---|
MicroProfile Metrics | camel-microprofile-metrics-starter | Stable-deprecated | 3.0 | Expose metrics from Camel routes. |
Properties | camel-base-starter | Stable | 2.3 | The properties component is used for property placeholders in your Camel application, such as endpoint URIs. |
camel-whatsapp-starter | Preview | 3.19 | Send messages to WhatsApp. |
3.3 CAMEL 数据格式
Camel数据格式的数量:39个JAR工件中有46个(不推荐使用0个)
Data Format | Artifact | Support Level | Since | Description |
---|---|---|---|---|
camel-any23-starter | Stable | 3.0 | Extract RDF data from HTML documents. | |
camel-asn1-starter | Stable | 2.20 | Encode and decode data structures using Abstract Syntax Notation One (ASN.1). | |
camel-avro-starter | Stable | 2.14 | Serialize and deserialize messages using Apache Avro binary data format. | |
camel-jackson-avro-starter | Stable | 3.10 | Marshal POJOs to Avro and back using Jackson. | |
camel-barcode-starter | Stable | 2.14 | Transform strings to various 1D/2D barcode bitmap formats and back. | |
camel-base64-starter | Stable | 2.11 | Encode and decode data using Base64. | |
camel-bindy-starter | Stable | 2.0 | Marshal and unmarshal between POJOs and key-value pair (KVP) format using Camel Bindy | |
camel-cbor-starter | Stable | 3.0 | Unmarshal a CBOR payload to POJO and back. | |
camel-crypto-starter | Stable | 2.3 | Encrypt and decrypt messages using Java Cryptography Extension (JCE). | |
camel-csv-starter | Stable | 1.3 | Handle CSV (Comma Separated Values) payloads. | |
camel-fhir-starter | Stable | 2.21 | Marshall and unmarshall FHIR objects to/from JSON. | |
camel-fhir-starter | Stable | 2.21 | Marshall and unmarshall FHIR objects to/from XML. | |
camel-flatpack-starter | Stable | 2.1 | Marshal and unmarshal Java lists and maps to/from flat files (such as CSV, delimited, or fixed length formats) using Flatpack library. | |
camel-grok-starter | Stable | 3.0 | Unmarshal unstructured data to objects using Logstash based Grok patterns. | |
camel-zip-deflater-starter | Stable | 2.0 | Compress and decompress messages using java.util.zip.GZIPStream. | |
camel-hl7-starter | Stable | 2.0 | Marshal and unmarshal HL7 (Health Care) model objects using the HL7 MLLP codec. | |
camel-ical-starter | Stable | 2.12 | Marshal and unmarshal iCal (.ics) documents to/from model objects. | |
camel-jacksonxml-starter | Stable | 2.16 | Unmarshal an XML payloads to POJOs and back using XMLMapper extension of Jackson. | |
camel-jaxb-starter | Stable | 1.0 | Unmarshal XML payloads to POJOs and back using JAXB2 XML marshalling standard. | |
camel-fastjson-starter | Stable | 2.20 | Marshal POJOs to JSON and back using Fastjson | |
camel-gson-starter | Stable | 2.10 | Marshal POJOs to JSON and back using Gson | |
camel-jackson-starter | Stable | 2.0 | Marshal POJOs to JSON and back using Jackson | |
camel-johnzon-starter | Stable | 2.18 | Marshal POJOs to JSON and back using Johnzon | |
camel-jsonb-starter | Stable | 3.7 | Marshal POJOs to JSON and back using JSON-B. | |
camel-xstream-starter | Stable | 2.0 | Marshal POJOs to JSON and back using XStream | |
camel-jsonapi-starter | Stable | 3.0 | Marshal and unmarshal JSON:API resources using JSONAPI-Converter library. | |
camel-lzf-starter | Stable | 2.17 | Compress and decompress streams using LZF deflate algorithm. | |
camel-mail-starter | Stable | 2.17 | Marshal Camel messages with attachments into MIME-Multipart messages and back. | |
camel-crypto-starter | Stable | 2.9 | Encrypt and decrypt messages using Java Cryptographic Extension (JCE) and PGP. | |
camel-protobuf-starter | Stable | 2.2 | Serialize and deserialize Java objects using Google’s Protocol buffers. | |
camel-jackson-protobuf-starter | Stable | 3.10 | Marshal POJOs to Protobuf and back using Jackson. | |
camel-rss-starter | Stable | 2.1 | Transform from ROME SyndFeed Java Objects to XML and vice-versa. | |
camel-soap-starter | Stable | 2.3 | Marshal Java objects to SOAP messages and back. | |
camel-swift-starter | Preview | 3.20 | Encode and decode SWIFT MT messages. | |
camel-swift-starter | Preview | 3.20 | Encode and decode SWIFT MX messages. | |
camel-syslog-starter | Stable | 2.6 | Marshall SyslogMessages to RFC3164 and RFC5424 messages and back. | |
camel-tarfile-starter | Stable | 2.16 | Archive files into tarballs or extract files from tarballs. | |
camel-thrift-starter | Stable | 2.20 | Serialize and deserialize messages using Apache Thrift binary data format. | |
camel-univocity-parsers-starter | Stable | 2.15 | Marshal and unmarshal Java objects from and to CSV (Comma Separated Values) using UniVocity Parsers. | |
camel-univocity-parsers-starter | Stable | 2.15 | Marshal and unmarshal Java objects from and to fixed length records using UniVocity Parsers. | |
camel-univocity-parsers-starter | Stable | 2.15 | Marshal and unmarshal Java objects from and to TSV (Tab-Separated Values) records using UniVocity Parsers. | |
camel-xmlsecurity-starter | Stable | 2.0 | Encrypt and decrypt XML payloads using Apache Santuario. | |
camel-xstream-starter | Stable | 1.3 | Marshal and unmarshal POJOs to/from XML using XStream library. | |
camel-snakeyaml-starter | Stable | 2.17 | Marshal and unmarshal Java objects to and from YAML using SnakeYAML | |
camel-zip-deflater-starter | Stable | 2.12 | Compress and decompress streams using java.util.zip.Deflater and java.util.zip.Inflater. | |
camel-zipfile-starter | Stable | 2.11 | Compression and decompress streams using java.util.zip.ZipStream. |
3.4 CAMEL 语言
Camel语言的数量:16个JAR工件中有23个(不推荐使用0个)
Language | Artifact | Support Level | Since | Description |
---|---|---|---|---|
camel-bean-starter | Stable | 1.3 | Calls a Java bean method. | |
camel-core-starter | Stable | 1.5 | A fixed value set only once during the route startup. | |
camel-core-starter | Stable | 3.7 | Evaluate a compiled simple expression. | |
camel-datasonnet-starter | Stable | 3.7 | To use DataSonnet scripts for message transformations. | |
camel-core-starter | Stable | 2.0 | Gets a property from the Exchange. | |
camel-core-starter | Stable | 1.1 | File related capabilities for the Simple language | |
camel-groovy-starter | Stable | 1.3 | Evaluates a Groovy script. | |
camel-core-starter | Stable | 1.5 | Gets a header from the Exchange. | |
camel-hl7-starter | Stable | 2.11 | Get the value of a HL7 message field specified by terse location specification syntax. | |
camel-javascript-starter | Preview | 3.20 | Evaluates a JavaScript expression. | |
camel-joor-starter | Stable | 3.7 | Evaluates a jOOR (Java compiled once at runtime) expression. | |
camel-jq-starter | Stable | 3.18 | Evaluates a JQ expression against a JSON message body. | |
camel-jsonpath-starter | Stable | 2.13 | Evaluates a JSONPath expression against a JSON message body. | |
camel-mvel-starter | Stable | 2.0 | Evaluates a MVEL template. | |
camel-ognl-starter | Stable | 1.1 | Evaluates an OGNL expression (Apache Commons OGNL). | |
camel-python-starter | Experimental | 3.19 | Evaluates a Python expression. | |
camel-core-starter | Stable | 2.8 | Uses an existing expression from the registry. | |
camel-core-starter | Stable | 1.1 | Evaluates a Camel simple expression. | |
camel-spring-starter | Stable | 2.7 | Evaluates a Spring expression (SpEL). | |
camel-core-starter | Stable | 2.0 | Tokenize text payloads using delimiter patterns. | |
camel-stax-starter | Stable | 2.14 | Tokenize XML payloads. | |
camel-xpath-starter | Stable | 1.1 | Evaluates an XPath expression against an XML payload. | |
camel-saxon-starter | Stable | 1.0 | Evaluates an XQuery expressions against an XML payload. |
四 STARTER 配置
清晰和可访问的配置是任何应用程序的关键部分。Camel启动器(组件、数据格式、语言)完全支持Spring Boot的外部配置机制。我们还增加了通过SpringBeans为更复杂的用例配置它们的可能性。
4.1 使用额外的配置
在内部,每个启动器都通过Spring Boot的ConfigurationProperties进行配置。每个配置参数都可以通过各种方式设置(application.[properties | json | yaml]文件、命令行参数、环境变量等…). 参数的形式为骆驼。camel.[component|language|dataformat].[name].[parameter]
例如,要配置ActiveMQ代理的URL,可以设置:
1 | tcp://localhost:61616 = |
或者要将CSV数据格式的delimeter配置为分号(;),可以设置:
1 | ; = |
Camel将在将财产设置为所需类型时使用其TypeConverter机制。您可以使用#bean:name
:
1 | #bean:myjtaTransactionManager = |
Bean通常用Java创建:
1 | "myjtaTransactionManager") ( |
bean也可以在配置文件中创建,但不建议用于复杂的用例。
4.2 使用BEANS
还可以通过SpringBeans创建和配置启动器。在创建启动程序(组件、数据格式、语言)之前,Camel将首先在注册表中查找它的名称(如果它已经存在)。例如,要配置Kafka组件:
1 | "kafka") ( |
Bean名称必须与正在配置的组件、数据格式或语言的名称相同。如果注释中未指定Bean名称,则会将其设置为方法名称。
典型的CamelSpringBoot项目将使用外部配置和Beans的组合来配置其应用程序。有关如何配置CamelSpringBoot项目的更多完整示例,请参阅我们的示例存储库。
参考文档 https://camel.apache.org/camel-spring-boot/3.20.x/