[[UsingExchangePatternAnnotations-UsingExchangePatternAnnotations]]
= Using Exchange Pattern Annotations

When working with xref:pojo-producing.adoc[POJO Producing] you invoke methods which
typically by default are InOut for xref:{eip-vc}:eips:requestReply-eip.adoc[Request
Reply]. That is there is an In message and an Out for the result.
Typically invoking this operation will be synchronous, the caller will
block until the server returns a result.

Camel has flexible xref:exchange-pattern.adoc[Exchange Pattern] support
- so you can also support the xref:{eip-vc}:eips:event-message.adoc[Event Message]
pattern to use InOnly for asynchronous or one way operations. These are
often called 'fire and forget' like sending a JMS message but not
waiting for any response.

From 1.5 onwards Camel supports annotations for specifying the message
exchange pattern on regular Java methods, classes or interfaces.

[[UsingExchangePatternAnnotations-SpecifyingInOnlymethods]]
== Specifying InOnly methods

Typically the default InOut is what most folks want but you can
customize to use InOnly using an annotation.

[source,syntaxhighlighter-pre]
----
public interface Foo {
  Object someInOutMethod(String input);
  String anotherInOutMethod(Cheese input);
  
  @InOnly
  void someInOnlyMethod(Document input);
}
----

The above code shows three methods on an interface; the first two use
the default InOut mechanism but the *someInOnlyMethod* uses the InOnly
annotation to specify it as being a oneway method call.

[[UsingExchangePatternAnnotations-Classlevelannotations]]
== Class level annotations

You can also use class level annotations to default all methods in an
interface to some pattern such as

[source,syntaxhighlighter-pre]
----
@InOnly
public interface Foo {
  void someInOnlyMethod(Document input);
  void anotherInOnlyMethod(String input);
}
----

Annotations will also be detected on base classes or interfaces. So for
example if you created a client side proxy for

[source,syntaxhighlighter-pre]
----
public class MyFoo implements Foo {
  ...
}
----

Then the methods inherited from Foo would be InOnly.

[[UsingExchangePatternAnnotations-Overloadingaclasslevelannotation]]
== Overloading a class level annotation

You can overload a class level annotation on specific methods. A common
use case for this is if you have a class or interface with many InOnly
methods but you want to just annote one or two methods as InOut

[source,syntaxhighlighter-pre]
----
@InOnly
public interface Foo {
  void someInOnlyMethod(Document input);
  void anotherInOnlyMethod(String input);
  
  @InOut
  String someInOutMethod(String input); 
}
----

In the above Foo interface the *someInOutMethod* will be InOut

[[UsingExchangePatternAnnotations-Usingyourownannotations]]
== Using your own annotations

You might want to create your own annotations to represent a group of
different bits of metadata; such as combining synchrony, concurrency and
transaction behaviour.

So you could annotate your annotation with the @Pattern annotation to
default the exchange pattern you wish to use.

For example lets say we want to create our own annotation called
@MyAsyncService

[source,syntaxhighlighter-pre]
----
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})

// lets add the message exchange pattern to it
@Pattern(ExchangePattern.InOnly)

// lets add some other annotations - maybe transaction behaviour?

public @interface MyAsyncService {
}
----

Now we can use this annotation and Camel will figure out the correct
exchange pattern...

[source,syntaxhighlighter-pre]
----
public interface Foo {
  void someInOnlyMethod(Document input);
  void anotherInOnlyMethod(String input);
  
  @MyAsyncService
  String someInOutMethod(String input); 
}
----
