// spring-boot-auto-configure options: START
:page-partial:
:doctitle: Camel Spring Boot Starter for facebook

== Spring Boot Auto-Configuration

When using facebook with Spring Boot make sure to use the following Maven dependency to have support for auto configuration:

[source,xml]
----
<dependency>
  <groupId>org.apache.camel.springboot</groupId>
  <artifactId>camel-facebook-starter</artifactId>
  <version>x.x.x</version>
  <!-- use the same version as your Camel core version -->
</dependency>
----


The component supports 32 options, which are listed below.



[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
| *camel.component.facebook.autowired-enabled* | Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc. | true | Boolean
| *camel.component.facebook.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 or ERROR level and ignored. | false | Boolean
| *camel.component.facebook.client-u-r-l* | Facebook4J API client URL |  | String
| *camel.component.facebook.client-version* | Facebook4J client API version |  | String
| *camel.component.facebook.configuration* | To use the shared configuration. The option is a org.apache.camel.component.facebook.config.FacebookConfiguration type. |  | FacebookConfiguration
| *camel.component.facebook.debug-enabled* | Enables deubg output. Effective only with the embedded logger | false | Boolean
| *camel.component.facebook.enabled* | Whether to enable auto configuration of the facebook component. This is enabled by default. |  | Boolean
| *camel.component.facebook.gzip-enabled* | Use Facebook GZIP encoding | true | Boolean
| *camel.component.facebook.http-connection-timeout* | Http connection timeout in milliseconds | 20000 | Integer
| *camel.component.facebook.http-default-max-per-route* | HTTP maximum connections per route | 2 | Integer
| *camel.component.facebook.http-max-total-connections* | HTTP maximum total connections | 20 | Integer
| *camel.component.facebook.http-proxy-host* | HTTP proxy server host name |  | String
| *camel.component.facebook.http-proxy-password* | HTTP proxy server password |  | String
| *camel.component.facebook.http-proxy-port* | HTTP proxy server port |  | Integer
| *camel.component.facebook.http-proxy-user* | HTTP proxy server user name |  | String
| *camel.component.facebook.http-read-timeout* | Http read timeout in milliseconds | 120000 | Integer
| *camel.component.facebook.http-retry-count* | Number of HTTP retries | 0 | Integer
| *camel.component.facebook.http-retry-interval-seconds* | HTTP retry interval in seconds | 5 | Integer
| *camel.component.facebook.http-streaming-read-timeout* | HTTP streaming read timeout in milliseconds | 40000 | Integer
| *camel.component.facebook.json-store-enabled* | If set to true, raw JSON forms will be stored in DataObjectFactory | false | Boolean
| *camel.component.facebook.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. | false | Boolean
| *camel.component.facebook.mbean-enabled* | If set to true, Facebook4J mbean will be registerd | false | Boolean
| *camel.component.facebook.o-auth-access-token* | The user access token |  | String
| *camel.component.facebook.o-auth-access-token-u-r-l* | OAuth access token URL | https://graph.facebook.com/oauth/access_token | String
| *camel.component.facebook.o-auth-app-id* | The application Id |  | String
| *camel.component.facebook.o-auth-app-secret* | The application Secret |  | String
| *camel.component.facebook.o-auth-authorization-u-r-l* | OAuth authorization URL | https://www.facebook.com/dialog/oauth | String
| *camel.component.facebook.o-auth-permissions* | Default OAuth permissions. Comma separated permission names. See \https://developers.facebook.com/docs/reference/login/#permissions for the detail |  | String
| *camel.component.facebook.pretty-debug-enabled* | Prettify JSON debug output if set to true | false | Boolean
| *camel.component.facebook.rest-base-u-r-l* | API base URL | https://graph.facebook.com/ | String
| *camel.component.facebook.use-s-s-l* | Use SSL | true | Boolean
| *camel.component.facebook.video-base-u-r-l* | Video API base URL | https://graph-video.facebook.com/ | String
|===
// spring-boot-auto-configure options: END
