Enhanced descriptions from Syndetics:

The Spring Framework is a major open source application development framework that makes Java/J2EE(TM) development easier and more productive. This book shows you not only what Spring can do but why, explaining its functionality and motivation to help you use all parts of the framework to develop successful applications.

You will be guided through all the Spring features and see how they form a coherent whole. In turn, this will help you understand the rationale for Spring′s approach, when to use Spring, and how to follow best practices. All this is illustrated with a complete sample application. When you finish the book, you will be well equipped to use Spring effectively in everything from simple Web applications to complex enterprise applications.

What you will learn from this book
∗ The core Inversion of Control container and the concept of Dependency Injection
∗ Spring′s Aspect Oriented Programming (AOP) framework and why AOP is important in J2EE development
∗ How to use Spring′s programmatic and declarative transaction management services effectively
∗ Ways to access data using Spring′s JDBC functionality, iBATIS SQL Maps, Hibernate, and other O/R mapping frameworks
∗ Spring services for accessing and implementing EJBs
∗ Spring′s remoting framework

Who this book is for

This book is for Java/J2EE architects and developers who want to gain a deeper knowledge of the Spring Framework and use it effectively.

Wrox Professional guides are planned and written by working programmers to meet the real-world needs of programmers, developers, and IT professionals. Focused and relevant, they address the issues technology professionals face every day. They provide examples, practical solutions, and expert education in new technologies, all designed to help programmers do a better job.

Table of contents provided by Syndetics

