book

Professional Java™ Development with the Spring Framework

Name: Professional Java™ Development with the Spring Framework
ISBN: 9780764574832

by Rod Johnson, Juergen Hoeller, Alef Arendsen, Thomas Risberg, Colin Sampaleanu

July 2005

Intermediate to advanced

672 pages

20h 12m

English

Wrox

Read now

Unlock full access

Copyright
About the Authors
Credits
Acknowledgments
Introduction
Whom This Book Is ForAims of This BookWhat This Book CoversAssumed KnowledgeRecommended ReadingWhat You Need to Use This BookThe Sample ApplicationConventionsSource CodeErratap2p.wrox.com
1. Introducing the Spring Framework
1.1. Why Spring?1.1.1. Problems with the Traditional Approach to J2EE1.1.2. Lightweight Frameworks1.1.3. Enter Spring1.2. Spring's Values1.3. Spring in Context1.3.1. Technologies1.3.1.1. Inversion of Control and Dependency Injection1.3.1.2. Aspect-Oriented Programming1.3.1.3. Consistent Abstraction1.3.1.3.1. Motivation1.3.1.3.2. Exceptions1.3.1.3.3. Resource Management1.3.2. Techniques1.3.3. Relationship to Other Frameworks1.3.3.1. Persistence Frameworks1.3.3.2. Web Frameworks1.3.3.3. AOP Frameworks1.3.3.4. Other Frameworks1.4. Architecting Applications with Spring1.4.1. The Big Picture1.4.2. Persistence and Integration1.4.2.1. Database1.4.2.2. Data Access Objects1.4.2.3. Persistent Domain Objects1.4.2.4. Persistence Technology1.4.3. Business Service Objects1.4.4. Presentation1.4.4.1. Web Tier1.4.4.2. Remote Access Facade1.4.4.3. Spring RCP1.5. The Future1.5.1. Release Schedule1.5.2. The Evolution of Java and J2EE1.5.3. Technology Currents1.5.4. Standards and Open Source1.6. The Spring Project and Community1.6.1. History1.6.2. Module Summary1.6.3. Supported Environments1.7. Summary
2. The Bean Factory and Application Context
2.1. Inversion of Control and Dependency Injection2.1.1. Different Forms of Dependency Injection2.1.2. Deciding Between Setter Injection and Constructor Injection2.2. The Container2.2.1. The Bean Factory2.2.2. The Application Context2.2.3. Starting the Container2.2.4. Using Beans from the Factory2.2.5. XML Bean Configuration2.2.6. The Basic Bean Definition2.2.6.1. Identifier2.2.6.2. Bean Creation Mechanism2.2.6.3. Singleton versus Non-Singleton Beans2.2.7. Specifying Bean Dependencies2.2.7.1. Specifying Bean Dependencies, Detailed2.2.7.2. Manual Dependency Declarations2.2.7.3. Autowiring Dependencies2.2.7.4. Constructor Argument Matching2.2.7.5. Validating Bean Dependencies2.2.8. Managing the Bean Lifecycle2.2.8.1. Initialization and Destruction Callbacks2.2.8.2. BeanFactoryAware and ApplicationContextAware Callbacks2.2.9. Abstracting Access to Services and Resources2.2.9.1. Examining Factory Beans2.2.9.2. Key Points and the Net Effect2.2.10. Reusing Bean Definitions2.2.10.1. Child Bean Definition Specifics2.2.11. Using Post-Processors to Handle Customized Beans and Containers2.2.11.1. Bean Post-Processors2.2.11.2. Bean Factory Post-Processors2.2.11.3. PropertyPlaceholderConfigurer2.2.11.4. PropertyOverrideConfigurer2.2.11.5. CustomEditorConfigurer2.2.11.5.1. Creating a Custom PropertyEditor2.2.11.5.2. Registering and Using the Custom PropertyEditor2.2.11.6. BeanNameAutoProxyCreator2.2.11.7. DefaultAdvisorAutoProxyCreator2.3. Summary
3. Advanced Container Concepts
3.1. Abstractions for Low-Level Resources3.1.1. The Application Context as a ResourceLoader3.1.2. The Application Context as a Message Source3.2. Application Events3.3. Managing the Container3.3.1. Resource Location Paths in ApplicationContext Constructors3.3.1.1. The Special classpath*: Prefix3.3.1.2. Ant-Style Paths3.3.2. Declarative Usage of Application Contexts3.3.3. Splitting Up Container Definitions into Multiple Files3.3.3.1. Combining the File Fragments Externally3.3.3.2. Combining File Fragments with the Import Element3.3.3.3. Combining File Fragments Programmatically3.3.4. Strategies for Handling Components3.3.5. Singletons for Accessing the Container3.4. Some Convenience Factory Beans3.4.1. PropertyPathFactoryBean3.4.2. FieldRetrievingFactoryBean3.4.3. MethodInvokingFactoryBean3.5. Property Editors Provided by Spring3.6. Strategies for Testing3.6.1. Unit Tests3.6.2. Tests That Use the Spring Container3.6.2.1. Managing the Container Configuration in a Test3.6.2.2. In-Appserver Tests3.7. Alternatives to XML3.7.1. Definitions from Properties Files3.7.2. Programmatic Bean Definitions3.7.3. Other Formats3.8. References3.9. Summary
4. Spring and AOP
4.1. Goals4.2. Assumptions4.3. Example4.4. Spring's AOP Framework4.4.1. The Interceptor Chain4.4.2. Pros and Cons4.4.3. Advice4.4.3.1. The AOP Alliance4.4.3.1.1. Method Interceptors4.4.3.2. Spring Advice Types4.4.3.2.1. Before Advice4.4.3.2.2. After Returning Advice4.4.3.2.3. Throws Advice4.4.3.2.4. Other Advice Types4.4.4. Pointcuts4.4.4.1. Spring Pointcut Concepts4.4.4.2. The Pointcut Interface and Friends4.4.4.3. Static and Dynamic Pointcuts4.4.4.4. Pointcuts Shipped with Spring4.4.4.4.1. Pointcut Constants4.4.4.4.2. NameMatchMethodPointcut4.4.4.4.3. Regular Expression Pointcuts4.4.4.4.4. ControlFlowPointcut4.4.4.4.5. StaticMethodMatcherPointcut Base Class4.4.4.4.6. DynamicMethodMatcherPointcut Base Class4.4.4.5. Operating on Pointcuts4.4.5. Advisors4.4.5.1. Advisor Implementations4.4.5.2. DefaultPointcutAdvisor4.4.5.3. Regular Expressions, Take 24.4.5.4. Wrapping4.4.6. Integration with the Spring IoC Container4.4.6.1. Basic Proxy Configuration4.4.6.2. Using ProxyFactoryBean4.4.6.2.1. Basic Concepts4.4.6.2.2. Simplifying Configuration When Using ProxyFactoryBean4.4.6.3. Understanding the Lifecycle of Objects4.4.6.4. Autoproxying4.4.6.4.1. BeanNameAutoProxyCreator4.4.6.4.2. DefaultAdvisorAutoProxyCreator4.4.6.4.3. Configuration Options4.4.6.4.4. Attribute-Driven Autoproxying4.4.6.5. Advanced Autoproxy Creation4.4.6.6. Making a Choice4.4.7. Examining and Manipulating Proxy State at Runtime4.4.8. Programmatic Proxy Creation4.5. Using Advanced Features of Spring's AOP Framework4.5.1. TargetSources4.5.1.1. HotSwappableTargetSource4.5.1.2. Pooling Target Source4.5.1.2.1. Use Out of the Box4.5.1.2.2. Use with Your Own Choice of Pooling Implementation4.5.1.2.3. When Should You Use Pooling?4.5.1.2.4. Exposing Pool Statistics4.5.1.3. Custom TargetSources4.5.1.3.1. Programmatic Access to the TargetSource4.5.1.4. Doing Without a Target Object4.5.2. Terminating the Interceptor Chain Early4.5.3. Using Introduction4.5.4. Exposing the Current Proxy4.5.5. Exposing the Current MethodInvocation4.5.6. Understanding Proxy Types4.5.7. Debugging and Testing4.5.8. Miscellaneous4.5.8.1. Changing Method Arguments4.5.8.2. Double Proxying4.5.8.3. Implementing Multiple AOP Framework Interfaces4.5.8.4. Serializing AOP Proxies4.5.8.5. Invoking proceed() More Than Once4.6. Integration with Other AOP Frameworks4.6.1. Goals4.6.2. AspectJ Integration4.6.2.1. Using Dependency Injection to Configure AspectJ Aspects4.6.2.1.1. Singleton Aspects4.6.2.1.2. More Advanced Usages4.6.2.1.3. Scoping Issues4.6.2.1.4. Understanding Aspect Association4.6.2.2. Choosing Between Spring AOP and AspectJ4.6.3. AspectWerkz4.7. References4.8. Summary
5. DAO Support and JDBC Framework
5.1. The Data Access Object Pattern5.2. Introducing Spring's JDBC Framework5.2.1. Motivation: Issues with Direct Use of JDBC5.2.1.1. Managing the Connection, Statements, and ResultSets5.2.1.2. Handling SQLExceptions5.2.1.3. Lookup of Resources5.2.1.4. JDBC Strengths5.2.1.4.1. Implementations Provided by Vendors5.2.1.4.2. Using SQL5.2.1.4.3. Cross Database Escape Syntax5.2.2. How Spring Can Help5.2.3. A Simple Example5.3. Building the Data Access Layer for the Sample Application5.3.1. Data Model for the Sample Application5.3.2. DataSource5.3.3. Exception Translation5.4. Operations with JdbcTemplate5.4.1. Use of Callback Methods5.4.2. JdbcTemplate Convenience Methods5.4.3. Basic Queries Using the JdbcTemplate5.4.4. Basic Updating with JdbcTemplate5.4.5. Advanced Use of JdbcTemplate5.4.6. Support for RowSet5.5. Using the RDBMS Operation Classes5.5.1. SqlQuery and MappingSqlQuery5.5.2. Inserts and Updates with SqlUpdate5.5.3. Updating a ResultSet Using UpdatableSqlQuery5.5.4. Generating Primary Keys5.5.5. Retrieving Database-Generated Keys5.5.6. Calling a Stored Procedure5.6. Advanced Concepts5.6.1. Running Spring JDBC in an Application Server5.6.1.1. Connection Pooling5.6.1.2. Connection and Statement Wrappers5.6.2. Using Custom Exception Translations5.6.2.1. Providing a CustomSQLErrorCodesTranslation5.6.2.2. Implementing an SQLErrorCodeSQLExceptionTranslator5.6.3. Reading and Writing LOB Data5.6.3.1. Using the JdbcTemplate for LOB Access5.6.3.2. Using the RDBMS Operation LOB Support5.6.3.3. Using LobHandler and JdbcExtractor Together5.6.4. Batch Updates5.6.5. Advanced Use of Stored Procedures5.6.5.1. Passing in a Complex Type as a Parameter5.6.5.2. Returning a ResultSet5.7. Additional Considerations5.7.1. Performance5.7.2. When to Use JDBC Versus O/R Mapping5.7.3. JDBC Versions and J2EE Versions5.8. Summary

