Prefer use of "Java EE" over "J2EE"

spring-jms/src/main/java/org/springframework/jms/connection/TransactionAwareConnectionFactoryProxy.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2015 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.
@@ -39,7 +39,7 @@ import org.springframework.util.Assert;
 /**
  * Proxy for a target JMS {@link javax.jms.ConnectionFactory}, adding awareness of
  * Spring-managed transactions. Similar to a transactional JNDI ConnectionFactory
- * as provided by a J2EE server.
+ * as provided by a Java EE application server.
  *
  * <p>Messaging code which should remain unaware of Spring's JMS support can work with
  * this proxy to seamlessly participate in Spring-managed transactions. Note that the

spring-jms/src/main/java/org/springframework/jms/core/JmsTemplate.java

@@ -51,7 +51,7 @@ import org.springframework.util.ReflectionUtils;
  * domain.
  *
  * <p>Default settings for JMS Sessions are "not transacted" and "auto-acknowledge".
- * As defined by the J2EE specification, the transaction and acknowledgement
+ * As defined by the Java EE specification, the transaction and acknowledgement
  * parameters are ignored when a JMS Session is created inside an active
  * transaction, no matter if a JTA transaction or a Spring-managed transaction.
  * To configure them for native JMS usage, specify appropriate values for
@@ -71,7 +71,7 @@ import org.springframework.util.ReflectionUtils;
  * {@link org.springframework.jms.connection.SingleConnectionFactory} as a
  * decorator for your target {@code ConnectionFactory}, reusing a single
  * JMS Connection in a thread-safe fashion; this is often good enough for the
- * purpose of sending messages via this template. In a J2EE environment,
+ * purpose of sending messages via this template. In a Java EE environment,
  * make sure that the {@code ConnectionFactory} is obtained from the
  * application's environment naming context via JNDI; application servers
  * typically expose pooled, transaction-aware factories there.

spring-jms/src/main/java/org/springframework/jms/listener/AbstractPollingMessageListenerContainer.java

@@ -46,20 +46,19 @@ import org.springframework.transaction.support.TransactionSynchronizationUtils;
  * configured through the {@link #setReceiveTimeout "receiveTimeout"} property.
  *
  * <p>The underlying mechanism is based on standard JMS MessageConsumer handling,
- * which is perfectly compatible with both native JMS and JMS in a J2EE environment.
+ * which is perfectly compatible with both native JMS and JMS in a Java EE environment.
- * Neither the JMS {@code MessageConsumer.setMessageListener} facility
+ * Neither the JMS {@code MessageConsumer.setMessageListener} facility  nor the JMS
- * nor the JMS ServerSessionPool facility is required. A further advantage
+ * ServerSessionPool facility is required. A further advantage of this approach is
- * of this approach is full control over the listening process, allowing for
+ * full control over the listening process, allowing for custom scaling and throttling
- * custom scaling and throttling and of concurrent message processing
+ * and of concurrent message processing (which is up to concrete subclasses).
- * (which is up to concrete subclasses).
  *
  * <p>Message reception and listener execution can automatically be wrapped
  * in transactions through passing a Spring
  * {@link org.springframework.transaction.PlatformTransactionManager} into the
  * {@link #setTransactionManager "transactionManager"} property. This will usually
  * be a {@link org.springframework.transaction.jta.JtaTransactionManager} in a
- * J2EE enviroment, in combination with a JTA-aware JMS ConnectionFactory obtained
+ * Java EE enviroment, in combination with a JTA-aware JMS ConnectionFactory
- * from JNDI (check your J2EE server's documentation).
+ * obtained from JNDI (check your application server's documentation).
  *
  * <p>This base class does not assume any specific mechanism for asynchronous
  * execution of polling invokers. Check out {@link DefaultMessageListenerContainer}

spring-jms/src/main/java/org/springframework/jms/support/JmsAccessor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 the original author or authors.
+ * Copyright 2002-2015 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.
@@ -79,7 +79,7 @@ public abstract class JmsAccessor implements InitializingBean {
 	 * Default is "false".
 	 * <p>Note that within a JTA transaction, the parameters passed to
 	 * {@code create(Queue/Topic)Session(boolean transacted, int acknowledgeMode)}
-	 * method are not taken into account. Depending on the J2EE transaction context,
+	 * method are not taken into account. Depending on the Java EE transaction context,
 	 * the container makes its own decisions on these values. Analogously, these
 	 * parameters are not taken into account within a locally managed transaction
 	 * either, since the accessor operates on an existing JMS Session in this case.

spring-tx/src/main/java/org/springframework/transaction/TransactionDefinition.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2015 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.
@@ -86,8 +86,8 @@ public interface TransactionDefinition {
 	 * <p><b>NOTE:</b> Actual transaction suspension will not work out-of-the-box
 	 * on all transaction managers. This in particular applies to
 	 * {@link org.springframework.transaction.jta.JtaTransactionManager},
-	 * which requires the {@code javax.transaction.TransactionManager}
+	 * which requires the {@code javax.transaction.TransactionManager} to be
-	 * to be made available it to it (which is server-specific in standard J2EE).
+	 * made available it to it (which is server-specific in standard Java EE).
 	 * <p>A {@code PROPAGATION_REQUIRES_NEW} scope always defines its own
 	 * transaction synchronizations. Existing synchronizations will be suspended
 	 * and resumed appropriately.
@@ -101,8 +101,8 @@ public interface TransactionDefinition {
 	 * <p><b>NOTE:</b> Actual transaction suspension will not work out-of-the-box
 	 * on all transaction managers. This in particular applies to
 	 * {@link org.springframework.transaction.jta.JtaTransactionManager},
-	 * which requires the {@code javax.transaction.TransactionManager}
+	 * which requires the {@code javax.transaction.TransactionManager} to be
-	 * to be made available it to it (which is server-specific in standard J2EE).
+	 * made available it to it (which is server-specific in standard Java EE).
 	 * <p>Note that transaction synchronization is <i>not</i> available within a
 	 * {@code PROPAGATION_NOT_SUPPORTED} scope. Existing synchronizations
 	 * will be suspended and resumed appropriately.

spring-tx/src/main/java/org/springframework/transaction/annotation/Propagation.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2015 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.
@@ -58,10 +58,11 @@ public enum Propagation {
 	/**
 	 * Create a new transaction, and suspend the current transaction if one exists.
 	 * Analogous to the EJB transaction attribute of the same name.
-	 * <p>Note: Actual transaction suspension will not work out-of-the-box on
+	 * <p><b>NOTE:</b> Actual transaction suspension will not work out-of-the-box
-	 * all transaction managers. This in particular applies to JtaTransactionManager,
+	 * on all transaction managers. This in particular applies to
+	 * {@link org.springframework.transaction.jta.JtaTransactionManager},
 	 * which requires the {@code javax.transaction.TransactionManager} to be
-	 * made available it to it (which is server-specific in standard J2EE).
+	 * made available it to it (which is server-specific in standard Java EE).
 	 * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager
 	 */
 	REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),