• Acknowledgments (p. ix)
• Introduction (p. xxiii)
• Chapter 1 Introducing the Spring Framework (p. 1)
• Why Spring? (p. 1)
• Problems with the Traditional Approach to J2EE (p. 1)
• Lightweight Frameworks (p. 3)
• Enter Spring (p. 5)
• Spring's Values (p. 6)
• Spring in Context (p. 8)
• Technologies (p. 8)
• Techniques (p. 18)
• Relationship to Other Frameworks (p. 19)
• Architecting Applications with Spring (p. 21)
• The Big Picture (p. 21)
• Persistence and Integration (p. 23)
• Business Service Objects (p. 27)
• Presentation (p. 27)
• The Future (p. 29)
• Release Schedule (p. 29)
• The Evolution of Java and J2EE (p. 29)
• Technology Currents (p. 31)
• Standards and Open Source (p. 31)
• The Spring Project and Community (p. 32)
• History (p. 32)
• Module Summary (p. 33)
• Supported Environments (p. 37)
• Summary (p. 37)
• Chapter 2 The Bean Factory and Application Context (p. 39)
• Inversion of Control and Dependency Injection (p. 40)
• Different Forms of Dependency Injection (p. 43)
• Deciding Between Setter Injection and Constructor Injection (p. 45)
• The Container (p. 47)
• The Bean Factory (p. 47)
• The Application Context (p. 48)
• Starting the Container (p. 50)
• Using Beans from the Factory (p. 52)
• XML Bean Configuration (p. 53)
• The Basic Bean Definition (p. 53)
• Specifying Bean Dependencies (p. 56)
• Managing the Bean Lifecycle (p. 64)
• Abstracting Access to Services and Resources (p. 67)
• Reusing Bean Definitions (p. 72)
• Using Post-Processors to Handle Customized Beans and Containers (p. 75)
• Summary (p. 81)
• Chapter 3 Advanced Container Concepts (p. 83)
• Abstractions for Low-Level Resources (p. 84)
• The Application Context as a ResourceLoader (p. 84)
• The Application Context as a Message Source (p. 87)
• Application Events (p. 89)
• Managing the Container (p. 91)
• Resource Location Paths in ApplicationContext Constructors (p. 92)
• Declarative Usage of Application Contexts (p. 93)
• Splitting Up Container Definitions into Multiple Files (p. 95)
• Strategies for Handling Components (p. 97)
• Singletons for Accessing the Container (p. 99)
• Some Convenience Factory Beans (p. 99)
• PropertyPathFactoryBean (p. 99)
• FieldRetrievingFactoryBean (p. 101)
• MethodInvokingFactoryBean (p. 101)
• Property Editors Provided by Spring (p. 102)
• Strategies for Testing (p. 103)
• Unit Tests (p. 103)
• Tests That Use the Spring Container (p. 106)
• Alternatives to XML (p. 108)
• Definitions from Properties Files (p. 108)
• Programmatic Bean Definitions (p. 110)
• Other Formats (p. 110)
• References (p. 110)
• Summary (p. 111)
• Chapter 4 Spring and AOP (p. 113)
• Goals (p. 113)
• Assumptions (p. 114)
• Example (p. 114)
• Spring's AOP Framework (p. 118)
• The Interceptor Chain (p. 118)
• Pros and Cons (p. 118)
• Advice (p. 119)
• Pointcuts (p. 125)
• Advisors (p. 130)
• Integration with the Spring IoC Container (p. 132)
• Examining and Manipulating Proxy State at Runtime (p. 145)
• Programmatic Proxy Creation (p. 146)
• Using Advanced Features of Spring's AOP Framework (p. 147)
• TargetSources (p. 147)
• Terminating the Interceptor Chain Early (p. 153)
• Using Introduction (p. 153)
• Exposing the Current Proxy (p. 156)
• Exposing the Current MethodInvocation (p. 157)
• Understanding Proxy Types (p. 158)
• Debugging and Testing (p. 159)
• Miscellaneous (p. 161)
• Integration with Other AOP Frameworks (p. 163)
• Goals (p. 164)
• AspectJ Integration (p. 164)
• AspectWerkz (p. 169)
• References (p. 169)
• Summary (p. 170)
• Chapter 5 DAO Support and JDBC Framework (p. 171)
• The Data Access Object Pattern (p. 172)
• Introducing Spring's JDBC Framework (p. 173)
• Motivation: Issues with Direct Use of JDBC (p. 173)
• How Spring Can Help (p. 175)
• A Simple Example (p. 176)
• Building the Data Access Layer for the Sample Application (p. 177)
• Data Model for the Sample Application (p. 177)
• DataSource (p. 178)
• Exception Translation (p. 180)
• Operations with JdbcTemplate (p. 183)
• Use of Callback Methods (p. 183)
• JdbcTemplate Convenience Methods (p. 184)
• Basic Queries Using the JdbcTemplate (p. 185)
• Basic Updating with JdbcTemplate (p. 186)
• Advanced Use of JdbcTemplate (p. 187)
• Support for RowSet (p. 188)
• Using the RDBMS Operation Classes (p. 189)
• SqlQuery and MappingSqlQuery (p. 190)
• Inserts and Updates with SqlUpdate (p. 192)
• Updating a ResultSet Using UpdatableSqlQuery (p. 193)
• Generating Primary Keys (p. 194)
• Retrieving Database-Generated Keys (p. 195)
• Calling a Stored Procedure (p. 196)
• Advanced Concepts (p. 199)
• Running Spring JDBC in an Application Server (p. 199)
• Using Custom Exception Translations (p. 201)
• Reading and Writing LOB Data (p. 203)
• Batch Updates (p. 208)
• Advanced Use of Stored Procedures (p. 210)
• Additional Considerations (p. 214)
• Performance (p. 214)
• When to Use JDBC Versus O/R Mapping (p. 215)
• JDBC Versions and J2EE Versions (p. 215)
• Summary (p. 215)
• Chapter 6 Transaction and Resource Management (p. 217)
• Background (p. 217)
• What Is a Transaction? (p. 217)
• The ACID Properties (p. 218)
• Concurrency Control (p. 220)
• Transactions and J2EE (p. 220)
• Local Transactions (p. 221)
• Global/Distributed Transactions (p. 221)
• Transaction Propagation (p. 221)
• Transaction Demarcation (p. 221)
• An Example of Spring's Transaction Support (p. 222)
• Introducing Spring's Transaction Abstraction (p. 224)
• Overview of Choices for Transaction Control (p. 225)
• Transaction Definition (p. 226)
• Transaction Status (p. 229)
• Transaction Demarcation Strategies (p. 229)
• Transaction Management Strategies (p. 242)
• DataSource Declarations (p. 251)
• Local Unpooled (p. 251)
• Local Pooled (p. 252)
• JNDI (p. 253)
• Choosing Between Local and JNDI DataSource (p. 253)
• Summary (p. 254)
• Chapter 7 Object/Relational Mapping (p. 255)
• Background (p. 256)
• Basic O/R Mapping (p. 256)
• Object Query Languages (p. 257)
• Transparent Persistence (p. 258)
• When to Choose O/R Mapping (p. 258)
• O/R Mapping Support in Spring (p. 259)
• Data Access Objects (p. 259)
• Transaction Management (p. 260)
• iBATIS SQL Maps (p. 261)
• Mapping File (p. 261)
• DAO Implementation (p. 263)
• Setup in a Spring Context (p. 265)
• Transaction Management (p. 266)
• iBATIS Summary (p. 267)
• Hibernate (p. 268)
• Mapping File (p. 269)
• DAO Implementation (p. 270)
• Setup in a Spring Context (p. 273)
• Transaction Management (p. 276)
• Open Session in View (p. 282)
• BLOB/CLOB Handling (p. 285)
• Hibernate: Summary (p. 287)
• JDO (p. 288)
• Persistent Object Lifecycle (p. 289)
• DAO Implementation (p. 289)
• Setup in a Spring Context (p. 291)
• Transaction Management (p. 293)
• PersistenceManager Lifecycle (p. 294)
• Open PersistenceManager in View (p. 295)
• JDO Dialect (p. 297)
• JDO: Summary (p. 298)
• Other O/R Mapping Tools (p. 299)
• Apache OJB (p. 299)
• TopLink (p. 300)
• Cayenne (p. 302)
• JSR-220 Persistence (p. 302)
• Summary (p. 302)
• Chapter 8 Lightweight Remoting (p. 305)
• Concepts and Scope (p. 306)
• Common Configuration Style (p. 307)
• Hessian and Burlap (p. 309)
• Accessing a Service (p. 310)
• Exporting a Service (p. 312)
• HTTP Invoker (p. 313)
• Accessing a Service (p. 314)
• Exporting a Service (p. 315)
• Customization Options (p. 316)
• RMI (p. 317)
• Accessing a Service (p. 318)
• Stub Lookup Strategies (p. 320)
• Exporting a Service (p. 322)
• Customization Options (p. 323)
• RMI-IIOP (p. 323)
• Web Services via JAX-RPC (p. 324)
• Accessing a Service (p. 326)
• Exporting a Service (p. 328)
• Custom Type Mappings (p. 330)
• Summary (p. 332)
• Chapter 9 Supporting Services (p. 335)
• JMS (p. 335)
• Introduction (p. 336)
• Motivation for Spring's JMS Support (p. 337)
• JMS Access via a Template (p. 338)
• Exception Handling (p. 340)
• ConnectionFactory Management (p. 340)
• Message Converters (p. 340)
• Destination Management (p. 342)
• Transaction Management (p. 343)
• JmsGatewaySupport (p. 343)
• The Future (p. 345)
• Scheduling with Spring (p. 345)
• Timers Versus Quartz (p. 346)
• Timers (p. 346)
• Quartz (p. 348)
• Sending Email with Spring (p. 354)
• Getting Started (p. 354)
• Reusing an Existing Mail Session (p. 355)
• Mail Sending Using COS (p. 356)
• Generic Mail Manager (p. 356)
• Scripting (p. 361)
• Consistent Model (p. 361)
• Other Scripting Languages (p. 365)
• Summary (p. 365)
• Chapter 10 Acegi Security System for Spring (p. 367)
• Enterprise Application Security Choices (p. 367)
• Typical Requirements (p. 367)
• Acegi Security in a Nutshell (p. 368)
• Java Authentication and Authorization Service (p. 372)
• Servlet Specification (p. 375)
• Acegi Security Fundamentals (p. 377)
• Authentication (p. 377)
• Storing the Authentication Object (p. 381)
• Authorization (p. 383)
• Domain Object Instance Security (p. 386)
• Example Code (p. 389)
• Introducing the Sample (p. 389)
• Security Unaware Implementation (p. 389)
• Security Approach (p. 391)
• Authentication (p. 391)
• Authorization (p. 392)
• Summary (p. 395)
• Chapter 11 Spring and EJB (p. 397)
• Deciding on the Need for EJBs (p. 397)
• Accessing EJBs (p. 399)
• The Boilerplate Approach (p. 399)
• The Spring Approach (p. 400)
• Implementing EJBs with Spring (p. 407)
• Stateless Session Beans (p. 407)
• Stateful Session Beans (p. 410)
• Message Driven Beans (p. 411)
• A Digression into XDoclet (p. 412)
• Singleton Container Access, Good or Evil? (p. 413)
• ContextSingletonBeanFactoryLocator and SingletonBeanFactoryLocator (p. 414)
• A Shared Context as the Parent of a Web-App Application Context (p. 416)
• Using a Shared Context from EJBs (p. 419)
• Testing Concerns (p. 420)
• Implement Business Functionality in POJO Delegate (p. 420)
• Use a Mock EJB Container (p. 420)
• Integration Testing Inside the AppServer (p. 421)
• Summary (p. 422)
• Chapter 12 Web MVC Framework (p. 423)
• A Simple Example (p. 423)
• General Architecture (p. 425)
• Web MVC Concepts (p. 426)
• Generic Web MVC Using a Dispatcher and Controllers (p. 427)
• Requirements for a Good Web MVC Framework (p. 428)
• Spring's Web MVC Equivalents (p. 429)
• Infrastructural Components (p. 430)
• The DispatcherServlet (p. 431)
• The WebApplicationContext (p. 434)
• Workflow Involved with Handling Requests (p. 436)
• Common Layout of a Spring MVC Web Application (p. 440)
• HandlerMappings (p. 441)
• BeanNameUrlHandlerMapping (p. 442)
• SimpleUrlHandlerMapping (p. 443)
• CommonsPathMapUrlHandlerMapping (p. 444)
• More Than One HandlerMapping (p. 445)
• HandlerExecutionChain and Interceptors (p. 446)
• WebContentInterceptor (p. 447)
• UserRoleAuthorizationInterceptor (p. 448)
• Other Handler Interceptors Provided by Spring MVC (p. 449)
• Handlers and Their Adapters (p. 449)
• ModelAndView and ViewResolvers (p. 450)
• UrlBasedViewResolvers (p. 450)
• BeanNameViewResolver and XmlViewResolver (p. 451)
• ResourceBundleViewResolver (p. 451)
• Chaining View Resolvers (p. 452)
• Locale Changing and Resolution (p. 454)
• HandlerExceptionResolvers (p. 456)
• Controllers (p. 458)
• WebContentGenerator (p. 458)
• AbstractController (p. 459)
• UrlFilenameViewController (p. 459)
• ParameterizableViewController (p. 460)
• MultiActionController (p. 460)
• Data Binding (p. 461)
• Convenient Functionality When Working with Data Binding (p. 463)
• Real-World Examples of Using Controllers (p. 464)
• Viewing a List of Performances Using the AbstractController (p. 464)
• Making a Reservation (p. 466)
• Wizard Functionality (p. 474)
• Basic Configuration (p. 474)
• Template Methods (p. 475)
• Flow of a Wizard (p. 476)
• Page Changes, Numbering, and Other Actions (p. 476)
• Extending Spring's Handler Infrastructure (p. 478)
• Uploading Files (p. 478)
• Configuring the Multipart Resolver (p. 479)
• Creating a Form to Upload a File (p. 479)
• Handling Uploaded Data (p. 479)
• Testing Your Controllers (p. 481)
• Testing Without the Application Context (p. 481)
• More Extensive Testing Using Mock Objects (p. 483)
• Testing Using the Complete Application Context (p. 484)
• Other Ways to Test a Web Application (p. 485)
• Summary (p. 485)
• Chapter 13 Web View Technologies (p. 487)
• An Example (p. 488)
• General Configuration (p. 488)
• JavaServer Pages (p. 489)
• FreeMarker (p. 489)
• Generating PDFs Using iText (p. 490)
• Considerations When Choosing a Technology (p. 491)
• View Objects and Models (p. 491)
• Features Offered by the AbstractView (p. 493)
• Issuing a New Request Using the RedirectView (p. 494)
• Using View Prefixes to Issue Forwards or Redirects (p. 495)
• JavaServer Pages (p. 496)
• Configuring Your Application to Use JSP (p. 497)
• Creating Forms Using Custom Tags (p. 497)
• Using Tag Files to Create Reusable Elements (p. 504)
• Velocity and FreeMarker (p. 505)
• Configuring the View Resolver (p. 505)
• Using the Form Simplification Macros (p. 507)
• Tiles (p. 511)
• Views Based on XML and XSLT (p. 514)
• Excel and Other Document-Based Views (p. 515)
• Generating an Excel File from Our List of Shows (p. 516)
• Using a Template as a Basis for Your Excel File (p. 517)
• Other Document-Based Views (p. 517)
• Using a HandlerInterceptor to Distinguish Between HTML and Excel (p. 517)
• Implementing Custom Views (p. 519)
• View and AbstractView (p. 520)
• Implementing a View Generating XML from a Data Object (p. 520)
• Considerations When Implementing Custom Views (p. 522)
• Summary (p. 522)
• Chapter 14 Integrating with Other Web Frameworks (p. 523)
• Considerations When Choosing an MVC Framework (p. 523)
• Comparing the Traditional Web MVC Frameworks (p. 524)
• Integrating with Spring: Core Concepts (p. 534)
• WebWork Integration (p. 536)
• Setting Up the ObjectFactory (p. 536)
• Struts Integration (p. 537)
• Using ActionSupport (p. 538)
• Using DelegationRequestProcessor and DelegationActionProxy (p. 539)
• Using an Auto Wiring Base Action (p. 542)
• Tapestry Integration (p. 543)
• Getting Beans for Tapestry (p. 543)
• The Page Class (p. 544)
• The Page Definition (p. 544)
• The Page Template (p. 545)
• Tapestry Integration Final Thoughts (p. 547)
• JavaServer Faces Integration (p. 547)
• Summary (p. 549)
• Chapter 15 The Sample Application (p. 551)
• Choice of Server Technologies (p. 552)
• Application Layers (p. 552)
• Persistence Layer (p. 554)
• Data Model (p. 554)
• Domain Object Model (p. 556)
• Object/Relational Mapping (p. 558)
• DAO Implementation (p. 561)
• Data Access Context (p. 563)
• Business Service Layer (p. 563)
• Services (p. 564)
• Application Context (p. 565)
• Web Layer (p. 566)
• Flow Through the Application (p. 566)
• Configuring the Application via web.xml (p. 568)
• Web Controllers (p. 569)
• View Technology (p. 571)
• Comparison with the J2EE Design and Development Implementation (p. 572)
• Simpler Technology (p. 572)
• Database Changes (p. 573)
• Server Configuration (p. 573)
• MySQL (p. 573)
• Tomcat (p. 574)
• Build and Deployment (p. 574)
• Creating and Loading the Database Tables (p. 574)
• Building the Application and Deploying It to the Tomcat Server (p. 575)
• Summary (p. 575)
• Chapter 16 Conclusion (p. 577)
• Problems Solved by Spring (p. 577)
• The Spring Solution (p. 578)
• Guidelines for Spring Development (p. 581)
• Technology Choices (p. 581)
• Layer by Layer (p. 583)
• Structuring Applications (p. 589)
• Testing Your Applications (p. 592)
• Related Projects (p. 594)
• Acegi Security for Spring (p. 594)
• Other Projects (p. 595)
• Spring in Non-J2EE Environments (p. 596)
• To Find Out More (p. 596)
• Books and Articles (p. 597)
• Online Resources (p. 597)
• Sample Applications (p. 597)
• The Future (p. 598)
• Appendix A Requirements for the Sample Application (p. 601)
• Overview (p. 601)
• User Populations (p. 602)
• Public Internet Users (p. 602)
• Box Office Users (p. 602)
• Administrators (p. 603)
• Assumptions (p. 603)
• Scope Limitations (p. 604)
• Delivery Schedule (p. 604)
• Internet User Interface (p. 605)
• Basic Workflow (p. 605)
• Error Handling (p. 606)
• Application Screens (p. 606)
• Non-Functional Requirements (p. 618)
• Hardware and Software Environment (p. 619)
• Index (p. 621)

