fix links, #22912
* ../scala and ../java links * removed -java -scala from anchors * fix FIXMEs of unresolved links * and some more weird link texts
This commit is contained in:
Patrik Nordwall
parent
4b260fd9fc
commit
3d9a997036
106 changed files with 778 additions and 850 deletions
|
|
@ -32,8 +32,8 @@ The above example exposes an actor over a TCP endpoint via Apache
|
|||
Camel's [Mina component](http://camel.apache.org/mina2.html). The actor implements the *getEndpointUri* method to define
|
||||
an endpoint from which it can receive messages. After starting the actor, TCP
|
||||
clients can immediately send messages to and receive responses from that
|
||||
actor. If the message exchange should go over HTTP (via Camel's <!-- FIXME: duplicate target id: jetty component --> `Jetty
|
||||
component`_), the actor's *getEndpointUri* method should return a different URI, for instance "jetty:[http://localhost:8877/example](http://localhost:8877/example)".
|
||||
actor. If the message exchange should go over HTTP (via Camel's Jetty
|
||||
component), the actor's *getEndpointUri* method should return a different URI, for instance "jetty:[http://localhost:8877/example](http://localhost:8877/example)".
|
||||
In the above case an extra constructor is added that can set the endpoint URI, which would result in
|
||||
the *getEndpointUri* returning the URI that was set using this constructor.
|
||||
|
||||
|
|
@ -72,13 +72,13 @@ You can also create a CamelMessage yourself with the appropriate body and header
|
|||
The akka-camel module is implemented as an Akka Extension, the `CamelExtension` object.
|
||||
Extensions will only be loaded once per `ActorSystem`, which will be managed by Akka.
|
||||
The `CamelExtension` object provides access to the [Camel](@github@/akka-camel/src/main/scala/akka/camel/Camel.scala) interface.
|
||||
The [Camel](@github@/akka-camel/src/main/scala/akka/camel/Camel.scala) interface in turn provides access to two important Apache Camel objects, the [CamelContext](https://svn.apache.org/repos/asf/camel/tags/camel-2.8.0/camel-core/src/main/java/org/apache/camel/CamelContext.java) and the <!-- FIXME: duplicate target id: producertemplate --> `ProducerTemplate`_.
|
||||
The [Camel](@github@/akka-camel/src/main/scala/akka/camel/Camel.scala) interface in turn provides access to two important Apache Camel objects, the [CamelContext](https://svn.apache.org/repos/asf/camel/tags/camel-2.8.0/camel-core/src/main/java/org/apache/camel/CamelContext.java) and the `ProducerTemplate`.
|
||||
Below you can see how you can get access to these Apache Camel objects.
|
||||
|
||||
@@snip [CamelExtensionTest.java]($code$/java/jdocs/camel/CamelExtensionTest.java) { #CamelExtension }
|
||||
|
||||
One `CamelExtension` is only loaded once for every one `ActorSystem`, which makes it safe to call the `CamelExtension` at any point in your code to get to the
|
||||
Apache Camel objects associated with it. There is one [CamelContext](https://svn.apache.org/repos/asf/camel/tags/camel-2.8.0/camel-core/src/main/java/org/apache/camel/CamelContext.java) and one <!-- FIXME: duplicate target id: producertemplate --> `ProducerTemplate`_ for every one `ActorSystem` that uses a `CamelExtension`.
|
||||
Apache Camel objects associated with it. There is one [CamelContext](https://svn.apache.org/repos/asf/camel/tags/camel-2.8.0/camel-core/src/main/java/org/apache/camel/CamelContext.java) and one `ProducerTemplate` for every one `ActorSystem` that uses a `CamelExtension`.
|
||||
By Default, a new [CamelContext](https://svn.apache.org/repos/asf/camel/tags/camel-2.8.0/camel-core/src/main/java/org/apache/camel/CamelContext.java) is created when the `CamelExtension` starts. If you want to inject your own context instead,
|
||||
you can implement the [ContextProvider](@github@/akka-camel/src/main/scala/akka/camel/ContextProvider.scala) interface and add the FQCN of your implementation in the config, as the value of the "akka.camel.context-provider".
|
||||
This interface define a single method `getContext()` used to load the [CamelContext](https://svn.apache.org/repos/asf/camel/tags/camel-2.8.0/camel-core/src/main/java/org/apache/camel/CamelContext.java).
|
||||
|
|
@ -88,7 +88,7 @@ Below an example on how to add the ActiveMQ component to the [CamelContext](http
|
|||
@@snip [CamelExtensionTest.java]($code$/java/jdocs/camel/CamelExtensionTest.java) { #CamelExtensionAddComponent }
|
||||
|
||||
The [CamelContext](https://svn.apache.org/repos/asf/camel/tags/camel-2.8.0/camel-core/src/main/java/org/apache/camel/CamelContext.java) joins the lifecycle of the `ActorSystem` and `CamelExtension` it is associated with; the [CamelContext](https://svn.apache.org/repos/asf/camel/tags/camel-2.8.0/camel-core/src/main/java/org/apache/camel/CamelContext.java) is started when
|
||||
the `CamelExtension` is created, and it is shut down when the associated `ActorSystem` is shut down. The same is true for the <!-- FIXME: unresolved link reference: producertemplate --> `ProducerTemplate`_.
|
||||
the `CamelExtension` is created, and it is shut down when the associated `ActorSystem` is shut down. The same is true for the `ProducerTemplate`.
|
||||
|
||||
The `CamelExtension` is used by both *Producer* and *Consumer* actors to interact with Apache Camel internally.
|
||||
You can access the `CamelExtension` inside a *Producer* or a *Consumer* using the `camel` method, or get straight at the *CamelContext*
|
||||
|
|
@ -125,8 +125,8 @@ actor. Messages consumed by actors from Camel endpoints are of type
|
|||
[CamelMessage](#camelmessage). These are immutable representations of Camel messages.
|
||||
|
||||
Here's another example that sets the endpointUri to
|
||||
`jetty:http://localhost:8877/camel/default`. It causes Camel's <!-- FIXME: duplicate target id: jetty component --> `Jetty
|
||||
component`_ to start an embedded [Jetty](http://www.eclipse.org/jetty/) server, accepting HTTP connections
|
||||
`jetty:http://localhost:8877/camel/default`. It causes Camel's Jetty
|
||||
component to start an embedded [Jetty](http://www.eclipse.org/jetty/) server, accepting HTTP connections
|
||||
from localhost on port 8877.
|
||||
|
||||
@@snip [Consumer2.java]($code$/java/jdocs/camel/Consumer2.java) { #Consumer2 }
|
||||
|
|
@ -138,7 +138,7 @@ client the response type should be [CamelMessage](#camelmessage). For any other
|
|||
new CamelMessage object is created by akka-camel with the actor response as message
|
||||
body.
|
||||
|
||||
<a id="camel-acknowledgements-java"></a>
|
||||
<a id="camel-acknowledgements"></a>
|
||||
### Delivery acknowledgements
|
||||
|
||||
With in-out message exchanges, clients usually know that a message exchange is
|
||||
|
|
@ -158,14 +158,14 @@ acknowledgement).
|
|||
|
||||
@@snip [Consumer3.java]($code$/java/jdocs/camel/Consumer3.java) { #Consumer3 }
|
||||
|
||||
<a id="camel-timeout-java"></a>
|
||||
<a id="camel-timeout"></a>
|
||||
### Consumer timeout
|
||||
|
||||
Camel Exchanges (and their corresponding endpoints) that support two-way communications need to wait for a response from
|
||||
an actor before returning it to the initiating client.
|
||||
For some endpoint types, timeout values can be defined in an endpoint-specific
|
||||
way which is described in the documentation of the individual <!-- FIXME: duplicate target id: camel components --> `Camel
|
||||
components`_. Another option is to configure timeouts on the level of consumer actors.
|
||||
way which is described in the documentation of the individual Camel
|
||||
components. Another option is to configure timeouts on the level of consumer actors.
|
||||
|
||||
Two-way communications between a Camel endpoint and an actor are
|
||||
initiated by sending the request message to the actor with the [ask](@github@/akka-actor/src/main/scala/akka/pattern/Patterns.scala) pattern
|
||||
|
|
@ -197,7 +197,7 @@ Producer actor and waits for a response.
|
|||
|
||||
The future contains the response CamelMessage, or an `AkkaCamelException` when an error occurred, which contains the headers of the response.
|
||||
|
||||
<a id="camel-custom-processing-java"></a>
|
||||
<a id="camel-custom-processing"></a>
|
||||
### Custom Processing
|
||||
|
||||
Instead of replying to the initial sender, producer actors can implement custom
|
||||
|
|
@ -235,7 +235,7 @@ To correlate request with response messages, applications can set the
|
|||
### ProducerTemplate
|
||||
|
||||
The [UntypedProducerActor](@github@/akka-camel/src/main/scala/akka/camel/javaapi/UntypedProducerActor.scala) class is a very convenient way for actors to produce messages to Camel endpoints.
|
||||
Actors may also use a Camel <!-- FIXME: unresolved link reference: producertemplate --> `ProducerTemplate`_ for producing messages to endpoints.
|
||||
Actors may also use a Camel `ProducerTemplate` for producing messages to endpoints.
|
||||
|
||||
@@snip [MyActor.java]($code$/java/jdocs/camel/MyActor.java) { #ProducerTemplate }
|
||||
|
||||
|
|
@ -244,7 +244,7 @@ For initiating a two-way message exchange, one of the
|
|||
|
||||
@@snip [RequestBodyActor.java]($code$/java/jdocs/camel/RequestBodyActor.java) { #RequestProducerTemplate }
|
||||
|
||||
<a id="camel-asynchronous-routing-java"></a>
|
||||
<a id="camel-asynchronous-routing"></a>
|
||||
## Asynchronous routing
|
||||
|
||||
In-out message exchanges between endpoints and actors are
|
||||
|
|
@ -259,18 +259,18 @@ asynchronous routing engine. Asynchronous responses are wrapped and added to the
|
|||
producer actor's mailbox for later processing. By default, response messages are
|
||||
returned to the initial sender but this can be overridden by Producer
|
||||
implementations (see also description of the `onRouteResponse` method
|
||||
in [Custom Processing](#camel-custom-processing-java)).
|
||||
in [Custom Processing](#camel-custom-processing)).
|
||||
|
||||
However, asynchronous two-way message exchanges, without allocating a thread for
|
||||
the full duration of exchange, cannot be generically supported by Camel's
|
||||
asynchronous routing engine alone. This must be supported by the individual
|
||||
<!-- FIXME: duplicate target id: camel components --> `Camel components`_ (from which endpoints are created) as well. They must be
|
||||
Camel components (from which endpoints are created) as well. They must be
|
||||
able to suspend any work started for request processing (thereby freeing threads
|
||||
to do other work) and resume processing when the response is ready. This is
|
||||
currently the case for a [subset of components](http://camel.apache.org/asynchronous-routing-engine.html) such as the <!-- FIXME: duplicate target id: jetty component --> `Jetty component`_.
|
||||
currently the case for a [subset of components](http://camel.apache.org/asynchronous-routing-engine.html) such as the Jetty component.
|
||||
All other Camel components can still be used, of course, but they will cause
|
||||
allocation of a thread for the duration of an in-out message exchange. There's
|
||||
also [Examples](#camel-examples-java) that implements both, an asynchronous
|
||||
also [Examples](#camel-examples) that implements both, an asynchronous
|
||||
consumer and an asynchronous producer, with the jetty component.
|
||||
|
||||
If the used Camel component is blocking it might be necessary to use a separate
|
||||
|
|
@ -297,22 +297,22 @@ most use cases, some applications may require more specialized routes to actors.
|
|||
The akka-camel module provides two mechanisms for customizing routes to actors,
|
||||
which will be explained in this section. These are:
|
||||
|
||||
* Usage of [Akka Camel components](#camel-components-java) to access actors.
|
||||
* Usage of [Akka Camel components](#camel-components) to access actors.
|
||||
Any Camel route can use these components to access Akka actors.
|
||||
* [Intercepting route construction](#camel-intercepting-route-construction-java) to actors.
|
||||
* [Intercepting route construction](#camel-intercepting-route-construction) to actors.
|
||||
This option gives you the ability to change routes that have already been added to Camel.
|
||||
Consumer actors have a hook into the route definition process which can be used to change the route.
|
||||
|
||||
<a id="camel-components-java"></a>
|
||||
<a id="camel-components"></a>
|
||||
### Akka Camel components
|
||||
|
||||
Akka actors can be accessed from Camel routes using the <!-- FIXME: duplicate target id: actor --> `actor`_ Camel component. This component can be used to
|
||||
Akka actors can be accessed from Camel routes using the actor Camel component. This component can be used to
|
||||
access any Akka actor (not only consumer actors) from Camel routes, as described in the following sections.
|
||||
|
||||
<a id="access-to-actors-java"></a>
|
||||
<a id="access-to-actors"></a>
|
||||
### Access to actors
|
||||
|
||||
To access actors from custom Camel routes, the <!-- FIXME: duplicate target id: actor --> `actor`_ Camel
|
||||
To access actors from custom Camel routes, the actor Camel
|
||||
component should be used. It fully supports Camel's [asynchronous routing
|
||||
engine](http://camel.apache.org/asynchronous-routing-engine.html).
|
||||
|
||||
|
|
@ -336,14 +336,14 @@ for instance `10 seconds` except that
|
|||
in the url it is handy to use a +
|
||||
between the amount and the unit, like
|
||||
for example `200+millis`
|
||||
See also [Consumer timeout](#camel-timeout-java).|
|
||||
See also [Consumer timeout](#camel-timeout).|
|
||||
|autoAck | Boolean | true |
|
||||
If set to true, in-only message exchanges
|
||||
are auto-acknowledged when the message is
|
||||
added to the actor's mailbox. If set to
|
||||
false, actors must acknowledge the
|
||||
receipt of the message.
|
||||
See also [Delivery acknowledgements](#camel-acknowledgements-java). |
|
||||
See also [Delivery acknowledgements](#camel-acknowledgements). |
|
||||
|
||||
Here's an actor endpoint URI example containing an actor path:
|
||||
|
||||
|
|
@ -364,10 +364,10 @@ The *CamelPath.toCamelUri* converts the *ActorRef* to the Camel actor component
|
|||
When a message is received on the jetty endpoint, it is routed to the Responder actor, which in return replies back to the client of
|
||||
the HTTP request.
|
||||
|
||||
<a id="camel-intercepting-route-construction-java"></a>
|
||||
<a id="camel-intercepting-route-construction"></a>
|
||||
### Intercepting route construction
|
||||
|
||||
The previous section, [Akka Camel components](#camel-components-java), explained how to setup a route to
|
||||
The previous section, [Akka Camel components](#camel-components), explained how to setup a route to
|
||||
an actor manually.
|
||||
It was the application's responsibility to define the route and add it to the current CamelContext.
|
||||
This section explains a more convenient way to define custom routes: akka-camel is still setting up the routes to consumer actors
|
||||
|
|
@ -391,13 +391,13 @@ returns a ProcessorDefinition (in the above example, the ProcessorDefinition
|
|||
returned by the end method. See the [org.apache.camel.model](https://svn.apache.org/repos/asf/camel/tags/camel-2.8.0/camel-core/src/main/java/org/apache/camel/model/) package for
|
||||
details). After executing the route definition handler, akka-camel finally calls
|
||||
a to(targetActorUri) on the returned ProcessorDefinition to complete the
|
||||
route to the consumer actor (where targetActorUri is the actor component URI as described in [Access to actors](#access-to-actors-java)).
|
||||
route to the consumer actor (where targetActorUri is the actor component URI as described in [Access to actors](#access-to-actors)).
|
||||
If the actor cannot be found, a *ActorNotRegisteredException* is thrown.
|
||||
|
||||
*) Before passing the RouteDefinition instance to the route definition handler,
|
||||
akka-camel may make some further modifications to it.
|
||||
|
||||
<a id="camel-examples-java"></a>
|
||||
<a id="camel-examples"></a>
|
||||
## Examples
|
||||
|
||||
The sample named [Akka Camel Samples with Java](@exampleCodeService@/akka-samples-camel-java) ([source code](@samples@/akka-sample-camel-java))
|
||||
|
|
@ -405,7 +405,7 @@ contains 3 samples:
|
|||
|
||||
>
|
||||
* Asynchronous routing and transformation - This example demonstrates how to implement consumer and
|
||||
producer actors that support [Asynchronous routing](#camel-asynchronous-routing-java) with their Camel endpoints.
|
||||
producer actors that support [Asynchronous routing](#camel-asynchronous-routing) with their Camel endpoints.
|
||||
* Custom Camel route - Demonstrates the combined usage of a `Producer` and a
|
||||
`Consumer` actor as well as the inclusion of a custom Camel route.
|
||||
* Quartz Scheduler Example - Showing how simple is to implement a cron-style scheduler by
|
||||
|
|
@ -414,7 +414,7 @@ using the Camel Quartz component
|
|||
## Configuration
|
||||
|
||||
There are several configuration properties for the Camel module, please refer
|
||||
to the @ref:[reference configuration](../scala/general/configuration.md#config-akka-camel).
|
||||
to the @ref:[reference configuration](general/configuration.md#config-akka-camel).
|
||||
|
||||
## Additional Resources
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue