Polishing

Author: jhoeller

spring-core/src/main/java/org/springframework/util/concurrent/DelegatingCompletableFuture.java

@@ -19,6 +19,8 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Future;
 
+import org.springframework.util.Assert;
+
 /**
  * Extension of {@link CompletableFuture} which allows for cancelling
  * a delegate along with the {@link CompletableFuture} itself.
@@ -30,10 +32,13 @@ class DelegatingCompletableFuture<T> extends CompletableFuture<T> {
 
 	private final Future<T> delegate;
 
+
 	public DelegatingCompletableFuture(Future<T> delegate) {
+		Assert.notNull(delegate, "Delegate must not be null");
 		this.delegate = delegate;
 	}
 
+
 	@Override
 	public boolean cancel(boolean mayInterruptIfRunning) {
 		boolean result = this.delegate.cancel(mayInterruptIfRunning);

spring-messaging/src/main/java/org/springframework/messaging/core/GenericMessagingTemplate.java

@@ -97,12 +97,10 @@ public long getReceiveTimeout() {
 		return this.receiveTimeout;
 	}
 
-
 	/**
 	 * Set the name of the header used to determine the send timeout (if present).
 	 * Default {@value #DEFAULT_SEND_TIMEOUT_HEADER}.
-	 * The header is removed before sending the message to avoid propagation.
-	 * @param sendTimeoutHeader the sendTimeoutHeader to set
+	 * <p>The header is removed before sending the message to avoid propagation.
 	 * @since 5.0
 	 */
 	public void setSendTimeoutHeader(String sendTimeoutHeader) {
@@ -111,18 +109,17 @@ public void setSendTimeoutHeader(String sendTimeoutHeader) {
 	}
 
 	/**
-	 * @return the configured sendTimeoutHeader.
+	 * Return the configured send-timeout header.
 	 * @since 5.0
 	 */
 	public String getSendTimeoutHeader() {
-		return sendTimeoutHeader;
+		return this.sendTimeoutHeader;
 	}
 
 	/**
 	 * Set the name of the header used to determine the send timeout (if present).
 	 * Default {@value #DEFAULT_RECEIVE_TIMEOUT_HEADER}.
 	 * The header is removed before sending the message to avoid propagation.
-	 * @param receiveTimeoutHeader the receiveTimeoutHeader to set
 	 * @since 5.0
 	 */
 	public void setReceiveTimeoutHeader(String receiveTimeoutHeader) {
@@ -131,11 +128,11 @@ public void setReceiveTimeoutHeader(String receiveTimeoutHeader) {
 	}
 
 	/**
-	 * @return the configured receiveTimeoutHeader
+	 * Return the configured receive-timeout header.
 	 * @since 5.0
 	 */
 	public String getReceiveTimeoutHeader() {
-		return receiveTimeoutHeader;
+		return this.receiveTimeoutHeader;
 	}
 
 	/**
@@ -157,6 +154,7 @@ public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
 		setDestinationResolver(new BeanFactoryMessageChannelDestinationResolver(beanFactory));
 	}
 
+
 	@Override
 	protected final void doSend(MessageChannel channel, Message<?> message) {
 		doSend(channel, message, sendTimeout(message));
@@ -267,6 +265,7 @@ else if (headerValue instanceof String) {
 		}
 	}
 
+
 	/**
 	 * A temporary channel for receiving a single reply message.
 	 */

src/docs/asciidoc/languages/kotlin.adoc

@@ -391,51 +391,48 @@ you will be able to write your Kotlin beans without any additional `open` keywor
 
 === Using immutable class instances for persistence
 
-In Kotlin, it is very convenient and considered best practice to declare
-read-only properties within the primary constructor, as in the following
-example:
+In Kotlin, it is very convenient and considered best practice to declare read-only properties
+within the primary constructor, as in the following example:
 
 [source,kotlin]
 ----
 class Person(val name: String, val age: Int)
 ----
 
 You can optionally add https://kotlinlang.org/docs/reference/data-classes.html[the `data` keyword]
-to make the compiler automatically derives the following members from all properties
-declared in the primary constructor:
+to make the compiler automatically derive the following members from all properties declared
+in the primary constructor:
 
 * equals()/hashCode() pair
 * toString() of the form "User(name=John, age=42)"
 * componentN() functions corresponding to the properties in their order of declaration
 * copy() function
 
-This allows to change easily just one of the properties even if `User` properties are read-only:
-his allows us to write:
-
+This allows for easy changes to individual properties even if `Person` properties are read-only:
 
 [source,kotlin]
 ----
 data class Person(val name: String, val age: Int)
 
-val jack = User(name = "Jack", age = 1)
+val jack = Person(name = "Jack", age = 1)
 val olderJack = jack.copy(age = 2)
 ----
 
-But some persistence technologies like JPA require a default constructor, preventing this
+Common persistence technologies such as JPA require a default constructor, preventing this
 kind of design. Fortunately, there is now a workaround for this
 https://stackoverflow.com/questions/32038177/kotlin-with-jpa-default-constructor-hell["default constructor hell"]
 since Kotlin provides a https://kotlinlang.org/docs/reference/compiler-plugins.html#kotlin-jpa-compiler-plugin[kotlin-jpa]
 plugin which generates synthetic no-arg constructor for classes annotated with JPA annotations.
 
-If you need to leverage this kind of mechanism for other persistence technologies, you can
-configure https://kotlinlang.org/docs/reference/compiler-plugins.html#how-to-use-no-arg-plugin[kotlin-noarg]
+If you need to leverage this kind of mechanism for other persistence technologies, you can configure
+the https://kotlinlang.org/docs/reference/compiler-plugins.html#how-to-use-no-arg-plugin[kotlin-noarg]
 plugin.
 
 [NOTE]
 ====
-As of Kay release train, Spring Data supports Kotlin immutable class instances
-and should not require `kotlin-noarg` plugin if the module leverages Spring Data object
-mapping (like with MongoDB, Redis, Cassandra, etc.).
+As of the Kay release train, Spring Data supports Kotlin immutable class instances and
+does not require the `kotlin-noarg` plugin if the module leverages Spring Data object
+mappings (like with MongoDB, Redis, Cassandra, etc).
 ====