Author notes provided by Syndetics

Rod Johnson is the founder of the Spring Framework and a well-known expert on Java and J2EE.
Rod holds a Ph.D. from Sydney University. Originally from a C/C++ background, he has been involved with Java and J2EE since their releases as a developer, architect, and consultant.
He is the author of two of the most popular and influential books on J2EE: Expert One-on-One J2EE Design and Development (Wrox, 2002), and J2EE without EJB (Wrox, 2004, with Juergen Hoeller). Both have played a major role in the rise of agile J2EE, and the move away from overly complex traditional J2EE architecture.
Rod is co-lead of the Spring Framework. He is a popular conference speaker and regularly appears at leading Java events in the US, Europe, and Asia. He serves in the Java Community Process (JCP) on the expert groups of several JSRs.
He also has wide consulting experience in banking and finance, insurance, software, and media. He is CEO of Interface21 (www.interface21.com), a consultancy devoted to providing expert J2EE and Spring Framework services.
He is actively involved with client projects as well as Spring development.

Juergen Hoeller is co-founder of Interface21, the company providing commercial Spring services from the source. He is a key driver of Spring development and has been release manager since Spring s inception. His special interests and responsibilities in the project cover a wide variety of topics, from the core container to transaction management, data access, and lightweight remoting.
Juergen has a Master s degree in computer science from the University of Linz, specializing in Java, OO modeling, and software engineering. He is co-author of Expert One-on-One J2EE Development without EJB (Wiley, 2004) and regularly presents at conferences and other events. He is also active in many community forums, including TheServerSide.

