GitHub-Spring
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

started "new in Spring 3" chapter; added some overview to introduction chapter 

git-svn-id: https://src.springframework.org/svn/spring-framework/trunk@906 50f2f4bb-b051-0410-bef5-90022cba6387
pull/1/head
Thomas Risberg 17 years ago
parent
b1fecb45e7
commit
60a6c76461
2 changed files with 285 additions and 79 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 199
      spring-framework-reference/src/new-in-3.xml
  2. 165
      spring-framework-reference/src/overview.xml

199
spring-framework-reference/src/new-in-3.xml
Unescape View File

@ -5,36 +5,207 @@ @@ -5,36 +5,207 @@
<section id="new-in-3-intro">
<title>Introduction</title>
<para>*** WORK IN PROGRESS ***</para>
<para>If you have been using the Spring Framework for some time, you will
be aware that Spring has undergone two major revisions: Spring 2.0,
released in October 2006, and Spring 2.5, released in November 2007.</para>
released in October 2006, and Spring 2.5, released in November 2007. It is
now time for a third overhaul resulting in Spring 3.0.</para>
<sidebar id="new-in-3-intro-java">
<title>Java SE and Java EE Support</title>
<para>The Spring Framework is now based on Java 5 and Java 6 is fully supported.</para>
<para>The Spring Framework is now based on Java 5 and Java 6 is fully
supported.</para>
<para>Furthermore, Spring is compatible with J2EE 1.4 and Java EE 5,
while at the same time introducing dedicated support for Java EE 6.</para>
while at the same time introducing some early support for Java EE
6.</para>
</sidebar>
</section>
<section id="new-in-3-other-documentation">
<section id="new-in-3-improved-docs">
<title>Improved documentation</title>
<sidebar id="new-in-3-intro-work-in-progress">
<title>Note:</title>
<para>The current documentation is a <emphasis>*** WORK IN PROGRESS
***</emphasis> and is currently being re-written to reflect all the
changes in the framework and from now relying on Java 5 features.</para>
</sidebar>
<para>The Spring reference documentation has also substantially been
updated to reflect all of the changes and new features for Spring 3.0.
While every effort has been made to ensure that there are no errors in this
documentation, some errors may nevertheless have crept in. If you do spot
any typos or even more serious errors, and you can spare a few cycles
updated to reflect all of the changes and new features for Spring 3.0.
While every effort has been made to ensure that there are no errors in
this documentation, some errors may nevertheless have crept in. If you do
spot any typos or even more serious errors, and you can spare a few cycles
during lunch, please do bring the error to the attention of the Spring
team by <ulink
url="http://jira.springframework.org/">raising an
team by <ulink url="http://jira.springframework.org/">raising an
issue</ulink>.</para>
</section>
<section id="new-in-3-modules-build">
<title>New module organization and build system</title>
<para>The framework modules have been revised and are now managed
separately with one source-tree per module jar:</para>
<itemizedlist>
<listitem>
<para>org.springframework.aop</para>
</listitem>
<listitem>
<para>org.springframework.beans</para>
</listitem>
<listitem>
<para>org.springframework.context</para>
</listitem>
<listitem>
<para>org.springframework.context.support</para>
</listitem>
<listitem>
<para>org.springframework.expression</para>
</listitem>
<listitem>
<para>org.springframework.instrument</para>
</listitem>
<listitem>
<para>org.springframework.jdbc</para>
</listitem>
<listitem>
<para>org.springframework.jms</para>
</listitem>
<listitem>
<para>org.springframework.orm</para>
</listitem>
<listitem>
<para>org.springframework.oxm</para>
</listitem>
<listitem>
<para>org.springframework.test</para>
</listitem>
<listitem>
<para>org.springframework.transaction</para>
</listitem>
<listitem>
<para>org.springframework.web</para>
</listitem>
<listitem>
<para>org.springframework.web.portlet</para>
</listitem>
<listitem>
<para>org.springframework.web.servlet</para>
</listitem>
</itemizedlist>
<sidebar id="new-in-3-intro-spring-jar">
<title>Note:</title>
<para>The spring.jar artifact that contained almost the entire framework
is no longer provided.</para>
</sidebar>
<para>We are now using a new Spring build system as known from Spring Web
Flow 2.0. This gives us:</para>
<itemizedlist>
<listitem>
<para>Ivy-based "Spring Build" system</para>
</listitem>
<listitem>
<para>consistent deployment procedure</para>
</listitem>
<listitem>
<para>consistent dependency management</para>
</listitem>
<listitem>
<para>consistent generation of OSGi manifests</para>
</listitem>
</itemizedlist>
</section>
</chapter>
<section id="new-in-3-features-overview">
<title>Overview of new features</title>
<para>This is a list of new features for Spring 3.0. We will cover these
features in more detail in the following sections.</para>
<itemizedlist>
<listitem>
<para>Java 5+ foundation</para>
<para>compatible with J2EE 1.4 and Java EE 5</para>
</listitem>
<listitem>
<para>Spring Expression Language</para>
<para>Unified EL++</para>
</listitem>
<listitem>
<para>Container enhancements</para>
<para>Core JavaConfigfeatures added</para>
</listitem>
<listitem>
<para>Comprehensive REST support</para>
<para>and other Spring @MVC additions</para>
</listitem>
<listitem>
<para>Declarative model validation</para>
<para>Hibernate Validator, JSR 303</para>
</listitem>
<listitem>
<para>Early support for Java EE 6</para>
<para>JSF 2.0, JPA 2.0, etc</para>
</listitem>
</itemizedlist>
</section>
<section id="new-feature-java-5">
<title>Java 5+ foundation</title>
<para><emphasis>*** WORK IN PROGRESS ***</emphasis></para>
</section>
<section id="new-feature-el">
<title>Spring Expression Language</title>
<para><emphasis>*** WORK IN PROGRESS ***</emphasis></para>
</section>
<section id="new-feature-java-config">
<title>Container enhancements</title>
<para><emphasis>*** WORK IN PROGRESS ***</emphasis></para>
</section>
<section id="new-feature-rest">
<title>Comprehensive REST support</title>
<para><emphasis>*** WORK IN PROGRESS ***</emphasis></para>
</section>
<section id="new-feature-validation">
<title>Declarative model validation</title>
<para><emphasis>*** WORK IN PROGRESS ***</emphasis></para>
</section>
<section id="new-feature-jee-6">
<title>Early support for Java EE 6</title>
<para><emphasis>*** WORK IN PROGRESS ***</emphasis></para>
</section>
</chapter>