@@ -69,10 +70,11 @@ public enum Propagation {
 	/**
 	 * Execute non-transactionally, suspend the current transaction if one exists.
 	 * Analogous to EJB transaction attribute of the same name.
-	 * <p>Note: Actual transaction suspension will not work on out-of-the-box
+	 * <p><b>NOTE:</b> Actual transaction suspension will not work out-of-the-box
-	 * on all transaction managers. This in particular applies to JtaTransactionManager,
+	 * on all transaction managers. This in particular applies to
+	 * {@link org.springframework.transaction.jta.JtaTransactionManager},
 	 * which requires the {@code javax.transaction.TransactionManager} to be
-	 * made available it to it (which is server-specific in standard J2EE).
+	 * made available it to it (which is server-specific in standard Java EE).
 	 * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager
 	 */
 	NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),

spring-tx/src/main/java/org/springframework/transaction/jta/WebSphereUowTransactionManager.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 the original author or authors.
+ * Copyright 2002-2015 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.
@@ -119,7 +119,7 @@ public class WebSphereUowTransactionManager extends JtaTransactionManager
 
 	/**
 	 * Set the WebSphere UOWManager to use as direct reference.
-	 * <p>Typically just used for test setups; in a J2EE environment,
+	 * <p>Typically just used for test setups; in a Java EE environment,
 	 * the UOWManager will always be fetched from JNDI.
 	 * @see #setUserTransactionName
 	 */