Stop referring to "Spring 3.x" features in documentation and code

spring-core/src/main/java/org/springframework/core/env/Environment.java

@@ -43,12 +43,11 @@ package org.springframework.core.env;
  * {@code Environment} in order to query profile state or resolve properties directly.
  *
  * <p>In most cases, however, application-level beans should not need to interact with the
- * {@code Environment} directly but instead may have to have {@code ${...}} property
+ * {@code Environment} directly but instead may request to have {@code ${...}} property
  * values replaced by a property placeholder configurer such as
  * {@link org.springframework.context.support.PropertySourcesPlaceholderConfigurer
  * PropertySourcesPlaceholderConfigurer}, which itself is {@code EnvironmentAware} and
- * as of Spring 3.1 is registered by default when using
- * {@code <context:property-placeholder/>}.
+ * registered by default when using {@code <context:property-placeholder/>}.
  *
  * <p>Configuration of the {@code Environment} object must be done through the
  * {@code ConfigurableEnvironment} interface, returned from all

spring-core/src/main/java/org/springframework/core/task/TaskExecutor.java

@@ -25,11 +25,11 @@ import java.util.concurrent.Executor;
  * <p>Implementations can use all sorts of different execution strategies,
  * such as: synchronous, asynchronous, using a thread pool, and more.
  *
- * <p>Equivalent to JDK 1.5's {@link java.util.concurrent.Executor}
- * interface; extending it now in Spring 3.0, so that clients may declare
- * a dependency on an Executor and receive any TaskExecutor implementation.
- * This interface remains separate from the standard Executor interface
- * mainly for backwards compatibility with JDK 1.4 in Spring 2.x.
+ * <p>Equivalent to Java's {@link java.util.concurrent.Executor} interface,
+ * so that clients may declare a dependency on an {@code Executor} and receive
+ * any {@code TaskExecutor} implementation. This interface remains separate from
+ * the standard {@code Executor} interface primarily for backwards compatibility
+ * with older APIs that depend on the {@code TaskExecutor} interface.
  *
  * @author Juergen Hoeller
  * @since 2.0

spring-core/src/main/java/org/springframework/core/task/support/ConcurrentExecutorAdapter.java

@@ -22,13 +22,13 @@ import org.springframework.core.task.TaskExecutor;
 import org.springframework.util.Assert;
 
 /**
- * Adapter that exposes the {@link java.util.concurrent.Executor} interface
- * for any Spring {@link org.springframework.core.task.TaskExecutor}.
+ * Adapter that exposes the {@link java.util.concurrent.Executor} interface for
+ * any Spring {@link org.springframework.core.task.TaskExecutor}.
  *
- * <p>This is less useful as of Spring 3.0, since TaskExecutor itself
- * extends the Executor interface. The adapter is only relevant for
- * <em>hiding</em> the TaskExecutor nature of a given object now,
- * solely exposing the standard Executor interface to a client.
+ * <p>This adapter is less useful since Spring 3.0, since TaskExecutor itself
+ * extends the {@code Executor} interface. The adapter is only relevant for
+ * <em>hiding</em> the {@code TaskExecutor} nature of a given object, solely
+ * exposing the standard {@code Executor} interface to a client.
  *
  * @author Juergen Hoeller
  * @since 2.5

spring-core/src/main/java/org/springframework/util/ClassUtils.java

@@ -1265,17 +1265,17 @@ public abstract class ClassUtils {
 	/**
 	 * Given a method, which may come from an interface, and a target class used
 	 * in the current reflective invocation, find the corresponding target method
-	 * if there is one. E.g. the method may be {@code IFoo.bar()} and the
-	 * target class may be {@code DefaultFoo}. In this case, the method may be
+	 * if there is one — for example, the method may be {@code IFoo.bar()},
+	 * and the target class may be {@code DefaultFoo}. In this case, the method may be
 	 * {@code DefaultFoo.bar()}. This enables attributes on that method to be found.
 	 * <p><b>NOTE:</b> In contrast to {@link org.springframework.aop.support.AopUtils#getMostSpecificMethod},
 	 * this method does <i>not</i> resolve bridge methods automatically.
 	 * Call {@link org.springframework.core.BridgeMethodResolver#findBridgedMethod}
-	 * if bridge method resolution is desirable (e.g. for obtaining metadata from
-	 * the original method definition).
-	 * <p><b>NOTE:</b> Since Spring 3.1.1, if Java security settings disallow reflective
-	 * access (e.g. calls to {@code Class#getDeclaredMethods} etc, this implementation
-	 * will fall back to returning the originally provided method.
+	 * if bridge method resolution is desirable &mdash; for example, to obtain
+	 * metadata from the original method definition.
+	 * <p><b>NOTE:</b> If Java security settings disallow reflective access &mdash;
+	 * for example, calls to {@code Class#getDeclaredMethods}, etc. &mdash; this
+	 * implementation will fall back to returning the originally provided method.
 	 * @param method the method to be invoked, which may come from an interface
 	 * @param targetClass the target class for the current invocation
 	 * (may be {@code null} or may not even implement the method)