6. Transaction and Resource Management
6.1. Background6.1.1. What Is a Transaction?6.1.2. The ACID Properties6.1.2.1. Atomicity6.1.2.2. Isolation6.1.3. Concurrency Control6.1.3.1. Pessimistic Locking6.1.3.2. Optimistic Locking6.2. Transactions and J2EE6.2.1. Local Transactions6.2.2. Global/Distributed Transactions6.2.3. Transaction Propagation6.2.4. Transaction Demarcation6.2.4.1. Programmatic Transaction Management6.2.4.2. Declarative Transactions6.3. An Example of Spring's Transaction Support6.4. Introducing Spring's Transaction Abstraction6.4.1. Overview of Choices for Transaction Control6.4.2. Transaction Definition6.4.2.1. Propagation Behavior6.4.2.2. Isolation6.4.2.3. Timeout6.4.2.4. Read-Only6.4.3. Transaction Status6.4.4. Transaction Demarcation Strategies6.4.4.1. Where to Demarcate Transactions6.4.4.2. Programmatic Transaction Demarcation6.4.4.2.1. Direct Programmatic Use of PlatformTransactionManager6.4.4.2.2. TransactionTemplate6.4.4.3. Declarative Transaction Demarcation6.4.4.3.1. ProxyFactoryBean/Transaction Interceptor6.4.4.3.2. TransactionProxyFactoryBean6.4.4.3.3. BeanNameAutoProxyCreator6.4.4.3.4. Source-Level Metadata Using Commons Attributes6.4.4.3.5. Source-Level Metadata Using J2SE 5.0 Annotations6.4.4.4. Performance Implications6.4.4.5. Transaction Demarcation Best Practices6.4.5. Transaction Management Strategies6.4.5.1. Single Resource Transaction Managers6.4.5.1.1. DataSourceTransactionManager6.4.5.1.2. HibernateTransactionManager6.4.5.1.3. JDOTransactionManager6.4.5.1.4. TopLinkTransactionManager6.4.5.1.5. PersistenceBrokerTransactionManager6.4.5.2. JtaTransactionManager6.4.5.2.1. Application Server–Specific JTA Configuration6.4.5.2.2. Considerations for JTA and O/R Mapping6.5. DataSource Declarations6.5.1. Local Unpooled6.5.2. Local Pooled6.5.3. JNDI6.5.4. Choosing Between Local and JNDI DataSource6.6. Summary
7. Object/Relational Mapping
7.1. Background7.1.1. Basic O/R Mapping7.1.2. Object Query Languages7.1.3. Transparent Persistence7.1.4. When to Choose O/R Mapping7.2. O/R Mapping Support in Spring7.2.1. Data Access Objects7.2.2. Transaction Management7.3. iBATIS SQL Maps7.3.1. Mapping File7.3.2. DAO Implementation7.3.3. Setup in a Spring Context7.3.4. Transaction Management7.3.5. iBATIS Summary7.4. Hibernate7.4.1. Mapping File7.4.2. DAO Implementation7.4.3. Setup in a Spring Context7.4.3.1. Setup as a JCA Connector7.4.4. Transaction Management7.4.4.1. JTA Synchronization7.4.4.2. Session Lifecycle7.4.4.3. Reattachment and the Duplicate Object Problem7.4.4.4. HibernateInterceptor7.4.5. Open Session in View7.4.5.1. Single Session Versus Deferred Close7.4.5.2. Configuration Examples7.4.6. BLOB/CLOB Handling7.4.7. Hibernate: Summary7.5. JDO7.5.1. Persistent Object Lifecycle7.5.2. DAO Implementation7.5.3. Setup in a Spring Context7.5.4. Transaction Management7.5.5. PersistenceManager Lifecycle7.5.6. Open PersistenceManager in View7.5.6.1. Configuration Examples7.5.7. JDO Dialect7.5.8. JDO: Summary7.6. Other O/R Mapping Tools7.6.1. Apache OJB7.6.2. TopLink7.6.3. Cayenne7.6.4. JSR-220 Persistence7.7. Summary
8. Lightweight Remoting
8.1. Concepts and Scope8.2. Common Configuration Style8.3. Hessian and Burlap8.3.1. Accessing a Service8.3.2. Exporting a Service8.4. HTTP Invoker8.4.1. Accessing a Service8.4.2. Exporting a Service8.4.3. Customization Options8.5. RMI8.5.1. Accessing a Service8.5.2. Stub Lookup Strategies8.5.3. Exporting a Service8.5.4. Customization Options8.5.5. RMI-IIOP8.6. Web Services via JAX-RPC8.6.1. Accessing a Service8.6.2. Exporting a Service8.6.3. Custom Type Mappings8.7. Summary
9. Supporting Services
9.1. JMS9.1.1. Introduction9.1.2. Motivation for Spring's JMS Support9.1.3. JMS Access via a Template9.1.3.1. Callback Methods9.1.3.2. Synchronous Receiving9.1.3.3. Quality of Service Parameters9.1.4. Exception Handling9.1.5. ConnectionFactory Management9.1.6. Message Converters9.1.7. Destination Management9.1.8. Transaction Management9.1.9. JmsGatewaySupport9.1.10. The Future9.2. Scheduling with Spring9.2.1. Timers Versus Quartz9.2.2. Timers9.2.3. Quartz9.2.3.1. Job9.2.3.2. JobDetail9.2.3.3. Trigger9.2.3.4. Scheduler9.3. Sending Email with Spring9.3.1. Getting Started9.3.2. Reusing an Existing Mail Session9.3.3. Mail Sending Using COS9.3.4. Generic Mail Manager9.3.4.1. Message Creation9.3.4.2. Recipients9.3.4.3. Content9.3.4.4. Attachments9.3.4.5. Sending9.4. Scripting9.4.1. Consistent Model9.4.1.1. Groovy9.4.1.2. Beanshell9.4.2. Other Scripting Languages9.5. Summary
10. Acegi Security System for Spring
10.1. Enterprise Application Security Choices10.1.1. Typical Requirements10.1.2. Acegi Security in a Nutshell10.1.2.1. Authentication10.1.2.2. Web Request Security10.1.2.3. Service Layer Security10.1.2.4. Domain Object Instance Security10.1.3. Java Authentication and Authorization Service10.1.4. Servlet Specification10.2. Acegi Security Fundamentals10.2.1. Authentication10.2.2. Storing the Authentication Object10.2.3. Authorization10.2.4. Domain Object Instance Security10.3. Example Code10.3.1. Introducing the Sample10.3.2. Security Unaware Implementation10.3.3. Security Approach10.3.4. Authentication10.3.5. Authorization10.4. Summary
11. Spring and EJB
11.1. Deciding on the Need for EJBs11.2. Accessing EJBs11.2.1. The Boilerplate Approach11.2.2. The Spring Approach11.2.2.1. Encapsulating the Home Object Lookup11.2.2.2. Encapsulating Stateless Session Bean Lookups11.2.2.2.1. Accessing Local EJBs11.2.2.2.2. Accessing Remote EJBs11.2.2.2.3. Accessing Remote EJBs, Unifying the Business Interface11.3. Implementing EJBs with Spring11.3.1. Stateless Session Beans11.3.2. Stateful Session Beans11.3.3. Message Driven Beans11.3.4. A Digression into XDoclet11.4. Singleton Container Access, Good or Evil?11.4.1. ContextSingletonBeanFactoryLocator and SingletonBeanFactoryLocator11.4.2. A Shared Context as the Parent of a Web-App Application Context11.4.3. Using a Shared Context from EJBs11.5. Testing Concerns11.5.1. Implement Business Functionality in POJO Delegate11.5.2. Use a Mock EJB Container11.5.3. Integration Testing Inside the AppServer11.6. Summary
12. Web MVC Framework
12.1. A Simple Example12.2. General Architecture12.2.1. Web MVC Concepts12.2.2. Generic Web MVC Using a Dispatcher and Controllers12.2.3. Requirements for a Good Web MVC Framework12.2.4. Spring's Web MVC Equivalents12.2.4.1. Executing Actions in Controllers12.2.4.2. Returning a ModelAndView12.2.4.3. Rendering a View12.2.4.4. Completing the Picture: The DispatcherServlet12.3. Infrastructural Components12.3.1. The DispatcherServlet12.3.2. The WebApplicationContext12.4. Workflow Involved with Handling Requests12.5. Common Layout of a Spring MVC Web Application12.6. HandlerMappings12.6.1. BeanNameUrlHandlerMapping12.6.2. SimpleUrlHandlerMapping12.6.3. CommonsPathMapUrlHandlerMapping12.6.4. More Than One HandlerMapping12.7. HandlerExecutionChain and Interceptors12.7.1. WebContentInterceptor12.7.2. UserRoleAuthorizationInterceptor12.7.3. Other Handler Interceptors Provided by Spring MVC12.8. Handlers and Their Adapters12.9. ModelAndView and ViewResolvers12.9.1. UrlBasedViewResolvers12.9.2. BeanNameViewResolver and XmlViewResolver12.9.3. ResourceBundleViewResolver12.9.4. Chaining View Resolvers12.9.4.1. Overriding One Specific View12.9.4.2. Disabling View Resolver Chaining12.10. Locale Changing and Resolution12.11. HandlerExceptionResolvers12.12. Controllers12.12.1. WebContentGenerator12.12.2. AbstractController12.12.3. UrlFilenameViewController12.12.4. ParameterizableViewController12.12.5. MultiActionController12.13. Data Binding12.13.1. Convenient Functionality When Working with Data Binding12.13.1.1. Checkboxes and Radio Buttons12.13.1.2. Indexed and Mapped Properties: Maps, Lists, and Arrays12.14. Real-World Examples of Using Controllers12.14.1. Viewing a List of Performances Using the AbstractController12.14.1.1. Workflow of the ViewShowController12.14.1.2. Implementing the Controller12.14.1.3. Wiring Up the Controller12.14.2. Making a Reservation12.14.2.1. SimpleFormController12.14.2.1.1. Properties to Configure the Controller With12.14.2.1.2. Callbacks and Template Methods for Custom Behavior12.14.2.1.3. Form Workflow12.15. Wizard Functionality12.15.1. Basic Configuration12.15.2. Template Methods12.15.3. Flow of a Wizard12.15.4. Page Changes, Numbering, and Other Actions12.16. Extending Spring's Handler Infrastructure12.17. Uploading Files12.17.1. Configuring the Multipart Resolver12.17.2. Creating a Form to Upload a File12.17.3. Handling Uploaded Data12.18. Testing Your Controllers12.18.1. Testing Without the Application Context12.18.2. More Extensive Testing Using Mock Objects12.18.3. Testing Using the Complete Application Context12.18.4. Other Ways to Test a Web Application12.19. Summary
13. Web View Technologies
13.1. An Example13.1.1. General Configuration13.1.2. JavaServer Pages13.1.3. FreeMarker13.1.4. Generating PDFs Using iText13.2. Considerations When Choosing a Technology13.3. View Objects and Models13.4. Features Offered by the AbstractView13.4.1. Issuing a New Request Using the RedirectView13.4.2. Using View Prefixes to Issue Forwards or Redirects13.5. JavaServer Pages13.5.1. Configuring Your Application to Use JSP13.5.2. Creating Forms Using Custom Tags13.5.2.1. BindStatus and spring:bind13.5.2.2. spring:nestedPath13.5.2.3. spring:transform13.5.2.4. spring:message13.5.2.5. A Final Note on Spring Tags13.5.3. Using Tag Files to Create Reusable Elements13.6. Velocity and FreeMarker13.6.1. Configuring the View Resolver13.6.1.1. Configuring Velocity13.6.1.2. Configuring FreeMarker13.6.2. Using the Form Simplification Macros13.6.2.1. Configuring Your FreeMarker and Velocity Templates to Use Macros13.6.2.2. Using Velocity or FreeMarker Macros to Create a Form13.7. Tiles13.8. Views Based on XML and XSLT13.9. Excel and Other Document-Based Views13.9.1. Generating an Excel File from Our List of Shows13.9.2. Using a Template as a Basis for Your Excel File13.9.3. Other Document-Based Views13.9.4. Using a HandlerInterceptor to Distinguish Between HTML and Excel13.10. Implementing Custom Views13.10.1. View and AbstractView13.10.2. Implementing a View Generating XML from a Data Object13.10.3. Considerations When Implementing Custom Views13.11. Summary
14. Integrating with Other Web Frameworks
14.1. Considerations When Choosing an MVC Framework14.1.1. Comparing the Traditional Web MVC Frameworks14.1.1.1. Data Binding and Validation14.1.1.1.1. WebWork14.1.1.1.2. Struts14.1.1.1.3. Spring MVC14.1.1.1.4. Tapestry14.1.1.1.5. JavaServer Faces14.1.1.2. Dealing with the Presentation Layer14.1.1.2.1. WebWork14.1.1.2.2. Struts14.1.1.2.3. Spring MVC14.1.1.2.4. Tapestry14.1.1.2.5. JavaServer Faces14.1.1.3. Controller Infrastructure and Interception Handling14.1.1.3.1. WebWork14.1.1.3.2. Struts14.1.1.3.3. Spring MVC14.1.1.3.4. Tapestry14.1.1.3.5. JavaServer Faces14.1.1.4. Other Characteristics14.1.1.4.1. WebWork14.1.1.4.2. Struts14.1.1.4.3. Spring Web MVC14.1.1.4.4. Tapestry14.1.1.4.5. JavaServer Faces14.2. Integrating with Spring: Core Concepts14.3. WebWork Integration14.3.1. Setting Up the ObjectFactory14.4. Struts Integration14.4.1. Using ActionSupport14.4.2. Using DelegationRequestProcessor and DelegationActionProxy14.4.2.1. Defining the Struts ActionServlet and the ContextLoaderPlugIn14.4.3. Using an Auto Wiring Base Action14.5. Tapestry Integration14.5.1. Getting Beans for Tapestry14.5.2. The Page Class14.5.3. The Page Definition14.5.4. The Page Template14.5.5. Tapestry Integration Final Thoughts14.6. JavaServer Faces Integration14.7. Summary
15. The Sample Application
15.1. Choice of Server Technologies15.2. Application Layers15.3. Persistence Layer15.3.1. Data Model15.3.2. Domain Object Model15.3.3. Object/Relational Mapping15.3.4. DAO Implementation15.3.5. Data Access Context15.4. Business Service Layer15.4.1. Services15.4.2. Application Context15.5. Web Layer15.5.1. Flow Through the Application15.5.2. Configuring the Application via web.xml15.5.3. Web Controllers15.5.4. View Technology15.6. Comparison with the J2EE Design and Development Implementation15.6.1. Simpler Technology15.6.2. Database Changes15.7. Server Configuration15.7.1. MySQL15.7.2. Tomcat15.8. Build and Deployment15.8.1. Creating and Loading the Database Tables15.8.2. Building the Application and Deploying It to the Tomcat Server15.9. Summary
16. Conclusion
16.1. Problems Solved by Spring16.2. The Spring Solution16.3. Guidelines for Spring Development16.3.1. Technology Choices16.3.1.1. Spring Versus "Old J2EE"16.3.1.2. Distributed Versus Local Objects16.3.1.3. Java Versus Other Languages?16.3.2. Layer by Layer16.3.2.1. A Layered Architecture16.3.2.2. Data Access and Integration16.3.2.3. Persistent Domain Model16.3.2.4. Business Services Layer16.3.2.4.1. Transaction Management16.3.2.4.2. Threading Issues16.3.2.5. Presentation Tier16.3.2.5.1. Web Application Presentation16.3.2.5.2. Remoting16.3.3. Structuring Applications16.3.3.1. Overall Issues16.3.3.2. Spring Configuration Issues16.3.3.2.1. Different Styles of Dependency Injection16.3.3.2.2. Autowiring16.3.3.2.3. Autoproxying16.3.3.2.4. Inheritance of Bean Definitions16.3.3.2.5. Breaking Up Configuration16.3.3.3. What Should Be an Aspect?16.3.4. Testing Your Applications16.3.4.1. Unit Testing16.3.4.2. In-Context Integration Testing16.3.4.3. Higher Levels of Testing16.4. Related Projects16.4.1. Acegi Security for Spring16.4.2. Other Projects16.5. Spring in Non-J2EE Environments16.6. To Find Out More16.6.1. Books and Articles16.6.2. Online Resources16.6.3. Sample Applications16.6.3.1. jPetStore16.6.3.2. PetClinic16.6.3.3. ImageDB16.7. The Future
A. Requirements for the Sample Application
A.1. OverviewA.2. User PopulationsA.2.1. Public Internet UsersA.2.2. Box Office UsersA.2.3. AdministratorsA.3. AssumptionsA.4. Scope LimitationsA.5. Delivery ScheduleA.6. Internet User InterfaceA.6.1. Basic WorkflowA.6.2. Error HandlingA.6.3. Application ScreensA.6.3.1. Welcome ScreenA.6.3.2. Display Show ScreenA.6.3.3. Book Seats ScreenA.6.3.4. Show Reservation ScreenA.6.3.5. Payment Details ScreenA.6.3.6. Confirm Reservation ScreenA.6.3.7. Box Office User InterfaceA.7. Non-Functional RequirementsA.8. Hardware and Software Environment

