This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
The following commit(s) were added to refs/heads/main by this push:
new a2445ac Polish and cleanup documentation
a2445ac is described below
commit a2445ac26f95bc941df049b0ecf56ff489465d5a
Author: Claus Ibsen <[email protected]>
AuthorDate: Wed Aug 11 13:46:01 2021 +0200
Polish and cleanup documentation
---
.../modules/ROOT/pages/data-format.adoc | 2 +-
docs/user-manual/modules/ROOT/pages/json.adoc | 608 +--------------------
.../modules/ROOT/pages/lambda-route-builder.adoc | 6 +-
docs/user-manual/modules/ROOT/pages/languages.adoc | 35 +-
docs/user-manual/modules/ROOT/pages/lifecycle.adoc | 86 +--
5 files changed, 39 insertions(+), 698 deletions(-)
diff --git a/docs/user-manual/modules/ROOT/pages/data-format.adoc
b/docs/user-manual/modules/ROOT/pages/data-format.adoc
index c274a6f..bd74d8a 100644
--- a/docs/user-manual/modules/ROOT/pages/data-format.adoc
+++ b/docs/user-manual/modules/ROOT/pages/data-format.adoc
@@ -19,7 +19,7 @@ the payload into some bean so that you can process it using
some
xref:bean-integration.adoc[Bean Integration] or perform
xref:predicate.adoc[Predicate] evaluation and so forth. To do this use
the `unmarshal` word in the xref:dsl.adoc[DSL] in Java or the
-xref:xml-configuration.adoc[XML Configuration].
+xref:xml-configuration.adoc[XML DSL].
For example:
diff --git a/docs/user-manual/modules/ROOT/pages/json.adoc
b/docs/user-manual/modules/ROOT/pages/json.adoc
index 1a2ca4e..7519dc5 100644
--- a/docs/user-manual/modules/ROOT/pages/json.adoc
+++ b/docs/user-manual/modules/ROOT/pages/json.adoc
@@ -1,607 +1,15 @@
[[JSON-JSON]]
= JSON
-JSON is a Data Format to marshal and unmarshal
+JSON is a xref:data-format.adoc[Data Format] to marshal and unmarshal
Java objects to and from http://www.json.org/[JSON].
-For JSON to object marshalling, Camel provides integration with three
-popular JSON libraries:
+For JSON to object marshalling, Camel provides integration with many
+popular JSON libraries such as:
-* The http://xstream.codehaus.org/[XStream library] and
-http://jettison.codehaus.org/[Jettsion]
-* The https://github.com/FasterXML/jackson[Jackson library]
-* *Camel 2.10:* The http://code.google.com/p/google-gson/[GSon library]
-* *Camel 2.18:* The http://johnzon.apache.org/[Johnzon library]
+- Jackson
+- Google GSon
+- Johnzon
-Every library requires adding the special camel component (see
-"Dependency..." paragraphs further down). By default Camel uses the
-Jackson library.
-
-[[JSON-UsingJSONdataformatwiththeJacksonlibrary]]
-== Using JSON data format with the Jackson library
-
-[source,java]
-------------------------------------------------------------
-// lets turn Object messages into json then send to MQSeries
-from("activemq:My.Queue").
- marshal().json().
- to("mqseries:Another.Queue");
-------------------------------------------------------------
-
-[[JSON-UsingJSONdataformatwiththeXStreamlibrary]]
-== Using JSON data format with the XStream library
-
-[source,java]
-------------------------------------------------------------
-// lets turn Object messages into json then send to MQSeries
-from("activemq:My.Queue").
- marshal().json(JsonLibrary.XStream).
- to("mqseries:Another.Queue");
-------------------------------------------------------------
-
-[[JSON-UsingJSONdataformatwiththeGSONlibrary]]
-== Using JSON data format with the GSON library
-
-[source,java]
-------------------------------------------------------------
-// lets turn Object messages into json then send to MQSeries
-from("activemq:My.Queue").
- marshal().json(JsonLibrary.Gson).
- to("mqseries:Another.Queue");
-------------------------------------------------------------
-
-[[JSON-UsingJSONdataformatwiththeJohnzonlibrary]]
-== Using JSON data format with the Johnzon library
-
-[source,java]
-------------------------------------------------------------
-// lets turn Object messages into json then send to MQSeries
-from("activemq:My.Queue").
- marshal().json(JsonLibrary.Johnzon).
- to("mqseries:Another.Queue");
-------------------------------------------------------------
-
-[[JSON-UsingJSONinSpringDSL]]
-=== Using JSON in Spring DSL
-
-When using Data Format in Spring DSL you need to
-declare the data formats first. This is done in the *DataFormats* XML
-tag.
-
-[source,xml]
-------------------------------------------------------------------------------------------------------------------------------
- <dataFormats>
- <!-- here we define a Json data format with the id jack and that
it should use the TestPojo as the class type when
- doing unmarshal. The unmarshalType is optional, if not
provided Camel will use a Map as the type -->
- <json id="jack" library="Jackson"
unmarshalType="org.apache.camel.component.jackson.TestPojo"/>
- </dataFormats>
-------------------------------------------------------------------------------------------------------------------------------
-
-And then you can refer to this id in the route:
-
-[source,xml]
--------------------------------------
- <route>
- <from uri="direct:back"/>
- <unmarshal><custom ref="jack"/></unmarshal>
- <to uri="mock:reverse"/>
- </route>
--------------------------------------
-
-[[JSON-ExcludingPOJOfieldsfrommarshalling]]
-== Excluding POJO fields from marshalling
-
-*As of Camel 2.10* +
- When marshalling a POJO to JSON you might want to exclude certain
-fields from the JSON output. With Jackson you can use
-http://wiki.fasterxml.com/JacksonJsonViews[JSON views] to accomplish
-this. First create one or more marker classes.
-
-Use the marker classes with the `@JsonView` annotation to
-include/exclude certain fields. The annotation also works on getters.
-
-Finally use the Camel `JacksonDataFormat` to marshall the above POJO to
-JSON.
-
-Note that the height field is missing in the resulting JSON:
-
-[source,java]
------------------------
-{"age":30, "weight":70}
------------------------
-
-The GSON library supports a similar feature through the notion of
-http://google-gson.googlecode.com/svn/trunk/gson/docs/javadocs/com/google/gson/ExclusionStrategy.html[ExclusionStrategies]:
-
-The `GsonDataFormat` accepts an `ExclusionStrategy` in its constructor:
-
-The line above will exclude fields annotated with `@ExcludeAge` when
-marshalling to JSON.
-
-[[JSON-Configuringfieldnamingpolicy]]
-== Configuring field naming policy
-
-*Since Camel 2.11*
-
-The GSON library supports specifying policies and strategies for mapping
-from json to POJO fields. A common naming convention is to map json
-fields using lower case with underscores.
-
-We may have this JSON string
-
-[source,java]
--------------------------
-{
- "id" : 123,
- "first_name" : "Donald"
- "last_name" : "Duck"
-}
--------------------------
-
-Which we want to map to a POJO that has getter/setters as
-
-*PersonPojo.java*
-
-[source,java]
-------------------------------------------------
-public class PersonPojo {
-
- private int id;
- private String firstName;
- private String lastName;
-
- public int getId() {
- return id;
- }
-
- public void setId(int id) {
- this.id = id;
- }
-
- public String getFirstName() {
- return firstName;
- }
-
- public void setFirstName(String firstName) {
- this.firstName = firstName;
- }
-
- public String getLastName() {
- return lastName;
- }
-
- public void setLastName(String lastName) {
- this.lastName = lastName;
- }
-}
-------------------------------------------------
-
-Then we can configure the
-`org.apache.camel.component.gson.GsonDataFormat` in a Spring XML files
-as shown below. Notice we use `fieldNamingPolicy` property to set the
-field mapping. This property is an enum from GSon
-`com.google.gson.FieldNamingPolicy` which has a number of pre defined
-mappings. If you need full control you can use the property
-`FieldNamingStrategy` and implement a custom
-`com.google.gson.FieldNamingStrategy` where you can control the mapping.
-
-*Configuring GsonDataFromat in Spring XML file*
-
-[source,xml]
--------------------------------------------------------------------------------------------------
- <!-- define the gson data format, where we configure the data format using
the properties -->
- <bean id="gson" class="org.apache.camel.component.gson.GsonDataFormat">
- <!-- we want to unmarshal to person pojo -->
- <property name="unmarshalType"
value="org.apache.camel.component.gson.PersonPojo"/>
- <!-- we want to map fields to use lower case and underscores -->
- <property name="fieldNamingPolicy"
value="LOWER_CASE_WITH_UNDERSCORES"/>
- </bean>
--------------------------------------------------------------------------------------------------
-
-And use it in Camel routes by referring to its bean id as shown:
-
-*Using gson from Camel Routes*
-
-[source,xml]
----------------------------------------------------------------
- <camelContext xmlns="http://camel.apache.org/schema/spring";>
-
- <route>
- <from uri="direct:inPojo"/>
- <marshal><custom ref="gson"/></marshal>
- </route>
-
- <route>
- <from uri="direct:backPojo"/>
- <unmarshal><custom ref="gson"/></unmarshal>
- </route>
-
- </camelContext>
----------------------------------------------------------------
-
-[[JSON-IncludeExcludefieldsusingthejsonViewattributewithJacksonDataFormat]]
-== Include/Exclude fields using the `jsonView` attribute with
`JacksonDataFormat`
-
-*Since Camel 2.12*
-
-As an example of using this attribute you can instead of:
-
-[source,java]
----------------------------------------------------------------------------------------------
-JacksonDataFormat ageViewFormat = new JacksonDataFormat(TestPojoView.class,
Views.Age.class);
-from("direct:inPojoAgeView").
- marshal(ageViewFormat);
----------------------------------------------------------------------------------------------
-
-Directly specify your http://wiki.fasterxml.com/JacksonJsonViews[JSON
-view] inside the Java DSL as:
-
-[source,java]
-------------------------------------------------------
-from("direct:inPojoAgeView").
- marshal().json(TestPojoView.class, Views.Age.class);
-------------------------------------------------------
-
-And the same in XML DSL:
-
-[source,xml]
----------------------------------------------------------------------------------------------------------------------------------------------------------
-<from uri="direct:inPojoAgeView"/>
- <marshal>
- <json library="Jackson"
unmarshalType="org.apache.camel.component.jackson.TestPojoView"
jsonView="org.apache.camel.component.jackson.Views$Age"/>
- </marshal>
----------------------------------------------------------------------------------------------------------------------------------------------------------
-
-[[JSON-SettingserializationincludeoptionforJacksonmarshal]]
-== Setting serialization include option for Jackson marshal
-
-*Since Camel 2.13.3/2.14*
-
-If you want to marshal a pojo to JSON, and the pojo has some fields with
-null values. And you want to skip these null values, then you need to
-set either an annotation on the pojo,
-
-[source,java]
-------------------------------
-@JsonInclude(Include.NON_NULL)
-public class MyPojo {
- ...
-}
-------------------------------
-
-But this requires you to include that annotation in your pojo source
-code. You can also configure the Camel JsonDataFormat to set the include
-option, as shown below:
-
-[source,java]
----------------------------------------------------
-JacksonDataFormat format = new JacksonDataFormat();
-format.setInclude("NON_NULL");
----------------------------------------------------
-
-Or from XML DSL you configure this as
-
-[source,java]
-------------------------------------------------------------
- <dataFormats>
- <json id="json" library="Jackson" include="NON_NULL"/>
- </dataFormats>
-------------------------------------------------------------
-
-[[JSON-UnmarshallingfromjsontoPOJOwithdynamicclassname]]
-== Unmarshalling from json to POJO with dynamic class name
-
-*Since Camel 2.14*
-
-If you use jackson to unmarshal json to POJO, then you can now specify a
-header in the message that indicate which class name to unmarshal to. +
-The header has key `CamelJacksonUnmarshalType` if that header is present
-in the message, then Jackson will use that as FQN for the POJO class to
-unmarshal the json payload as. Notice that behavior is enabled out of
-the box from Camel 2.14 onwards.
-
- For JMS end users there is the JMSType header from the JMS spec that
-indicates that also. To enable support for JMSType you would need to
-turn that on, on the jackson data format as shown:
-
-[source,java]
----------------------------------------------------
-JacksonDataFormat format = new JacksonDataFormat();
-format.setAllowJmsType(true);
----------------------------------------------------
-
-Or from XML DSL you configure this as
-
-[source,java]
--------------------------------------------------------------
- <dataFormats>
- <json id="json" library="Jackson" allowJmsType="true"/>
- </dataFormats>
--------------------------------------------------------------
-
-[[JSON-UnmarshallingfromjsontoListMaporListpojo]]
-== Unmarshalling from json to List<Map> or List<pojo>
-
-*Since Camel 2.14*
-
-If you are using Jackson to unmarshal json to a list of map/pojo, you
-can now specify this by setting `useList="true"` or use
-the `org.apache.camel.component.jackson.ListJacksonDataFormat`. For
-example with Java you can do as shown below:
-
-[source,java]
--------------------------------------------------------
-JacksonDataFormat format = new ListJacksonDataFormat();
-// or
-JacksonDataFormat format = new JacksonDataFormat();
-format.useList();
-// and you can specify the pojo class type also
-format.setUnmarshalType(MyPojo.class);
--------------------------------------------------------
-
-And if you use XML DSL then you configure to use list using `useList`
-attribute as shown below:
-
-[source,java]
---------------------------------------------------------
- <dataFormats>
- <json id="json" library="Jackson" useList="true"/>
- </dataFormats>
---------------------------------------------------------
-
-And you can specify the pojo type also
-
-[source,java]
--------------------------------------------------------------------------------------------
- <dataFormats>
- <json id="json" library="Jackson" useList="true"
unmarshalType="com.foo.MyPojo"/>
- </dataFormats>
--------------------------------------------------------------------------------------------
-
-[[JSON-UsingcustomJacksonObjectMapper]]
-== Using custom Jackson ObjectMapper
-
-*Since Camel 2.17*
-
-You can use custom Jackson ObjectMapper instance, can be configured as
-shown below.
-
-[source,java]
------------------------------------------------------------------
- <dataFormats>
- <json id="json" library="Jackson" objectMapper="myMapper"/>
- </dataFormats>
------------------------------------------------------------------
-
-Where myMapper is the id of the custom instance that Camel will lookup
-in the Registry
-
-[[JSON-UsingcustomJacksonmodules]]
-== Using custom Jackson modules
-
-*Since Camel 2.15*
-
-You can use custom Jackson modules by specifying the class names of
-those using the moduleClassNames option as shown below.
-
-[source,java]
------------------------------------------------------------------------------------------------------------------------------------------------------
- <dataFormats>
- <json id="json" library="Jackson" useList="true"
unmarshalType="com.foo.MyPojo"
moduleClassNames="com.foo.MyModule,com.foo.MyOtherModule"/>
- </dataFormats>
------------------------------------------------------------------------------------------------------------------------------------------------------
-
-When using moduleClassNames then the custom jackson modules are not
-configured, by created using default constructor and used as-is. If a
-custom module needs any custom configuration, then an instance of the
-module can be created and configured, and then use modulesRefs to refer
-to the module as shown below:
-
-[source,java]
-------------------------------------------------------------------------------------------------------------------------
- <bean id="myJacksonModule" class="com.foo.MyModule">
- ... // configure the module as you want
- </bean>
-
- <dataFormats>
- <json id="json" library="Jackson" useList="true"
unmarshalType="com.foo.MyPojo" moduleRefs="myJacksonModule"/>
- </dataFormats>
-------------------------------------------------------------------------------------------------------------------------
-
- Multiple modules can be specified separated by comma, such as
-moduleRefs="myJacksonModule,myOtherModule"
-
-[[JSON-EnablingordisablefeaturesusingJackson]]
-== Enabling or disable features using Jackson
-
-*Since Camel 2.15*
-
-Jackson has a number of features you can enable or disable, which its
-ObjectMapper uses. For example to disable failing on unknown properties
-when marshalling, you can configure this using the disableFeatures:
-
-[source,java]
--------------------------------------------------------------------------------------------------------------------------
- <dataFormats>
- <json id="json" library="Jackson" unmarshalType="com.foo.MyPojo"
disableFeatures="FAIL_ON_UNKNOWN_PROPERTIES"/>
- </dataFormats>
--------------------------------------------------------------------------------------------------------------------------
-
-You can disable multiple features by separating the values using comma.
-The values for the features must be the name of the enums from Jackson
-from the following enum classes
-
-* com.fasterxml.jackson.databind.SerializationFeature
-* com.fasterxml.jackson.databind.DeserializationFeature
-* com.fasterxml.jackson.databind.MapperFeature
-
-To enable a feature use the enableFeatures options instead.
-
-From Java code you can use the type safe methods from camel-jackson
-module:
-
-[source,java]
-----------------------------------------------------------------------
-JacksonDataFormat df = new JacksonDataFormat(MyPojo.class);
-df.disableFeature(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
-df.disableFeature(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES);
-----------------------------------------------------------------------
-
-[[JSON-ConvertingMapstoPOJOusingJackson]]
-== Converting Maps to POJO using Jackson
-
-Available since *Camel 2.16*. Jackson `ObjectMapper` can be used to
-convert maps to POJO objects. Jackson component comes with the data
-converter that can be used to convert `java.util.Map` instance to
-non-String, non-primitive and non-Number objects.
-
-[source,java]
-----------------------------------------------------------------
-Map<String, Object> invoiceData = new HashMap<String, Object>();
-invoiceData.put("netValue", 500);
-producerTemplate.sendBody("direct:mapToInvoice", invoiceData);
-...
-// Later in the processor
-Invoice invoice = exchange.getIn().getBody(Invoice.class);
-----------------------------------------------------------------
-
-If there is a single `ObjectMapper` instance available in the Camel
-registry, it will used by the converter to perform the conversion.
-Otherwise the default mapper will be used.
-
-[[JSON-FormattedJSONmarshalling-pretty-printing]]
-== Formatted JSON marshalling (pretty-printing)
-
-*Since Camel 2.16*
-
-Using the `prettyPrint` option one can output a well formatted JSON
-while marshalling:
-
-[source,java]
----------------------------------------------------------------
- <dataFormats>
- <json id="xstream" prettyPrint="true"/>
- <json id="jackson" prettyPrint="true" library="Jackson"/>
- <json id="gson" prettyPrint="true" library="Gson"/>
- </dataFormats>
----------------------------------------------------------------
-
-And in Java DSL:
-
-[source,java]
-------------------------------------------------------------------
-from("direct:inPretty").marshal().json(true);
-
-from("direct:inPretty").marshal().json(JsonLibrary.Jackson, true);
-
-from("direct:inPretty").marshal().json(JsonLibrary.Gson, true);
-------------------------------------------------------------------
-
-Please note that as of Camel 2.16 there’re 5 different overloaded
-`json()` DSL methods which support the `prettyPrint` option in
-combination with other settings for `JsonLibrary`, `unmarshalType`,
-`jsonView` etc.
-
-[[JSON]]
-
-[[JSON-IntegratingJacksonwithCamelsTypeConverters]]
-== Integrating Jackson with Camel's TypeConverters
-
-[[JSON.1]]
-
-*Since Camel 2.17*
-
-The `camel-jackson` module allows to integrate Jackson as
-a Type Converter in the Camel registry. This
-works in similar ways that `camel-jaxb` integrates with the type
-converter as well. However `camel-jackson` must be explicit enabled,
-which is done by setting some options on the `CamelContext` properties,
-as shown below:
-
-[source,java]
------------------------------------------------------------------------------------------------------------------------
-// enable Jackson json type converter
-getContext().getGlobalOptions().put("CamelJacksonEnableTypeConverter", "true");
-// allow Jackson json to convert to pojo types also (by default jackson only
converts to String and other simple types)
-getContext().getGlobalOptions().put("CamelJacksonTypeConverterToPojo", "true");
------------------------------------------------------------------------------------------------------------------------
-
-The `camel-jackson` type converter integrates with JAXB which means you
-can annotate POJO class with JAXB annotations that Jackson can
-leverage.
-
-[[JSON-DependenciesforJackson]]
-== Dependencies for Jackson
-
-To use JSON in your camel routes you need to add the a dependency on
-*camel-jackson* which implements this data format.
-
-If you use maven you could just add the following to your pom.xml,
-substituting the version number for the latest & greatest release (see
-the download page for the latest versions).
-
-[source,xml]
-----------------------------------------
-<dependency>
- <groupId>org.apache.camel</groupId>
- <artifactId>camel-jackson</artifactId>
- <version>x.x.x</version>
-</dependency>
-----------------------------------------
-
-[[JSON-DependenciesforXStream]]
-== Dependencies for XStream
-
-To use JSON in your camel routes you need to add the a dependency on
-*camel-xstream* which implements this data format.
-
-If you use maven you could just add the following to your pom.xml,
-substituting the version number for the latest & greatest release (see
-the download page for the latest versions).
-
-[source,xml]
-----------------------------------------
-<dependency>
- <groupId>org.apache.camel</groupId>
- <artifactId>camel-xstream</artifactId>
- <version>x.x.x</version>
-</dependency>
-----------------------------------------
-
-[[JSON-DependenciesforGSON]]
-== Dependencies for GSON
-
-To use JSON in your camel routes you need to add the a dependency on
-*camel-gson* which implements this data format.
-
-If you use maven you could just add the following to your pom.xml,
-substituting the version number for the latest & greatest release (see
-the download page for the latest versions).
-
-[source,xml]
--------------------------------------
-<dependency>
- <groupId>org.apache.camel</groupId>
- <artifactId>camel-gson</artifactId>
- <version>x.x.x</version>
-</dependency>
--------------------------------------
-
-[[JSON-DependenciesforJohnzon]]
-== Dependencies for Johnzon
-
-To use JSON in your camel routes you need to add the a dependency on
-*camel-johnzon* which implements this data format.
-
-If you use maven you could just add the following to your pom.xml,
-substituting the version number for the latest & greatest release (see
-the download page for the latest versions).
-
-[source,xml]
--------------------------------------
-<dependency>
- <groupId>org.apache.camel</groupId>
- <artifactId>camel-johnzon</artifactId>
- <version>x.x.x</version>
-</dependency>
--------------------------------------
+How to use JSon with Camel then see the documentation (for the JSon data
library of choice)
+in the list of xref:latest@components:dataformats:index.adoc[Data Formats].
\ No newline at end of file
diff --git a/docs/user-manual/modules/ROOT/pages/lambda-route-builder.adoc
b/docs/user-manual/modules/ROOT/pages/lambda-route-builder.adoc
index c35d104..c139eec 100644
--- a/docs/user-manual/modules/ROOT/pages/lambda-route-builder.adoc
+++ b/docs/user-manual/modules/ROOT/pages/lambda-route-builder.adoc
@@ -1,7 +1,7 @@
[[LambdaRouteBuilder-LambdaRouteBuilder]]
= LambdaRouteBuilder
-The `LambdaRouteBuilder` is a functional interface which is used for creating
a routing rule using the DSL,
+The `LambdaRouteBuilder` is a functional interface which is used for creating
a routing rule using the xref:dsl.adoc[DSL],
using Java lambda style.
[source,java]
@@ -50,12 +50,14 @@ public class MyConfiguration {
The `LambdaEndpointRouteBuilder` has _type safe_ endpoint but requires to
prefix with the instance name (`rb`)
when choosing an endpoint name. Notice above how to select the kafka endpoint
+[source,java]
----
rb.from(rb.kafka("cheese"))
----
-And with the regular `LambdaRouteBuilder` its just a String so the `rb` prefix
is not needed:
+With the regular `LambdaRouteBuilder` it's just a `String` type, so the `rb`
prefix is not needed anymore:
+[source,java]
----
rb.from("kafka:cheese")
----
diff --git a/docs/user-manual/modules/ROOT/pages/languages.adoc
b/docs/user-manual/modules/ROOT/pages/languages.adoc
index 0444caf..edba9e3 100644
--- a/docs/user-manual/modules/ROOT/pages/languages.adoc
+++ b/docs/user-manual/modules/ROOT/pages/languages.adoc
@@ -5,36 +5,13 @@ To support flexible and powerful
xref:{eip-vc}:eips:enterprise-integration-patterns.adoc[Enterprise Integration
Patterns], Camel supports various Languages to create an
xref:expression.adoc[Expression] or xref:predicate.adoc[Predicate]
-within either the xref:dsl.adoc[Routing Domain Specific Language] or the
-xref:xml-configuration.adoc[XML Configuration].
+within the xref:routes.adoc[Routes] and xref:dsl.adoc[DSL]..
-== Note
-*Combining Predicates**
+== Supported languages
-When creating predicates (expressions that evaluate to `true` or
-`false`), you can combine several predicates -- regardless of the
-language they are built with -- by using the `PredicateBuilder` class.
-For more information, see xref:predicate.adoc[Compound Predicates].
-
-
-== The following is the list of currently supported languages:
-
-* xref:components:languages:bean-language.adoc[Bean Language] for using Java
for expressions
-* xref:components:languages:constant-language.adoc[Constant]
-* xref:components:languages:header-language.adoc[Header]
-* xref:components:languages:jsonpath-language.adoc[JSonPath]
-* xref:components:languages:mvel-language.adoc[Mvel]
-* xref:components:languages:ognl-language.adoc[OGNL]
-* xref:components:languages:ref-language.adoc[Ref Language]
-* xref:components:languages:exchangeProperty-language.adoc[ExchangeProperty]
-** xref:components:languages:groovy-language.adoc[Groovy]
-* xref:components:languages:simple-language.adoc[Simple]
-** xref:components:languages:file-language.adoc[File Language]
-* xref:components:languages:spel-language.adoc[Spring Expression Language]
-* xref:components:languages:tokenize-language.adoc[Tokenizer]
-* xref:components:languages:xpath-language.adoc[XPath]
-* xref:components:languages:xquery-language.adoc[XQuery]
+There are about 20 different
xref:latest@components:languages:index.adoc[Languages] such
+as scripted programming languages such as Groovy, and template based languages
like Velocity and Freemarker,
+and XML/JSon languages, and many others.
Most of these languages are also supported used as
-xref:parameter-binding-annotations.adoc[Annotation Based
-Expression Language].
+xref:parameter-binding-annotations.adoc[Annotation Based Expression Language]
in Java beans.
diff --git a/docs/user-manual/modules/ROOT/pages/lifecycle.adoc
b/docs/user-manual/modules/ROOT/pages/lifecycle.adoc
index 03872da..450c89d 100644
--- a/docs/user-manual/modules/ROOT/pages/lifecycle.adoc
+++ b/docs/user-manual/modules/ROOT/pages/lifecycle.adoc
@@ -3,57 +3,46 @@
Camel uses a simple _lifecycle_ interface called
https://www.javadoc.io/doc/org.apache.camel/camel-api/current/org/apache/camel/Service.html[Service]
-which has a single start() and stop() method.
+which has `start()` and `stop()` methods.
-Various classes implement Service such as
-CamelContext along with a number of
-Component and Endpoint classes.
+Many of Camel's classes implement `Service` such as
+`CamelContext` along with all `Component` and `Endpoint` classes.
When you use Camel you typically have to start the
-CamelContext which will start all the various
+`CamelContext` which will start all the various
components and endpoints and activate the routing rules until the
context is stopped again.
-If you are working with Spring you may wish to read the
-Camel Spring documentation.
-
-[[Lifecycle-CamelContextLifecycle]]
== CamelContext Lifecycle
The `CamelContext` provides methods to control its lifecycle:
+* `build`
+* `init`
* `start`
* `stop`
-* `suspend` *Camel 2.5*
-* `resume` *Camel 2.5*
+* `suspend`
+* `resume`
-The operations is paired: start/stop and suspend/resume.
+The operations are paired: start/stop and suspend/resume.
-Stop is performing a Graceful shutdown
-which means all its internal state, cache, etc is cleared. And the
+Stop is performing a xref:graceful-shutdown.adoc[Graceful Shutdown]
+which means all its internal state, cache, etc is cleared; and the
routes is being stopped in a graceful manner to ensure messages are given
-time to complete. If you start a `CamelContext` after a stop, then its
-performing a _cold_ start, recreating all the state, cache etc. again.
+time to complete.
+IMPORTANT: If you start a `CamelContext` after a stop, then its
+performing a _cold_ start, recreating all the state, cache etc. again; which
is not guaranteed to startup correctly again.
Instead you can use the suspend/resume operations. They will keep the
`CamelContext` _warm_ and only suspend/stop routes using the same
-Graceful shutdown feature. This ensures messages are given time to complete.
+graceful shutdown feature. This ensures messages are given time to complete.
End users is encouraged to use suspend/resume if you are temporary
stopping a Camel application.
All these operations are available in JMX as well,
-so you can control Camel from a management console.
+so you can control Camel from JMX management.
-If you write unit tests and perform _cold_ restarts using stop/start
-then any previously looked up Endpoints etc. is
-obsolete, and therefore you need to re-lookup those endpoints again.
-
-Instead use suspend/resume which keeps these
-Endpoints and therefore you can still use them after
-resuming.
-
-[[Lifecycle-Servicelifecycle]]
== Service lifecycle
A service (`org.apache.camel.Service`) in Camel adheres to the following
@@ -61,48 +50,13 @@ lifecycle states as illustrated in the diagram below:
image::service_lifecycle.png[image]
-*Notice:* A service can optimally support suspend/resume by the
-`org.apache.camel.SuspendableService`. This means not all services in
-Camel supports suspension. It's encouraged that consumers support
-suspension which allows to suspend/resume routes.
-
The `org.apache.camel.support.service.ServiceSupport` is a good base class to
extend for custom services as it offers the basic functionally to keep
track of state. You implement your custom logic in the `doStart`,
`doStop`, `doSuspend`, `doResume` methods.
-[[Lifecycle-Routeslifecycle]]
-== Routes lifecycle
-
-Routes in Camel have the following operations to control its lifecycle
-
-* `start`
-* `stop`
-* `suspend`
-* `resume`
-* `remove` (previously named shutdown)
-
-The `remove` operation will *remove* the route, for example in
-JMX the route will then be unregistered and its
-gone. So only use remove if you really want to remove the route. The
-route must have been stopped before you can remove.
-
-The `start` and `resume` operations in JMX checks
-the state beforehand. So if a route is stopped and you click `resume`,
-it will know to invoke `start`. And likewise if a route has been
-suspended and you click `start` it knows to `resume` instead. This makes
-management a bit easier.
-
-If a route is suspended then it keeps its resources and all their JMX
-metrics alive. Where as stopping a route will graceful stop the route,
-and clear its resources, and as well their JMX metrics. If you want to
-temporary "pause" a route, then consider using suspend/resume over
-stop/start.
-
-If a route consumer does not support suspension, it will fallback and
-stop the route instead.
-
-[[Lifecycle-RelatedInfo]]
-== Related Info
+TIP: A service can optimally support suspend/resume by the
+`org.apache.camel.SuspendableService`. This means not all services in
+Camel supports suspension. It's encouraged that consumers support
+suspension which allows suspending/resuming routes.
-xref:components::controlbus-component.adoc[Take a look at the Control Bus
Component]
