anchor.diff:  injection to customize the converter
   * converter methods should be thread safe and reentrant
   
  -[[TypeConverter-Exchangeparameter]]
  -== Exchange parameter
  +=== Exchange parameter
   
   The type converter accepts the `Exchange` as an optional 2nd parameter.
   This is usable if the type converter for instance needs information from
  
positive.code: * `byte[]` and `ByteBuffer`
  * `InputStream` and `OutputStream`
  * `Reader` and `Writer`
  * `Document` and `Source`
  
  To convert the body of a message to another type:
  
  [source,java]
  ----
  Message message = exchange.getIn();
  Document document = message.getBody(Document.class); // <1>
  ----
  <1> where https://www.javadoc.io/doc/org.apache.camel/camel-api/current/org/apache/camel/Message.html#getBody-java.lang.Class-[`Message#getBody(Class)`] performs the conversion.
  
  [[TypeConverter-HowTypeConversionworks]]
  == How Type Conversion works
  
  The type conversion strategy is defined by the
  https://www.javadoc.io/doc/org.apache.camel/camel-api/current/org/apache/camel/TypeConverter.html[TypeConverter]
  interface that can be customized on a
  https://www.javadoc.io/doc/org.apache.camel/camel-api/current/org/apache/camel/CamelContext.html[CamelContext].
  
  Camel provides a default type converter registry.
  From Camel 3 onwards, the type converter registry implementation generates source code using the Camel Maven
  Package Plugin, allowing Camel, at runtime, to load and invoke these type converters via
  quick Java method invocations. In Camel 2, type converters are registered using annotation based discovery, invoking the type converters via the https://docs.oracle.com/javase/tutorial/reflect/[Java Reflection API].
  
  
  [[TypeConverter-TypeConverterRegistry]]
  == TypeConverterRegistry
  
  Add a `TypeConverter` to the
  https://www.javadoc.io/doc/org.apache.camel/camel-api/current/org/apache/camel/spi/TypeConverterRegistry.html[`TypeConverterRegistry`]
  at runtime using the xref:camelcontext.adoc[CamelContext]:
  
  [source,java]
  ----
  CamelContext context = ...;
  context.getTypeConverterRegistry();
  ----
  
  NOTE: This is useful on platforms where the automatic type converters discovery fails due to classloading issues.
  
  [[TypeConverter-TypeConverterRegistryutilizationstatistics]]
  === TypeConverterRegistry utilization statistics
  
  Camel can gather utilization statistics of the runtime usage of type
  converters. These statistics are available in JMX as well as
  from https://www.javadoc.io/doc/org.apache.camel/camel-api/latest/org/apache/camel/spi/TypeConverterRegistry.html#getStatistics--[`TypeConverterRegistry#getStatistics()`].
  
  These statistics are turned off by
  default as there is some performance overhead under very high concurrent
  load.
  
  Enabling statistics in Java:
  
  
negative.code: 
  [source,xml]
  ----
  <camelContext typeConverterStatisticsEnabled="true">
      ...
  </camelContext>
  ----
  
  == TypeConverter using @Converter annotation
  
  All the type converters that comes out of the box are coded as Java methods on _converter_ classes.
  
  This means a class has been annotated with `@Converter` and the methods in the class
  becomes a type converter _pair_ when the methods is also annotated with `@Converter` such as:
  
  [source,java]
  ----
  