Alef Arendsen studied computer sciences at the University of Utrecht. Later, also in Utrecht, Alef started his first company. After this turned out to be too little a challenge, Alef went to work for SmartHaven, an Amsterdam-based VCfunded company providing J2EE components for knowledge management applications. He was responsible for streamlining the development process and designing parts of the component infrastructure. In early 2002, together with Joost van de Wijgerd, Alef founded JTeam, a software company providing J2EE development services. Alef is a core Spring committer and, while remaining involved with JTeam, he is now a consultant for Interface21. He is a frequent speaker at public conferences. Alef can be reached by email at alef@interface21.com. You can also read his blog at http://blog.arendsen.net.

Thomas Risberg is a database developer working for TargetrRx, a pharmaceutical market research company located in Horsham, Pennsylvania. He has many years of experience working with both large and small organizations on various database-related projects ranging from simple data entry programs to large data warehousing implementations. Thomas is a reformed COBOL programmer who came to Java via Xbase, Visual Basic, and PL/SQL. He served as an Oracle DBA for a couple of years but decided that software development was really where his heart was. Thomas has a B.A. degree in information processing from the University of Stockhom, Sweden. He is a certified Oracle Professional DBA and a Sun Certified Java Programmer and J2EE Architect.
Thomas joined the Spring Framework development team in early 2003 and is mostly involved in evolving the JDBC layer. His non-computer related interests are soccer, photography, and travel.

Colin Sampaleanu has had a long and varied career spanning almost two decades after a childhood spent tinkering with computers and software including experience developing for and managing his own retail software company, other years in the C++ shrinkwrap and enterprise software space, experience with Java since the early days of the language, and a complete focus on enterprise Java since the late nineties.
Colin is a currently a principal partner at Interface21, which specializes in Spring training, consulting, and support. Prior to joining Interface21, Colin was Chief Architect at a software incubator / VC.
As a core Spring developer and Interface21 principal, Colin spends much of his time talking and writing about the benefits of Spring, and promoting agile software development architectures and methodologies in general.