165
spring-framework-reference/src/overview.xml
Unescape View File

@ -2,70 +2,105 @@ @@ -2,70 +2,105 @@
<chapter id="introduction">
<title>Introduction</title>
<sidebar id="background-ioc">
<title>Background</title>
<para>In early 2004, Martin Fowler asked the readers of his site: when
talking about Inversion of Control: <quote><emphasis>the question is, what
aspect of control are [they] inverting?</emphasis></quote>. Fowler then
suggested renaming the principle (or at least giving it a more
self-explanatory name), and started to use the term <firstterm>Dependency
Injection</firstterm>. His article then continued to explain the ideas
underpinning the Inversion of Control (<acronym>IoC</acronym>) and
Dependency Injection (<acronym>DI</acronym>) principle.</para>
<para>If you need a decent insight into IoC and DI, please do refer to
said article : <ulink
url="http://martinfowler.com/articles/injection.html">http://martinfowler.com/articles/injection.html</ulink>.</para>
</sidebar>
<para>Java applications (a loose term which runs the gamut from constrained
applets to full-fledged n-tier server-side enterprise applications)
typically are composed of a number of objects that collaborate with one
another to form the application proper. The objects in an application can
thus be said to have <emphasis>dependencies</emphasis> between
themselves.</para>
<para>The Java language and platform provides a wealth of functionality for
architecting and building applications, ranging all the way from the very
basic building blocks of primitive types and classes (and the means to
define new classes), to rich full-featured application servers and web
frameworks. One area that is decidedly conspicuous by its absence is any
means of taking the basic building blocks and composing them into a coherent
whole; this area has typically been left to the purvey of the architects and
developers tasked with building an application (or applications). Now to be
fair, there are a number of design patterns devoted to the business of
composing the various classes and object instances that makeup an
all-singing, all-dancing application. Design patterns such as
<firstterm>Factory</firstterm>, <firstterm>Abstract Factory</firstterm>,
<firstterm>Builder</firstterm>, <firstterm>Decorator</firstterm>, and
<firstterm>Service Locator</firstterm> (to name but a few) have widespread
recognition and acceptance within the software development industry
(presumably that is why these patterns have been formalized as patterns in
the first place). This is all very well, but these patterns are just that:
best practices given a name, typically together with a description of what
the pattern does, where the pattern is typically best applied, the problems
that the application of the pattern addresses, and so forth. Notice that the
last paragraph used the phrase <quote>... a <emphasis>description</emphasis>
of what the pattern does...</quote>; pattern books and wikis are typically
listings of such formalized best practice that you can certainly take away,
mull over, and then <emphasis>implement yourself</emphasis> in your
application.</para>
<para>The IoC component of the Spring Framework addresses the enterprise
concern of taking the classes, objects, and services that are to compose an
application, by providing a formalized means of composing these various
disparate components into a fully working application ready for use. The
Spring Framework takes best practices that have been proven over the years
in numerous applications and formalized as design patterns, and actually
codifies these patterns as first class objects that you as an architect and
developer can take away and integrate into your own application(s). This is
a <firstterm>Very Good Thing Indeed</firstterm> as attested to by the
numerous organizations and institutions that have used the Spring Framework
to engineer robust, <emphasis>maintainable</emphasis> applications.</para>
<section id="introduction-overview">
<title>Overview</title>
<para>Fundamentally, what is Spring? We think of it as a Platform for your Java code. It provides
comprehensive infrastructural support for developing Java applications. Spring deals with the plumbing
so you can focus on solving the domain problem</para>
<para>Spring as a platform allows applications to be built from “plain old Java objects” (POJOs). This is true
for the Java SE programming model as well as within a number of other environments including full and partial Java EE.
Spring allows enterprise services to be applied to POJOs in a non-invasive way</para>
<para>Examples of Spring as a platform:</para>
<itemizedlist>
<listitem>
<para>Make a Java method execute in a database transaction; without the implementer dealing with transaction
APIs</para>
</listitem>
<listitem>
<para>Make a local Java method a remote-procedure; without the implementer dealing with remoting APIs</para>
</listitem>
<listitem>
<para>Make a local Java method a management operation; without the implementer dealing with JMX APIs</para>
</listitem>
<listitem>
<para>Make a local Java method a message handler; without the implementer dealing with JMS APIs</para>
</listitem>
</itemizedlist>
<section id="introduction-dependency-injection">
<title>Dependency Injection</title>
<sidebar id="background-ioc">
<title>Background</title>
<para>In early 2004, Martin Fowler asked the readers of his site: when
talking about Inversion of Control: <quote><emphasis>the question is, what
aspect of control are [they] inverting?</emphasis></quote>. Fowler then
suggested renaming the principle (or at least giving it a more
self-explanatory name), and started to use the term <firstterm>Dependency
Injection</firstterm>. His article then continued to explain the ideas
underpinning the Inversion of Control (<acronym>IoC</acronym>) and
Dependency Injection (<acronym>DI</acronym>) principle.</para>
<para>If you need a decent insight into IoC and DI, please do refer to
said article: <ulink
url="http://martinfowler.com/articles/injection.html">http://martinfowler.com/articles/injection.html</ulink>.</para>
</sidebar>
<para>Java applications (a loose term which runs the gamut from constrained
applets to full-fledged n-tier server-side enterprise applications)
typically are composed of a number of objects that collaborate with one
another to form the application proper. The objects in an application can
thus be said to have <emphasis>dependencies</emphasis> between
themselves.</para>
<para>The Java language and platform provides a wealth of functionality for
architecting and building applications, ranging all the way from the very
basic building blocks of primitive types and classes (and the means to
define new classes), to rich full-featured application servers and web
frameworks. One area that is decidedly conspicuous by its absence is any
means of taking the basic building blocks and composing them into a coherent
whole; this area has typically been left to the purvey of the architects and
developers tasked with building an application (or applications). Now to be
fair, there are a number of design patterns devoted to the business of
composing the various classes and object instances that makeup an
all-singing, all-dancing application. Design patterns such as
<firstterm>Factory</firstterm>, <firstterm>Abstract Factory</firstterm>,
<firstterm>Builder</firstterm>, <firstterm>Decorator</firstterm>, and
<firstterm>Service Locator</firstterm> (to name but a few) have widespread
recognition and acceptance within the software development industry
(presumably that is why these patterns have been formalized as patterns in
the first place). This is all very well, but these patterns are just that:
best practices given a name, typically together with a description of what
the pattern does, where the pattern is typically best applied, the problems
that the application of the pattern addresses, and so forth. Notice that the
last paragraph used the phrase <quote>... a <emphasis>description</emphasis>
of what the pattern does...</quote>; pattern books and wikis are typically
listings of such formalized best practice that you can certainly take away,
mull over, and then <emphasis>implement yourself</emphasis> in your
application.</para>
<para>The IoC component of the Spring Framework addresses the enterprise
concern of taking the classes, objects, and services that are to compose an
application, by providing a formalized means of composing these various
disparate components into a fully working application ready for use. The
Spring Framework takes best practices that have been proven over the years
in numerous applications and formalized as design patterns, and actually
codifies these patterns as first class objects that you as an architect and
developer can take away and integrate into your own application(s). This is
a <firstterm>Very Good Thing Indeed</firstterm> as attested to by the
numerous organizations and institutions that have used the Spring Framework
to engineer robust, <emphasis>maintainable</emphasis> applications.</para>
</section>
<section id="introduction-modules">
<title>Modules</title>
<para>The Spring Framework contains a lot of features, which are
well-organized in six modules shown in the diagram below. This chapter
@ -86,7 +121,7 @@ @@ -86,7 +121,7 @@
</mediaobject></para>
<para>The <link
linkend="beans-introduction"><emphasis>Core</emphasis></link> package is
linkend="beans-introduction"><emphasis>Core</emphasis></link> module is
the most fundamental part of the framework and provides the IoC and
Dependency Injection features. The basic concept here is the
<classname>BeanFactory</classname>, which provides a sophisticated

Write Preview
Loading…
Cancel
Save