anchor.diff:  = POJO producing
   
   There are two different ways to send messages to any Camel
  -xref:endpoint.adoc[Endpoint] from a POJO.
  +xref:endpoint.adoc[Endpoint] from a POJO:
   
  -[[POJOProducing-EndpointInject]]
  -== Via `@EndpointInject`
  +- Using `@Produce` or `@EndpointInject`
  +- Or to hide using an interface
   
  -To allow sending of messages from POJOs you can use the `org.apache.camel.EndpointInject` annotation.
  -This will inject a `org.apache.camel.ProducerTemplate` so that the bean can participate in message exchanges.
  +== Using @Produce
   
  -Example: Send a message to the *`foo.bar`* ActiveMQ queue:
  +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 {
  -  @EndpointInject("activemq:foo.bar")
  +  @Produce("activemq:foo")
     ProducerTemplate producer;
   
     public void doSomething() {
  
positive.code: ----
  
  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
  dependency.
  
  [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`*, *`@EndpointInject`*.
  
  ====
  
  [[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:
  
  [source,java]
  ----
  public interface MyListener {
      String sayHello(String name);
  }
  
  
negative.code:     protected MyListener producer;
  
      public void doSomething() {
          // lets send a message and get a response back
          String response = producer.sayHello("James");
      }
  }
  ----
  
  Here Camel will automatically inject a smart client side proxy at
  the `@Produce` annotation - an instance of the `MyListener`
  interface.
  
  When we invoke methods on this interface the method call is
  turned into an object and is sent to the
  endpoint; in this case the xref:components::activemq-component.adoc[ActiveMQ] endpoint to
  queue *`foo`*. Because the `sayHello` method has a return type (`String`) then Camel
  will use xref:{eip-vc}:eips:requestReply-eip.adoc[Request Reply] (InOut) messaging.
  
  [source,java]
  ----
  public interface MyListener {
      void sayHello(String name);
  }
  ----
  
  If the method is a `void` method, then Camel will use xref:{eip-vc}:eips:event-message.adoc[Event Message] (InOnly) messaging.
  