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 8f3d202ec597 CAMEL-21356 - Javadoc compliance with doclint for Java 17
in camel-management and camel-base-engine (#29719)
8f3d202ec597 is described below
commit 8f3d202ec597bf283090327a7578286cfcb73300
Author: Loris Boiteux <[email protected]>
AuthorDate: Thu Nov 12 19:08:37 2026 +0100
CAMEL-21356 - Javadoc compliance with doclint for Java 17 in
camel-management and camel-base-engine (#29719)
Co-authored-by: Claude Opus 5.5 <[email protected]>
---
.../catalog/beans/DurationRoutePolicyFactory.json | 2 +-
.../camel/bean/DurationRoutePolicyFactory.json | 2 +-
.../apache/camel/impl/debugger/BacklogTracer.java | 6 +-
.../debugger/DefaultBacklogTracerEventMessage.java | 4 +-
.../camel/impl/engine/AbstractCamelContext.java | 8 +--
.../camel/impl/engine/CamelInternalProcessor.java | 10 ++--
.../impl/engine/CamelPostProcessorHelper.java | 2 +-
.../engine/DefaultAsyncProcessorAwaitManager.java | 4 +-
.../impl/engine/DefaultCamelBeanPostProcessor.java | 2 +-
.../impl/engine/DefaultCamelContextExtension.java | 2 +-
.../apache/camel/impl/engine/DefaultChannel.java | 4 +-
.../camel/impl/engine/DefaultConsumerTemplate.java | 4 +-
.../impl/engine/DefaultManagementNameStrategy.java | 6 +-
.../impl/engine/DefaultManagementStrategy.java | 16 +++---
.../camel/impl/engine/DefaultProducerTemplate.java | 2 +-
.../impl/engine/DefaultResourceResolvers.java | 4 +-
.../org/apache/camel/impl/engine/DefaultRoute.java | 2 +-
.../camel/impl/engine/DefaultShutdownStrategy.java | 65 +++++++++++-----------
.../engine/DefaultSupervisingRouteController.java | 2 +-
.../apache/camel/impl/engine/DefaultTracer.java | 2 +-
.../camel/impl/engine/DurationRoutePolicy.java | 2 +-
.../impl/engine/DurationRoutePolicyFactory.java | 6 +-
.../impl/engine/HashMapHeadersMapFactory.java | 4 +-
.../impl/engine/InternalRouteStartupManager.java | 2 +-
.../camel/impl/engine/IntrospectionSupport.java | 26 ++++-----
.../engine/LimitedPollingConsumerPollStrategy.java | 10 ++--
.../camel/impl/engine/PooledExchangeFactory.java | 2 +-
.../org/apache/camel/impl/engine/RouteService.java | 6 +-
.../impl/engine/SharedCamelInternalProcessor.java | 6 +-
.../camel/impl/engine/SimpleCamelContext.java | 11 ++--
.../management/CompositePerformanceCounter.java | 6 +-
.../DefaultInstrumentationProcessor.java | 2 +-
.../camel/management/DefaultManagementAgent.java | 4 +-
.../management/DelegatePerformanceCounter.java | 10 ++--
.../InstrumentationInterceptStrategy.java | 2 +-
.../management/JmxManagementLifecycleStrategy.java | 16 +++---
.../camel/management/JmxManagementStrategy.java | 6 +-
.../management/JmxNotificationEventNotifier.java | 6 +-
.../camel/management/LoggingEventNotifier.java | 2 +-
.../apache/camel/management/ManagedLoadTimer.java | 2 +-
.../camel/management/PerformanceCounter.java | 4 +-
.../camel/management/PublishEventNotifier.java | 2 +-
.../camel/management/mbean/ManagedRoute.java | 2 +-
.../management/mbean/RouteCoverageXmlParser.java | 2 +-
.../apache/camel/management/mbean/Statistic.java | 11 ++--
45 files changed, 151 insertions(+), 150 deletions(-)
diff --git
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/beans/DurationRoutePolicyFactory.json
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/beans/DurationRoutePolicyFactory.json
index 91572e4d134a..bfca012d2fc5 100644
---
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/beans/DurationRoutePolicyFactory.json
+++
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/beans/DurationRoutePolicyFactory.json
@@ -5,7 +5,7 @@
"javaType": "org.apache.camel.impl.engine.DurationRoutePolicyFactory",
"interfaceType": "org.apache.camel.spi.RoutePolicyFactory",
"title": "Duration Route Policy Factory",
- "description": "RoutePolicyFactory which executes for a duration and then
triggers an action. This can be used to stop a set of routes after they have
processed a number of messages, or has been running for N seconds.",
+ "description": "RoutePolicyFactory which executes for a duration and then
triggers an action. This can be used to stop a set of routes after they have
processed a number of messages, or have been running for N seconds.",
"deprecated": false,
"groupId": "org.apache.camel",
"artifactId": "camel-base-engine",
diff --git
a/core/camel-base-engine/src/generated/resources/META-INF/services/org/apache/camel/bean/DurationRoutePolicyFactory.json
b/core/camel-base-engine/src/generated/resources/META-INF/services/org/apache/camel/bean/DurationRoutePolicyFactory.json
index 91572e4d134a..bfca012d2fc5 100644
---
a/core/camel-base-engine/src/generated/resources/META-INF/services/org/apache/camel/bean/DurationRoutePolicyFactory.json
+++
b/core/camel-base-engine/src/generated/resources/META-INF/services/org/apache/camel/bean/DurationRoutePolicyFactory.json
@@ -5,7 +5,7 @@
"javaType": "org.apache.camel.impl.engine.DurationRoutePolicyFactory",
"interfaceType": "org.apache.camel.spi.RoutePolicyFactory",
"title": "Duration Route Policy Factory",
- "description": "RoutePolicyFactory which executes for a duration and then
triggers an action. This can be used to stop a set of routes after they have
processed a number of messages, or has been running for N seconds.",
+ "description": "RoutePolicyFactory which executes for a duration and then
triggers an action. This can be used to stop a set of routes after they have
processed a number of messages, or have been running for N seconds.",
"deprecated": false,
"groupId": "org.apache.camel",
"artifactId": "camel-base-engine",
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/BacklogTracer.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/BacklogTracer.java
index 42a6ebba6062..616293960485 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/BacklogTracer.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/BacklogTracer.java
@@ -50,8 +50,8 @@ import org.slf4j.LoggerFactory;
/**
* A tracer used for message tracing, storing a copy of the message details in
a backlog.
- * <p/>
- * This tracer allows to store message tracers per node in the Camel routes.
The tracers is stored in a backlog queue
+ * <p>
+ * This tracer allows to store message tracers per node in the Camel routes.
The tracers are stored in a backlog queue
* (FIFO based) which allows to pull the traced messages on demand.
*/
public class BacklogTracer extends ServiceSupport implements
org.apache.camel.spi.SyntheticBacklogTracer {
@@ -117,7 +117,7 @@ public class BacklogTracer extends ServiceSupport
implements org.apache.camel.sp
*
* @param definition the processor definition
* @param exchange the exchange
- * @return <tt>true</tt> to trace, <tt>false</tt> to skip
tracing
+ * @return <code>true</code> to trace, <code>false</code> to
skip tracing
*/
@Override
public boolean shouldTrace(NamedNode definition, Exchange exchange) {
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/DefaultBacklogTracerEventMessage.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/DefaultBacklogTracerEventMessage.java
index ca34bf2359ff..cb75685abb6d 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/DefaultBacklogTracerEventMessage.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/debugger/DefaultBacklogTracerEventMessage.java
@@ -349,8 +349,8 @@ public final class DefaultBacklogTracerEventMessage
implements BacklogTracerEven
/**
* Dumps the event message as XML using the {@link #ROOT_TAG} as root tag.
- * <p/>
- * The <tt>timestamp</tt> tag is formatted in the format defined by {@link
#TIMESTAMP_FORMAT}
+ * <p>
+ * The <code>timestamp</code> tag is formatted in the format defined by
{@link #TIMESTAMP_FORMAT}
*
* @return xml representation of this event
*/
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
index 0bcdf44f1888..b6b092313e57 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
@@ -333,8 +333,8 @@ public abstract class AbstractCamelContext extends
BaseService
/**
* Creates the {@link CamelContext} using {@link
org.apache.camel.support.DefaultRegistry} as registry.
- * <p/>
- * Use one of the other constructors to force use an explicit registry.
+ * <p>
+ * Use one of the other constructors to force the use of an explicit
registry.
*/
protected AbstractCamelContext() {
this(true);
@@ -4785,8 +4785,8 @@ public abstract class AbstractCamelContext extends
BaseService
protected abstract ModelToStructureDumper createModelToStructureDumper();
/**
- * The generator of the checksums of routes, or <tt>null</tt> without
camel-xml-io on the classpath: then the routes
- * have no checksum.
+ * The generator of the checksums of routes, or <code>null</code> without
camel-xml-io on the classpath: then the
+ * routes have no checksum.
*/
protected ModelChecksumGenerator createModelChecksumGenerator() {
return
ResolverHelper.resolveBootstrapService(getCamelContextReference(),
ModelChecksumGenerator.FACTORY,
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/CamelInternalProcessor.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/CamelInternalProcessor.java
index 19076bdc2dfe..b217c017c156 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/CamelInternalProcessor.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/CamelInternalProcessor.java
@@ -100,17 +100,17 @@ import static
org.apache.camel.impl.engine.DefaultChannel.getOrCreateBacklogTrac
* <li>{@link Transformer}</li>
* </ul>
* ... and more.
- * <p/>
+ * <p>
* This implementation executes this cross cutting functionality as a {@link
CamelInternalProcessorAdvice} advice
* (before and after advice) by executing the {@link
CamelInternalProcessorAdvice#before(org.apache.camel.Exchange)} and
* {@link CamelInternalProcessorAdvice#after(org.apache.camel.Exchange,
Object)} callbacks in correct order during
* routing. This reduces number of stack frames needed during routing, and
reduce the number of lines in stacktraces, as
* well makes debugging the routing engine easier for end users.
- * <p/>
- * <b>Debugging tips:</b> Camel end users whom want to debug their Camel
applications with the Camel source code, then
+ * <p>
+ * <b>Debugging tips:</b> Camel end users who want to debug their Camel
applications with the Camel source code, then
* make sure to read the source code of this class about the debugging tips,
which you can find in the
* {@link #process(org.apache.camel.Exchange, org.apache.camel.AsyncCallback)}
method.
- * <p/>
+ * <p>
* The added advices can implement {@link Ordered} to control in which order
the advices are executed.
*/
public class CamelInternalProcessor extends DelegateAsyncProcessor implements
InternalProcessor {
@@ -697,7 +697,7 @@ public class CamelInternalProcessor extends
DelegateAsyncProcessor implements In
* Strategy to determine if this policy is allowed to run
*
* @param policy the policy
- * @return <tt>true</tt> to run
+ * @return <code>true</code> to run
*/
boolean isRoutePolicyRunAllowed(RoutePolicy policy) {
if (policy instanceof StatefulService ss) {
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/CamelPostProcessorHelper.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/CamelPostProcessorHelper.java
index 471dcc499865..22662075d233 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/CamelPostProcessorHelper.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/CamelPostProcessorHelper.java
@@ -701,7 +701,7 @@ public class CamelPostProcessorHelper implements
CamelContextAware {
* Implementations can override this method to determine if the bean is
singleton.
*
* @param bean the bean
- * @return <tt>true</tt> if its singleton scoped, for prototype
scoped <tt>false</tt> is returned.
+ * @return <code>true</code> if it is singleton scoped, for prototype
scoped <code>false</code> is returned.
*/
protected boolean isSingleton(Object bean, String beanName) {
if (bean instanceof IsSingleton singleton) {
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultAsyncProcessorAwaitManager.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultAsyncProcessorAwaitManager.java
index 480b381c0b9a..5291ceba2c33 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultAsyncProcessorAwaitManager.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultAsyncProcessorAwaitManager.java
@@ -70,8 +70,8 @@ public class DefaultAsyncProcessorAwaitManager extends
ServiceSupport implements
/**
* Calls the async version of the processor's process method and waits for
it to complete before returning. This can
* be used by {@link AsyncProcessor} objects to implement their sync
version of the process method.
- * <p/>
- * <b>Important:</b> This method is discouraged to be used, as its better
to invoke the asynchronous
+ * <p>
+ * <b>Important:</b> This method is discouraged to be used, as it is
better to invoke the asynchronous
* {@link AsyncProcessor#process(org.apache.camel.Exchange,
org.apache.camel.AsyncCallback)} method, whenever
* possible.
*
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelBeanPostProcessor.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelBeanPostProcessor.java
index 508ab8c2152e..f106c941c4c0 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelBeanPostProcessor.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelBeanPostProcessor.java
@@ -60,7 +60,7 @@ import static org.apache.camel.util.ObjectHelper.isEmpty;
* <a href="http://camel.apache.org/recipientlist-annotation.html";>a Recipient
List router via annotations</a>.
* {@link org.apache.camel.RoutingSlip} for creating <a
href="http://camel.apache.org/routingslip-annotation.html";>a
* Routing Slip router via annotations</a>.
- * <p/>
+ * <p>
* Components such as camel-spring can leverage this post-processor to hook in
Camel bean post-processing into their
* bean processing framework.
*/
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
index 01a79fd3590f..0bc46298872e 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
@@ -997,7 +997,7 @@ class DefaultCamelContextExtension implements
ExtendedCamelContext {
* a restart, and stopped when the CamelContext stops again. This includes
the internal services of the
* CamelContext, the context plugins that are services, a custom debugger,
and the services added with
* {@link org.apache.camel.CamelContext#addService(Object)}.
- * <p/>
+ * <p>
* The injector is not included as it is created again on restart (the
type converters are not registered as
* internal services), and the services that are not stopped with the
CamelContext (such as the executor service
* manager) are still registered.
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultChannel.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultChannel.java
index e7a287ab9efb..7655754b37d3 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultChannel.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultChannel.java
@@ -56,9 +56,9 @@ import org.slf4j.LoggerFactory;
/**
* DefaultChannel is the default {@link Channel}.
- * <p/>
+ * <p>
* The current implementation is just a composite containing the interceptors
and error handler that beforehand was
- * added to the route graph directly. <br/>
+ * added to the route graph directly. <br>
* With this {@link Channel} we can in the future implement better strategies
for routing the {@link Exchange} in the
* route graph, as we have a {@link Channel} between each and every node in
the graph.
*/
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultConsumerTemplate.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultConsumerTemplate.java
index 2a39e1d5b550..ac537539057d 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultConsumerTemplate.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultConsumerTemplate.java
@@ -236,12 +236,12 @@ public class DefaultConsumerTemplate extends
ServiceSupport implements ConsumerT
/**
* Extracts the body from the given result.
- * <p/>
+ * <p>
* If the exchange pattern is provided it will try to honor it and
retrieve the body from either IN or OUT according
* to the pattern.
*
* @param result the result
- * @return the result, can be <tt>null</tt>.
+ * @return the result, can be <code>null</code>.
*/
protected Object extractResultBody(Exchange result) {
Object answer = null;
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultManagementNameStrategy.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultManagementNameStrategy.java
index 88e22fa3dfcd..11581838594b 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultManagementNameStrategy.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultManagementNameStrategy.java
@@ -25,9 +25,9 @@ import org.apache.camel.util.StringHelper;
/**
* Default implementation of {@link ManagementNameStrategy}
- * <p/>
- * This implementation will by default use a name pattern as <tt>#name#</tt>
and in case of a clash, then the pattern
- * will fallback to be using the counter as <tt>#name#-#counter#</tt>.
+ * <p>
+ * This implementation will by default use a name pattern as
<code>#name#</code> and in case of a clash, then the
+ * pattern will fall back to using the counter as
<code>#name#-#counter#</code>.
*/
public class DefaultManagementNameStrategy implements ManagementNameStrategy {
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultManagementStrategy.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultManagementStrategy.java
index b0acb3cbd950..b7ede56eea10 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultManagementStrategy.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultManagementStrategy.java
@@ -37,15 +37,13 @@ import org.apache.camel.util.ObjectHelper;
/**
* A default management strategy that does <b>not</b> manage.
- * <p/>
- * This is default only used if Camel detects that it cannot use the JMX
capable
- * {@link org.apache.camel.management.JmxManagementStrategy} strategy. Then
Camel will fallback to use this instead that
- * is basically a simple and <tt>noop</tt> strategy.
- * <p/>
- * This class can also be used to extend your custom management implement. In
fact the JMX capable provided by Camel
- * extends this class as well.
- *
- * @see org.apache.camel.management.JmxManagementStrategy
+ * <p>
+ * This is only used by default if Camel detects that it cannot use the JMX
capable
+ * {@code org.apache.camel.management.JmxManagementStrategy} strategy. Then
Camel will fallback to use this instead that
+ * is basically a simple and <code>noop</code> strategy.
+ * <p>
+ * This class can also be used to extend your custom management
implementation. In fact the JMX capable strategy
+ * provided by Camel extends this class as well.
*/
public class DefaultManagementStrategy extends ServiceSupport implements
ManagementStrategy, CamelContextAware {
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultProducerTemplate.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultProducerTemplate.java
index 0eeca96f4d5d..89c2fce9e197 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultProducerTemplate.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultProducerTemplate.java
@@ -48,7 +48,7 @@ import org.apache.camel.util.ObjectHelper;
import org.apache.camel.util.concurrent.SynchronousExecutorService;
/**
- * Template (named like Spring's TransactionTemplate & JmsTemplate et al) for
working with Camel and sending
+ * Template (named like Spring's TransactionTemplate & JmsTemplate et al)
for working with Camel and sending
* {@link Message} instances in an {@link Exchange} to an {@link Endpoint}.
*/
public class DefaultProducerTemplate extends ServiceSupport implements
ProducerTemplate {
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultResourceResolvers.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultResourceResolvers.java
index 1a93b89e102a..b7f340b98bf6 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultResourceResolvers.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultResourceResolvers.java
@@ -63,7 +63,7 @@ public final class DefaultResourceResolvers {
/**
* Resolves a timeout from the properties component, falling back to the
given default.
- * <p/>
+ * <p>
* Resolution happens per resource rather than once per resolver because a
resolver is a long-lived service while
* the properties it reads can be reloaded underneath it.
*/
@@ -430,7 +430,7 @@ public final class DefaultResourceResolvers {
/**
* Opens the connection with both timeouts applied.
- * <p/>
+ * <p>
* The read timeout is per read rather than for the transfer as a
whole, so a large resource arriving slowly is
* not cut off as long as bytes keep coming; it bounds the wait on a
server that accepts the connection and then
* says nothing, which is the case that otherwise stalls the caller
forever.
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultRoute.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultRoute.java
index 7156080c38a0..e5f0a13232d6 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultRoute.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultRoute.java
@@ -67,7 +67,7 @@ import org.apache.camel.util.TimeUtils;
/**
* Default implementation of {@link Route}.
- * <p/>
+ * <p>
* Use the API from {@link org.apache.camel.CamelContext} to control the
lifecycle of a route, such as starting and
* stopping using the {@link
org.apache.camel.spi.RouteController#startRoute(String)} and
* {@link org.apache.camel.spi.RouteController#stopRoute(String)} methods.
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultShutdownStrategy.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultShutdownStrategy.java
index fbf510891bf5..86375b8a7fee 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultShutdownStrategy.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultShutdownStrategy.java
@@ -67,53 +67,53 @@ import org.slf4j.LoggerFactory;
/**
* Default {@link org.apache.camel.spi.ShutdownStrategy} which uses graceful
shutdown.
- * <p/>
+ * <p>
* Graceful shutdown ensures that any inflight and pending messages will be
taken into account and it will wait until
- * these exchanges has been completed.
- * <p/>
+ * these exchanges have been completed.
+ * <p>
* This strategy will perform graceful shutdown in two steps:
* <ul>
* <li>Graceful - By suspending/stopping consumers, and let any in-flight
exchanges complete</li>
* <li>Forced - After a given period of time, a timeout occurred and if there
are still pending exchanges to complete,
* then a more aggressive forced strategy is performed.</li>
* </ul>
- * The idea by the <tt>graceful</tt> shutdown strategy, is to stop taking in
more new messages, and allow any existing
- * inflight messages to complete. Then when there is no more inflight messages
then the routes can be fully shutdown.
- * This mean that if there is inflight messages then we will have to wait for
these messages to complete. If they do not
- * complete after a period of time, then a timeout triggers. And then a more
aggressive strategy takes over.
- * <p/>
- * The idea by the <tt>forced</tt> shutdown strategy, is to stop continue
processing messages. And force routes and its
- * services to shutdown now. There is a risk when shutting down now, that some
resources is not properly shutdown, which
- * can cause side effects. The timeout value is by default 45 seconds, but can
be customized.
- * <p/>
- * As this strategy will politely wait until all exchanges has been completed
it can potential wait for a long time, and
- * hence why a timeout value can be set. When the timeout triggers you can
also specify whether the remainder consumers
- * should be shutdown now or ignore.
- * <p/>
+ * The idea by the <code>graceful</code> shutdown strategy, is to stop taking
in more new messages, and allow any
+ * existing inflight messages to complete. Then when there are no more
inflight messages then the routes can be fully
+ * shutdown. This means that if there are inflight messages then we will have
to wait for these messages to complete. If
+ * they do not complete after a period of time, then a timeout triggers. And
then a more aggressive strategy takes over.
+ * <p>
+ * The idea by the <code>forced</code> shutdown strategy, is to stop
processing messages. And force routes and its
+ * services to shutdown now. There is a risk when shutting down now, that some
resources are not properly shutdown,
+ * which can cause side effects. The timeout value is by default 45 seconds,
but can be customized.
+ * <p>
+ * As this strategy will politely wait until all exchanges have been completed
it can potentially wait for a long time,
+ * and hence why a timeout value can be set. When the timeout triggers you can
also specify whether the remainder
+ * consumers should be shutdown now or ignore.
+ * <p>
* Will by default use a timeout of 45 seconds by which it will shutdown now
the remaining consumers. This ensures that
* when shutting down Camel it at some point eventually will shutdown. This
behavior can of course be configured using
* the {@link #setTimeout(long)} and {@link #setShutdownNowOnTimeout(boolean)}
methods.
- * <p/>
- * Routes will by default be shutdown in the reverse order of which they where
started. You can customize this using the
+ * <p>
+ * Routes will by default be shutdown in the reverse order in which they were
started. You can customize this using the
* {@link #setShutdownRoutesInReverseOrder(boolean)} method.
- * <p/>
- * After route consumers have been shutdown, then any {@link ShutdownPrepared}
services on the routes is being prepared
- * for shutdown, by invoking {@link
ShutdownPrepared#prepareShutdown(boolean,boolean)} which <tt>force=false</tt>.
- * <p/>
+ * <p>
+ * After route consumers have been shutdown, then any {@link ShutdownPrepared}
services on the routes are being prepared
+ * for shutdown, by invoking {@link
ShutdownPrepared#prepareShutdown(boolean,boolean)} with
<code>force=false</code>.
+ * <p>
* Then if a timeout occurred and the strategy has been configured with
shutdown-now on timeout, then the strategy
* performs a more aggressive forced shutdown, by forcing all consumers to
shutdown and then invokes
- * {@link ShutdownPrepared#prepareShutdown(boolean,boolean)} with
<tt>force=true</tt> on the services. This allows the
- * services to know they should force shutdown now.
- * <p/>
+ * {@link ShutdownPrepared#prepareShutdown(boolean,boolean)} with
<code>force=true</code> on the services. This allows
+ * the services to know they should force shutdown now.
+ * <p>
* When timeout occurred and a forced shutdown is happening, then there may be
threads/tasks which are still inflight
- * which may be rejected continued being routed. By default this can cause
WARN and ERRORs to be logged. The option
+ * which may be rejected from being routed further. By default this can cause
WARN and ERRORs to be logged. The option
* {@link #setSuppressLoggingOnTimeout(boolean)} can be used to suppress these
logs, so they are logged at TRACE level
* instead.
- * <p/>
+ * <p>
* Also when a timeout occurred then information about the inflight exchanges
is logged, if
- * {@link #isLogInflightExchangesOnTimeout()} is enabled (is by default). This
allows end users to known where these
+ * {@link #isLogInflightExchangesOnTimeout()} is enabled (is by default). This
allows end users to know where these
* inflight exchanges currently are in the route(s), and how long time they
have been inflight.
- * <p/>
+ * <p>
* This information can also be obtained from the {@link
org.apache.camel.spi.InflightRepository} at all time during
* runtime.
*/
@@ -398,8 +398,9 @@ public class DefaultShutdownStrategy extends ServiceSupport
implements ShutdownS
}
/**
- * Future for the task of the shutdown that was started last, while that
shutdown is in progress, or <tt>null</tt>.
- * <p/>
+ * Future for the task of the shutdown that was started last, while that
shutdown is in progress, or
+ * <code>null</code>.
+ * <p>
* Important: This API is only for advanced use-cases.
*/
public Future<?> getCurrentShutdownTaskFuture() {
@@ -921,7 +922,7 @@ public class DefaultShutdownStrategy extends ServiceSupport
implements ShutdownS
/**
* Logs information about the inflight exchanges
*
- * @param infoLevel <tt>true</tt> to log at INFO level, <tt>false</tt> to
log at DEBUG level
+ * @param infoLevel <code>true</code> to log at INFO level,
<code>false</code> to log at DEBUG level
*/
protected void logInflightExchanges(CamelContext camelContext,
List<RouteStartupOrder> routes, boolean infoLevel) {
// check if we need to log
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultSupervisingRouteController.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultSupervisingRouteController.java
index 125c99d64b1d..1abfda1f50a2 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultSupervisingRouteController.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultSupervisingRouteController.java
@@ -67,7 +67,7 @@ import org.slf4j.LoggerFactory;
* A supervising capable {@link RouteController} that delays the startup of
the routes after the camel context startup
* and takes control of starting the routes in a safe manner. This controller
is able to retry starting failing routes,
* and have various options to configure settings for backoff between
restarting routes.
- * <p/>
+ * <p>
* When a route has been successfully started, then this supervising
controller will no longer manage the route and
* afterward the route is managed by the default route controller. The
supervising capabilities are designed to only be
* in use during the startup of the application.
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultTracer.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultTracer.java
index a3a7b036f7da..38c9f00ba81f 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultTracer.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultTracer.java
@@ -45,7 +45,7 @@ import static
org.apache.camel.support.LoggerHelper.getLineNumberLoggerName;
/**
* Default {@link Tracer} implementation that will log traced messages to the
logger named
- * <tt>org.apache.camel.Tracing</tt>.
+ * <code>org.apache.camel.Tracing</code>.
*/
public class DefaultTracer extends ServiceSupport implements
CamelContextAware, Tracer {
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DurationRoutePolicy.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DurationRoutePolicy.java
index ddc8ac107011..8f9e425b2ca3 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DurationRoutePolicy.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DurationRoutePolicy.java
@@ -35,7 +35,7 @@ import org.slf4j.LoggerFactory;
/**
* {@link org.apache.camel.spi.RoutePolicy} which executes for a duration and
then triggers an action.
- * <p/>
+ * <p>
* This can be used to stop the route after it has processed a number of
messages, or has been running for N seconds.
*/
@Metadata(label = "bean",
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DurationRoutePolicyFactory.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DurationRoutePolicyFactory.java
index 029d12998de6..2681239d43b8 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DurationRoutePolicyFactory.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DurationRoutePolicyFactory.java
@@ -26,13 +26,13 @@ import org.apache.camel.support.PatternHelper;
/**
* {@link org.apache.camel.spi.RoutePolicyFactory} which executes for a
duration and then triggers an action.
- * <p/>
- * This can be used to stop a set of routes (or CamelContext) after they have
processed a number of messages, or has
+ * <p>
+ * This can be used to stop a set of routes (or CamelContext) after they have
processed a number of messages, or have
* been running for N seconds.
*/
@Metadata(label = "bean",
description = "RoutePolicyFactory which executes for a duration and
then triggers an action."
- + " This can be used to stop a set of routes after
they have processed a number of messages, or has been running for N seconds.",
+ + " This can be used to stop a set of routes after
they have processed a number of messages, or have been running for N seconds.",
annotations = {
"interfaceName=org.apache.camel.spi.RoutePolicyFactory" })
@Configurer(metadataOnly = true)
public class DurationRoutePolicyFactory implements RoutePolicyFactory {
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/HashMapHeadersMapFactory.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/HashMapHeadersMapFactory.java
index e9b693ec59d6..d1ccfa4936ea 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/HashMapHeadersMapFactory.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/HashMapHeadersMapFactory.java
@@ -23,8 +23,8 @@ import org.apache.camel.spi.HeadersMapFactory;
/**
* HashMap {@link HeadersMapFactory} which uses a plain {@link
java.util.HashMap}. Important: The map is case sensitive
- * which means headers such as <tt>content-type</tt> and <tt>Content-Type</tt>
are two different keys which can be a
- * problem for some protocols such as HTTP based. Therefore use this
implementation with care.
+ * which means headers such as <code>content-type</code> and
<code>Content-Type</code> are two different keys which can
+ * be a problem for some protocols such as HTTP based. Therefore use this
implementation with care.
*/
public class HashMapHeadersMapFactory implements HeadersMapFactory {
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/InternalRouteStartupManager.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/InternalRouteStartupManager.java
index c1d76fadf01a..bbdbfdbbf723 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/InternalRouteStartupManager.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/InternalRouteStartupManager.java
@@ -155,7 +155,7 @@ final class InternalRouteStartupManager {
/**
* Starts the routes services in a proper manner which ensures the routes
will be started in correct order, check
* for clash and that the routes will also be shutdown in correct order as
well.
- * <p/>
+ * <p>
* This method <b>must</b> be used to start routes in a safe manner.
*
* @param checkClash whether to check for startup order clash
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/IntrospectionSupport.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/IntrospectionSupport.java
index 5b6f514f45a4..c009dd7902b7 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/IntrospectionSupport.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/IntrospectionSupport.java
@@ -53,15 +53,15 @@ import static org.apache.camel.util.ObjectHelper.isNotEmpty;
/**
* Helper for introspections of beans.
- * <p/>
+ * <p>
* <b>Important: </b> Its recommended to call the {@link #stop()} method when
{@link org.apache.camel.CamelContext} is
* being stopped. This allows to clear the introspection cache.
- * <p/>
- * This implementation will skip methods from <tt>java.lang.Object</tt> and
<tt>java.lang.reflect.Proxy</tt>.
- * <p/>
+ * <p>
+ * This implementation will skip methods from <code>java.lang.Object</code>
and <code>java.lang.reflect.Proxy</code>.
+ * <p>
* This implementation will use a cache when the {@link #getProperties(Object,
java.util.Map, String)} method is being
* used. Also the {@link #cacheClass(Class)} method gives access to the
introspect cache.
- * <p/>
+ * <p>
* This class is only for internal use by Camel - not for end users; use
{@link BeanIntrospection} instead.
*/
final class IntrospectionSupport {
@@ -111,7 +111,7 @@ final class IntrospectionSupport {
/**
* {@link org.apache.camel.CamelContext} should call this stop method when
its stopping.
- * <p/>
+ * <p>
* This implementation will clear its introspection cache.
*/
static void stop() {
@@ -206,14 +206,14 @@ final class IntrospectionSupport {
/**
* Will inspect the target for properties.
- * <p/>
- * Notice a property must have both a getter/setter method to be included.
Notice all <tt>null</tt> values will be
- * included.
+ * <p>
+ * Notice a property must have both a getter/setter method to be included.
Notice all <code>null</code> values will
+ * be included.
*
* @param target the target bean
* @param properties the map to fill in found properties
* @param optionPrefix an optional prefix to append the property key
- * @return <tt>true</tt> if any properties was found,
<tt>false</tt> otherwise.
+ * @return <code>true</code> if any properties were found,
<code>false</code> otherwise.
*/
static boolean getProperties(Object target, Map<String, Object>
properties, String optionPrefix) {
return getProperties(target, properties, optionPrefix, true);
@@ -221,14 +221,14 @@ final class IntrospectionSupport {
/**
* Will inspect the target for properties.
- * <p/>
+ * <p>
* Notice a property must have both a getter/setter method to be included.
*
* @param target the target bean
* @param properties the map to fill in found properties
* @param optionPrefix an optional prefix to append the property key
- * @param includeNull whether to include <tt>null</tt> values
- * @return <tt>true</tt> if any properties was found,
<tt>false</tt> otherwise.
+ * @param includeNull whether to include <code>null</code> values
+ * @return <code>true</code> if any properties were found,
<code>false</code> otherwise.
*/
static boolean getProperties(
Object target, Map<String, Object> properties, String
optionPrefix, boolean includeNull) {
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/LimitedPollingConsumerPollStrategy.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/LimitedPollingConsumerPollStrategy.java
index 25189de2786a..55c4cef6f2b5 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/LimitedPollingConsumerPollStrategy.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/LimitedPollingConsumerPollStrategy.java
@@ -29,8 +29,8 @@ import org.slf4j.LoggerFactory;
/**
* A {@link org.apache.camel.spi.PollingConsumerPollStrategy} which supports
suspending consumers if they failed for X
* number of times in a row.
- * <p/>
- * If Camel cannot successfully consumer from a given consumer, then after X
consecutive failed attempts the consumer
+ * <p>
+ * If Camel cannot successfully consume from a given consumer, then after X
consecutive failed attempts the consumer
* will be suspended/stopped. This prevents the log to get flooded with failed
attempts, for example during nightly
* runs.
*/
@@ -46,8 +46,8 @@ public class LimitedPollingConsumerPollStrategy extends
DefaultPollingConsumerPo
}
/**
- * Sets the limit for how many straight rollbacks causes this strategy to
suspend the fault consumer.
- * <p/>
+ * Sets the limit for how many straight rollbacks cause this strategy to
suspend the faulty consumer.
+ * <p>
* When the consumer has been suspended, it has to be manually
resumed/started to be active again. The limit is by
* default 3.
*
@@ -107,7 +107,7 @@ public class LimitedPollingConsumerPollStrategy extends
DefaultPollingConsumerPo
*
* @param consumer the consumer
* @param endpoint the endpoint
- * @return whether to retry immediately, is default
<tt>false</tt>
+ * @return whether to retry immediately, is <code>false</code>
by default
* @throws Exception can be thrown in case something goes wrong
*/
protected boolean onRollback(Consumer consumer, Endpoint endpoint) throws
Exception {
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/PooledExchangeFactory.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/PooledExchangeFactory.java
index a264fbece4cd..0d7603ae3ff2 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/PooledExchangeFactory.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/PooledExchangeFactory.java
@@ -98,7 +98,7 @@ public final class PooledExchangeFactory extends
PrototypeExchangeFactory {
/**
* Releases the exchange back into the pool.
- * <p/>
+ * <p>
* An exchange created with auto release is put into the pool when it is
done. If it is not done yet (it was given
* back without being routed) this method does that and returns whether
the pool took it, so false when the pool was
* full and the exchange was discarded. If it is already done, its unit of
work has handed it to the pool before,
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/RouteService.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/RouteService.java
index 7ecd5487182c..1a40d641060f 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/RouteService.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/RouteService.java
@@ -93,9 +93,9 @@ public class RouteService extends ChildServiceSupport {
/**
* Gather all the endpoints this route service uses
- * <p/>
+ * <p>
* This implementation finds the endpoints by searching all the child
services for {@link EndpointAware} processors
- * which uses an endpoint.
+ * which use an endpoint.
*/
public Set<Endpoint> gatherEndpoints() {
Set<Endpoint> answer = new LinkedHashSet<>();
@@ -143,7 +143,7 @@ public class RouteService extends ChildServiceSupport {
/**
* Extracts a non-null, non-empty error message from the exception or its
cause chain.
- * <p/>
+ * <p>
* {@link Throwable#getLocalizedMessage()} can return {@code null} for
exceptions such as
* {@link NullPointerException} that carry no message, which would cause
{@link FailedToStartRouteException} to
* throw {@link NullPointerException} from its own constructor (via {@code
Objects.requireNonNull}) instead of
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/SharedCamelInternalProcessor.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/SharedCamelInternalProcessor.java
index 2ebad801c71e..918e29bc2f4f 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/SharedCamelInternalProcessor.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/SharedCamelInternalProcessor.java
@@ -53,14 +53,14 @@ import org.slf4j.LoggerFactory;
* <li>{@link Transformer}</li>
* </ul>
* ... and more.
- * <p/>
+ * <p>
* This implementation executes this cross cutting functionality as a {@link
CamelInternalProcessorAdvice} advice
* (before and after advice) by executing the {@link
CamelInternalProcessorAdvice#before(Exchange)} and
* {@link CamelInternalProcessorAdvice#after(Exchange, Object)} callbacks in
correct order during routing. This reduces
* number of stack frames needed during routing, and reduce the number of
lines in stacktraces, as well makes debugging
* the routing engine easier for end users.
- * <p/>
- * <b>Debugging tips:</b> Camel end users whom want to debug their Camel
applications with the Camel source code, then
+ * <p>
+ * <b>Debugging tips:</b> Camel end users who want to debug their Camel
applications with the Camel source code, then
* make sure to read the source code of this class about the debugging tips,
which you can find in the
* {@link #process(Exchange, AsyncCallback, AsyncProcessor, Processor)} method.
*/
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/SimpleCamelContext.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/SimpleCamelContext.java
index 8fe587dd8baa..5eb8397859da 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/SimpleCamelContext.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/SimpleCamelContext.java
@@ -129,19 +129,20 @@ public class SimpleCamelContext extends
AbstractCamelContext {
/**
* Creates the {@link CamelContext} using {@link DefaultRegistry} as
registry.
- * <p/>
- * Use one of the other constructors to force use an explicit registry.
+ * <p>
+ * Use one of the other constructors to force the use of an explicit
registry.
*/
public SimpleCamelContext() {
this(true);
}
/**
- * Creates the {@link CamelContext} and allows to control whether the
context should automatic initialize or not.
- * <p/>
+ * Creates the {@link CamelContext} and allows to control whether the
context should automatically initialize or
+ * not.
+ * <p>
* Note: Not for end users - this method is used internally by
camel-blueprint/camel-cdi
*
- * @param init whether to automatic initialize.
+ * @param init whether to automatically initialize.
*/
public SimpleCamelContext(boolean init) {
super(init);
diff --git
a/core/camel-management/src/main/java/org/apache/camel/management/CompositePerformanceCounter.java
b/core/camel-management/src/main/java/org/apache/camel/management/CompositePerformanceCounter.java
index d6280e596afe..caaee9380007 100644
---
a/core/camel-management/src/main/java/org/apache/camel/management/CompositePerformanceCounter.java
+++
b/core/camel-management/src/main/java/org/apache/camel/management/CompositePerformanceCounter.java
@@ -19,9 +19,9 @@ package org.apache.camel.management;
import org.apache.camel.Exchange;
/**
- * A composite {@link PerformanceCounter} is used for tracking performance
statistics on both a per context, route, and
- * route group levels, by issuing callbacks on both when an event happens.
- * <p/>
+ * A composite {@link PerformanceCounter} is used for tracking performance
statistics on a per context, route and route
+ * group level, by issuing callbacks on each of them when an event happens.
+ * <p>
* This implementation is used so the {@link
org.apache.camel.management.mbean.ManagedCamelContext} can aggregate all
* stats from the routes.
*/
diff --git
a/core/camel-management/src/main/java/org/apache/camel/management/DefaultInstrumentationProcessor.java
b/core/camel-management/src/main/java/org/apache/camel/management/DefaultInstrumentationProcessor.java
index e76916849a22..3c3e76063eb3 100644
---
a/core/camel-management/src/main/java/org/apache/camel/management/DefaultInstrumentationProcessor.java
+++
b/core/camel-management/src/main/java/org/apache/camel/management/DefaultInstrumentationProcessor.java
@@ -30,7 +30,7 @@ import org.slf4j.LoggerFactory;
/**
* JMX enabled processor or advice that uses the {@link
org.apache.camel.management.mbean.ManagedCounter} for
* instrumenting processing of exchanges.
- * <p/>
+ * <p>
* This implementation has been optimised to work in dual mode, either as an
advice or as a processor. The former is
* faster and the latter is required when the error handler has been
configured with redelivery enabled.
*/
diff --git
a/core/camel-management/src/main/java/org/apache/camel/management/DefaultManagementAgent.java
b/core/camel-management/src/main/java/org/apache/camel/management/DefaultManagementAgent.java
index 2d184167f0f3..6c0e83ba6b9c 100644
---
a/core/camel-management/src/main/java/org/apache/camel/management/DefaultManagementAgent.java
+++
b/core/camel-management/src/main/java/org/apache/camel/management/DefaultManagementAgent.java
@@ -401,7 +401,7 @@ public class DefaultManagementAgent extends ServiceSupport
implements Management
/**
* Gets the names of the registered processor mbeans that belong to the
given route.
- * <p/>
+ * <p>
* This avoids querying (and reading the route id of) every processor
mbean of the CamelContext, which is slow when
* there are many routes.
*
@@ -416,7 +416,7 @@ public class DefaultManagementAgent extends ServiceSupport
implements Management
/**
* Gets the managed object of the registered processor mbean with the
given id.
- * <p/>
+ * <p>
* This avoids walking every route to find the processor and its
definition, which is slow when there are many
* routes.
*
diff --git
a/core/camel-management/src/main/java/org/apache/camel/management/DelegatePerformanceCounter.java
b/core/camel-management/src/main/java/org/apache/camel/management/DelegatePerformanceCounter.java
index 533300687bb8..c61fcc8c5a0d 100644
---
a/core/camel-management/src/main/java/org/apache/camel/management/DelegatePerformanceCounter.java
+++
b/core/camel-management/src/main/java/org/apache/camel/management/DelegatePerformanceCounter.java
@@ -20,13 +20,13 @@ import org.apache.camel.Exchange;
/**
* Delegates to another {@link PerformanceCounter}.
- * <p/>
- * This is used to allow Camel to pre initialize these delegate performance
counters when Camel creates the actual route
- * from the model. Then later as the various processors, routes etc. is
created and registered in the
+ * <p>
+ * This is used to allow Camel to pre-initialize these delegate performance
counters when Camel creates the actual route
+ * from the model. Then later as the various processors, routes etc. are
created and registered in the
* {@link org.apache.camel.spi.LifecycleStrategy} then we link this to the real
* {@link org.apache.camel.management.mbean.ManagedPerformanceCounter} mbean
so the mbean can gather statistics.
- * <p/>
- * This delegation is needed as how Camel is designed to register services in
the
+ * <p>
+ * This delegation is needed because of how Camel is designed to register
services in the
* {@link org.apache.camel.spi.LifecycleStrategy} in various stages.
*/
public class DelegatePerformanceCounter implements PerformanceCounter {
diff --git
a/core/camel-management/src/main/java/org/apache/camel/management/InstrumentationInterceptStrategy.java
b/core/camel-management/src/main/java/org/apache/camel/management/InstrumentationInterceptStrategy.java
index 681d7d4a14ca..5184f8e14720 100644
---
a/core/camel-management/src/main/java/org/apache/camel/management/InstrumentationInterceptStrategy.java
+++
b/core/camel-management/src/main/java/org/apache/camel/management/InstrumentationInterceptStrategy.java
@@ -28,7 +28,7 @@ import org.apache.camel.util.ObjectHelper;
/**
* This strategy class wraps targeted processors with a {@link
InstrumentationProcessor}. Each InstrumentationProcessor
* has an embedded {@link ManagedPerformanceCounter} for monitoring
performance metrics.
- * <p/>
+ * <p>
* This class looks up a map to determine which PerformanceCounter should go
into the InstrumentationProcessor for any
* particular target processor.
*/
diff --git
a/core/camel-management/src/main/java/org/apache/camel/management/JmxManagementLifecycleStrategy.java
b/core/camel-management/src/main/java/org/apache/camel/management/JmxManagementLifecycleStrategy.java
index d46bf6d411a6..2f27d09998a5 100644
---
a/core/camel-management/src/main/java/org/apache/camel/management/JmxManagementLifecycleStrategy.java
+++
b/core/camel-management/src/main/java/org/apache/camel/management/JmxManagementLifecycleStrategy.java
@@ -380,7 +380,7 @@ public class JmxManagementLifecycleStrategy extends
ServiceSupport implements Li
* After {@link CamelContext} has been enlisted in JMX using
* {@link #onContextStarted(org.apache.camel.CamelContext)} then we can
enlist any pre-registered services as well,
* as we had to wait for {@link CamelContext} to be enlisted first.
- * <p/>
+ * <p>
* A component/endpoint/service etc. can be pre-registered when using
dependency injection and annotations such as
* {@link org.apache.camel.Produce}, {@link
org.apache.camel.EndpointInject}. Therefore, we need to capture those
* registrations up front, and then afterward enlist in JMX when {@link
CamelContext} is being started.
@@ -1106,8 +1106,8 @@ public class JmxManagementLifecycleStrategy extends
ServiceSupport implements Li
/**
* Removes the wrapped processors for the given routes, as they are no
longer in use.
- * <p/>
- * This is needed to avoid accumulating memory, if a lot of routes is
being added and removed.
+ * <p>
+ * This is needed to avoid accumulating memory, if a lot of routes are
being added and removed.
*
* @param routes the routes
*/
@@ -1265,14 +1265,14 @@ public class JmxManagementLifecycleStrategy extends
ServiceSupport implements Li
/**
* Whether to register the mbean.
- * <p/>
- * The {@link ManagementAgent} has options which controls when to
register. This allows us to only register mbeans
- * accordingly. For example by default any dynamic endpoints is not
registered. This avoids to register excessive
+ * <p>
+ * The {@link ManagementAgent} has options which control when to register.
This allows us to only register mbeans
+ * accordingly. For example by default any dynamic endpoints are not
registered. This avoids registering excessive
* mbeans, which most often is not desired.
*
* @param service the object to register
- * @param route an optional route the mbean is associated with, can be
<tt>null</tt>
- * @return <tt>true</tt> to register, <tt>false</tt> to skip
registering
+ * @param route an optional route the mbean is associated with, can be
<code>null</code>
+ * @return <code>true</code> to register, <code>false</code> to
skip registering
*/
protected boolean shouldRegister(Object service, Route route) {
// the agent hasn't been started
diff --git
a/core/camel-management/src/main/java/org/apache/camel/management/JmxManagementStrategy.java
b/core/camel-management/src/main/java/org/apache/camel/management/JmxManagementStrategy.java
index 666ee1eb14c0..3caf98cc5c2e 100644
---
a/core/camel-management/src/main/java/org/apache/camel/management/JmxManagementStrategy.java
+++
b/core/camel-management/src/main/java/org/apache/camel/management/JmxManagementStrategy.java
@@ -35,9 +35,9 @@ import org.slf4j.LoggerFactory;
/**
* A JMX capable {@link org.apache.camel.spi.ManagementStrategy} that Camel by
default uses if possible.
- * <p/>
- * Camel detects whether its possible to use this JMX capable strategy and if
<b>not</b> then Camel will fallback to the
- * {@link DefaultManagementStrategy} instead.
+ * <p>
+ * Camel detects whether it is possible to use this JMX capable strategy and
if <b>not</b> then Camel will fall back to
+ * the {@link DefaultManagementStrategy} instead.
*
* @see org.apache.camel.spi.ManagementStrategy
*/
diff --git
a/core/camel-management/src/main/java/org/apache/camel/management/JmxNotificationEventNotifier.java
b/core/camel-management/src/main/java/org/apache/camel/management/JmxNotificationEventNotifier.java
index 7e51c9c88eaf..78372da05777 100644
---
a/core/camel-management/src/main/java/org/apache/camel/management/JmxNotificationEventNotifier.java
+++
b/core/camel-management/src/main/java/org/apache/camel/management/JmxNotificationEventNotifier.java
@@ -74,9 +74,9 @@ public class JmxNotificationEventNotifier extends
EventNotifierSupport implement
/**
* Sets the source to be used when broadcasting events. The source is just
a readable identifier which helps the
- * receiver see where the event is coming from. You can assign a value
such a server or application name etc.
- * <p/>
- * By default <tt>Camel</tt> will be used as source.
+ * receiver see where the event is coming from. You can assign a value
such as a server or application name etc.
+ * <p>
+ * By default <code>Camel</code> will be used as source.
*
* @param source the source
*/
diff --git
a/core/camel-management/src/main/java/org/apache/camel/management/LoggingEventNotifier.java
b/core/camel-management/src/main/java/org/apache/camel/management/LoggingEventNotifier.java
index b24386f7abb4..872bdcf74aec 100644
---
a/core/camel-management/src/main/java/org/apache/camel/management/LoggingEventNotifier.java
+++
b/core/camel-management/src/main/java/org/apache/camel/management/LoggingEventNotifier.java
@@ -22,7 +22,7 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
- * Logging event notifier that only notifies if <tt>INFO</tt> log level has
been configured for its logger.
+ * Logging event notifier that only notifies if <code>INFO</code> log level
has been configured for its logger.
*/
public class LoggingEventNotifier extends EventNotifierSupport {
diff --git
a/core/camel-management/src/main/java/org/apache/camel/management/ManagedLoadTimer.java
b/core/camel-management/src/main/java/org/apache/camel/management/ManagedLoadTimer.java
index 9101554d71de..c81c0511a6c5 100644
---
a/core/camel-management/src/main/java/org/apache/camel/management/ManagedLoadTimer.java
+++
b/core/camel-management/src/main/java/org/apache/camel/management/ManagedLoadTimer.java
@@ -21,7 +21,7 @@ import org.apache.camel.support.TimerListenerManager;
/**
* The {@link org.apache.camel.support.TimerListenerManager} used for tracking
load statistics.
- * <p/>
+ * <p>
* From Camel 2.13 onwards the {@link ManagedLoadTimer} is only enabled if
* {@link org.apache.camel.spi.ManagementAgent#getLoadStatisticsEnabled()} is
enabled.
*/
diff --git
a/core/camel-management/src/main/java/org/apache/camel/management/PerformanceCounter.java
b/core/camel-management/src/main/java/org/apache/camel/management/PerformanceCounter.java
index 9eaac3f3c91e..33c626b97254 100644
---
a/core/camel-management/src/main/java/org/apache/camel/management/PerformanceCounter.java
+++
b/core/camel-management/src/main/java/org/apache/camel/management/PerformanceCounter.java
@@ -48,7 +48,7 @@ public interface PerformanceCounter {
/**
* Are statistics enabled?
- * <p/>
+ * <p>
* They can be enabled and disabled at runtime
*
* @return whether statistics are enabled or not
@@ -57,7 +57,7 @@ public interface PerformanceCounter {
/**
* Sets whether statistics are enabled.
- * <p/>
+ * <p>
* They can be enabled and disabled at runtime
*
* @param statisticsEnabled whether statistics are enabled or not
diff --git
a/core/camel-management/src/main/java/org/apache/camel/management/PublishEventNotifier.java
b/core/camel-management/src/main/java/org/apache/camel/management/PublishEventNotifier.java
index ac8d759f3b9b..a8a9c82feaf3 100644
---
a/core/camel-management/src/main/java/org/apache/camel/management/PublishEventNotifier.java
+++
b/core/camel-management/src/main/java/org/apache/camel/management/PublishEventNotifier.java
@@ -35,7 +35,7 @@ import org.slf4j.LoggerFactory;
/**
* A {@link org.apache.camel.spi.EventNotifier} which publishes the {@link
EventObject} to some
* {@link org.apache.camel.Endpoint}.
- * <p/>
+ * <p>
* This notifier is only enabled when {@link CamelContext} is started. This
avoids problems when sending notifications
* during start/shutdown of {@link CamelContext} which causes problems by
sending those events to Camel routes by this
* notifier.
diff --git
a/core/camel-management/src/main/java/org/apache/camel/management/mbean/ManagedRoute.java
b/core/camel-management/src/main/java/org/apache/camel/management/mbean/ManagedRoute.java
index be08000140f2..3c00217e7553 100644
---
a/core/camel-management/src/main/java/org/apache/camel/management/mbean/ManagedRoute.java
+++
b/core/camel-management/src/main/java/org/apache/camel/management/mbean/ManagedRoute.java
@@ -1086,7 +1086,7 @@ public class ManagedRoute extends
ManagedPerformanceCounter implements ManagedRo
/**
* Gets the names of the processor (or step) mbeans of this route.
- * <p/>
+ * <p>
* The default management agent knows the mbeans of each route, otherwise
all the processor mbeans of the
* CamelContext are queried, which is slow with many routes as the route
id of each mbean must be read.
*/
diff --git
a/core/camel-management/src/main/java/org/apache/camel/management/mbean/RouteCoverageXmlParser.java
b/core/camel-management/src/main/java/org/apache/camel/management/mbean/RouteCoverageXmlParser.java
index 9bbb76c780ad..4a2c841647f6 100644
---
a/core/camel-management/src/main/java/org/apache/camel/management/mbean/RouteCoverageXmlParser.java
+++
b/core/camel-management/src/main/java/org/apache/camel/management/mbean/RouteCoverageXmlParser.java
@@ -41,7 +41,7 @@ import
org.apache.camel.api.management.mbean.ManagedRouteMBean;
/**
* An XML parser that uses SAX to enrich route stats in the route dump.
- * <p/>
+ * <p>
* The coverage details:
* <ul>
* <li>exchangesTotal - Total number of exchanges</li>
diff --git
a/core/camel-management/src/main/java/org/apache/camel/management/mbean/Statistic.java
b/core/camel-management/src/main/java/org/apache/camel/management/mbean/Statistic.java
index 20aec48e159d..3b6ab10f6c2f 100644
---
a/core/camel-management/src/main/java/org/apache/camel/management/mbean/Statistic.java
+++
b/core/camel-management/src/main/java/org/apache/camel/management/mbean/Statistic.java
@@ -18,10 +18,10 @@ package org.apache.camel.management.mbean;
/**
* Base implementation of {@link Statistic}
- * <p/>
- * The following modes is available:
+ * <p>
+ * The following modes are available:
* <ul>
- * <li>VALUE - A statistic with this update mode is a simple value that is a
straight forward representation of the
+ * <li>VALUE - A statistic with this update mode is a simple value that is a
straightforward representation of the
* updated value.</li>
* <li>DELTA - A statistic with this update mode is a value that represents
the delta between the last two recorded
* values (or the initial value if two updates have not been recorded). This
value can be negative if the delta goes up
@@ -32,9 +32,10 @@ package org.apache.camel.management.mbean;
* values applied to this statistic.</li>
* <li>MINIMUM - A statistic with this update mode is a value that represents
the minimum value amongst the update
* values applied to this statistic.</li>
- * <ul>
+ * </ul>
+ * <p>
* The MAXIMUM and MINIMUM modes are not 100% thread-safe as there can be a
lost-update problem. This is on purpose
- * because the performance overhead to ensure atomic updates costs to much on
CPU and memory footprint. The other modes
+ * because the performance overhead to ensure atomic updates costs too much on
CPU and memory footprint. The other modes
* are thread-safe.
*/
public abstract class Statistic {
