Replace 'Java EE' with 'enterprise Java' as appropriate

Also change 'JEE' -> 'Java EE'

git-svn-id: https://src.springframework.org/svn/spring-framework/trunk@3539 50f2f4bb-b051-0410-bef5-90022cba6387

spring-framework-reference/src/aop.xml

@@ -74,9 +74,9 @@
         <listitem>
           <para><emphasis>Aspect</emphasis>: a modularization of a concern
           that cuts across multiple classes. Transaction management is a good
-          example of a crosscutting concern in Java EE applications. In Spring
+          example of a crosscutting concern in enterprise Java applications.
-          AOP, aspects are implemented using regular classes (the <link
+          In Spring AOP, aspects are implemented using regular classes (the
-          linkend="aop-schema">schema-based approach</link>) or regular
+          <link linkend="aop-schema">schema-based approach</link>) or regular
           classes annotated with the <interfacename>@Aspect</interfacename>
           annotation (the <link
           linkend="aop-ataspectj"><interfacename>@AspectJ</interfacename>
@@ -211,7 +211,7 @@
 
       <para>Spring AOP is implemented in pure Java. There is no need for a
       special compilation process. Spring AOP does not need to control the
-      class loader hierarchy, and is thus suitable for use in a Java EE web
+      class loader hierarchy, and is thus suitable for use in a Servlet
       container or application server.</para>
 
       <para>Spring AOP currently supports only method execution join points
@@ -235,8 +235,8 @@
       efficiently with Spring AOP, such as advise very fine-grained objects
       (such as domain objects typically): AspectJ is the best choice in such
       cases. However, our experience is that Spring AOP provides an excellent
-      solution to most problems in Java EE applications that are amenable to
+      solution to most problems in enterprise Java applications that are
-      AOP.</para>
+      amenable to AOP.</para>
 
       <para>Spring AOP will never strive to compete with AspectJ to provide a
       comprehensive AOP solution. We believe that both proxy-based frameworks

spring-framework-reference/src/beans.xml

@@ -5206,8 +5206,8 @@ public @interface MovieQualifier {
 
       <para>Spring also supports injection using the JSR-250
       <interfacename>@Resource</interfacename> annotation on fields or bean
-      property setter methods. This is a common pattern in Java EE 5 and Java
+      property setter methods. This is a common pattern in Java EE 5 and 6,
-      6, for example, in JSF 1.2 managed beans or JAX-WS 2.0 endpoints. Spring
+      for example in JSF 1.2 managed beans or JAX-WS 2.0 endpoints. Spring
       supports this pattern for Spring-managed objects as well.</para>
 
       <para><interfacename>@Resource</interfacename> takes a name attribute,

spring-framework-reference/src/transaction.xml

@@ -169,8 +169,8 @@ TR: OK AS IS - I think it's fine as is - the concepts apply to both programmatic
         management?</title>
 
         <para>The Spring Framework's transaction management support changes
-        traditional rules as to when a Java EE application requires an
+        traditional rules as to when a enterprise Java application requires
-        application server.</para>
+        an application server.</para>
 
         <para>In particular, you do not need an application server simply for
         declarative transactions through EJBs. In fact, even if your

spring-framework-reference/src/web-integration.xml

@@ -607,19 +607,19 @@
     </para>
 
     <para>While Spring has its own <link linkend="mvc">powerful web
-    layer</link>, there are a number of unique advantages to building a Java EE
+    layer</link>, there are a number of unique advantages to building an
-    application using a combination of Tapestry for the web user interface and
+    enterprise Java application using a combination of Tapestry for the web
-    the Spring container for the lower layers. This section of the web
+    user interface and the Spring container for the lower layers. This section
-    integration chapter attempts to detail a few best practices for combining
+    of the web integration chapter attempts to detail a few best practices for
-    these two frameworks.</para>
+    combining these two frameworks.</para>
-
+
-    <para>A <emphasis>typical</emphasis> layered Java EE application built with
+    <para>A <emphasis>typical</emphasis> layered enterprise Java application
-    Tapestry and Spring will consist of a top user interface (UI) layer built
+    built with Tapestry and Spring will consist of a top user interface (UI)
-    with Tapestry, and a number of lower layers, all wired together by one or
+    layer built with Tapestry, and a number of lower layers, all wired together
-    more Spring containers. Tapestry's own reference documentation contains
+    by one or more Spring containers. Tapestry's own reference documentation
-    the following snippet of best practice advice. (Text that the author of
+    contains the following snippet of best practice advice. (Text that the
-    this Spring section has added is contained within <literal>[]</literal>
+    author of this Spring section has added is contained within
-    brackets.)</para>
+    <literal>[]</literal> brackets.)</para>
     
     <para>
         <quote>
@@ -1092,7 +1092,7 @@ public abstract class Login extends BasePage implements ErrorProperty, PageRende
         are coming from, and in fact it is easy to slip in another implementation,
         for example, during testing. This inversion of control is one of the prime
         goals and benefits of the Spring Framework, and we have managed to extend
-        it all the way up the Java EE stack in this Tapestry application.</para>
+        it throughout the stack in this Tapestry application.</para>
       </section>
     </section>
 

spring-framework-reference/src/xsd-configuration.xml

@@ -466,7 +466,7 @@ public class Client {
         </section>
         <section id="xsd-config-body-schemas-jee">
             <title>The <literal>jee</literal> schema</title>
-            <para>The <literal>jee</literal> tags deal with JEE (Java Enterprise Edition)-related
+            <para>The <literal>jee</literal> tags deal with Java EE (Java Enterprise Edition)-related
             configuration issues, such as looking up a JNDI object and defining EJB references.</para>
             <para>To use the tags in the <literal>jee</literal> schema, you need to have
             the following preamble at the top of your Spring XML configuration file;