book

Spring Recipes, Second Edition

Name: Spring Recipes, Second Edition
ISBN: 9781430224990

by Gary Mak, Josh Long, Daniel Rubio

August 2010

Intermediate to advanced

1200 pages

26h 7m

English

Apress

Read now

Unlock full access

Copyright
About the Authors
About the Technical Reviewers
Acknowledgments
Introduction
Who This Book Is ForHow This Book Is StructuredConventionsPrerequisitesDownloading the codeContacting the Authors
1. Introduction to Spring
1.1. Instantiating the Spring IoC Container1.1.1. Problem1.1.2. Solution1.1.3. How It Works1.1.3.1. Instantiating an Application Context1.1.3.2. Getting Beans from the IoC Container1.2. Configuring Beans in the Spring IoC Container1.2.1. Problem1.2.2. Solution1.2.3. How It Works1.2.3.1. Creating the Bean Class1.2.3.2. Creating the Bean Configuration File1.2.3.3. Declaring Beans in the Bean Configuration File1.2.3.4. Defining Bean Properties by Shortcut1.2.3.5. Configuring Collections for Your Beans1.2.3.6. Lists, Arrays, and Sets1.2.3.7. Maps and Properties1.2.3.7.1. Merging the Collection of the Parent Bean1.3. Creating Beans by Invoking a Constructor1.3.1. Problem1.3.2. Solution1.3.3. How It Works1.4. Resolving Constructor Ambiguity1.4.1. Problem1.4.2. Solution1.4.3. How It Works1.5. Specifying Bean References1.5.1. Problem1.5.2. Solution1.5.3. How It Works1.5.3.1. Specifying Bean References for Setter Methods1.5.3.2. Specifying Bean References for Constructor Arguments1.5.3.3. Declaring Inner Beans1.6. Specifying the Data Type for Collection Elements1.6.1. Problem1.6.2. Solution1.6.3. How It Works1.7. Creating Beans Using Spring's FactoryBean1.7.1. Problem1.7.2. Solution1.7.3. How It Works1.8. Defining Collections Using Factory Beans and the Utility Schema1.8.1. Problem1.8.2. Solution1.8.3. How It Works1.8.3.1. Specifying the Concrete Class for Collections1.8.3.2. Defining Stand-Alone Collections1.9. Checking Properties with Dependency Checking1.9.1. Problem1.9.2. Solution1.9.3. How It Works1.9.3.1. Checking Properties of the Simple Types1.9.3.2. Checking Properties of the Object Types1.9.3.3. Checking Properties of All Types1.9.3.4. Dependency Checking and Constructor Injection1.10. Checking Properties with the @Required Annotation1.10.1. Problem1.10.2. Solution1.10.3. How It Works1.11. Auto-Wiring Beans with XML Configuration1.11.1. Problem1.11.2. Solution1.11.3. How It Works1.11.3.1. Auto-Wiring by Type1.11.3.2. Auto-Wiring by Name1.11.3.3. Auto-Wiring by Constructor1.11.3.4. Auto-Wiring by Auto-Detection1.11.3.5. Auto-Wiring and Dependency Checking1.12. Auto-Wiring Beans with @Autowired and @Resource1.12.1. Problem1.12.2. Solution1.12.3. How It Works1.12.3.1. Auto-Wiring a Single Bean of Compatible Type1.12.3.2. Auto-Wiring All Beans of Compatible Type1.12.3.3. Auto-Wiring by Type with Qualifiers1.12.3.4. Auto-Wiring by Name1.13. Inheriting Bean Configuration1.13.1. Problem1.13.2. Solution1.13.3. How It Works1.14. Scanning Components from the Classpath1.14.1. Problem1.14.2. Solution1.14.3. How It Works1.14.3.1. Scanning Components Automatically1.14.3.2. Filtering Components to Scan1.14.3.3. Naming Detected Components1.15. Summary
2. Advanced Spring IoC Container
2.1. Creating Beans by Invoking a Static Factory Method2.1.1. Problem2.1.2. Solution2.1.3. How It Works2.2. Creating Beans by Invoking an Instance Factory Method2.2.1. Problem2.2.2. Solution2.2.3. How It Works2.3. Declaring Beans from Static Fields2.3.1. Problem2.3.2. Solution2.3.3. How It Works2.4. Declaring Beans from Object Properties2.4.1. Problem2.4.2. Solution2.4.3. How It Works2.5. Using the Spring Expression Language2.5.1. Problem2.5.2. Solution2.5.3. How It Works2.5.3.1. Features of the Language Syntax2.5.3.2. Uses of the Language in Your Configurations2.5.3.3. Using the Spring Expression Language Parser2.6. Setting Bean Scopes2.6.1. Problem2.6.2. Solution2.6.3. How It Works2.7. Customizing Bean Initialization and Destruction2.7.1. Problem2.7.2. Solution2.7.3. How It Works2.7.3.1. Implementing the InitializingBean and DisposableBean Interfaces2.7.3.2. Setting the init-method and destroy-method Attributes2.7.3.3. Annotating the @PostConstruct and @PreDestroy Annotations2.8. Reducing XML Configuration with Java Config2.8.1. Problem2.8.2. Solution2.8.3. How It Works2.9. Making Beans Aware of the Container2.9.1. Problem2.9.2. Solution2.9.3. How It Works2.10. Loading External Resources2.10.1. Problem2.10.2. Solution2.10.3. How It Works2.10.3.1. Resource Prefixes2.10.3.2. Injecting Resources2.11. Creating Bean Post Processors2.11.1. Problem2.11.2. Solution2.11.3. How It Works2.12. Externalizing Bean Configurations2.12.1. Problem2.12.2. Solution2.12.3. How It Works2.13. Resolving Text Messages2.13.1. Problem2.13.2. Solution2.13.3. How It Works2.14. Communicating with Application Events2.14.1. Problem2.14.2. Solution2.14.3. How It Works2.14.3.1. Defining Events2.14.3.2. Publishing Events2.14.3.3. Listening to Events2.15. Registering Property Editors in Spring2.15.1. Problem2.15.2. Solution2.15.3. How It Works2.16. Creating Custom Property Editors2.16.1. Problem2.16.2. Solution2.16.3. How It Works2.17. Concurrency with TaskExecutors2.17.1. Problem2.17.2. Solution2.17.3. How It Works2.17.3.1. Java SE2.17.3.2. Java EE2.17.3.3. Spring's Solution2.18. Summary
3. Spring AOP and AspectJ Support
3.1. Enabling AspectJ Annotation Support in Spring3.1.1. Problem3.1.2. Solution3.1.3. How It Works3.2. Declaring Aspects with AspectJ Annotations3.2.1. Problem3.2.2. Solution3.2.3. How It Works3.2.3.1. Before Advices3.2.3.2. After Advices3.2.3.3. After Returning Advices3.2.3.4. After Throwing Advices3.2.3.5. Around Advices3.3. Accessing the Join Point Information3.3.1. Problem3.3.2. Solution3.3.3. How It Works3.4. Specifying Aspect Precedence3.4.1. Problem3.4.2. Solution3.4.3. How It Works3.5. Reusing Pointcut Definitions3.5.1. Problem3.5.2. Solution3.5.3. How It Works3.6. Writing AspectJ Pointcut Expressions3.6.1. Problem3.6.2. Solution3.6.3. How It Works3.6.3.1. Method Signature Patterns3.6.3.2. Type Signature Patterns3.6.3.3. Bean Name Patterns3.6.3.4. Combining Pointcut Expressions3.6.3.5. Declaring Pointcut Parameters3.7. Introducing Behaviors to Your Beans3.7.1. Problem3.7.2. Solution3.7.3. How It Works3.8. Introducing States to Your Beans3.8.1. Problem3.8.2. Solution3.8.3. How It Works3.9. Declaring Aspects with XML-Based Configurations3.9.1. Problem3.9.2. Solution3.9.3. How It Works3.9.3.1. Declaring Aspects3.9.3.2. Declaring Pointcuts3.9.3.3. Declaring Advices3.9.3.4. Declaring Introductions3.10. Load-Time Weaving AspectJ Aspects in Spring3.10.1. Problem3.10.2. Solution3.10.3. How It Works3.10.3.1. Load-Time Weaving by the AspectJ Weaver3.10.3.2. Load-Time Weaving by Spring Load-Time Weaver3.11. Configuring AspectJ Aspects in Spring3.11.1. Problem3.11.2. Solution3.11.3. How It Works3.12. Injecting Spring Beans into Domain Objects3.12.1. Problem3.12.2. Solution3.12.3. How It Works3.13. Summary
4. Scripting in Spring
4.1. Implementing Beans with Scripting Languages4.1.1. Problem4.1.2. Solution4.1.3. How It Works4.1.3.1. Scripting Beans with JRuby4.1.3.2. Scripting Beans with Groovy4.1.3.3. Scripting Beans with BeanShell4.2. Injecting Spring Beans into Scripts4.2.1. Problem4.2.2. Solution4.2.3. How It Works4.2.3.1. Injecting Spring Beans into JRuby4.2.3.2. Injecting Spring Beans into Groovy4.2.3.3. Injecting Spring Beans into BeanShell4.3. Refreshing Beans from Scripts4.3.1. Problem4.3.2. Solution4.3.3. How It Works4.4. Defining Script Sources Inline4.4.1. Problem4.4.2. Solution4.4.3. How It Works4.5. Summary
5. Spring Security
5.1. Securing URL Access5.1.1. Problem5.1.2. Solution5.1.3. How It Works5.1.3.1. Setting Up a Spring MVC Application That Uses Spring Security5.1.3.2. Creating the Configuration Files5.1.3.3. Creating the Controllers and Page Views5.1.3.4. Securing URL Access5.2. Logging In to Web Applications5.2.1. Problem5.2.2. Solution5.2.3. How It Works5.2.3.1. HTTP Basic Authentication5.2.3.2. Form-Based Login5.2.3.3. The Logout Service5.2.3.4. Anonymous Login5.2.3.5. Remember-Me Support5.3. Authenticating Users5.3.1. Problem5.3.2. Solution5.3.3. How It Works5.3.3.1. Authenticating Users with In-Memory Definitions5.3.3.2. Authenticating Users Against a Database5.3.3.3. Encrypting Passwords5.3.3.4. Authenticating Users Against an LDAP Repository5.3.3.5. Caching User Details5.4. Making Access Control Decisions5.4.1. Problem5.4.2. Solution5.4.3. How It Works5.5. Securing Method Invocations5.5.1. Problem5.5.2. Solution5.5.3. How It Works5.5.3.1. Securing Methods by Embedding a Security Interceptor5.5.3.2. Securing Methods with Pointcuts5.5.3.3. Securing Methods with Annotations5.6. Handling Security in Views5.6.1. Problem5.6.2. Solution5.6.3. How It Works5.6.3.1. Displaying Authentication Information5.6.3.2. Rendering View Contents Conditionally5.7. Handling Domain Object Security5.7.1. Problem5.7.2. Solution5.7.3. How It Works5.7.3.1. Setting Up an ACL Service5.7.3.2. Maintaining ACLs for Domain Objects5.7.3.3. Making Access Control Decisions Based on ACLs5.7.3.4. Handling Domain Objects Returned from Methods5.8. Summary

