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

== Spring Boot Auto-Configuration

When using fastjson 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-fastjson-starter</artifactId>
  <version>x.x.x</version>
  <!-- use the same version as your Camel core version -->
</dependency>
----


The component supports 3 options, which are listed below.



[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
| *camel.dataformat.json-fastjson.content-type-header* | Whether the data format should set the Content-Type header with the type from the data format. For example application/xml for data formats marshalling to XML, or application/json for data formats marshalling to JSON | true | Boolean
| *camel.dataformat.json-fastjson.enabled* | Whether to enable auto configuration of the json-fastjson data format. This is enabled by default. |  | Boolean
| *camel.dataformat.json-fastjson.unmarshal-type-name* | Class name of the java type to use when unmarshalling |  | String
|===
// spring-boot-auto-configure options: END
