Polish Javadoc in Spring MVC async support

This commit fixes some typographical and grammatical errors in various
classes in Spring MVC's async support.

spring-web/src/main/java/org/springframework/web/context/request/async/DeferredResult.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,13 +32,13 @@
  * <p>Subclasses can extend this class to easily associate additional data or
  * behavior with the {@link DeferredResult}. For example, one might want to
  * associate the user used to create the {@link DeferredResult} by extending the
- * class and adding an addition property for the user. In this way, the user
+ * class and adding an additional property for the user. In this way, the user
  * could easily be accessed later without the need to use a data structure to do
  * the mapping.
  *
  * <p>An example of associating additional behavior to this class might be
  * realized by extending the class to implement an additional interface. For
- * example, one might want to implement a {@link Comparable} so that when the
+ * example, one might want to implement {@link Comparable} so that when the
  * {@link DeferredResult} is added to a {@link PriorityQueue} it is handled in
  * the correct order.
  *

spring-web/src/main/java/org/springframework/web/context/request/async/WebAsyncManager.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.
@@ -37,9 +37,9 @@
  * as an SPI and not typically used directly by application classes.
  *
  * <p>An async scenario starts with request processing as usual in a thread (T1).
- * Concurrent request handling can be innitiated by calling
- * {@linkplain #startCallableProcessing(Callable, Object...) startCallableProcessing} or
- * {@linkplain #startDeferredResultProcessing(DeferredResult, Object...) startDeferredResultProcessing}
+ * Concurrent request handling can be initiated by calling
+ * {@link #startCallableProcessing(Callable, Object...) startCallableProcessing} or
+ * {@link #startDeferredResultProcessing(DeferredResult, Object...) startDeferredResultProcessing},
  * both of which produce a result in a separate thread (T2). The result is saved
  * and the request dispatched to the container, to resume processing with the saved
  * result in a third thread (T3). Within the dispatched thread (T3), the saved
@@ -263,7 +263,7 @@ public void startCallableProcessing(final Callable<?> callable, Object... proces
 	 * the timeout value of the {@code AsyncWebRequest} before delegating to
 	 * {@link #startCallableProcessing(Callable, Object...)}.
 	 *
-	 * @param webAsyncTask an WebAsyncTask containing the target {@code Callable}
+	 * @param webAsyncTask a WebAsyncTask containing the target {@code Callable}
 	 * @param processingContext additional context to save that can be accessed
 	 * via {@link #getConcurrentResultContext()}
 	 * @throws Exception If concurrent processing failed to start

spring-web/src/main/java/org/springframework/web/context/request/async/WebAsyncTask.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,15 +46,15 @@ public class WebAsyncTask<V> {
 
 
 	/**
-	 * Create an {@code WebAsyncTask} wrapping the given {@link Callable}.
+	 * Create a {@code WebAsyncTask} wrapping the given {@link Callable}.
 	 * @param callable the callable for concurrent handling
 	 */
 	public WebAsyncTask(Callable<V> callable) {
 		this(null, null, null, callable);
 	}
 
 	/**
-	 * Create an {@code WebAsyncTask} with a timeout value and a {@link Callable}.
+	 * Create a {@code WebAsyncTask} with a timeout value and a {@link Callable}.
 	 * @param timeout timeout value in milliseconds
 	 * @param callable the callable for concurrent handling
 	 */
@@ -63,7 +63,7 @@ public WebAsyncTask(long timeout, Callable<V> callable) {
 	}
 
 	/**
-	 * Create an {@code WebAsyncTask} with a timeout value, an executor name, and a {@link Callable}.
+	 * Create a {@code WebAsyncTask} with a timeout value, an executor name, and a {@link Callable}.
 	 * @param timeout timeout value in milliseconds; ignored if {@code null}
 	 * @param callable the callable for concurrent handling
 	 */
@@ -73,7 +73,7 @@ public WebAsyncTask(Long timeout, String executorName, Callable<V> callable) {
 	}
 
 	/**
-	 * Create an {@code WebAsyncTask} with a timeout value, an executor instance, and a Callable.
+	 * Create a {@code WebAsyncTask} with a timeout value, an executor instance, and a Callable.
 	 * @param timeout timeout value in milliseconds; ignored if {@code null}
 	 * @param callable the callable for concurrent handling
 	 */
@@ -113,7 +113,7 @@ public AsyncTaskExecutor getExecutor() {
 			return this.executor;
 		}
 		else if (this.executorName != null) {
-			Assert.state(this.beanFactory != null, "A BeanFactory is required to look up an task executor bean");
+			Assert.state(this.beanFactory != null, "A BeanFactory is required to look up a task executor bean");
 			return this.beanFactory.getBean(this.executorName, AsyncTaskExecutor.class);
 		}
 		else {

spring-webmvc/src/main/java/org/springframework/web/servlet/config/annotation/AsyncSupportConfigurer.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.
@@ -29,7 +29,7 @@
 import org.springframework.web.context.request.async.DeferredResultProcessingInterceptor;
 
 /**
- * Helps with configuring a options for asynchronous request processing.
+ * Helps with configuring options for asynchronous request processing.
  *
  * @author Rossen Stoyanchev
  * @since 3.2
@@ -50,9 +50,9 @@ public class AsyncSupportConfigurer {
 	/**
 	 * Set the default {@link AsyncTaskExecutor} to use when a controller method
 	 * returns a {@link Callable}. Controller methods can override this default on
-	 * a per-request basis by returning an {@link WebAsyncTask}.
+	 * a per-request basis by returning a {@link WebAsyncTask}.
 	 *
-	 * <p>By default a {@link SimpleAsyncTaskExecutor} instance is used and it's
+	 * <p>By default a {@link SimpleAsyncTaskExecutor} instance is used, and it's
 	 * highly recommended to change that default in production since the simple
 	 * executor does not re-use threads.
 	 *
@@ -79,7 +79,7 @@ public AsyncSupportConfigurer setDefaultTimeout(long timeout) {
 	}
 
 	/**
-	 * Configure lifecycle intercepters with callbacks around concurrent request
+	 * Configure lifecycle interceptors with callbacks around concurrent request
 	 * execution that starts when a controller returns a
 	 * {@link java.util.concurrent.Callable}.
 	 *
@@ -92,7 +92,7 @@ public AsyncSupportConfigurer registerCallableInterceptors(CallableProcessingInt
 	}
 
 	/**
-	 * Configure lifecycle intercepters with callbacks around concurrent request
+	 * Configure lifecycle interceptors with callbacks around concurrent request
 	 * execution that starts when a controller returns a {@link DeferredResult}.
 	 *
 	 * @param interceptors the interceptors to register