6. Integrating Spring with Other Web Frameworks
6.1. Accessing Spring in Generic Web Applications6.1.1. Problem6.1.2. Solution6.1.3. How It Works6.2. Using Spring in Your Servlets and Filters6.2.1. Problem6.2.2. Solution6.2.3. How It Works6.2.3.1.6.2.3.1.1. Servlets6.2.3.1.2. Filters6.3. Integrating Spring with Struts 1.x6.3.1. Problem6.3.2. Solution6.3.3. How It Works6.3.3.1. Loading Spring's Application Context into a Struts Application6.3.3.2. Accessing Spring's Application Context in Struts Actions6.3.3.3. Declaring Struts Actions in Spring's Bean Configuration File6.4. Integrating Spring with JSF6.4.1. Problem6.4.2. Solution6.4.3. How It Works6.4.3.1. Resolving Spring Beans in JSF6.4.3.2. Declaring JSF Managed Beans in Spring's Bean Configuration File6.5. Integrating Spring with DWR6.5.1. Problem6.5.2. Solution6.5.3. How It Works6.5.3.1. Exposing Spring Beans for Remote Invocation6.5.3.2. Configuring DWR in Spring's Bean Configuration File6.6. Summary
7. Spring Web Flow
7.1. Managing a Simple UI Flow with Spring Web Flow7.1.1. Problem7.1.2. Solution7.1.3. How It Works7.1.3.1. Setting Up a Spring MVC Application That Uses Spring Web Flow7.1.3.2. Creating the Configuration Files7.1.3.3. Creating Web Flow Definitions7.1.3.4. Creating the Page Views7.2. Modeling Web Flows with Different State Types7.2.1. Problem7.2.2. Solution7.2.3. How It Works7.2.3.1. Defining View States7.2.3.2. Defining Action States7.2.3.3. Defining Decision States7.2.3.4. Defining End States7.2.3.5. Defining Subflow States7.3. Securing Web Flows7.3.1. Problem7.3.2. Solution7.3.3. How It Works7.4. Persisting Objects in Web Flows7.4.1. Problem7.4.2. Solution7.4.3. How It Works7.4.3.1. Configuring JPA in Spring's Application Context7.4.3.2. Setting Up JPA for Spring Web Flow7.4.3.3. Using JPA in Web Flows7.5. Integrating Spring Web Flow with JSF7.5.1. Problem7.5.2. Solution7.5.3. How It Works7.5.3.1. Rendering JSF Views for Spring Web Flow7.5.3.2. Actions and ActionListeners7.5.3.3. Using the JSF Components of Spring Faces7.6. Using RichFaces with Spring Web Flow7.6.1. Problem7.6.2. Solution7.6.3. Approach7.6.3.1. Setting Up RichFaces With JSF7.7. Summary
8. Spring @MVC
8.1. Developing a Simple Web Application with Spring MVC8.1.1. Problem8.1.2. Solution8.1.3. How It Works8.1.3.1. Setting up a Spring MVC Application8.1.3.2. Creating the Configuration Files8.1.3.3. Activating Spring MVC annotation scanning8.1.3.4. Creating Spring MVC Controllers8.1.3.5. Creating JSP Views8.1.3.6. Deploying the Web Application8.2. Mapping requests with @RequestMapping8.2.1. Problem8.2.2. Solution8.2.3. How It Works8.2.3.1. Mapping requests by method8.2.3.2. Mapping requests by class8.2.3.3. Mapping requests by HTTP request type8.3. Intercepting Requests with Handler Interceptors8.3.1. Problem8.3.2. Solution8.3.3. How It Works8.4. Resolving User Locales8.4.1. Problem8.4.2. Solution8.4.3. How It Works8.4.3.1. Resolving Locales by an HTTP Request Header8.4.3.2. Resolving Locales by a Session Attribute8.4.3.3. Resolving Locales by a Cookie8.4.3.4. Changing a User's Locale8.5. Externalizing Locale-Sensitive Text Messages8.5.1. Problem8.5.2. Solution8.5.3. How It Works8.6. Resolving Views by Names8.6.1. Problem8.6.2. Solution8.6.3. How It Works8.6.3.1. Resolving Views Based on a template's name and location8.6.3.2. Resolving Views from an XML Configuration File8.6.3.3. Resolving Views from a Resource Bundle8.6.3.4. Resolving Views with Multiple Resolvers8.6.3.5. The Redirect Prefix8.7. Views and Content Negotiation8.7.1. Problem8.7.2. Solution8.7.3. How It Works8.8. Mapping Exceptions to Views8.8.1. Problem8.8.2. Solution8.8.3. How It Works8.9. Assigning values in a Controller with @Value8.9.1. Problem8.9.2. Solution8.9.3. How It Works8.10. Handling Forms with Controllers8.10.1. Problem8.10.2. Solution8.10.3. How It Works8.10.3.1. Creating a form's views8.10.3.2. Creating a form's service processing8.10.3.3. Creating a form's controller8.10.3.4. Initializing a model attribute object and pre-populating a form with values8.10.3.5. Providing form Reference Data8.10.3.6. Binding Properties of Custom Types8.10.3.7. Validating Form Data8.10.3.8. Expiring a controller's Session Data8.11. Handling Multipage Forms with Wizard Form Controllers8.11.1. Problem8.11.2. Solution8.11.3. How It Works8.11.3.1. Creating Wizard Form Pages8.11.3.2. Creating a Wizard Form Controller8.11.3.3. Validating Wizard Form Data8.12. Bean validation with Annotations (JSR-303)8.12.1. Problem8.12.2. Solution8.12.3. How It Works8.13. Creating Excel and PDF Views8.13.1. Problem8.13.2. Solution8.13.3. How It Works8.13.3.1. Creating Excel Views8.13.3.2. Creating PDF Views8.13.3.3. Creating resolvers for Excel and PDF views8.13.3.4. Creating date based PDF and XLS file names8.14. Summary
9. Spring REST
9.1. Publishing a REST Service with Spring9.1.1. Problem9.1.2. Solution9.1.3. How It Works9.2. Accessing a REST Service with Spring9.2.1. Problem9.2.2. Solution9.2.3. How It Works9.3. Publishing RSS and Atom feeds9.3.1. Problem9.3.2. Solution9.3.3. How It Works9.4. Publishing JSON with REST services9.4.1. Problem9.4.2. Solution9.4.3. How It Works9.5. Accessing REST Services with Elaborate XML Responses9.5.1. Problem9.5.2. Solution9.5.3. How It Works9.6. Summary
10. Spring and Flex
10.1. Getting started with Flex10.1.1. Problem10.1.2. Solution10.1.3. How It Works10.1.3.1. Flex Development Basics10.1.3.2. The Tools10.2. Leaving the Sandbox10.2.1. Problem10.2.2. Solution10.2.3. How It Works10.2.3.1. FlashVars10.2.3.2. ExternalInterface10.2.3.3. HTTP and HTTPS10.2.3.4. Consuming SOAP Services10.2.3.5. Flash Remoting with AMF10.3. Adding the Spring BlazeDS support to an application10.3.1. Problem10.3.2. Solution10.3.3. How It Works10.3.3.1. Installing the Spring Support10.4. Exposing Services Through BlazeDS / Spring10.4.1. Problem10.4.2. Solution10.4.3. How It Works10.5. Working With Server-Side Objects10.5.1. Problem10.5.2. Solution10.5.3. How It Works10.6. Consuming Message-Oriented Services Using BlazeDS and Spring10.6.1. Problem10.6.2. Solution10.6.3. How It Works10.6.3.1. JMS10.6.3.2. Spring Integration10.6.3.3. BlazeDS10.6.3.4. Sending Messages from Flex10.7. Bringing Dependency Injection to your ActionScript Client10.7.1. Problem10.7.2. Solution10.7.3. How It Works10.8. Summary
11. Grails
11.1. Getting and Installing Grails11.1.1. Problem11.1.2. Solution11.1.3. How It Works11.2. Creating a Grails Application11.2.1. Problem11.2.2. Solution11.2.3. How It Works11.2.3.1. A Grails Application's File and Directory Structure11.2.3.2. Running an Application11.2.3.3. Creating Your First Grails Application Construct11.2.3.4. Exporting a Grails Application to a WAR11.3. Grails Plug-Ins11.3.1. Problem11.3.2. Solution11.3.3. How It Works11.4. Developing, Producing, and Testing in Grails Environments11.4.1. Problem11.4.2. Solution11.4.3. How It Works11.5. Creating an Application's Domain Classes11.5.1. Problem11.5.2. Solution11.5.3. How It Works11.6. Generating CRUD Controllers and Views for an Application's Domain Classes11.6.1. Problem11.6.2. Solution11.6.3. How It Works11.7. Internationalization (I18n) Message Properties11.7.1. Problem11.7.2. Solution11.7.3. How it works11.8. Changing Permanent Storage Systems11.8.1. Problem11.8.2. Solution11.8.3. How It Works11.8.3.1. Setting Up an RDBMS Driver11.8.3.2. Configuring an RDBMS Instance11.9. Logging11.9.1. Problem11.9.2. Solution11.9.3. How It Works11.9.3.1. Configuring Custom Appenders and Loggers11.9.3.2. Configuring Layouts11.10. Running Unit and Integration Tests11.10.1. Problem11.10.2. Solution11.10.3. How It Works11.11. Using Custom Layouts and Templates11.11.1. Problem11.11.2. Solution11.11.3. How It Works11.12. Using GORM Queries11.12.1. Problem11.12.2. Solution11.12.3. How It Works11.13. Creating Custom Tags11.13.1. Problem11.13.2. Solution11.13.3. How It Works11.14. Summary
12. Spring Roo
12.1. Setting Up the Spring Roo Development Environment12.1.1. Problem12.1.2. Solution12.1.3. How It Works12.1.3.1. Maven12.1.3.2. SpringSource Tool Suite12.1.3.3. Spring Roo12.2. Creating Your First Spring Roo Project12.2.1. Problem12.2.2. Solution12.2.3. How It Works12.2.3.1. Exploring the Maven Project12.2.3.2. Getting Started Using STS12.3. Importing an Existing Project into SpringSource Tool Suite12.3.1. Problem12.3.2. Solution12.3.3. How It Works12.4. Building A Better Application, Quicker12.4.1. Problem12.4.2. Solution12.4.3. How It Works12.4.3.1. Coding the Backend12.4.3.2. Coding the Front-end12.5. Removing Spring Roo from Your Project12.5.1. Problem12.5.2. Solution12.5.3. How It Works12.6. Summary
13. Spring Testing
13.1. Creating Tests with JUnit and TestNG13.1.1. Problem13.1.2. Solution13.1.3. How It Works13.1.3.1. Testing with JUnit 313.1.3.2. Testing with JUnit 413.1.3.3. Testing with TestNG13.2. Creating Unit Tests and Integration Tests13.2.1. Problem13.2.2. Solution13.2.3. How It Works13.2.3.1. Creating Unit Tests for Isolated Classes13.2.3.2. Creating Unit Tests for Dependent Classes Using Stubs and Mock Objects13.2.3.3. Creating Integration Tests13.3. Unit Testing Spring MVC Controllers13.3.1. Problem13.3.2. Solution13.3.3. How It Works13.4. Managing Application Contexts in Integration Tests13.4.1. Problem13.4.2. Solution13.4.3. How It Works13.4.3.1. Accessing the Context with JUnit 3 Legacy Support13.4.3.2. Accessing the Context with the TestContext Framework in JUnit 413.4.3.3. Accessing the Context with the TestContext Framework in JUnit 313.4.3.4. Accessing the Context with the TestContext Framework in TestNG13.5. Injecting Test Fixtures into Integration Tests13.5.1. Problem13.5.2. Solution13.5.3. How It Works13.5.3.1. Injecting Test Fixtures with JUnit 3 Legacy Support13.5.3.2. Injecting Test Fixtures with the TestContext Framework in JUnit 413.5.3.3. Injecting Test Fixtures with the TestContext Framework in JUnit 313.5.3.4. Injecting Test Fixtures with the TestContext Framework in TestNG13.6. Managing Transactions in Integration Tests13.6.1. Problem13.6.2. Solution13.6.3. How It Works13.6.3.1. Managing Transactions with JUnit 3 Legacy Support13.6.3.2. Managing Transactions with the TestContext Framework in JUnit 413.6.3.3. Managing Transactions with the TestContext Framework in JUnit 313.6.3.4. Managing Transactions with the TestContext Framework in TestNG13.7. Accessing a Database in Integration Tests13.7.1. Problem13.7.2. Solution13.7.3. How It Works13.7.3.1. Accessing a Database with JUnit 3 Legacy Support13.7.3.2. Accessing a Database with the TestContext Framework13.8. Using Spring's Common Testing Annotations13.8.1. Problem13.8.2. Solution13.8.3. How It Works13.8.3.1. Using Common Testing Annotations with JUnit 3 Legacy Support13.8.3.2. Using Common Testing Annotations with the TestContext Framework13.9. Summary
14. Spring Portlet MVC Framework
14.1. Developing a Simple Portlet with Spring Portlet MVC14.1.1. Problem14.1.2. Solution14.1.3. How It Works14.1.3.1. Setting Up a Portlet Application14.1.3.2. Creating the Configuration Files14.1.3.3. Creating Portlet Controllers14.1.3.4. Resolving View Names into Views14.1.3.5. Creating Portlet Views14.1.3.6. Deploying the Portlet Application14.2. Mapping Portlet Requests to Handlers14.2.1. Problem14.2.2. Solution14.2.3. How It Works14.2.3.1. Mapping Requests by the Portlet Mode14.2.3.2. Mapping Requests by a Parameter14.3. Handling Portlet Forms with Simple Form Controllers14.3.1. Problem14.3.2. Solution14.3.3. How It Works14.3.3.1. Creating Form Controllers14.3.3.2. Validating Form Data14.4. Summary
15. Data Access
15.1. Problems with Direct JDBC15.1.1. Setting Up the Application Database15.1.2. Understanding the Data Access Object Design Pattern15.1.3. Implementing the DAO with JDBC15.1.4. Configuring a Data Source in Spring15.1.5. How It Works15.1.6. Running the DAO15.1.7. Taking It A Step Further15.2. Using a JDBC Template to Update a Database15.2.1. Problem15.2.2. Solution15.2.3. How It Works15.2.3.1. Updating a Database with a Statement Creator15.2.3.2. Updating a Database with a Statement Setter15.2.3.3. Updating a Database with a SQL Statement and Parameter Values15.2.3.4. Batch Updating a Database15.3. Using a JDBC Template to Query a Database15.3.1. Problem15.3.2. Solution15.3.3. How It Works15.3.3.1. Extracting Data with Row Callback Handler15.3.3.2. Extracting Data with a Row Mapper15.3.3.3. Querying for Multiple Rows15.3.3.4. Querying for a Single Value15.4. Simplifying JDBC Template Creation15.4.1. Problem15.4.2. Solution15.4.3. How It Works15.4.3.1. Injecting a JDBC Template15.4.3.2. Extending the JdbcDaoSupport Class15.5. Using the Simple JDBC Template with Java 1.515.5.1. Problem15.5.2. Solution15.5.3. How It Works15.5.3.1. Using a Simple JDBC Template to Update a Database15.5.3.2. Using a Simple JDBC Template to Query a Database15.6. Using Named Parameters in a JDBC Template15.6.1. Problem15.6.2. Solution15.6.3. How It Works15.7. Handling Exceptions in the Spring JDBC Framework15.7.1. Problem15.7.2. Solution15.7.3. How It Works15.7.3.1. Understanding Exception Handling in the Spring JDBC Framework15.7.3.2. Customizing Data Access Exception Handling15.8. Problems with Using ORM Frameworks Directly15.8.1. Problem15.8.2. Solution15.8.3. How It Works15.8.4. Persisting Objects Using the Hibernate API with Hibernate XML Mappings15.8.5. Persisting Objects Using the Hibernate API with JPA Annotations15.8.6. Persisting Objects Using JPA with Hibernate as the Engine15.9. Configuring ORM Resource Factories in Spring15.9.1. Problem15.9.2. Solution15.9.3. How It Works15.9.3.1. Configuring a Hibernate Session Factory in Spring15.9.3.2. Configuring a JPA Entity Manager Factory in Spring15.10. Persisting Objects with Spring's ORM Templates15.10.1. Problem15.10.2. Solution15.10.3. How It Works15.10.3.1. Using a Hibernate Template and a JPA Template15.10.3.2. Extending the Hibernate and JPA DAO Support Classes15.11. Persisting Objects with Hibernate's Contextual Sessions15.11.1. Problem15.11.2. Solution15.11.3. How It Works15.12. Persisting Objects with JPA's Context Injection15.12.1. Problem15.12.2. Solution15.12.3. How It Works15.13. Summary
16. Transaction Management in Spring
16.1. Problems with Transaction Management16.1.1.16.1.1.1. Managing Transactions with JDBC Commit and Rollback16.2. Choosing a Transaction Manager Implementation16.2.1. Problem16.2.2. Solution16.2.3. How It Works16.3. Managing Transactions Programmatically with the Transaction Manager API16.3.1. Problem16.3.2. Solution16.3.3. How It Works16.4. Managing Transactions Programmatically with a Transaction Template16.4.1. Problem16.4.2. Solution16.4.3. How It Works16.5. Managing Transactions Declaratively with Transaction Advices16.5.1. Problem16.5.2. Solution16.5.3. How It Works16.6. Managing Transactions Declaratively with the @Transactional Annotation16.6.1. Problem16.6.2. Solution16.6.3. How It Works16.7. Setting the Propagation Transaction Attribute16.7.1. Problem16.7.2. Solution16.7.3. How It Works16.7.3.1. The REQUIRED Propagation Behavior16.7.3.2. The REQUIRES_NEW Propagation Behavior16.7.3.3. Setting the Propagation Attribute in Transaction Advices, Proxies, and APIs16.8. Setting the Isolation Transaction Attribute16.8.1. Problem16.8.2. Solution16.8.3. How It Works16.8.3.1. The READ_UNCOMMITTED and READ_COMMITTED Isolation Levels16.8.3.2. The REPEATABLE_READ Isolation Level16.8.3.3. The SERIALIZABLE Isolation Level16.8.3.4. Setting the Isolation Level Attribute in Transaction Advices, Proxies, and APIs16.9. Setting the Rollback Transaction Attribute16.9.1. Problem16.9.2. Solution16.9.3. How It Works16.10. Setting the Timeout and Read-Only Transaction Attributes16.10.1. Problem16.10.2. Solution16.10.3. How It Works16.11. Managing Transactions with Load-Time Weaving16.11.1. Problem16.11.2. Solution16.11.3. How It Works16.12. Summary
17. EJB, Spring Remoting, and Web Services
17.1. Exposing and Invoking Services Through RMI17.1.1. Problem17.1.2. Solution17.1.3. How It Works17.1.3.1. Exposing an RMI Service17.1.3.2. Invoking an RMI Service17.2. Creating EJB 2.x Components with Spring17.2.1. Problem17.2.2. Solution17.2.3. How It Works17.2.3.1. Creating EJB 2.x Components Without Spring's Support17.2.3.2. Creating EJB 2.x Components with Spring's Support17.3. Accessing Legacy EJB 2.x Components in Spring17.3.1. Problem17.3.2. Solution17.3.3. How It Works17.3.3.1. Accessing EJB 2.x Components17.4. Creating EJB 3.0 Components in Spring17.4.1. Problem17.4.2. Solution17.4.3. How It Works17.5. Accessing EJB 3.0 Components in Spring17.5.1. Problem17.5.2. Solution17.5.3. How It Works17.5.3.1. Accessing EJB 3.0 Components with Spring's Support17.6. Exposing and Invoking Services Through HTTP17.6.1. Problem17.6.2. Solution17.6.3. How It Works17.6.3.1. Exposing a Hessian Service17.6.3.2. Invoking a Hessian Service17.6.3.3. Exposing a Burlap Service17.6.3.4. Invoking a Burlap Service17.6.3.5. Exposing an HTTP Invoker Service17.6.3.6. Invoking an HTTP Invoker Service17.7. Choosing a SOAP Web Service Development Approach17.7.1. Problem17.7.2. Solution17.7.3. How It Works17.7.3.1. Contract-Last Web Services17.7.3.2. Contract-First Web Services17.7.3.3. Comparison17.8. Exposing and Invoking a Contract-Last SOAP Web Services Using JAX-WS17.8.1. Problem17.8.2. Solution17.8.3. How It Works17.8.3.1. Exposing a Web Service Using The JAX-WS Endpoint Support in the JDK17.8.3.2. Exposing a Web Service Using CXF17.8.3.3. Invoking a Web Service Using CXF17.9. Defining the Contract of a Web Service17.9.1. Problem17.9.2. Solution17.9.3. How It Works17.9.3.1. Creating Sample XML Messages17.9.3.2. Generating an XSD File from Sample XML Messages17.9.3.3. Optimizing the Generated XSD File17.9.3.4. Previewing the Generated WSDL File17.10. Implementing Web Services Using Spring-WS17.10.1. Problem17.10.2. Solution17.10.3. How It Works17.10.3.1. Setting Up a Spring-WS Application17.10.3.2. Mapping Web Service Requests to Endpoints17.10.3.3. Creating Service Endpoints17.10.3.4. Publishing the WSDL File17.11. Invoking Web Services Using Spring-WS17.11.1. Problem17.11.2. Solution17.11.3. How It Works17.12. Developing Web Services with XML Marshalling17.12.1. Problem17.12.2. Solution17.12.3. How It Works17.12.3.1. Creating Service Endpoints with XML Marshalling17.12.3.2. Invoking Web Services with XML Marshalling17.13. Creating Service Endpoints with Annotations17.13.1. Problem17.13.2. Solution17.13.3. How It Works17.14. Summary
18. Spring in the Enterprise
18.1. Exporting Spring Beans as JMX MBeans18.1.1. Problem18.1.2. Solution18.1.3. How It Works18.1.3.1. Registering MBeans Without Spring's Support18.1.3.2. Exporting Spring Beans as MBeans18.1.3.3. Exposing MBeans for Remote Access18.1.3.4. Assembling the Management Interface of MBeans18.1.3.5. Auto-Detecting MBeans by Annotations18.2. Publishing and Listening to JMX Notifications18.2.1. Problem18.2.2. Solution18.2.3. How It Works18.2.3.1. Publishing JMX Notifications18.2.3.2. Listening to JMX Notifications18.3. Accessing Remote JMX MBeans in Spring18.3.1. Problem18.3.2. Solution18.3.3. How It Works18.3.3.1. Accessing Remote MBeans Through an MBean Server Connection18.3.3.2. Accessing Remote MBeans Through an MBean Proxy18.4. Sending E-mail with Spring's E-mail Support18.4.1. Problem18.4.2. Solution18.4.3. How It Works18.4.3.1. Sending E-mail Using the JavaMail API18.4.3.2. Sending E-mail with Spring's MailSender18.4.3.3. Defining an E-mail Template18.4.3.4. Sending MIME Messages18.5. Scheduling with Spring's Quartz Support18.5.1. Problem18.5.2. Solution18.5.3. How It Works18.5.3.1. Using Quartz Without Spring's Support18.5.3.2. Using Quartz with Spring's Support18.6. Scheduling With Spring 3.0's Scheduling Namespace18.6.1. Problem18.6.2. Solution18.6.3. How It Works18.7. Summary
19. Messaging
19.1. Sending and Receiving JMS Messages with Spring19.1.1. Problem19.1.2. Solution19.1.3. How It Works19.1.3.1. Sending and Receiving Messages Without Spring's Support19.1.3.2. Sending and Receiving Messages with Spring's JMS Template19.1.3.3. Sending and Receiving Messages to and from a Default Destination19.1.3.4. Extending the JmsGatewaySupport Class19.2. Converting JMS Messages19.2.1. Problem19.2.2. Solution19.2.3. Approach19.3. Managing JMS Transactions19.3.1. Problem19.3.2. Approach19.3.3. Solution19.4. Creating Message-Driven POJOs in Spring19.4.1. Problem19.4.2. Solution19.4.3. How It Works19.4.3.1. Listening for JMS Messages with Message Listeners19.4.3.2. Listening for JMS Messages with POJOs19.4.3.3. Converting JMS Messages19.4.3.4. Managing JMS Transactions19.4.3.5. Using Spring's JMS Schema19.5. Making the Connection19.5.1. Problem19.5.2. Solution19.5.3. How It Works19.6. Summary
20. Spring Integration
20.1. Integrating One System with Another Using EAI20.1.1. Problem20.1.2. Solution20.1.3. How It Works20.1.3.1. Picking an Integration Style20.1.3.2. Building on an ESB Solution20.2. Integrating Two Systems Using JMS20.2.1. Problem20.2.2. Solution20.2.3. How it Works20.2.3.1. Building an Message Driven Pojo (MDP) Using Spring Integration20.3. Interrogating Spring Integration Messages for Context Information20.3.1. Problem20.3.2. Solution20.3.3. How it Works20.3.3.1. Using MessageHeaders for Fun and Profit20.4. Integrating Two Systems Using a File System20.4.1. Problem20.4.2. Solution20.4.3. How It Works20.4.3.1. Concerns in Dealing with a File System20.5. Transforming a Message from One Type to Another20.5.1. Problem20.5.2. Solution20.5.3. How It Works20.5.3.1. Modifying a Message's Payload20.5.3.2. Modifying a Message's Headers20.6. Error Handling Using Spring Integration20.6.1. Problem20.6.2. Solution20.6.3. How It Works20.6.3.1. Routing to Custom Handlers Based on the Type of Exception20.6.3.2. Building a Solution with Multiple Error Channels20.7. Forking Integration Control: Splitters and Aggregators20.7.1. Problem20.7.2. Solution20.7.3. How it Works20.7.3.1. Using a Splitter20.7.3.2. Using Aggregators20.8. Conditional Routing with Routers20.8.1. Problem20.8.2. Solution20.8.3. How It Works20.9. Adapting External Systems to the Bus20.9.1. Problem20.9.2. Solution20.9.3. How It Works20.9.3.1. An Inbound Twitter Adapter20.9.3.2. Twitter Messages20.9.3.3. A Simple MessageSource20.9.3.4. An Outbound Twitter Example20.10. Staging Events Using Spring Batch20.10.1. Problem20.10.2. Solution20.10.3. How It Works20.11. Using Gateways20.11.1. Problem20.11.2. Solution20.11.3. How It Works20.11.3.1. SimpleMessagingGateway20.11.3.2. Breaking the Interface Dependency20.12. Summary
21. Spring Batch
21.1. Runtime Metadata Model21.2. Setting Up Spring Batch's Infrastructure21.2.1. Problem21.2.2. Solution21.2.3. How It Works21.3. Reading and Writing (but No Arithmetic)21.3.1. Problem21.3.2. Solution21.3.3. How It Works21.3.3.1. The Job Configuration21.3.3.2. Input21.3.3.3. Output21.4. Writing a Custom ItemWriter and ItemReader21.4.1. Problem21.4.2. Solution21.4.3. How It Works21.4.3.1. Writing a Custom ItemReader21.4.3.2. Writing a Custom ItemWriter21.5. Processing Input Before Writing21.5.1. Problem21.5.2. Solution21.5.3. How It Works21.5.3.1. Chaining Processors Together21.6. Better Living through Transactions21.6.1. Problem21.6.2. Solution21.6.3. How It Works21.6.3.1. Transactions21.6.3.2. Rollbacks21.7. Retrying21.7.1. Problem21.7.2. Solution21.7.3. How It Works21.7.3.1. Configuring a Step21.7.3.2. Retry Template21.7.3.3. AOP-Based Retries21.8. Controlling Step Execution21.8.1. Problem21.8.2. Solution21.8.3. How It Works21.8.3.1. Sequential Steps21.8.3.2. Concurrency21.8.3.3. Conditional Steps with Statuses21.8.3.4. Conditional Steps with Decisions21.9. Launching a Job21.9.1. Problem21.9.2. Solution21.9.3. How It Works21.9.3.1. Launching From a Web Application21.9.3.2. Running from the Command Line21.9.3.3. Running On A Schedule21.10. Parameterizing a Job21.10.1. Problem21.10.2. Solution21.10.3. How It Works21.10.3.1. Launching a Job with Parameters21.10.3.2. Accessing JobParameters21.11. Summary
22. Spring on the Grid
22.1. Clustering Object State Using Terracotta22.1.1. Problem22.1.2. Solution22.1.3. How It Works22.1.3.1. Deploying a Simple Example with Terracotta22.1.3.2. Terracotta Architecture and Deployment22.1.3.3. The XML Configuration File22.2. Farming Out Execution to a Grid22.2.1. Problem22.2.2. Solution22.2.3. Approach22.2.3.1. Deployment22.3. Load Balancing a Method22.3.1. Problem22.3.2. Solution22.3.3. Approach22.4. Parallelizing Processing22.4.1. Problem22.4.2. Solution22.4.3. Approach22.5. Deploying on GridGain22.5.1. Problem22.5.2. Solution22.5.3. How It Works22.5.3.1. Creating a Grid Node22.5.3.2. Provisioning a Grid Node22.5.3.3. Getting Access to the Spring Container from a Task22.5.3.4. Node-Specific GridGain Configuration22.6. Summary
23. jBPM and Spring
23.1. Software Processes23.2. Understanding Workflow Models23.2.1. Problem23.2.2. Solution23.2.3. How It Works23.3. Installing jBPM23.3.1. Problem23.3.2. Solution23.3.3. How It Works23.4. Integrating jBPM 4 with Spring23.4.1. Problem23.4.2. Solution23.4.3. How It Works23.4.3.1. The Application Context23.5. Building a Service with Spring23.5.1. Problem23.5.2. Solution23.5.3. How It Works23.6. Building a Business Process23.6.1. Problem23.6.2. Solution23.6.3. How It Works23.7. Summary
24. OSGi and Spring
24.1. Getting Started with OSGi24.1.1. Problem24.1.2. Solution24.1.3. How It Works24.1.3.1. OSGi and JavaBeans24.1.3.2. The helloworld-service Service24.1.3.3. Installing Equinox24.1.3.4. Using the Service in a Client Bundle24.2. Getting Started Using Spring Dynamic Modules24.2.1. Problem24.2.2. Solution24.2.3. How It Works24.3. Exporting a Service Using Spring Dynamic Modules24.3.1. Problem24.3.2. Solution24.3.3. How It Works24.3.3.1. Interfacing with the OSGi Runtime24.4. Finding a Specific Service in the OSGi Registry24.4.1. Problem24.4.2. Solution24.4.3. How It Works24.4.3.1. Ranking24.4.3.2. Service Attributes24.4.3.3. Cardinality24.5. Publishing a Service Under Multiple Interfaces24.5.1. Problem24.5.2. Solution24.5.3. How It Works24.6. Customizing Spring Dynamic Modules24.6.1. Problem24.6.2. Solution24.6.3. How It Works24.6.3.1. Making Spring Process OSGi Annotations on Beans24.6.3.2. Changing the Default HTTP Server That Spring Uses When Deploying a .war24.7. Using SpringSource dm Server24.7.1. Problem24.7.2. Solution24.7.3. How It Works24.8. SpringSource's Tooling24.8.1. Problem24.8.2. Solution24.8.3. How it Works24.9. Summary

