INT-2964 Various JavaDoc Fixes

INT-2964 - JavaDoc: <emphasis> should be <em>

INT-2964 - JavaDoc: <p/> should be <p>

INT-2964 - JavaDoc polishing

* <li></li> should be wrapped in <ul></ul>
* wrap code snippets in {@code myCode()}
* change <code>false</false> to <code>false</code>

INT-2964 - Polish - Fix more JavaDoc errors

* Mockito-all dependency causes JavaDoc error. Change dependency to Mockito-Core.

spring-integration-core/src/main/java/org/springframework/integration/MessageChannel.java

@@ -18,7 +18,7 @@ package org.springframework.integration;
 
 /**
  * Base channel interface defining common behavior for sending messages.
- * 
+ *
  * @author Mark Fisher
  */
 public interface MessageChannel {
@@ -28,25 +28,25 @@ public interface MessageChannel {
 	 * non-recoverable errors. Otherwise, if the Message cannot be sent for a
 	 * non-fatal reason this method will return 'false', and if the Message is
 	 * sent successfully, it will return 'true'.
-	 * 
+	 *
 	 * <p>Depending on the implementation, this method may block indefinitely.
 	 * To provide a maximum wait time, use {@link #send(Message, long)}.
-	 * 
+	 *
 	 * @param message the {@link Message} to send
-	 * 
-	 * @return whether the Message has been sent successfully
+	 *
+	 * @return whether or not the Message has been sent successfully
 	 */
 	boolean send(Message<?> message);
 
 	/**
 	 * Send a message, blocking until either the message is accepted or the
 	 * specified timeout period elapses.
-	 * 
+	 *
 	 * @param message the {@link Message} to send
 	 * @param timeout the timeout in milliseconds
-	 * 
+	 *
 	 * @return <code>true</code> if the message is sent successfully,
-	 * <code>false</false> if the specified timeout period elapses or
+	 * <code>false</code> if the specified timeout period elapses or
 	 * the send is interrupted
 	 */
 	boolean send(Message<?> message, long timeout);

spring-integration-core/src/main/java/org/springframework/integration/aggregator/AbstractCorrelatingMessageHandler.java

@@ -49,11 +49,11 @@ import org.springframework.util.CollectionUtils;
  * and is used as a base class for Aggregator - {@link AggregatingMessageHandler} and
  * Resequencer - {@link ResequencingMessageHandler},
  * or custom implementations requiring correlation.
- * <p/>
+ * <p>
  * To customize this handler inject {@link CorrelationStrategy},
  * {@link ReleaseStrategy}, and {@link MessageGroupProcessor} implementations as
  * you require.
- * <p/>
+ * <p>
  * By default the {@link CorrelationStrategy} will be a
  * {@link HeaderAttributeCorrelationStrategy} and the {@link ReleaseStrategy} will be a
  * {@link SequenceSizeReleaseStrategy}.

spring-integration-core/src/main/java/org/springframework/integration/aggregator/CorrelatingMessageBarrier.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
@@ -33,11 +33,11 @@ import org.springframework.integration.store.SimpleMessageStore;
  * When a message can be processed it is up to the client to take care of the locking (potentially from the ReleaseStrategy's
  * {@link org.springframework.integration.aggregator.ReleaseStrategy#canRelease(org.springframework.integration.store.MessageGroup) canRelease(..)}
  * method).
- * <p/>
+ * <p>
  * This class differs from AbstractCorrelatingMessageHandler in that it completely decouples the receiver and the sender. It can
  * be applied in scenarios where completion of a message group is not well defined but only a certain amount of messages
  * for any given correlation key may be processed at a time.
- * <p/>
+ * <p>
  * The messages will be stored in a {@link org.springframework.integration.store.MessageGroupStore MessageStore}
  * for each correlation key.
  *

spring-integration-core/src/main/java/org/springframework/integration/aggregator/MessageGroupProcessor.java

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2011 the original author or authors.
- * 
+ * Copyright 2002-2013 the original author or authors.
+ *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
  * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
  * specific language governing permissions and limitations under the License.
@@ -27,7 +27,7 @@ public interface MessageGroupProcessor {
 	 * Process the given MessageGroup. Implementations are free to return as few or as many messages based on the
 	 * invocation as needed. For example an aggregating processor will return only a single message representing the
 	 * group, while a resequencing processor will return all messages whose preceding sequence has been satisfied.
-	 * <p/>
+	 * <p>
 	 * If a multiple messages are returned the return value must be a Collection&lt;Message&gt;.
 	 */
 	Object processMessageGroup(MessageGroup group);

spring-integration-core/src/main/java/org/springframework/integration/annotation/Payloads.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2010 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,9 +26,10 @@ import java.lang.annotation.Target;
  * This annotation marks a method parameter as being a list of message payloads, for POJO handlers that deal with lists
  * of messages (e.g. aggregators and release strategies).
  * <p>
- * Example: void foo(@Payloads("city.name") List<String> cityName) - will map the value of the 'name' property of the 'city'
+ * Example:
+ * {@code void foo(@Payloads("city.name") List<String> cityName)} - will map the value of the 'name' property of the 'city'
  * property of all the payload objects in the input list.
- * 
+ *
  * @author Dave Syer
  * @since 2.0
  */

spring-integration-core/src/main/java/org/springframework/integration/channel/DirectChannel.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -43,7 +43,7 @@ public class DirectChannel extends AbstractSubscribableChannel {
 
 	/**
 	 * Create a DirectChannel with a {@link LoadBalancingStrategy}. The
-	 * strategy <emphasis>must not</emphasis> be null.
+	 * strategy <em>must not</em> be null.
 	 */
 	public DirectChannel(LoadBalancingStrategy loadBalancingStrategy) {
 		this.dispatcher.setLoadBalancingStrategy(loadBalancingStrategy);

spring-integration-core/src/main/java/org/springframework/integration/channel/ExecutorChannel.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -32,10 +32,10 @@ import org.springframework.util.ErrorHandler;
  * {@link UnicastingDispatcher} which in turn delegates all dispatching
  * invocations to an {@link Executor}.
  * <p>
- * <emphasis>NOTE: unlike DirectChannel, the ExecutorChannel does not support a
+ * <em><b>NOTE</b>: unlike DirectChannel, the ExecutorChannel does not support a
  * shared transactional context between sender and handler, because the
  * {@link Executor} typically does not block the sender's Thread since it
- * uses another Thread for the dispatch.</emphasis> (SyncTaskExecutor is an
+ * uses another Thread for the dispatch.</em> (SyncTaskExecutor is an
  * exception but would provide no value for this channel. If synchronous
  * dispatching is required, a DirectChannel should be used instead).
  *

spring-integration-core/src/main/java/org/springframework/integration/context/IntegrationObjectSupport.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2010 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -31,7 +31,7 @@ import org.springframework.util.StringUtils;
 /**
  * A base class that provides convenient access to the bean factory as
  * well as {@link TaskScheduler} and {@link ConversionService} instances.
- * <p/>
+ * <p>
  * <p>This is intended to be used as a base class for internal framework
  * components whereas code built upon the integration framework should not
  * require tight coupling with the context but rather rely on standard

spring-integration-core/src/main/java/org/springframework/integration/core/MessageHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2010 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,7 +21,7 @@ import org.springframework.integration.MessagingException;
 
 /**
  * Base interface for any component that handles Messages.
- * 
+ *
  * @author Mark Fisher
  * @author Iwein Fuld
  */
@@ -34,11 +34,11 @@ public interface MessageHandler {
 	 * message, but fails to do so, a <code>MessageHandlingException</code> is
 	 * thrown. In the last case it is recommended to treat the message as tainted
 	 * and go into an error scenario.
-	 * <p/>
+	 * <p>
 	 * When the handling results in a failure of another message being sent
 	 * (e.g. a "reply" message), that failure  will trigger a
 	 * <code>MessageDeliveryException</code>.
-	 * 
+	 *
 	 * @param message the message to be handled
 	 * @throws org.springframework.integration.MessageRejectedException if the handler doesn't accept the message
 	 * @throws org.springframework.integration.MessageHandlingException when something fails during the handling

spring-integration-core/src/main/java/org/springframework/integration/dispatcher/OrderedAwareCopyOnWriteArraySet.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -46,7 +46,7 @@ import org.springframework.util.StringUtils;
  * of the insertion while maintaining the order of insertion for the un-ordered elements.
  * <p>
  * The class is package-protected and only intended for use by the AbstractDispatcher. It
- * <emphasis>must</emphasis> enforce safe concurrent access for all usage by the dispatcher.
+ * <em>must</em> enforce safe concurrent access for all usage by the dispatcher.
  *
  * @author Oleg Zhurakousky
  * @author Mark Fisher

spring-integration-core/src/main/java/org/springframework/integration/dispatcher/UnicastingDispatcher.java

@@ -1,4 +1,4 @@
-/* Copyright 2002-2012 the original author or authors.
+/* Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -35,11 +35,11 @@ import org.springframework.integration.core.MessageHandler;
  * as determined by the {@link LoadBalancingStrategy} if one is configured. As
  * soon as <em>one</em> of the handlers accepts the Message, the dispatcher will
  * return <code>true</code> and ignore the rest of its handlers.
- * <p/>
+ * <p>
  * If the dispatcher has no handlers, a {@link MessageDeliveryException} will be
  * thrown. If all handlers throw Exceptions, the dispatcher will throw an
  * {@link AggregateMessageDeliveryException}.
- * <p/>
+ * <p>
  * A load-balancing strategy may be provided to this class to control the order in
  * which the handlers will be tried.
  *
@@ -152,7 +152,7 @@ public class UnicastingDispatcher extends AbstractDispatcher {
 	/**
 	 * Handles Exceptions that occur while dispatching. If this dispatcher has
 	 * failover enabled, it will only throw an Exception when the handler list
-	 * is exhausted. The 'isLast' flag will be <emphasis>true</emphasis> if the
+	 * is exhausted. The 'isLast' flag will be <em>true</em> if the
 	 * Exception occurred during the final iteration of the MessageHandlers.
 	 * If failover is disabled for this dispatcher, it will re-throw any
 	 * Exception immediately.

spring-integration-core/src/main/java/org/springframework/integration/filter/MessageFilter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2010 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -32,7 +32,7 @@ import org.springframework.util.Assert;
  * {@link MessageRejectedException} depending on the value of its
  * {@link #throwExceptionOnRejection} property. If a discard channel is
  * provided, the rejected Messages will be sent to that channel.
- * 
+ *
  * @author Mark Fisher
  * @author Oleg Zhurakousky
  */
@@ -56,14 +56,14 @@ public class MessageFilter extends AbstractReplyProducingMessageHandler {
 
 
 	/**
-	 * Specify whether this filter should throw a 
+	 * Specify whether this filter should throw a
 	 * {@link MessageRejectedException} when its selector does not accept a
 	 * Message. The default value is <code>false</code> meaning that rejected
 	 * Messages will be quietly dropped or sent to the discard channel if
 	 * available. Typically this value would not be <code>true</code> when
 	 * a discard channel is provided, but if so, it will still apply
 	 * (in such a case, the Message will be sent to the discard channel,
-	 * and <emphasis>then</emphasis> the exception will be thrown).
+	 * and <em>then</em> the exception will be thrown).
 	 * @see #setDiscardChannel(MessageChannel)
 	 */
 	public void setThrowExceptionOnRejection(boolean throwExceptionOnRejection) {

spring-integration-core/src/main/java/org/springframework/integration/gateway/GatewayMethodInboundMessageMapper.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -51,20 +51,20 @@ import org.springframework.util.StringUtils;
 /**
  * A Message Mapper implementation that supports mapping <i>to</i> a
  * Message from an argument array when invoking gateway methods.
- * <p/>
- * Some examples of legal method signatures:<br/>
- * <tt>public void dealWith(Object payload);</tt><br/>
- * <tt>public void dealWith(Message message);</tt><br/>
- * <tt>public void dealWith(@Header String myHeader, Object payload);</tt><br/>
- * <br/>
- * <tt>public void dealWith(@Headers Map headers, Object payload);</tt><br/>
- * <tt>public void dealWith(@Headers Properties headers, Map payload);</tt><br/>
- * <tt>public void dealWith(Properties headers, Object payload);</tt><br/>
- * <p/>
- * Some examples of illegal method signatures: <br/>
- * <tt>public void dealWith(Object payload, String payload);</tt><br/>
- * <tt>public void dealWith(Message message, Object payload);</tt><br/>
- * <tt>public void dealWith(Properties headers, Map payload);</tt><br/>
+ * <p>
+ * Some examples of legal method signatures:<br>
+ * <tt>public void dealWith(Object payload);</tt><br>
+ * <tt>public void dealWith(Message message);</tt><br>
+ * <tt>public void dealWith(@Header String myHeader, Object payload);</tt><br>
+ * <br>
+ * <tt>public void dealWith(@Headers Map headers, Object payload);</tt><br>
+ * <tt>public void dealWith(@Headers Properties headers, Map payload);</tt><br>
+ * <tt>public void dealWith(Properties headers, Object payload);</tt><br>
+ * <p>
+ * Some examples of illegal method signatures: <br>
+ * <tt>public void dealWith(Object payload, String payload);</tt><br>
+ * <tt>public void dealWith(Message message, Object payload);</tt><br>
+ * <tt>public void dealWith(Properties headers, Map payload);</tt><br>
  *
  * @author Mark Fisher
  * @author Iwein Fuld

spring-integration-core/src/main/java/org/springframework/integration/handler/BridgeHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2010 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,12 +23,12 @@ import org.springframework.integration.Message;
  * directly to the output channel without modifying it. The main purpose of this
  * handler is to bridge a PollableChannel to a SubscribableChannel or
  * vice-versa.
- * <p/>
+ * <p>
  * The BridgeHandler can be used as a stopper at the end of an assembly line of
  * channels. In this setup the output channel doesn't have to be set, but if the
  * output channel is omitted the <tt>REPLY_CHANNEL</tt> MUST be set on the
  * message. Otherwise, a MessagingException will be thrown at runtime.
- * 
+ *
  * @author Mark Fisher
  * @author Iwein Fuld
  */

spring-integration-core/src/main/java/org/springframework/integration/handler/DelayHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -49,12 +49,12 @@ import org.springframework.util.CollectionUtils;
  * therefore, the calling thread does not block. The advantage of this approach
  * is that many delays can be managed concurrently, even very long delays,
  * without producing a buildup of blocked Threads.
- * <p/>
+ * <p>
  * One thing to keep in mind, however, is that any active transactional context
  * will not propagate from the original sender to the eventual recipient. This
  * is a side-effect of passing the Message to the output channel after the
  * delay with a different Thread in control.
- * <p/>
+ * <p>
  * When this handler's 'delayHeaderName' property is configured, that value, if
  * present on a Message, will take precedence over the handler's 'defaultDelay'
  * value. The actual header value may be a long, a String that can be parsed
@@ -111,7 +111,7 @@ public class DelayHandler extends AbstractReplyProducingMessageHandler implement
 	/**
 	 * Set the default delay in milliseconds. If no 'delayHeaderName' property
 	 * has been provided, the default delay will be applied to all Messages. If
-	 * a delay should <emphasis>only</emphasis> be applied to Messages with a
+	 * a delay should <em>only</em> be applied to Messages with a
 	 * header, then set this value to 0.
 	 */
 	public void setDefaultDelay(long defaultDelay) {
@@ -137,7 +137,7 @@ public class DelayHandler extends AbstractReplyProducingMessageHandler implement
 	}
 
 	/**
-	 * Specify the <code>List<Advice></code> to advise {@link DelayHandler.ReleaseMessageHandler} proxy.
+	 * Specify the {@code List<Advice>} to advise {@link DelayHandler.ReleaseMessageHandler} proxy.
 	 * Usually used to add transactions to delayed messages retrieved from a transactional message store.
 	 *
 	 * @see #createReleaseMessageTask
@@ -182,7 +182,7 @@ public class DelayHandler extends AbstractReplyProducingMessageHandler implement
 	 * Checks if 'requestMessage' wasn't delayed before
 	 * ({@link #releaseMessageAfterDelay} and {@link DelayHandler.DelayedMessageWrapper}).
 	 * Than determine 'delay' for 'requestMessage' ({@link #determineDelayForMessage})
-	 * and if <code>delay > 0</code> schedules 'releaseMessage' task after 'delay'.
+	 * and if {@code delay > 0} schedules 'releaseMessage' task after 'delay'.
 	 *
 	 * @param requestMessage - the Message which may be delayed.
 	 * @return - <code>null</code> if 'requestMessage' is delayed,

spring-integration-core/src/main/java/org/springframework/integration/handler/MessageHandlerChain.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,7 +21,6 @@ import org.springframework.aop.support.AopUtils;
 import org.springframework.beans.DirectFieldAccessor;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.context.SmartLifecycle;
-import org.springframework.core.Ordered;
 import org.springframework.integration.Message;
 import org.springframework.integration.MessageChannel;
 import org.springframework.integration.MessageHandlingException;
@@ -40,21 +39,21 @@ import java.util.concurrent.locks.ReentrantLock;
 /**
  * A composite {@link MessageHandler} implementation that invokes a chain of
  * MessageHandler instances in order.
- * <p/>
+ * <p>
  * Each of the handlers except for the last one <b>must</b> implement the
  * {@link MessageProducer} interface. The last handler must also <b>if</b>
  * the chain itself has an output channel configured. No other assumptions
  * are made about the type of handler.
- * <p/>
+ * <p>
  * It is expected that each handler will produce reply messages and send them to
  * its output channel, although this is not enforced. It is possible to filter
  * messages in the middle of the chain, for example using a
  * {@link MessageFilter}. A {@link MessageHandler} returning null will have the
  * same effect, although this option is less expressive.
- * <p/>
+ * <p>
  * This component can be used from the namespace to improve the readability of
  * the configuration by removing channels that can be created implicitly.
- * <p/>
+ * <p>
  *
  * <pre>
  * &lt;chain&gt;

spring-integration-core/src/main/java/org/springframework/integration/handler/advice/AbstractRequestHandlerAdvice.java

@@ -99,8 +99,9 @@ public abstract class AbstractRequestHandlerAdvice extends IntegrationObjectSupp
 	}
 
 	/**
-	 * Subclasses implement this method to apply behavior to the {@link MessageHandler}.<p/> callback.execute()
-	 * invokes the handler method and returns its result, or null.
+	 * Subclasses implement this method to apply behavior to the {@link MessageHandler}.
+	 * <p>
+	 * callback.execute() invokes the handler method and returns its result, or null.
 	 *
 	 * @param callback Subclasses invoke the execute() method on this interface to invoke the handler method.
 	 * @param target   The target handler.

spring-integration-core/src/main/java/org/springframework/integration/mapping/AbstractHeaderMapper.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -97,7 +97,7 @@ public abstract class AbstractHeaderMapper<T> implements RequestReplyHeaderMappe
 	/**
 	 * Specify a prefix to be prepended to the header name for any integration
 	 * message header that is being mapped to or from a user-defined value.
-	 * <p/>
+	 * <p>
 	 * This does not affect the standard properties for the particular protocol, such as
 	 * contentType for AMQP, etc. The header names used for mapping such properties are
 	 * defined in a corresponding Headers class as constants (e.g. AmqpHeaders).

spring-integration-core/src/main/java/org/springframework/integration/router/RecipientListRouter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -31,25 +31,25 @@ import org.springframework.util.Assert;
  * <recipient-list-router id="simpleRouter" input-channel="routingChannelA">
  *     <recipient channel="channel1"/>
  *     <recipient channel="channel2"/>
- * </recipient-list-router>
+ * </recipient-list-router>
  * </pre>
- * <p/>
+ * <p>
  * A Message Router that sends Messages to a list of recipient channels. The
  * recipients can be provided as a static list of {@link MessageChannel}
  * instances via the {@link #setChannels(List)} method, or for dynamic behavior,
  * the values can be provided via the {@link #setRecipients(List)} method.
- * <p/>
+ * <p>
  * For more advanced, programmatic control of dynamic recipient lists, consider
  * using the @Router annotation or extending {@link AbstractMappingMessageRouter} instead.
- * <p/>
+ * <p>
  * Contrary to a standard &lt;router .../&gt; this handler will try to send to
  * all channels that are configured as recipients. It is to channels what a
  * publish subscribe channel is to endpoints.
- * <p/>
+ * <p>
  * Using this class only makes sense if it is essential to send messages on
  * multiple channels instead of sending them to multiple handlers. If the latter
  * is an option using a publish subscribe channel is the more flexible solution.
- * 
+ *
  * @author Mark Fisher
  * @author Oleg Zhurakousky
  */

spring-integration-core/src/main/java/org/springframework/integration/store/MessageGroup.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,11 +21,11 @@ import java.util.Collection;
 import org.springframework.integration.Message;
 
 /**
- * A group of messages that are correlated with each other and should be processed in the same context. 
- * <p/>
+ * A group of messages that are correlated with each other and should be processed in the same context.
+ * <p>
  * The message group allows implementations to be mutable, but this behavior is optional. Implementations should take
  * care to document their thread safety and mutability.
- * 
+ *
  * @author Dave Syer
  * @author Oleg Zhurakousky
  */
@@ -45,7 +45,7 @@ public interface MessageGroup {
 	 * @return the key that links these messages together
 	 */
 	Object getGroupId();
-	
+
 	/**
 	 * Returns the sequenceNumber of the last released message. Used in Resequencer use cases only
 	 */
@@ -55,9 +55,9 @@ public interface MessageGroup {
 	 * @return true if the group is complete (i.e. no more messages are expected to be added)
 	 */
 	boolean isComplete();
-	
+
 	/**
-	 * 
+	 *
 	 */
 	void complete();
 
@@ -80,7 +80,7 @@ public interface MessageGroup {
 	 * @return the timestamp (milliseconds since epoch) associated with the creation of this group
 	 */
 	long getTimestamp();
-	
+
 	/**
 	 * @return the timestamp (milliseconds since epoch) associated with the time this group was last updated
 	 */

spring-integration-core/src/main/java/org/springframework/integration/transformer/HeaderEnricher.java

@@ -41,7 +41,7 @@ import org.springframework.integration.support.MessageBuilder;
  * Accepts the boolean 'overwrite' property that specifies whether values should
  * be overwritten. By default, any existing header values for a given key, will
  * <em>not</em> be replaced.
- * 
+ *
  * @author Mark Fisher
  * @author David Turanski
  * @author Artem Bilan
@@ -83,7 +83,7 @@ public class HeaderEnricher implements Transformer, BeanNameAware, InitializingB
 	/**
 	 * Specify whether <code>null</code> values, such as might be returned from
 	 * an expression evaluation, should be skipped. The default value is
-	 * <code>true</code>. Set this to <code>false</false> if a
+	 * <code>true</code>. Set this to <code>false</code> if a
 	 * <code>null</code> value should trigger <i>removal</i> of the
 	 * corresponding header instead.
 	 */
@@ -220,7 +220,7 @@ public class HeaderEnricher implements Transformer, BeanNameAware, InitializingB
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see
 	 * org.springframework.beans.factory.BeanNameAware#setBeanName(java.lang
 	 * .String)
@@ -232,7 +232,7 @@ public class HeaderEnricher implements Transformer, BeanNameAware, InitializingB
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see
 	 * org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
 	 */

spring-integration-core/src/main/java/org/springframework/integration/util/DefaultLockRegistry.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
@@ -22,7 +22,7 @@ import org.springframework.util.Assert;
  * the array is based on the 'mask' parameter passed in the constructor. The default mask is 0xFF which will create
  * and array consisting of 256 {@link ReentrantLock} instances.
  * When the {@link #obtain(Object)} method is called with the lockKey (e.g., Object) the index of the {@link Lock}
- * is determined by masking the object's hashCode (e.g., object.hashCode & mask) and the {@link Lock} is returned.
+ * is determined by masking the object's hashCode (e.g., {@code object.hashCode & mask}) and the {@link Lock} is returned.
  *
  * @author Oleg Zhurakousky
  * @author Gary Russell
@@ -48,8 +48,10 @@ public final class DefaultLockRegistry implements LockRegistry {
 	 * mask - the mask must have a value Math.pow(2, n) - 1 where n
 	 * is 1 to 31, creating a hash of Math.pow(2, n) locks.
 	 * <p> Examples:
+	 * <ul>
 	 * <li>0x3ff (1023) - 1024 locks</li>
 	 * <li>0xfff (4095) - 4096 locks</li>
+	 * </ul>
 	 * <p>
 	 * @param mask
 	 */

spring-integration-core/src/main/java/org/springframework/integration/util/SimplePool.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -133,7 +133,9 @@ public class SimplePool<T> implements Pool<T> {
 
 	/**
 	 * Adjusts the wait timeout - the time for which getItem() will wait if no idle
-	 * entries are available. <br/>Default: infinity.
+	 * entries are available.
+	 * <br>
+	 * Default: infinity.
 	 * @param waitTimeout The wait timeout in milliseconds.
 	 */
 	public void setWaitTimeout(long waitTimeout) {

spring-integration-core/src/test/java/org/springframework/integration/aggregator/scenarios/AggregationResendTests.java

@@ -58,7 +58,7 @@ public class AggregationResendTests {
 	 * explicit timeout value of 1 second on the aggregator. What we'll see is
 	 * that we get one aggregate Message back immediately.
 	 *
-	 * <p>We should <emphasis>not</emphasis> get another 3 after the 1 second.
+	 * <p>We should <em>not</em> get another 3 after the 1 second.
 	 */
 	@Test
 	@Ignore // timeout is no longer supported
@@ -72,7 +72,7 @@ public class AggregationResendTests {
 	 * after 60 seconds. What we'll see is that we get one aggregate Message back
 	 * immediately.
 	 *
-	 * <p>We should <emphasis>not</emphasis> get another 3 after the 60 seconds.
+	 * <p>We should <em>not</em> get another 3 after the 60 seconds.
 	 */
 	@Test
 	@Ignore // disabling from normal testing, should be the same behavior whether explicit or default