anchor.diff:  ----
   
   The downside of this is that your code is now dependent on a Camel API,
  -the *`ProducerTemplate`*. The next section describes how to remove this
  +the `ProducerTemplate`. The next section describes how to remove this
   dependency.
   
  -[TIP]
  -====
  +TIP: See xref:pojo-consuming.adoc[POJO Consuming] for how to use a property
  +on the bean as endpoint configuration, e.g., using the `property`
  +attribute on `@Produce` or `@EndpointInject`.
   
  -See xref:pojo-consuming.adoc[POJO Consuming] for how to use a property
  -on the bean as endpoint configuration, e.g., using the *`property`*
  -attribute on *`@Produce`*, *`@EndpointInject`*.
  +== Hiding the Camel APIs From Your Code
   
  -====
  -
  -[[POJOProducing-HidingtheCamelAPIsFromYourCodeUsingProduce]]
  -== Hiding the Camel APIs From Your Code Using `@Produce`
  -
  -You can hide Camel APIs from your application code so the next option might
  -be more suitable. You can add the *`@Produce`* annotation to an injection
  -point (a field or property setter) using a *`ProducerTemplate`* *or*
  -using some interface you use in your business logic. Example:
  +You can hide Camel APIs from your application code.
  +You can add the `@Produce` annotation to an injection
  +point (a field or property setter) using some interface
  +you use in your business logic. Example:
   
   [source,java]
   ----
   public interface MyListener {
  +    // this method is request/reply (InOut) because the method has a return value
  +    // to use one way (InOnly) then the method should be a void method
       String sayHello(String name);
   }
   
  
positive.code:     protected MyListener producer;
  
      public void doSomething() {
          // lets send a message
          String response = producer.sayHello("James");
      }
  }
  ----
  
  Here Camel will automatically inject a smart client side proxy at
  the *`@Produce`* annotation - an instance of the *`MyListener`*
  instance. When we invoke methods on this interface the method call is
  turned into an object and it is sent to the
  endpoint - in this case the xref:components::activemq-component.adoc[ActiveMQ] endpoint to
  queue *`foo`*; then the caller blocks for a response.
  
  If you want to make asynchronous message sends then use an
  xref:using-exchange-pattern-annotations.adoc[@InOnly] annotation on the injection point.
  
negative.code: = POJO producing
  
  There are two different ways to send messages to any Camel
  xref:endpoint.adoc[Endpoint] from a POJO:
  
  - Using `@Produce` or `@EndpointInject`
  - Or to hide using an interface
  
  == Using @Produce
  
  To allow sending of messages from POJOs you can use the `@Produce` annotation.
  This will inject a `org.apache.camel.ProducerTemplate` so that the bean can send messages.
  
  For example to send a message to the foo queue on ActiveMQ:
  
  [source,java]
  ----
  public class Foo {
    @Produce("activemq:foo")
    ProducerTemplate producer;
  
    public void doSomething() {
  