Overview

With over 3 Million users/developers, Spring Framework is the leading "out of the box" Java framework. Spring addresses and offers simple solutions for most aspects of your Java/Java EE application development, and guides you to use industry best practices to design and implement your applications.

The release of Spring Framework 3 has ushered in many improvements and new features. Spring Recipes: A Problem-Solution Approach, Second Edition continues upon the bestselling success of the previous edition but focuses on the latest Spring 3 features for building enterprise Java applications. This book provides elementary to advanced code recipes to account for the following, found in the new Spring 3:

Spring fundamentals: Spring IoC container, Spring AOP/ AspectJ, and more
Spring enterprise: Spring Java EE integration, Spring Integration, Spring Batch, jBPM with Spring, Spring Remoting, messaging, transactions, scaling using Terracotta and GridGrain, and more.
Spring web: Spring MVC, Spring Web Flow 2, Spring Roo, other dynamic scripting, integration with popular Grails Framework (and Groovy), REST/web services, and more.

This book guides you step by step through topics using complete and real-world code examples. Instead of abstract descriptions on complex concepts, you will find live examples in this book. When you start a new project, you can consider copying the code and configuration files from this book, and then modifying them for your needs. This can save you a great deal of work over creating a project from scratch!

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

Spring Boot 2.0 Cookbook - Second Edition

Publisher Resources

ISBN: 9781430224990Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills