BUY 2010/09/10


Spring Enterprise Recipes: A Problem-Solution Approach

Spring Enterprise Recipes: A Problem-Solution Approach




Spring Enterprise Recipes - A Problem-Solution Approach -


Chapter 1. Introduction to Spring
    Section 1.1. Instantiating the Spring IoC Container
    Section 1.2. Configuring Beans in the Spring IoC Container
    Section 1.3. Auto-Wiring Beans with XML Configuration
    Section 1.4. Auto-Wiring Beans with @Autowired and @Resource
    Section 1.5. Scanning Components from the Classpath
    Section 1.6. Setting Bean Scopes
    Section 1.7. Customizing Bean Initialization and Destruction
    Section 1.8. Resolving Text Messages
    Section 1.9. Loading External Resources
    Section 1.10. Enabling AspectJ Annotation Support in Spring
    Section 1.11. Declaring Aspects with AspectJ Annotations
    Section 1.12. Reusing Pointcut Definitions
    Section 1.13. Writing AspectJ Pointcut Expressions
    Section 1.14. Introducing Behaviors to Your Beans
    Section 1.15. Introducing States to Your Beans
    Section 1.16. Summary

Chapter 2. What's New in Spring 3.0?
    Section 2.0. Upgrades to the SpringSource Portfolio
    Section 2.1. Getting Started with the Latest and Greatest Spring Framework
    Section 2.2. Using Java 5 Syntax in Spring
    Section 2.3. Achieving Concurrency with TaskExecutors
    Section 2.4. Using the Spring Expression Language
    Section 2.5. My Code Doesn't Compile!
    Section 2.6. Reducing XML Configuration with Java Config
    Section 2.7. Summary

Chapter 3. Data Access
    Section 3.0. Problems with Direct JDBC
    Section 3.1. Using a JDBC Template to Update a Database
    Section 3.2. Using a JDBC Template to Query a Database
    Section 3.3. Simplifying JDBC Template Creation
    Section 3.4. Using the Simple JDBC Template with Java 1.5
    Section 3.5. Using Named Parameters in a JDBC Template
    Section 3.6. Handling Exceptions in the Spring JDBC Framework
    Section 3.7. Problems with Using ORM Frameworks Directly
    Section 3.8. Configuring ORM Resource Factories in Spring
    Section 3.9. Persisting Objects with Spring's ORM Templates
    Section 3.10. Persisting Objects with Hibernate's Contextual Sessions
    Section 3.11. Persisting Objects with JPA's Context Injection
    Section 3.12. Summary

Chapter 4. Transaction Management in Spring
    Section 4.1. Problems with Transaction Management
    Section 4.2. Choosing a Transaction Manager Implementation
    Section 4.3. Managing Transactions Programmatically with the Transaction Manager API
    Section 4.4. Managing Transactions Programmatically with a Transaction Template
    Section 4.5. Managing Transactions Declaratively with Transaction Advices
    Section 4.6. Managing Transactions Declaratively with the @Transactional Annotation
    Section 4.7. Setting the Propagation Transaction Attribute
    Section 4.8. Setting the Isolation Transaction Attribute
    Section 4.9. Setting the Rollback Transaction Attribute
    Section 4.10. Setting the Timeout and Read-Only Transaction Attributes
    Section 4.11. Managing Transactions with Load-Time Weaving
    Section 4.12. Summary

Chapter 5. EJB, Spring Remoting, and Web Services
    Section 5.1. Exposing and Invoking Services Through RMI
    Section 5.2. Creating EJB 2.x Components with Spring
    Section 5.3. Accessing EJB 2.x Components in Spring
    Section 5.4. Creating EJB 3.0 Components in Spring
    Section 5.5. Accessing EJB 3.0 Components in Spring
    Section 5.6. Exposing and Invoking Services Through HTTP
    Section 5.7. Choosing a Web Service Development Approach
    Section 5.8. Exposing and Invoking Web Services Using XFire
    Section 5.9. Defining the Contract of Web Services
    Section 5.10. Implementing Web Services Using Spring-WS
    Section 5.11. Invoking Web Services Using Spring-WS
    Section 5.12. Developing Web Services with XML Marshalling
    Section 5.13. Creating Service Endpoints with Annotations
    Section 5.14. Summary

Chapter 6. Spring in the Enterprise
    Section 6.1. Exporting Spring Beans as JMX MBeans
    Section 6.2. Publishing and Listening to JMX Notifications
    Section 6.3. Accessing Remote JMX MBeans in Spring
    Section 6.4. Sending E-mail with Spring's E-mail Support
    Section 6.5. Scheduling with Spring's JDK Timer Support
    Section 6.6. Scheduling with Spring's Quartz Support
    Section 6.7. Summary

Chapter 7. Messaging
    Section 7.1. Sending and Receiving JMS Messages with Spring
    Section 7.2. Converting JMS Messages
    Section 7.3. Managing JMS Transactions
    Section 7.4. Creating Message-Driven POJOs in Spring
    Section 7.5. Summary

Chapter 8. Spring Integration
    Section 8.1. Getting Started with Spring Integration
    Section 8.2. Integrating One System with Another Using EAI
    Section 8.3. Integrating Two Systems Using JMS
    Section 8.4. Interrogate Spring Integration Messages for Context Information
    Section 8.5. Integrating Two Systems Using a File System
    Section 8.6. Transforming a Message from One Type to Another
    Section 8.7. Error Handling Using Spring Integration
    Section 8.8. Forking Integration Control: Splitters and Aggregators
    Section 8.9. Conditional Routing with Routers
    Section 8.10. Adapting External Systems to the Bus
    Section 8.11. Staging Events Using Spring Batch
    Section 8.12. Gateways
    Section 8.13. Summary

Chapter 9. Spring Batch
    Section 9.1. Getting Started with the Spring Batch Distribution
    Section 9.2. Setting Up Spring Batch's Infrastructure
    Section 9.3. Running Jobs
    Section 9.4. Reading and Writing (but No Arithmetic)
    Section 9.5. Writing a Custom ItemWriter and ItemReader
    Section 9.6. Processing Input Before Writing
    Section 9.7. Better Living through Transactions
    Section 9.8. Retry
    Section 9.9. Controlling Step Execution
    Section 9.10. Parameterizing a Job
    Section 9.11. Summary

Chapter 10. Distributed Spring
    Section 10.1. Cluster Object State Using Terracotta
    Section 10.2. Using Spring to Simplify Terracotta Configuration
    Section 10.3. You Want to Farm Out Execution to a Grid
    Section 10.4. Load Balancing a Method
    Section 10.5. Parallelizing Processing
    Section 10.6. On GridGain Deployment
    Section 10.7. Summary

Chapter 11. jBPM and Spring
    Section 11.0. Software Processes
    Section 11.1. Understanding Workflow Models
    Section 11.2. Installing jBPM
    Section 11.3. Integrating jBPM 4 with Spring
    Section 11.4. Building a Service With Spring
    Section 11.5. Building a Business Process
    Section 11.6. Summary

Chapter 12. OSGi and Spring
    Section 12.1. Getting Started With OSGi
    Section 12.2. How do I get Started Using Spring Dynamic Modules?
    Section 12.3. How do I Export a Service Using Spring Dynamic Modules?
    Section 12.4. Finding a Specific Service in the OSGi Registry
    Section 12.5. Publishing a Service Under Multiple Interfaces
    Section 12.6. Customizing Spring Dynamic Modules
    Section 12.7. Using SpringSource dm Server
    Section 12.8. SpringSource's Tooling
    Section 12.9. Summary