Content preview from Professional Java™ Development with the Spring Framework

Chapter 1. Introducing the Spring Framework

Why Spring?

The Spring Framework is an open source application framework that aims to make J2EE development easier. In this chapter we'll look at the motivation for Spring, its goals, and how Spring can help you develop high-quality applications quickly.

Note

Spring is an application framework. Unlike single-tier frameworks such as Struts or Hibernate, Spring aims to help structure whole applications in a consistent, productive manner, pulling together best-of-breed single-tier frameworks to create a coherent architecture.

Problems with the Traditional Approach to J2EE

Since the widespread implementation of J2EE applications in 1999/2000, J2EE has not been an unqualified success in practice. While it has brought a welcome standardization to core middle-tier concepts such as transaction management, many—perhaps most—J2EE applications are over-complex, take excessive effort to develop, and exhibit disappointing performance. While Spring is applicable in a wide range of environments—not just server-side J2EE applications—the original motivation for Spring was the J2EE environment, and Spring offers many valuable services for use in J2EE applications.

Experience has highlighted specific causes of complexity and other problems in J2EE applications. (Of course, not all of these problems are unique to J2EE!) In particular:

J2EE applications tend to contain excessive amounts of "plumbing" code. In the many code reviews we've done as consultants, time ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Pivotal Certified Professional Core Spring 5 Developer Exam: A Study Guide Using Spring Framework 5

Publisher Resources

ISBN: 9780764574832Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business